工程实践1 模块化训练 链表（有序）合并 数组（有序）合并

1.链表合并

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status; //Status 为函数的类型，其值是函数结果状态代码，如OK等
typedef int ElemType; // ElemType为数据元素类型，根据实际情况而定，这里假设为int 
struct LNode               /* 结点定义 */     
 {
   ElemType data;
   struct LNode *next;
 };
typedef struct LNode *LinkList; /* 表的头指针类型 */

Status GetElem(LinkList L,int i,ElemType *e)
 { 
   int j=1; /* j为计数器 */
   LinkList p=L; /* p指向第一个结点 */
   while(j<i) /* 顺指针向后查找, 直到p指向第i个元素*/
   {
     p=p->next;
     j++;
   } 	
   *e=p->data;   /* 取第i个元素 */
   return OK;
 }
Status ListLength(LinkList L)
{
	int i=0;//计数器
	LinkList p =L;
	while(p)
	{
		i++;
		p=p->next;
	}
	
	return i;
}
Status LocateElem(LinkList L,ElemType e,Status compare(ElemType a,ElemType b))
{
	/*初始条件：线性表L已存在，compare()是数据元素判定函数（满足为1，不满足为0）*/
	/*操作结果：若这样的数据元素存在，则返回值为1。若这样的数据元素不存在，则返回值为0*/
	int i=0;
	LinkList p=L;
	while(p)
	{
		if(compare(p->data,e))
		{
			return 1;
		}
		p=p->next;
	}
	return 0;
}
Status equal (ElemType a,ElemType b)
{
	/*equal()是数据元素判定函数（满足为1，不满足为0）*/
	if(a==b)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
Status ListInsert(LinkList L,Status i,Status e)
{
	/*操作结果：在单链线性表之后插入元素e*/
	int j=0;
	i--;
	LinkList p=L,s;
	while(j<i-1)/*通过循环让p指向链表末尾*/
	{
		p=p->next;
		j++;
	}
	s=(LinkList)malloc(sizeof(struct LNode));/*生成新节点*/
	s->data=e;/*插入L中*/
	s->next=NULL;
	p->next=s;
	return OK;
}
void Union(LinkList *La, LinkList *Lb) 
 { // 将所有在表Lb（代表B集合）中但不在La（代表A集合）中的数据元素插入到La中
	int La_len,Lb_len;
	int i;
	ElemType e;
   La_len=ListLength(*La); // 求表La的长度
   Lb_len=ListLength(*Lb);
   for(i=1;i<=Lb_len;i++)
   {
      GetElem(*Lb,i,&e); // 取表Lb中第i个数据元素赋给变量e
     if(!LocateElem(*La,e,equal)) // 表La中不存在和e相同的元素,则将e插入La中
       ListInsert(*La,++La_len,e);
   }
 }
void input(LinkList *L)/*尾插法创建链表*/
{
	ElemType data;
	LinkList head=NULL, cur, tail;
	scanf("%d",&data);
	while(data!=0)/*data输入为0为止*/
	{
		cur=(LinkList)malloc(sizeof(struct LNode));
		cur->data=data;
		cur->next=NULL;
		if(head==NULL)
		{
			head=cur;
		}
		else
		{
			tail->next=cur;//把cur接到尾节点上
		}
		tail=cur;//cur成为新的尾节点
		scanf("%d",&data);
	}
	*L=head;
}
void output(LinkList *L)
{
	LinkList p=*L;
	while(p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;
	}
}
int main ()
{
	LinkList p1,p2;
	printf("请输入链表1的数据，输入0结束\n");
	input(&p1);
	printf("请输入链表2的数据，输入0结束\n");
	input(&p2);
	Union(&p1,&p2);
	printf("合并完成\n");
	output(&p1);
	return 0;
}

2.链表有序合并

#include<stdio.h>
#include<stdlib.h>

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status; //Status 为函数的类型，其值是函数结果状态代码，如OK等
typedef int ElemType;  // ElemType为数据元素类型，根据实际情况而定，这里假设为int 
struct LNode               /* 结点定义 */     
 {
   ElemType data;
   struct LNode *next;
 };
 typedef struct LNode *LinkList; /* 表的头指针类型 */
 Status GetElem(LinkList L,int i,ElemType *e)
 { 
   int j=1; /* j为计数器 */
   LinkList p=L; /* p指向第一个结点 */
   while(j<i) /* 顺指针向后查找, 直到p指向第i个元素*/                                                  
   {
     p=p->next;
     j++;
   } 
   *e=p->data;   /* 取第i个元素 */
   return OK;
 }
 Status ListLength(LinkList L)
{
	int i=0;//计数器
	LinkList p =L;
	while(p)
	{
		i++;
		p=p->next;
	}
	return i;
}
 Status ListInsert(LinkList *L,int i,Status e)
{
	/*操作结果：在带头节点的单链线性表L中第i个位置之前插入元素e*/
	LinkList p,s;
	s=(LinkList)malloc(sizeof(struct LNode));
	s->data=e;
	s->next=NULL;
	int j=0;
	if(*L==NULL)
	{
		*L=s;
	}
	p=*L;
	while(p->next!=NULL)//移到链表末尾
	{
		p=p->next;
	}
	if(i!=1)
	{
		p->next=s;
	}
	return OK;
}
  void MergeList(LinkList La, LinkList Lb, LinkList *Lc) 
 { /* 已知表La和Lb中的数据元素按值非递减排列。 */
   /* 归并La和Lb得到新的表Lc,Lc的数据元素也按值非递减排列 */
	 int i,j,k,La_len,Lb_len;
	 ElemType ai,bj;
   i=j=1;k=0;
   La_len=ListLength(La);
   Lb_len=ListLength(Lb);
   while(i<=La_len&&j<=Lb_len)          /* 表La和表Lb均非空 */
   {
     GetElem(La,i,&ai);
     GetElem(Lb,j,&bj);
     if(ai<=bj)
     {
       ListInsert(Lc,++k,ai);
       ++i;
     }
     else
     {
       ListInsert(Lc,++k,bj);
       ++j;
     }
   }
   while(i<=La_len)                /* 表La非空且表Lb空 */
   {
     GetElem(La,i++,&ai);
     ListInsert(Lc,++k,ai);
   }
   while(j<=Lb_len)                /* 表Lb非空且表La空 */
   {
     GetElem(Lb,j++,&bj);
     ListInsert(Lc,++k,bj);
   }
 }
void input(LinkList *L)/*尾插法创建链表*/
{
	ElemType data;
	LinkList head=NULL, cur, tail;
	scanf("%d",&data);
	while(data!=0)/*data输入为0为止*/
	{
		cur=(LinkList)malloc(sizeof(struct LNode));
		cur->data=data;
		cur->next=NULL;
		if(head==NULL)
		{
			head=cur;
		}
		else
		{
			tail->next=cur;//把cur接到尾节点上
		}
		tail=cur;//cur成为新的尾节点
		scanf("%d",&data);
	}
	*L=head;
}
void output(LinkList *L)
{
	LinkList p=*L;
	while(p!=NULL)
	{
		printf("%d ",p->data);
		p=p->next;
	}
}
 int main ()
{
	LinkList La,Lb,Lc=NULL;
	printf("请输入链表a的数据，输入0结束\n");
	input(&La);
	printf("请输入链表b的数据，输入0结束\n");
	input(&Lb);
	MergeList(La,Lb,&Lc);
	printf("合并完成\n");
	output(&Lc);
	return 0;
}

3.数组合并

#include<stdio.h>
#include<stdlib.h>
#define MAXSIZE 50          /* 存储空间初始分配量 */
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status; //Status 为函数的类型，其值是函数结果状态代码，如OK等
typedef int ElemType; // ElemType为数据元素类型，根据实际情况而定，这里假设为int  

typedef struct
{
	ElemType data[MAXSIZE];  /* 数组，存储数据元素 */
	int length;              /* 表当前有效长度 */
}SqList;  

Status GetElem(SqList L,int i,ElemType *e)
{
    *e=L.data[i-1];
    return OK;
}
Status ListLength(SqList L)
{
	return L.length;
}
Status equal(ElemType a1,ElemType a2)
{
	if(a1==a2)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}
Status LocateElem(SqList L, ElemType e, Status compare(ElemType a1,ElemType a2))
{
	int i;
	for(i=1;i<=L.length;i++)
	{
		if(compare(L.data[i-1],e))
		{
			return 1;
		}
	}
	return 0;
}
Status ListInsert(SqList *L,ElemType i,ElemType e)
{
	L->data[i-1]=e;
	L->length++;
	return OK;
}
void Union(SqList *La,SqList Lb)
 { /* 将所有在表Lb中但不在La中的数据元素插入到La中 */
   ElemType e;
   int La_len,Lb_len;
   int i;
   La_len=ListLength(*La); /* 求表La的长度 */
   Lb_len=ListLength(Lb);
   for(i=1;i<=Lb_len;i++)
   {
     GetElem(Lb,i,&e); /* 取Lb中第i个数据元素赋给e */
     if(!LocateElem(*La,e,equal)) /* La中不存在和e相同的元素,则插入之 */
       ListInsert(La,++La_len,e);
   }
 }
void input(SqList *L)
{
	int a,i;
	printf("请输入数据长度\n");
	scanf("%d",&a);
	L->length=a;
	printf("请输入数据\n");
	for(i=0;i<a;i++)
	{
		scanf("%d",&L->data[i]);
	}
}
void output(SqList *L)
{
	int i;
	for(i=0;i<L->length;i++)
	{
		printf("%d ",L->data[i]);
	}
}
int main ()
{
	SqList La,Lb;
	input(&La);
	input(&Lb);
	Union(&La,Lb);
	printf("合并完成\n");
	output(&La);
	
	return 0;
}

4.数组有序合并

#include<stdio.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status; //Status 为函数的类型，其值是函数结果状态代码，如OK等
typedef int ElemType;  // ElemType为数据元素类型，根据实际情况而定，这里假设为int 
#define MAXSIZE 50          /* 存储空间初始分配量 */
typedef struct
{
	ElemType data[MAXSIZE];  /* 数组，存储数据元素 */
	int length;              /* 表当前有效长度 */
}SqList;   
Status GetElem(SqList L,int i,ElemType *e)
{ /* 操作结果：用e返回L中第i个数据元素的值,
             注意i是指位置，第1个位置的数组是从0开始 */
    *e=L.data[i-1];
    return OK;
}
Status ListLength(SqList L)
{
	return L.length;
}
Status ListInsert(SqList *L,ElemType i,ElemType e)
{
	L->data[i-1]=e;
	L->length++;
	return OK;
}
void MergeList(SqList La, SqList Lb, SqList *Lc) 
 { /* 已知表La和Lb中的数据元素按值非递减排列。 */
   /* 归并La和Lb得到新的表Lc,Lc的数据元素也按值非递减排列 */
	 int i,j,k,La_len,Lb_len;
   i=j=1;
	k=0;
	ElemType ai,bj;
   La_len=ListLength(La);
   Lb_len=ListLength(Lb);
   while(i<=La_len&&j<=Lb_len)          /* 表La和表Lb均非空 */
   {
     GetElem(La,i,&ai);
     GetElem(Lb,j,&bj);
     if(ai<=bj)
     {
       ListInsert(Lc,++k,ai);
       ++i;
     }
     else
     {
       ListInsert(Lc,++k,bj);
       ++j;
     }
   }
   while(i<=La_len)                /* 表La非空且表Lb空 */
   {
     GetElem(La,i++,&ai);
     ListInsert(Lc,++k,ai);
   }
   while(j<=Lb_len)                /* 表Lb非空且表La空 */
   {
     GetElem(Lb,j++,&bj);
     ListInsert(Lc,++k,bj);
   }
  
 }
void input(SqList *L)
{
	int a,i;
	printf("请输入数据长度\n");
	scanf("%d",&a);
	L->length=a;
	printf("请输入数据\n");
	for(i=0;i<a;i++)
	{
		scanf("%d",&L->data[i]);
	}
}
void output(SqList *L)
{
	int i;
	for(i=0;i<L->length;i++)
	{
		printf("%d ",L->data[i]);
	}
}
int main ()
{
	SqList La,Lb,Lc;
	Lc.length=0;
	input(&La);
	input(&Lb);
	 MergeList(La,Lb,&Lc);
	 output(&Lc);
	return 0;
}