C语言归并两个递增单链表

题目

解答

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

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList; //指向单链表结点的指针 

/*初始化单链表L*/
int InitList_L(LinkList *L){
	(*L) = (LinkList)malloc(sizeof(LNode));
	if(!(*L))
		exit(0);
	(*L)->next = NULL;  //将首元结点置为空
	return 1;
}

/*在单链表L第i个位置之前插入e*/
int ListInsert_L(LinkList L, int i, int e){
	LinkList p, s;
	int j;
	
	p = L;
	j = 0; 
	
	while(p && j<i-1){  //寻找第i-1个结点 
		p = p->next;
		++j;
	}
	
	if(!p || j>i-1)
		return 0;

	s = (LinkList)malloc(sizeof(LNode));
	if(!s)
		exit(0);
	s->data = e;
	s->next = p->next;
	p->next = s;

	return 1;
}

/*归并两个递增单链表为一个递增单链表*/
int Algo_1(LinkList La, LinkList *Lb, LinkList *Lc){
	LinkList pa, pb, qa, qb, s;

	/*La或Lb有一个不存在或两个均为空表时，合并错误*/
	if(!La || !Lb || (!La->next && !(*Lb)->next))
		return 0;
	
	*Lc = La;	//利用La的头结点作Lc的头结点
	pa = La; //令pa指向La的头结点【作为新链表的尾结点指针使用】
	qa = La->next; //令qa指向La的首元结点
	qb = (*Lb)->next; //令qb指向Lb的首元结点
	
	/*采尾插法建立递增链表*/
	/*谁小谁先插-->到最后大的在后面，小的在前面*/
	while(qa && qb){ //当La和Lb都未遍历完时
		if(qa->data<=qb->data){ //如果La中结点小，则La中结点插入
			pa->next = qa;  //将qa接到尾结点后面
			pa = qa;  //尾结点指针后移指向新的尾部
			qa = qa->next; //qa指向下一个结点
		} 
		else{ //如果Lb中结点小，则Lb中结点插入
			pa->next = qb;  //将qb接到尾结点后面
			pa = qb;  //尾结点指针后移指向新的尾部
			qb = qb->next; //qb指向下一个结点
		}
	}
	
	/*如果La中还有剩余结点，则剩余结点继续尾插*/
	while(qa){ 
		pa->next = qa;  
		pa = qa; 
		qa = qa->next;
	}
	
	/*如果Lb中还有剩余结点，则剩余结点继续尾插*/
	while(qb){
		pa->next = qb;  
		pa = qb; 
		qb = qb->next;
	}
	 
	pa->next=NULL; //构造好的链表的尾结点置为空
		
	free(*Lb); //释放Lb结点的空间
	
	return 1;
}

/*归并两个递增单链表为一个递减单链表*/
int Algo_2(LinkList La, LinkList *Lb, LinkList *Lc){
	LinkList qa, qb, s;

	/*La或Lb有一个不存在或两个均为空表时，合并错误*/
	if(!La || !Lb || (!La->next && !(*Lb)->next))
		return 0;
	
	*Lc = La;	//利用La的头结点作Lc的头结点
	qa = La->next; //令qa指向La的首元结点
	qb = (*Lb)->next; //令qb指向Lb的首元结点
	La->next = NULL; //将La头结点的next置为空
	
	/*采用头插法建立递减链表*/
	/*谁小谁先插-->到最后小的在后面，大的在前面*/
	while(qa && qb){ //当La和Lb都未遍历完时
		if(qa->data<=qb->data){ //如果La中结点小，则La中结点插入
			s = qa->next;    //令s指向La中结点的next
			qa->next = La->next; //La中结点的next指向La头结点的next
			La->next = qa; //La头结点的next指向La中结点
			qa = s; //令qa继续指向La中的下一个结点
		} 
		else{ //如果Lb中结点小，则Lb中结点插入
			s = qb->next;  //令s指向Lb中结点的next
			qb->next = La->next; //Lb中结点的next指向La头结点的next
			La->next = qb; //La头结点的next指向Lb中结点
			qb = s; //令qb继续指向Lb中的下一个结点
		}
	}
	
	/*如果La中还有剩余结点，则剩余结点继续头插*/
	while(qa){ 
		s = qa->next;
		qa->next = La->next;
		La->next = qa;
		qa = s;
	}
	
	/*如果Lb中还有剩余结点，则剩余结点继续头插*/
	while(qb){
		s = qb->next;
		qb->next = La->next;
		La->next = qb;
		qb = s;
	}
		
	free(*Lb); //释放Lb结点的空间
	
	return 1;
}

/*递归法正序打印单链表【初始传入的L为首元结点】*/
void ListTraverse(LinkList L){
	if(L==NULL)  //递归的结束条件
		return;
	else{
		printf("%d ",L->data);  //先打印当前节点的数据
		ListTraverse(L->next); //递归单链表
	}
}

int main(){
	LinkList La, Lb, Lc;
	LinkList Ld, Le, Lf;
	int i;
	/*利用La和Lb的结点空间构造递增单链表Lc*/
	if(InitList_L(&La) && InitList_L(&Lb) && InitList_L(&Lc)){ 
		for(i=1; i<=5; i++){ //创建链表La和Lb
			ListInsert_L(La, i, 2*i-1);
			ListInsert_L(Lb, i, 2*i);		
		} 	
	}
	printf("创建好的链表为：\n");
	printf("La = ");
	ListTraverse(La->next); 	
	printf("\n");	
	printf("Lb = ");
	ListTraverse(Lb->next); 			
	printf("\n");	
	Algo_1(La, &Lb, &Lc);	
	printf("递增归并La和Lb为Lc = ");
	ListTraverse(Lc->next); 	
	printf("\n");			
	/*利用Ld和Le的结点空间构造递减单链表Lf*/
	if(InitList_L(&Ld) && InitList_L(&Le) && InitList_L(&Lf)){ 
		for(i=1; i<=5; i++){
			ListInsert_L(Ld, i, 2*i-1);
			ListInsert_L(Le, i, 2*i);		
		} 	
	}
	printf("创建好的链表为：\n");
	printf("Ld = ");
	ListTraverse(Ld->next); 	
	printf("\n");	
	printf("Le = ");
	ListTraverse(Le->next); 			
	printf("\n");	
	Algo_2(Ld, &Le, &Lf);	
	printf("递减归并Ld和Le为Lf = ");
	ListTraverse(Lf->next); 	
	printf("\n");			
	return 0;
}