⑴ 关于两顺序表合并成一个顺序表的操作,怎么用C写,要注释,刚入门的菜鸟。
将两个有序数组合并成一个有序数组,方法请参考归并排序中的合并操作。
⑵ 数据结构【两个有序顺序表的合并】
这里用数组表示有序表。a[],n,b[],m;假设都是由小到大的,排序后也是由小到大的。结果存于c[],k
这里把相等也当成有序的。
void combine(int a[],int n,int b[],int m,int c[])
{
int i,j;
i=j=0;
k=0;
while(i<n&&j<m)
{
if(a[i]<b[j]) {c[k++]=a[i];i++;}
else {c[k++]=b[j];j++;}
}
for(;i<n;i++) c[k++]=a[i];
for(;j<m;j++) c[k++]=b[j];
}
⑶ 编写一个用顺序存储结构实现将两个有序表合成一个有序表的算法
用数组写了个思路,如果你们要求用链表的话改一下就可以了:
/*
把num1 num2 合并,输出到num_merge
*/
void merge(int num1[],int num2[],int num_merge[]){
int length1 = sizeof(num1)/sizeof(int);
int length2 = sizeof(num2)/sizeof(int);
int i = 0,j = 0,length_merge = 0;
while(length_merge < length1 && i< length2){
if(num1[i]<num2[j]){
num_merge[length_merge++] = num1[i++];
}else if(num1[i]>num2[j]){
num_merge[length_merge++] = num2[j++];
}else{
num_merge[length_merge++] = num1[i++];
j++;
}
}
while(length_merge < length1){
num_merge[length_merge++] = num1[i++];
}
while(length_merge < length2){
num_merge[length_merge++] = num2[j++];
}
}
⑷ 将两个顺序存储的有序表合并成一个有序表
将两个顺序存储的有序表合并成一个有序表的代码如下:
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#define MaxSize 50
typedef struct
{
int data[MaxSize];
int length;
}SqList;
void ListInsert(SqList *L,int i,int e)
{
int j;
if(i<1||i>L->length+1)
exit(-1);
if(L->length>=MaxSize)
exit(-1);
for(j=L->length;j>=i;j--)
L->data[j]=L->data[j-1];
L->data[i-1]=e;
L->length++;
}
void DispList(SqList *L)
{
int i;
for(i=0;i<L->length;i++)
printf("%d ",L->data[i]);
printf("
");
}
void Exchange(SqList *A,SqList *B,SqList *C)
{
int i=0,j=0,k=0;
while(i<A->length&&j<B->length)
{
if(A->data[i]<B->data[j])
C->data[k++]=A->data[i++];
else if(A->data[i]>B->data[j])
C->data[k++]=B->data[j++];
}
while(i<A->length)
C->data[k++]=A->data[i++];
while(j<B->length)
C->data[k++]=B->data[j++];
C->length=k;
}
void main()
{
SqList *A,*B,*C;
A=(SqList*)malloc(sizeof(SqList));
A->length=0;
B=(SqList*)malloc(sizeof(SqList));
B->length=0;
C=(SqList*)malloc(sizeof(SqList));
C->length=0;
ListInsert(A,1,1);
ListInsert(A,2,3);
ListInsert(A,3,5);
ListInsert(A,4,7);
ListInsert(A,5,9);
ListInsert(B,1,2);
ListInsert(B,2,4);
ListInsert(B,3,6);
ListInsert(B,4,8);
ListInsert(B,5,10);
ListInsert(B,6,12);
Exchange(A,B,C);
printf("顺序表A:");
DispList(A);
printf("顺序表B:");
DispList(B);
printf("顺序表C:");
DispList(C);
}
(4)两个有序表的原地合并的存储结构扩展阅读:
第二种解法的核心代码
bool Merge(SeqList A, SeqList B, SeqList &C)
{//C为合并后的顺序表
if (A.length + B.length > C.MaxSize) return false;//超出最大存储空间
int i = 0, j = 0, k = 0;
while( i < A.length && j < B.length)
{
if (A.data[i] <= B.data[j])
C.data[k++] = A.data[i++];
else
C.data[k++] = B.data[j++];
}
while (i < A.length) C.data[k++] = A.data[i++];
while (j < B.length) C.data[k++] = B.data[j++];
C.length = k;
return true;
}
⑸ 数据结构(C语言版):顺序存储结构上编程实现将两个有序表合成一个有序表,要完整程序,包括MAIN函数。
#include<stdio.h>
void merger(int d1[10],int t1,int d2[10],int t2,int result[20])
{ int k1=0,k2=0,k=0;
while(k1<t1 && k2<t2)
{ if(d1[k1]<d2[k2])
result[k++]=d1[k1++];
else
result[k++]=d2[k2++];
}
if(k1<t1)
for(k2=k1;k2<t1;k2++)
result[k++]=d1[k2];
else
for(k1=k2;k1<t2;k1++)
result[k++]=d2[k1];
}
int main()
{ int data1[10]={3,5,7,9,12,19,25,26,27},data2[10]={1,4,6,8,9,15,17,21},r[20];
int total1=6,total2=8,k;
merger(data1,total1,data2,total2,r);
for(k=0; k<total1+total2;k++)
printf("%d. %d\n",k+1,r[k]);
printf("\ntotal1=%d total2=%d",total1,total2) ;
system("pause");
}
⑹ 数据结构:将两个有序的单链表合并成一个有序的单链表,要求用原表的结点空间。
#include "stdlib.h"
#include "time.h"
struct link
{
int data;
struct link *next;
};
//不带头节点的链表
struct link *CreateLink(int n)
{
struct link *head=NULL,*p=NULL,*q=NULL;
srand( n*1000);
int temp = rand()%10;
head = (struct link *)malloc(sizeof(struct link));
head->data = temp;
head->next = NULL;
p = head;
for (int i=1; i<n; i++)
{
q = (struct link *)malloc(sizeof(struct link));
temp = temp+rand()%100;
q->data = temp;//ascend
q->next = NULL;
p->next = q;
p = q;
}
return head;
}
void PrintLink(struct link *head)
{
struct link *p=head;
printf("\nData in the Link:");
while (p!=NULL)
{
printf("%d ",p->data);
p = p->next;
}
}
struct link *MergeLink(struct link *h1, struct link *h2)
{
struct link *head;
struct link *head1=h1,*head2=h2;
//哪个链表第一个节点值小,则把它的头指针作为合并后的头指针
if (h1->data>h2->data)
{
head1 = h2;
head2 = h1;
}
head = head1;
struct link *tmp=NULL;
while (head2 != NULL)
{
while ( (head1->next->data < head2->data) && head1->next!=NULL)
{
head1 = head1->next;
}
tmp = head2;
head2 = head2->next;
tmp->next = head1->next;
head1->next = tmp;
}
return head;
}
int main()
{
struct link *head1=NULL,*head2=NULL;
head1 = CreateLink(10);
PrintLink(head1);
head2 = CreateLink(13);
PrintLink(head2);
struct link *head=NULL;
head = MergeLink(head1,head2);
PrintLink(head);
return 1;
}
⑺ 用顺序存储实现两个线性表合并
合并两个线性表中的元素,相同的元素只保留一个,代码如下:
#pragma once
#define ListSize 200
#include <iostream>
using namespace std;
typedef int DataType;
typedef struct
{
DataType list[ListSize];
int length;
}SeqList;
//初始化线性表
void InitList(SeqList *L)
{
L->length = 0;//把线性表长度置为0
}
//判断线性表是否为空,线性表为空返回1,否则返回0
int ListEmpty(SeqList L)
{
if (L.length == 0)
return 1;
else
return 0;
}
//按照序号查找
int GetElem(SeqList L, int i, DataType *e)
/*查找线性表中第i个元素,查找成功返回给e,并返回1表示成功,否则返回-1,表示失败*/
{
if (i<1 || i>L.length)
return -1;
else
*e = L.list[i - 1];
return 1;
}
//按照内容查找
int LocateElem(SeqList L, DataType e)
{
int i;
for (i = 0; i < L.length; i++)/*从第一个元素开始与e进行比较*/
if (L.list[i] == e) /*若存在与e相等的元素*/
return i + 1; /*返回该元素的在线性表中的序号*/
return 0; /*否则,返回0 */
}
//插入操作
int InsertList(SeqList *L, int i, DataType e)
/*在顺序表中的第i个位置插入元素e,插入成功返回1,插入不合法返回-1,顺序表满返回0.*/
{
int j;
if (i<1||i>L->length+1)/*在插入元素前,判断插入位置是否合法*/
{
cout <<"插入位置"<<i<<"不合法!" << endl;
return -1;
}
else if (L->length>=ListSize)/*在插入元素之前,判断顺序表是否已经满,不能插入元素*/
{
cout << "顺序表已经满,不能插入元素。" << endl;
return 0;
}
else
{
for (j = L->length; j >= i; j--)
/*将第i个位置以后的元素依次后移*/
{
L->list[j] = L->list[j - 1];
}
L->list[i - 1] = e;
L->length = L->length + 1;
return 1;
}
}
/*删除操作,删除第i个元素*/
int DeleteList(SeqList *L, int i, DataType *e)
{
int j;
if (L->length<=0)
{
cout << "顺序表表已空,不能进行删除!" << endl;
return 0;
}
else if (i<1||i>L->length)
{
cout << "删除位置不合适!" << endl;
return -1;
}
else
{
*e = L->list[i - 1];
for (j = i; j <= L->length - 1;j++)
{
L->list[j - 1] = L->list[j];
}
L->length = L->length - 1;
return 1;
}
}
/*求线性表的长度*/
int ListLength(SeqList L)
{
return L.length;
}
/*清空顺序表*/
void ClearList(SeqList *L)
{
L->length = 0;
}
(7)两个有序表的原地合并的存储结构扩展阅读
线性表的顺序存储结构,就是在内存中找到一块空间,通过占位的方式,把一定内存空间给占了,然后把相同数据类型的数据元素依次存放在这块空间中。
既然线性表的每个数据元素的类型相同,所以C语言(其他语言也相同)用一维数组来实现顺序存储结构,即把第一个数据元素存到数组下标为0的位置中,接着把线性表相邻的元素存储在数组中相邻的位置。
顺序存储的属性
三个属性:
1、存储空间的起始位置:数组data,它的存储位置就是存储空间的存储位置。
2、线性表的最大存储容量:数组的长度MaxSize.
3、线性表的当前长度:length。
⑻ 怎么将两个顺序存储的有序表合并成一个有序表
具体代码如下:
#include<stdio.h>
#include<stdlib.h>
#define MAX 40
typedef struct
{
int data[MAX];
int length;
}LinkList;
void Initial_List(LinkList * &l,int n)//初始化顺序表
{
int i=0;
l=(LinkList *)malloc(sizeof(LinkList));
l->length = 0;
for(;i<n;i++)
scanf("%d",l->data+i);
l->length = n;
}
void Link(LinkList *l1,LinkList *l2,LinkList * &l3)//连接顺序表
{
int i,j;
l3=(LinkList *)malloc(sizeof(LinkList));
l3->length = l1->length + l2->length;
for(i=0;i<l3->length;i++)
{
if(i<l1->length)
{
l3->data[i] = l1->data[i];
}
else
{
l3->data[i] = l2->data[i%(l1->length)];
}
}
for(i=0;i<l3->length;i++)
{
for(j=i+1;j<l3->length;j++)
{
if(l3->data[i]>l3->data[j])
{
int temp=l3->data[i];
l3->data[i]=l3->data[j];
l3->data[j]=temp;
}
}
}
}
void Disp_List(LinkList *l)
{
int i=0;
printf("output: ");
for(;i<l->length;i++)
printf("%d ",l->data[i]);
printf(" ");
}
int main()
{
LinkList *l1,*l2,*l3;
int n;
printf("请输入第一个序列的元素个数: ");
scanf("%d",&n);
printf("请输入第一个序列的所有元素: ");
Initial_List(l1,n);
printf("请输入第二个序列的元素个数: ");
scanf("%d",&n);
printf("请输入第二个序列的所有元素: ");
Initial_List(l2,n);
Link(l1,l2,l3);
Disp_List(l3);
return 0;
}
⑼ 数据结构的问题:两张有序顺序表合并成新的有序顺序表
#include<stdio.h>
void main()
{
int i,j,m,n;
int k=0;
int a[]={1,2,4,4,7,9}; //a,b均为旧表,c为新表
int b[]={0,1,3,6,9,10};
int c[20]; //此处取20是为了留足够空间给a,b表合并
m=0;
n=0;
while( n<6 || m<6 )
{
if(m<6 && n<6)
{
if(a[m]>=b[n])
{
c[k++]=b[n++];
}
else
{
c[k++]=a[m++];
}
}
else
{
if(m<6)
{
c[k++]=a[m++];
}
else if(n<6)
{
c[k++]=b[n++];
}
}
}
for(i=0;i<k;i++)
{
printf("%d\n",c[i]); //此处输出C表的数值
}
getchar();
}