单链表全部算法

本篇纯粹体现链表各种操作的具体代码实现，采用了带头结点的单链表，废话不多说，直接上代码+注释：

#include<stdio.h>
#include<stdlib.h>
/*
	链表的结构
*/
typedef struct LNode{
	int data;
	struct LNode*next;
}*LinkList;
/*
	打印链表
*/
void ShowLinkList(LinkList&L);
/*
	初始化链表，使指针指向头结点
*/
void InitList(LinkList&L);
/*
	根据传来的length参数顺序创建多长的链表
*/
void CreateLinkListSequence(LinkList&L,int length);
/*
	根据传来的length参数逆序创建多长的链表
*/
void CreateLinkListReverse(LinkList&L,int length);
/*
	在第i个位置之前插入结点值为data的结点
*/
void InsertList(LinkList&L, int i, int data);
/*
	在第i个位置之前产出结点，并把结点的值返回给data
*/
void DeleteList(LinkList&L, int i, int &data);
/*
	对链表进行排序（非递减）
*/
void SortLinkList(LinkList&L);
/*
	合并两个非递减的链表
*/
void MergetLinkList(LinkList&L1, LinkList&L2, LinkList&L3);
/*
	删除重复的结点,使结点值至多出现一次,不改变结点之间的相对位置
*/
void DeleteRepeatNode(LinkList&L);
/*
	对A表做操作，删除A表中那些即在B表中出现又在C表中出现的元素
*/
void DeleteRepeatNodeAtAListBList(LinkList&A, LinkList&B, LinkList&C);
/* 
	求两个单链表表示的集合的交集，并将结果用一个新的单链表保存并返回
*/
void subsetTwoLinkList(LinkList&La, LinkList&Lb, LinkList&Lc);
/*
	查找链表中倒数第k个位置的结点并返回该节点
*/
LinkList Find_Reverse(LinkList&L, int k);
/*
	将一个单链表拆分成两个单链表，原表保留值为偶数的节点，值为奇数的结点按次序组成新的连表
*/
LinkList SplitToOddNode(LinkList&L);
/*
	//就地逆置链表
*/
LinkList ReversePosition(LinkList&L);

<pre class="cpp" name="code">int IsOrderlyIncrease(LinkList&L){
	LinkList p = L->next;
	int flag = 1;
	while (p->next){
		if (p->data > p->next->data){
			flag = 0;
		}
		p = p->next;
	}
	return flag;//1有序，0无序
}
void ShowLinkList(LinkList&L){
	for (LinkList p = L->next; p; p = p->next){
		printf("%d ", p->data);
	}
}
void InitList(LinkList&L){
	if ((L = (LinkList)malloc(sizeof(LNode))) == NULL){
		printf("分配结点失败\n");
		exit(EXIT_FAILURE);
	}
	L->next = NULL;
}
void CreateLinkListSequence(LinkList&L, int length){
	LinkList head = L;
	LinkList p = head;
	for (int i = 1; i <= length; i++){
		printf("正在创建第%d个结点", i);
		LinkList q = (LinkList)malloc(sizeof(LNode));
		scanf_s("%d", &q->data);
		q->next = p->next;
		p->next = q;
		p = q;
	}
}
void CreateLinkListReverse(LinkList&L, int length){
	LinkList head = L;
	for (int i = 1; i <= length; i++){
		printf("正在创建第%d个结点", i);
		LinkList q = (LinkList)malloc(sizeof(LNode));
		scanf_s("%d", &q->data);
		q->next = head->next;
		head->next = q;
	}
}
void InsertList(LinkList&L, int i, int data){
	LinkList p = L;
	int j = 0;
	while (p&&j < i - 1){
		j++;
		p = p->next;
	}
	if (!p || j>i - 1){
		printf("位置出错\n");
		exit(EXIT_FAILURE);
	}
	LinkList s = (LinkList)malloc(sizeof(LNode));
	s->data = data;
	s->next = p->next;
	p->next = s;
}
void DeleteList(LinkList&L, int i, int &data){
	LinkList p = L;
	int j = 0;
	while (p&&j < i - 1){
		j++;
		p = p->next;
	}
	if (!p || j>i - 1){
		printf("位置出错\n");
		exit(EXIT_FAILURE);
	}
	LinkList s = p->next;
	data = s->data;
	p->next = s->next;
	free(s);
}
void SortLinkList(LinkList&L){
	for (LinkList p = L->next; p; p = p->next){
		LinkList q = p->next;
		for (; q; q = q->next){
			if (p->data > q->data){
				int t = p->data; p->data = q->data; q->data = t;
			}
		}
	}
}
//将非递减的L1和非递减的L2合并成一个L3的非递减序列
void MergetLinkList(LinkList&L1, LinkList&L2, LinkList&L3){
	if (!IsOrderlyIncrease(L1)){
		SortLinkList(L1);
	}
	if (!IsOrderlyIncrease(L2)){
		SortLinkList(L2);
	}
	LinkList p = L1->next;
	LinkList q = L2->next;
	LinkList s = L3;
	while (p&&q){
		if (p->data < q->data){
			s->next = p;
			p = p->next;
			s = s->next;
		}
		else{
			s->next = q;
			q = q->next;
			s = s->next;
		}
	}
	s->next = q ? q : p;
}
//删除重复的结点,使结点值至多出现一次,不改变结点之间的相对位置
void DeleteRepeatNode(LinkList&L){
	LinkList p = L->next;
	LinkList k;
	for (; p; p = p->next){
		LinkList q = p->next;
		k = p;
		for (; q;){
			if (p->data == q->data){
				k->next = q->next;
				free(q);
				q = k->next;
			}
			else{
				k = q;
				q = q->next;
			}
		}
	}
}
//对A表做操作，删除那些即在B表中出现又在C表中出现的元素
void DeleteRepeatNodeAtAListBList(LinkList&A, LinkList&B, LinkList&C){
	LinkList p = A->next;
	LinkList s = A;//p的前驱
	for (; p;){
	RE:LinkList q = B->next;
		for (; q; q = q->next){
			LinkList m = C->next;
			for (; m; m = m->next){
				if ((p->data == q->data) && (p->data == m->data) && (q->data == m->data)){
					s->next = p->next;
					free(p);
					p = s->next;
					goto RE;
				}
			}
		}
		s = p;
		p = p->next;
	}
}
//求两个单链表表示的集合的交集，并将结果用一个新的单链表保存并返回
void SubsetTwoLinkList(LinkList&La, LinkList&Lb, LinkList&Lc){
	LinkList p = La->next;
	LinkList s = Lc;
	for (; p; p = p->next){
		LinkList q = Lb->next;
		for (; q; q = q->next){
			if (p->data == q->data){
				s->next = p;
				s = s->next;
				break;
			}
		}
	}
}
//查找链表中倒数第k个位置的结点并返回该节点
LinkList Find_Reverse(LinkList&L, int k){
	LinkList p = L;
	LinkList q = L;
	while (p){
		k--;
		if (k < 0){
			q = q->next;
		}
		p = p->next;
	}
	return q;
}
//将一个单链表拆分成两个单链表，原表保留值为偶数的节点，值为奇数的结点按次序组成新的连表
LinkList SplitToOddNode(LinkList&L){
	LinkList head, p = L->next, q = L;
	InitList(head);
	LinkList s = head;
	while (p){
		if (p->data % 2 != 0){
			s->next = p;
			q->next = p->next;
			p = p->next;
			s = s->next;
		}
		else{
			q = p;
			p = p->next;
		}
	}
	s->next = NULL;
	return head;
}
//就地逆置链表
LinkList ReversePosition(LinkList&L){
	LinkList head,s;
	InitList(head);
	LinkList p = L->next;
	LinkList q = L->next;
	while (p){
		p = p->next;
		q->next = head->next;
		head->next = q;
		q = p;
	}
	return head;
}

各个函数已经测试编译通过，功能良好。