顺序表合并

题目：

顺序表A和顺序表B的元素都是非递减排列，利用线性表的基本运算，将它们合并成一个顺序表C，

要求顺序表C中的元素也是非递减排列。例如，A=(6,11,11,23)，B=(2,10,12,12,21)，则C=(2,6,11,

11,12,12,21,23)。

代码：

#include<stdio.h>					/*包含输入输出头文件*/
#include"SeqList.h"					/*包含顺序表实现文件*/

// #define ListSize 100
// typedef int DataType;
// typedef struct
// {
// 	DataType list[ListSize];
// 	int length;
// }SeqList;

void MergeList(SeqList A,SeqList B,SeqList *C);	/*合并顺序表A和B中元素的函数声明*/
void main()
{
int i,flag;
DataType a[]={6,11,11,23};
DataType b[]={2,10,12,12,21};
DataType e;
SeqList A,B,C;					/*声明顺序表A，B和C*/
InitList(&A);					/*初始化顺序表A*/
InitList(&B);					/*初始化顺序表B*/
InitList(&C);					/*初始化顺序表C*/

printf("sizeof(a)___%lu\n",sizeof(a));
printf("sizeof(a[0])__%lu\n",sizeof(a[0]));

for(i=1;i<=sizeof(a)/sizeof(a[0]);i++)				/*将数组a中的元素插入到顺序表A中*/
{
if(InsertList(&A,i,a[i-1])==0)
{
printf("位置不合法");
return;
}
}
for(i=1;i<=sizeof(b)/sizeof(b[0]);i++)				/*将数组b中元素插入到顺序表B中*/
{
if(InsertList(&B,i,b[i-1])==0)
{
printf("位置不合法");
return;
}
}
printf("顺序表A中的元素：\n");
for(i=1;i<=A.length;i++)		/*输出顺序表A中的每个元素*/
{
flag=GetElem(A,i,&e);		/*返回顺序表A中的每个元素到e中*/
if(flag==1)
printf("%4d",e);
}
printf("\n");
printf("顺序表B中的元素：\n");
for(i=1;i<=B.length;i++)		/*输出顺序表B中的每个元素*/
{
flag=GetElem(B,i,&e);		/*返回顺序表B中的每个元素到e中*/
if(flag==1)
printf("%4d",e);
}
printf("\n");
printf("将在A中出现B的元素合并后C中的元素：\n");
MergeList(A,B,&C);					/*将在顺序表A和B中的元素合并*/
for(i=1;i<=C.length;i++)			/*显示输出合并后C中所有元素*/
{
flag=GetElem(C,i,&e);
if(flag==1)
printf("%4d",e);
}
printf("\n");

}
void MergeList(SeqList A,SeqList B,SeqList *C)
/*合并顺序表A和B的元素到C中，并保持元素非递减排序*/
{
int i,j,k;
DataType e1,e2;
i=1;j=1;k=1;
while(i<=A.length&&j<=B.length)
{
GetElem(A,i,&e1);				/*取出顺序表A中的元素*/
GetElem(B,j,&e2);				/*取出顺序表B中的元素*/
if(e1<=e2)						/*比较顺序表A和顺序表B中的元素*/
{
InsertList(C,k,e1);			/*将较小的一个插入到C中*/
i++;						/*往后移动一个位置，准备比较下一个元素*/
k++;
}
else
{
InsertList(C,k,e2);			/*将较小的一个插入到C中*/
j++;						/*往后移动一个位置，准备比较下一个元素*/
k++;
}

}
while(i<=A.length)					/*如果A中元素还有剩余，这时B中已经没有元素*/
{
GetElem(A,i,&e1);
InsertList(C,k,e1);				/*将A中剩余元素插入到C中*/
i++;
k++;
}
while(j<=B.length)					/*如果B中元素还有剩余，这时A中已经没有元素*/
{
GetElem(B,j,&e2);
InsertList(C,k,e2);				/*将B中剩余元素插入到C中*/
j++;
k++;
}
C->length=A.length+B.length;		/*C的表长等于A和B的表长的和*/
}

头文件：

#define ListSize 100
typedef int DataType;
typedef struct
{
DataType list[ListSize];
int length;
}SeqList;

/*将线性表初始化为空的线性表只需要把线性表的长度length置为0*/
void InitList(SeqList *L)
{
L->length=0; /*把线性表的长度置为0*/
}

/*判断线性表是否为空，线性表为空返回1，否则返回0*/
int ListEmpty(SeqList L)
{
if(L.length==0) /*判断线性表的长度是否为9*/
return 1; /*当线性表为空时，返回1；否则返回0*/
else
return 0;
}

/*查找线性表中第i个元素。查找成功将该值返回给e，并返回1表示成功；否则返回-1表示失败。*/
int GetElem(SeqList L,int i,DataType *e)
{
if(i<1||i>L.length) /*在查找第i个元素之前，判断该序号是否合法*/
return -1;
*e=L.list[i-1]; /*将第i个元素的值赋值给e*/
return 1;
}

/*查找线性表中元素值为e的元素，查找成功将对应元素的序号返回，否则返回0表示失败。*/
int LocateElem(SeqList L,DataType e)
{
int i;
for(i=0;i<L.length;i++) /*从第一个元素开始比较*/
if(L.list[i]==e)
return i+1;
return 0;
}

/*在顺序表的第i个位置插入元素e，插入成功返回1，如果插入位置不合法返回-1，顺序表满返回0*/
int InsertList(SeqList *L,int i,DataType e)
{
int j;
if(i<1||i>L->length+1) /*在插入元素前，判断插入位置是否合法*/
{
printf("插入位置i不合法！\n");
return -1;
}
else if(L->length>=ListSize) /*在插入元素前，判断顺序表是否已经满，不能插入元素*/
{
printf("顺序表已满，不能插入元素。\n");
return 0;
}
else
{
for(j=L->length;j>=i;j--) /*将第i个位置以后的元素依次后移*/
L->list[j]=L->list[j-1];
L->list[i-1]=e; /*插入元素到第i个位置*/
L->length=L->length+1; /*将顺序表长增1*/
return 1;
}
}

int DeleteList(SeqList *L,int i,DataType *e)
{
int j;
if(L->length<=0)
{
printf("顺序表已空不能进行删除!\n");
return 0;
}
else if(i<1||i>L->length)
{
printf("删除位置不合适!\n");
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;
}


输出：

sizeof(a)___16                                                                                                                                                            

sizeof(a[0])__4                                                                                                                                                           

顺序表A中的元素：                                                                                                                                                         

   6  11  11  23                                                                                                                                                          

顺序表B中的元素：                                                                                                                                                         

   2  10  12  12  21                                                                                                                                                      

将在A中出现B的元素合并后C中的元素：                                                                                                                                       

   2   6  10  11  11  12  12  21  23