王道考研数据结构链表专题

王道后面的链表的代码实现：
link.h

#pragma once
typedef int ElemType;
typedef char Element;

typedef struct Node {
	Element data;
	struct Node* next;
}Node,* Link;

//定义一个单链表结点
typedef struct LNOde
{
	ElemType data;
	struct LNOde* next;
}LNode, * LinkList;
//定义一个双链表结点
typedef struct DNode {
	ElemType data;
	struct DNode* proir, * next;
}DNode, *DLinklist;
//定义一个Locate双链表结点
typedef struct Dlnode {
	ElemType data;
	struct Dlnode* prior, * next;
	ElemType freg;	//表示调用频度
}Dlnode, *DlocateList;

//数组尾插法建立单词单链表
void listchar_RailInsert(Link& L, char arr[], int len);
//正向建立循环双链表
void DlinkRailInsert(DLinklist& L ,int drr[], int len);
//数组尾插法建立单链表
void list_RailInsert1(LinkList& L, int arr[], int len);
//数组尾插法建立循环单链表
void list_RailInsertCycle(LinkList& L, int arr[], int len);
//遍历单链表
void arrayList(LinkList L);
//遍历输出循环单链表
void arrListCycle(LinkList L);
//1.递归删除不带头节点的单链表
void del_value(LinkList& L,ElemType x);
//2.一遍顺序扫描带头结点的单链表删除指定元素
void del_f(LinkList& L, ElemType x);
// 3. 反向输出带头结点单链表的每个节点的值
void ouputData(LinkList L);
//4.编写在带头结点的单链表L中删除一个最小节点的高效算法(假设最小节点值唯一)
void del_MinNode(LinkList& L);
void del_MinNode2(LinkList& L);
//5.将带头结点的单链表就地逆置(空间复杂度O(1))
void reverse(LinkList L);
//5.将带头结点的单链表就地逆置(空间复杂度O(1))
void reverse2(LinkList L);
//6.使带头节点的单链表元素递增有序
void addOrderly(LinkList L);

//7.在无序链表中删除给定的范围内元素的值
void del_values(LinkList& L, ElemType x, ElemType y);
// 7.在无序链表中删除给定的范围内元素的值
void del_values2(LinkList & L, ElemType x, ElemType y);

//8.找出两个单链表的公共节点
void findCommonNode(LinkList L1, LinkList L2);

//9.按递增次序输出单链表中各节点的数据元素，并释放节点所占的存储空间
void outputElement(LinkList L);

//10.将一个带头结点的单链表A分解为两个带头结点的单链表A和B，使得A原奇，B原偶
LinkList resolve(LinkList &L);

//11.将线性表拆分为两个单链表
LinkList decompose(LinkList &L);

//11.将线性表拆分为两个单链表
LinkList decompose2(LinkList& A);

//12.设计算法删除递增有序的单链表中出现的重复元素
void del_Element(LinkList& L);

//13.将两个有序递增单链表合并为递减单链表，并利用原来两个单链表的结点存放归并后的单链表
LinkList combine(LinkList& L1, LinkList& L2);

//14.设计算法从递增有序的单链表A和B中提取出公共元素产生单链表C，要求不破坏A、B结点
void extractCommon(LinkList L1, LinkList L2);

//15、两个递增有序的链表分别表示两个集合，编写函数求A、B交集存放于A集合中
void merge(LinkList& La, LinkList& Lb);

//16.判断单链表B是否包含单链表B
int contain(LinkList& La, LinkList& Lb);

//17.设计一个算法用于判断带头结点的循环双链表是否对称
int symmetry(DLinklist L);

//18. 合并两个循环单链表，使合并后的链表仍保持循环单链表形式
void combine2(LinkList La, LinkList Lb);

//19.设计算法寻找带头结点的循环单链表的最小值输出并删除，直到单链表为空，然后删除头结点
void del_MinAll(LinkList& L);

//20.locate(L,X)函数的编写 
void initlocate(DlocateList &L, int a[], int len);
//void locate(DlocateList L, int x);

//21.编写算法求倒数第k个结点的值
int fundkValue(LinkList L,int k);

//22.找出单链表保存的单词具有相同的后缀的第一个单词
void findCommon(Link La, Link Lb);

//23.删除重复元素值(包括绝对值)，只保留第一个出现的元素
void delCommonValue(LinkList& L,int m);

//24.判断一个链表是否有环，有环则输出环的起始点
int isCycle(LinkList L);

//25.链表的重新排序
void resortLink(LinkList& L);

LinkPratice.cpp

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


//数组尾插法建立单词单链表
void listchar_RailInsert(Link& L, char arr[], int len) {
	L = (Link)malloc(sizeof(Node));//创建头结点
	Node* s, * r = L;//r表示尾指针
	L->next = NULL;
	int i = 0;
	while (i < len) {
		s = (Node*)malloc(sizeof(Node));//建立一个新的节点
		s->data = arr[i++];
		r->next = s;
		r = s;
	}
	r->next = NULL;//尾指针置空;
	Node* p = L->next;
	while (p) {
		printf("%c", p->data);
		p = p->next;
	}
	printf("\n");
}
//数组尾插法建立单链表
void list_RailInsert1(LinkList& L,int arr[],int len) {
	int x;
	L = (LinkList)malloc(sizeof(LNOde));//创建头结点
	LNOde* s, * r = L;//r表示尾指针
	L->next = NULL;
	
	int i = 0;
	while (i<len) {
		s = (LNOde*)malloc(sizeof(LNOde));//建立一个新的节点
		s->data = arr[i++];
		r->next = s;
		r = s;
	}
	r->next = NULL;//尾指针置空;

}

//数组尾插法建立循环单链表
void list_RailInsertCycle(LinkList& L, int arr[], int len) {
	int x;
	L = (LinkList)malloc(sizeof(LNOde));//创建头结点
	LNOde* s, * r = L;//r表示尾指针
	L->next = NULL;

	int i = 0;
	while (i < len) {
		s = (LNOde*)malloc(sizeof(LNOde));//建立一个新的节点
		s->data = arr[i++];
		r->next = s;
		r = s;
	}
	r->next = L;//尾指针指向头结点;
}

//指针显示输出链表
void arrayList(LinkList L) {
	LNOde* first;
	first = L->next;
	while (first) {
		printf("%d ", first->data);
		first = first->next;
	}
	printf("\n");
}

//正向建立循环双链表(尾插法)
void DlinkRailInsert(DLinklist& L, int drr[], int len) {
	L = (DLinklist)malloc(sizeof(DNode));//创建循环链表头结点
	DNode* r = L;	//尾指针
	L->next = NULL;
	for (int i = 0; i < len; i++)
	{
		int x = drr[i];
		DNode* s = (DNode*)malloc(sizeof(DNode));//每次创建结点
		s->data = x;
		r->next = s;
		s->proir = r;
		r = s;
	}
	r->next = L;
	L->proir = r;

	DNode* p = L->next;
	while (p != L) {
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

//1.递归删除不带头节点的单链表
void del_value(LinkList& L, ElemType x) {

	LNOde* p;//指向待删除的节点
	if (L == NULL) {
		return;			//递归的出口
	}
	if (L->data == x) {	//查找到值为x的L
		p = L;
		L = L->next;
		free(p);
		del_value(L, x);	//递归调用
	}
	else {				//若L指向的值不为x
		del_value(L->next, x);	 //递归调用
	}
}

//2.一遍顺序扫描带头结点的单链表删除指定元素
void del_f(LinkList& L, ElemType x) {
	LNOde* head = L->next; LNOde* pre = L, * q;//声明一个头结点,维护一个前驱
	while (head) {
		if (head->data == x) {	//查找到要删除的元素
			q = head;
			head = head->next;
			pre->next = head;	//删除*q节点
			free(q);		 // 释放*q节点的空间

		}
		else {
			head = head->next;
			pre = pre->next;
		}
	}
}

//3. 反向输出带头结点单链表的每个节点的值
void ouputData(LinkList L) {
	//LNOde* p = L, temp;//指针p表示头结点
	//LNOde* head = L->next;//头指针
	//p->next = head;
	//if (L->next != NULL) {
	//	head = head->next;
	//}
	//if (L->next == NULL) {	//到达最尾部就输出
	//	
	//	printf("%d ", L->data);
	//	ouputData(p);
	//}

	if (L->next != NULL) {		
		ouputData(L->next);
	}
	if (L != NULL) printf("%d ", L->data);
}

//4.编写在带头结点的单链表L中删除一个最小节点的高效算法(假设最小节点值唯一)
void del_MinNode(LinkList& L) {
	LNOde* min = L->next; LNOde* head = L->next; LNOde* p;
	while (head) {
		if (head->data < min->data) {
			min = head;
		}
		head = head->next;
	}
	int x = min->data;//最小元素的值 
	while (head){
		if (head->data == x) {
			p = head->next;// p指向最小元素节点的下一个节点
			head->data = head->next->data;//交换元素
			head->next = p->next;//将最小元素断链
			free(p);
		}
		head = head->next;
	}

}

//4.编写在带头结点的单链表L中删除一个最小节点的高效算法(假设最小节点值唯一)
void del_MinNode2(LinkList& L) {
	LNOde* pre = L, * p = pre->next;	//表示当前节点的前驱指针和当前指针;
	LNOde* minpre = pre, * minp = p;//表示最小节点的前驱指针和最小指针;
	while (p!=NULL) {
		if (p->data < minp->data) {
			minpre = pre;
			minp = p;
		}
		pre = p;
		p = p->next;
	}
	minpre->next = minp->next;	//删除最小节点
	free(minp);
}

//5.将带头结点的单链表就地逆置(空间复杂度O(1))
void reverse(LinkList L) {
	LNOde* p, * s;
	p = L->next;
	L->next = NULL;
	while (p != NULL) {
		s = p->next;
		p->next = L->next ;
		L->next = p;
		p = s;
	}
}

//5.将带头结点的单链表就地逆置(空间复杂度O(1))
void reverse2(LinkList L) {
	LNOde* p, * r;	//p为工作指针，r为p的后继，以防断链
	p = L->next;	//从L的第一个元素开始
	L->next = NULL;	//先将L的next域置空
	while (p != NULL) {	//依次将节点摘下
		r = p->next;	//暂存p的后继
		p->next = L->next;	//将p插入到头结点之后
		L->next = p;
		p = r;
	}
}

//6.使带头节点的单链表元素递增有序
void addOrderly(LinkList L) {
	LNode* p, * s;//表示当前工作指针和p的后继
	p = L->next;
	L->next = NULL;
	while (p != NULL) {	//开始断链
		s = p->next;
		
	}

}

//7.在无序链表中删除给定的范围内元素的值
void del_values(LinkList &L,ElemType x,ElemType y) {
	LNOde* p = L->next, * s;//p表示工作指针,s表示指向p的后继节点
	while (p) {
		if (p->data > x && p->data < y) {//找到符合条件的节点
			s = p->next;
			p->data = p->next->data;//将后继节点的值复制给p，然后只要删除s即可
			p->next->next = s->next;
			free(s);//释放空间
		}
		else {
			p = p->next;
			s = p->next;
		}
	}
}

//7.在无序链表中删除给定的范围内元素的值
void del_values2(LinkList& L, ElemType x, ElemType y) {
	LNOde* pre = L, * p = L->next;//表示当前节点的前驱和当前节点
	while (p) {
		if (p->data > x && p->data < y) {//找到符合条件的节点就删除
			pre->next = p->next;
			free(p);
			p = pre->next;
		}
		else {
			pre = p;
			p = p->next;
		}
	}
}

//8.找出两个单链表的公共节点
void findCommonNode(LinkList L1, LinkList L2) {
	LNOde* L1head = L1->next, * L2head = L2->next;//分别指向L1和L2的第一个节点
	while (L1head) {
		while (L2head) {
			if (L2head->data == L1head->data) {
				printf("%d ", L2head->data);//相同就直接输出
			}
			
				L2head = L2head->next;
			
		}
		L1head = L1head->next;		//L1指向下一个元素
		L2head = L2->next;			//每次比完后恢复原位
	}
}

//9.按递增次序输出单链表中各节点的数据元素，并释放节点所占的存储空间
void outputElement(LinkList L) {

}

//10.将一个带头结点的单链表A分解为两个带头结点的单链表A和B，使得A原序号奇，B原序号偶
LinkList resolve(LinkList &A) {
	LinkList B; int count = 0;
	B = (LinkList)malloc(sizeof(LNOde));	//创建B表表头
	B->next = NULL;		//初始化B表
	LNode* ra = A, *rb = B;			//ra和rb分别指向A和B的尾指针
	LNOde* p = A->next, * s;//p为工作指针
	A->next = NULL;//将A初始化
	while (p) {
		count++;
		//s = p->next;	//s为p的后继
		if ((count & 1) == 0) {	// 序号偶数则存在B中
			rb->next = p;
			rb = p;
		}
		else {			// 序号奇数则存在A中
			ra->next = p;
			ra = p;
		}
		p = p->next;
	}
	ra->next = NULL; rb->next = NULL;
	return B;
}

//11.将线性表拆分为两个单链表
LinkList decompose(LinkList &A) {
	LinkList B = (LinkList)malloc(sizeof(LNOde));	//创建B表头
	B->next = NULL;		//B表初始化
	LNOde* b = B, * a = A;//a为表头指针，b为表尾指针
	LNOde* p, * q;//p表示当前工作指针，q为p的后继
	p = A->next;
	//A->next = NULL; // 将A初始化
	while (p) {
		//s = p->next;
		a->next = p; a = p;	//插入A中
		p = p->next;
		if (p != NULL) {
			q = p->next;
			p->next = b->next;	//尾插法插入B中
			b->next = p;
			p = q;
		}
	}
		a->next = NULL;
		return B;
	}

//11.将线性表拆分为两个单链表
LinkList decompose2(LinkList& A) {
	int count = 0;
	LinkList B = (LinkList)malloc(sizeof(LNOde));	//创建B表头
	B->next = NULL;		//B表初始化
	LNOde* b = B, * a = A;//a为表头指针，b为表尾指针
	LNOde* p, * q;//p表示当前工作指针，q为p的后继
	p = A->next;
	A->next = NULL; // 将A初始化
	while (p) {
		count++;
		q = p->next;	//q为p的后继
		if ((count & 1) == 1) {
			a->next = p;
			a = p;	//插入A中
		}
		else {
			p->next = b->next;//尾插法插入B中
			b->next = p;
		}
		p = q;
	}
	a->next = NULL;
	return B;
}

//12.设计算法删除递增有序的单链表中出现的重复元素
void del_Element(LinkList &L) {
	LNOde* slow = L->next, * fast,*p;//设置快慢指针,p为暂时指针
	while (slow->next!=NULL) {
		fast = slow->next;
		if (fast->data == slow->data) {	//相等则表示有相同的元素
			slow->next = fast->next;
			p = fast;
			free(p);
		}
		else {
			slow = slow->next;
		}
		
	}
}

//13.将两个有序递增单链表合并为递减单链表，并利用原来两个单链表的结点存放归并后的单链表
LinkList combine(LinkList &L1, LinkList& L2) {
	LNOde* La = L1->next, * Lb = L2->next, *p;//La和Lb分别表示两个链表的第一个结点，p为工作指针
	L1->next = NULL; //将L1设置为当前合成的新链表;
	while (La && Lb) {//先找出两个链表的公共部分
		if (La->data <= Lb->data) {	//比较元素
			p = La->next;	//暂存La的后继结点
			La->next = L1->next;
			L1->next = La;

			La = p;	//La继续往下走
		}
		else {
			p = Lb->next;//暂存Lb的后继结点
			Lb->next = L1->next;
			L1->next = Lb;

			Lb = p;//Lb继续往下走
		}

	}
	if (La) {	//L1有剩余
		Lb = La;
	}
	while (Lb) {	//一起处理
		p = Lb->next;//暂存Lb的后继结点
		Lb->next = L1->next;
		L1->next = Lb;

		Lb = p;//Lb继续往下走
	}
	free(L2);
	return L1;
}

//14.设计算法从递增有序的单链表A和B中提取出公共元素产生单链表C，要求不破坏A、B结点
void extractCommon(LinkList L1, LinkList L2) {
	LNOde* La = L1->next, * Lb = L2->next,*r;
	LinkList C = (LinkList)malloc(sizeof(LNOde));//建立新表C
	r = C; //r始终指向C的尾结点
	while (La && Lb) {
		if (La->data < Lb->data) {	//小于的话La向后移一位
			La = La->next;
		}
		else if (La->data > Lb->data) {
			Lb = Lb->next;
		}
		else {			//相等则一起向后移一位
			LNOde* s = (LNOde*)malloc(sizeof(LNOde));//创建一个新的结点
			s->data = La->data;
			r->next = s;
			r = s;
			La = La->next;
			Lb = Lb->next;
		}
	}
	r->next = NULL;
	arrayList(C);
}

//15、两个递增有序的链表分别表示两个集合，编写函数求A、B交集存放于A集合中
void merge(LinkList& La, LinkList& Lb) {
	LNOde* pa = La->next, * pb = Lb->next, * pc = La,*temp;// pa,pb分别表示工作指针，pc指向La的头结点
	while (pa && pb) {
		if (pa->data == pb->data) {	//元素相等就加入pa
			pc ->next = pa;
			pc = pa;
			pa = pa->next;
			temp = pb;	//将pb中的结点释放
			pb = pb->next;
			free(temp);	//释放结点temp
		}
		else if (pa->data < pb->data) {
			temp = pa;
			pa = pa->next;
			free(temp);//释放结点temp
		}
		else {
			temp = pb;
			pb = pb->next;
			free(temp);//释放结点temp
		}
	}
	while (pa) {//while循环结束后，如果La中还有剩余则遍历
		temp = pa;
		pa = pa->next;
		free(temp);//释放结点temp
	}
	while (pb) {//while循环结束后，如果Lb中还有剩余则遍历
		temp = pb;
		pb = pb->next;
		free(temp);//释放结点temp
	}
	pc->next = NULL;
	free(Lb);
	arrayList(La);
}

//16.判断单链表B是否包含单链表B
int contain(LinkList& La, LinkList& Lb) {
	LNOde* pa = La->next, * pb = Lb->next, * pre = pa;//pa和pb分别表示工作指针
	while (pa && pb) {
		if (pa->data == pb->data) {
			pa = pa->next;
			pb = pb->next;
		}
		else {
			pre = pre->next;	//A从下一个元素开始
			pa = pre;
			pb = Lb->next;		// B每次从头开始
		}
	}
	if (pb == NULL) {	//判断pb是否能比较完了
		return 1;
	}
	return 0;
}

//17.设计一个算法用于判断带头结点的循环双链表是否对称
int symmetry(DLinklist L) {
	//从两边扫描循环双链表，判断是否对称
	DNode* p = L->next, *q = L->proir;
	while (p != q && q->next != p) {
		if (p->data == q->data) {
			p = p->next;
			q = q->proir;
		}
		else {
			return 0;
		}
	}
	return 1;
}

//18. 合并两个循环单链表，使合并后的链表仍保持循环单链表形式
void combine2(LinkList La, LinkList Lb) {
	LNOde* h1 = La, * h2 = Lb, * p = Lb->next;//h1和h2分别指向循环单链表的头结点
	Lb->next = NULL;//断链Lb
	while (h1->next != La) {
		h1 = h1->next;
	}
	h1->next = p;
	while (h1->next != Lb) {
		h1 = h1->next;
	}
	h1->next = La;
	arrListCycle(La);
}

//遍历输出循环单链表
void arrListCycle(LinkList L) {
	LNOde* f = L->next;
	while (f && f != L) {
		printf("%d ", f->data);
		f = f->next;
	}
	printf("\n");
}

//19.设计算法寻找带头结点的循环单链表的最小值输出并删除，直到单链表为空，然后删除头结点
void del_MinAll(LinkList& L) {
	while (L->next != L) {	//当链表不为空时一直循环
		LNOde* p = L->next, * pre = L, *minp=p,*minpre=pre;	//p为工作指针，pre为p的前驱
		while (p != L) {
			if (minp->data > p->data) {
				minp = p;	//min指向最小元素
				minpre = pre;
			}
			pre = p;
			p = p->next;
		}
		printf("%d ", minp->data);//输出最小元素
		minpre->next = minp->next;//删除最小值指针结点
		free(minp);
	}
	free(L);
}

//尾插法创建locate双链表
void initlocate(DlocateList &L,int a[],int len) {
	L = (DlocateList)malloc(sizeof(Dlnode));//建立双链表头结点
	Dlnode* s, * r;//r为尾指针
	r = L;
	int i = 0;
	while (i<len) {
		s = (Dlnode*)malloc(sizeof(Dlnode));//创建结点
		s->data = a[i++];//赋值
		s->freg = 0;
		r->next = s;//插入
		s->prior = r;
		r = s;
	}
	r->next = NULL;
	Dlnode *p = L->next;
	while (p) {
		printf("%d ", p->data);
		p = p->next;
	}
}
//20.locate(L,X)函数的编写 
//void locate(DlocateList L, int x) {
//	Dlnode* p = L->next, * pre=L;//p第一个工作指针,temp为临时指针
//	while (p) {
//		if (p->data == x) {	//找到相同结点时，freg加一 
//			p->freg++;	//同时插入到头结点后面
//
//			pre->next = p;
//			pre->next = p->next;	//删除节点temp 
//			p->next->prior=p->prior;
//			//然后插入到头结点后面即可
//			Dlnode* s = (Dlnode*)malloc(sizeof(Dlnode));
//			s->data = x;
//			s->next = L->next;
//			L->next->prior = s;
//			L->next = s;
//			s->prior = L;
//		}
//		p = p->next;
//	}
//	Dlnode* p = L->next;
//	while (p) {
//		printf("%d ", p->data);
//		p = p->next;
//	}
//	printf("\n");
//}

//21.编写算法求倒数第k个结点的值
int fundkValue(LinkList L,int k) {
	LNOde* list = L, * slow = list->next,*temp=list->next, * fast;	//list为头指针
	while (k-- >0 && temp!=NULL) {
		temp = temp->next;
	}
	if (k > 0) {
		return 0;
	}
	else {
		fast = temp;
		while (fast) {
			slow = slow->next;
			fast = fast->next;
		}
		printf("输出的倒数第%d 个结点的值为%d \n",k, slow->data);
		return 1;
	}
	
}

//22.找出单链表保存的单词具有相同的后缀的第一个单词
void findCommon(Link La, Link Lb) {
	Node* p = La->next, * q = Lb->next,*s1=La->next,*s2=Lb->next;//str1和str2分别是La和Lb的第一个结点
	int count1 = 0, count2 = 0;
	while (p) {
		count1++;
		p = p->next;
	}
	while (q) {
		count2++;
		q = q->next;
	}
	int temp =count1-count2;
	while (temp-- > 0) {
		s1 = s1->next;
	}
	while (s1 && s2) {
		if (s1->data == s2->data) {
			printf("%c", s1->data);
			return;
		}
		else {
			s1 = s1->next;
			s2 = s2->next;
		}
	}
	printf("\n");
}

//23.删除重复元素值(包括绝对值)，只保留第一个出现的元素
void delCommonValue(LinkList& L, int n) {
	LNOde* p = L, * r;
	int* q, m;
	q = (int*)malloc(sizeof(int) * (n + 1));	//申请n+1个位置的辅助空间
	for (int i = 0; i < n + 1; i++){
		*(q + i) = 0;				//数组元素初始值赋值0
	}
		while (p->next != NULL) {//遍历单链表元素
			m = p->next->data > 0 ? p->next->data : -p->next->data;	//判断元素的正负
			if (*(q + m) == 0) {	//判断该节点的data是否出现过
				*(q + m) = 1;		//第一次出现
				p = p->next;		//保留
			}
			else {					//重复出现则删除
				r = p->next;
				p->next = r->next;
				free(r);
			}
		}
	free(q);
	arrayList(L);
}

//24.判断一个链表是否有环，有环则输出环的起始点
int isCycle(LinkList L) {
	LNOde* slow = L->next, * fast = L->next;	//设置快慢指针
	while (slow != NULL&&fast->next!=NULL) {
		fast = fast->next->next;	//快指针每次走两步
		slow = slow->next;		//慢指针每次走一步
		if (fast == slow) {
			return fast->next->data;	//如果快慢指针相同则一定有环且下一个指针即为出口
		}
	}
	return 0;
}

//25.链表的重新排序
void resortLink(LinkList& L) {
	
}

LinkTest.cpp

#include<stdio.h>
#include"link.h"
int  main() {
    LinkList link, link1, link3, link4,link5; DlocateList dlocate; Link charlink,charlink1;
    DLinklist Dlink;
    int arr[] = {1,2,3,4,5,6,7};
    int arr2[] = {3,4,5,7};
    int len = sizeof(arr) / sizeof(int);
    int len2 = sizeof(arr2) / sizeof(int);
    list_RailInsert1(link,arr,len);
    list_RailInsert1(link1, arr2, len2);
    printf("尾插法建立的单链表为：\n");
    arrayList(link); arrayList(link1);
    printf("递归删除后的单链表为：\n");
    del_value(link,2);//1.递归删除元素
    del_f(link,2);//2.一遍顺序扫描删除指定元素
    arrayList(link);
    ouputData(link);//3. 反向输出带头结点单链表的每个节点的值
    printf("\n");
    printf("删除最小节点元素后的单链表为：\n");
    del_MinNode(link);//4.编写在带头结点的单链表L中删除一个最小节点的高效算法(假设最小节点值唯一)
    arrayList(link);
    del_MinNode2(link);
    arrayList(link);
    //将带头结点的单链表就地逆置(空间复杂度O(1))
     printf("单链表就地逆置后为：\n");
     reverse(link); arrayList(link);
     reverse2(link); arrayList(link);
     printf("删除指定区间后的元素为：\n");
     del_values2(link, 2, 5); arrayList(link);
     printf("尾插法建立的单链表2为：\n");
    // list_RailInsert(link1);
     printf("输出两个链表相同的元素：\n");
     findCommonNode(link, link1);
     printf("递增输出单链表中的各元素：\n");
     outputElement(link);
     printf("输出分解后的两个单链表为：\n");
     /*link3 = resolve(link);
     arrayList(link3);
     arrayList(link);*/
     /*printf("变换后的两个单链表分别为：\n");
     link3 = decompose(link); arrayList(link3);
     arrayList(link);*/
     printf("输出删除重复元素后的单链表为：\n");
     del_Element(link);  arrayList(link);
     printf("输出合并后的单链表为：\n");
     arrayList(combine(link,link1));
     /*printf("输出两个链表的公共元素为：\n");
     extractCommon(link, link1);
     printf("输出归并后的单链表为：\n");
     merger(link, link1);*/
     printf("输出单链表A中是否包含单链表B的结果：\n");
     printf("%d \n",contain(link, link1));
     int drr[] = {1,2,1};
     int dlen = sizeof(drr) / sizeof(int);
     printf("创建的循环双链表为： \n");
     DlinkRailInsert(Dlink,drr,dlen);
     printf("输出的结果为：%d \n", symmetry(Dlink));
     printf("合并后的循环单链表为：\n");
     int dlink[] = { 1,2,3 }; int lend1 = sizeof(dlink) / sizeof(int);
     int dlink2[] = { 4,5,6 }; int lend2 = sizeof(dlink2) / sizeof(int);
     list_RailInsertCycle(link3, dlink, lend1);
     list_RailInsertCycle(link4, dlink2, lend2);
     combine2(link3, link4); printf("\n");
     LinkList minlist;
     int min[] = { 3,2,4,6,9,2 };
     int lenmin = sizeof(min) / sizeof(int);
     list_RailInsertCycle(minlist, min, lenmin);
     printf("插入后的循环单链表为：\n"); arrListCycle(minlist);
     printf("输出依次找到的最小值为：\n");
     del_MinAll(minlist);
     printf("\n");
     printf("输出创建的双链表为：\n");
     int a[] = {1,4,6,7,9,5};
     int le = sizeof(a) / sizeof(int);
     initlocate(dlocate,a,le);//创建locate双链表
     printf("\n");
     printf("输出双链表按频度访问节点的所有元素：\n");
     //locate(dlocate, 6);
     printf("输出倒数第k个结点的值：\n");
     printf("返回的结果为：%d\n", fundkValue(link, 1));
     printf("插入的两个单词单链表为：\n");
     char ch[] = {'l','o','d','o','i','n','g'};
     int chlen = sizeof(ch) / sizeof(char);
     char ch1[] = { 'b','e','o','i','n','g' };
     int chlen1 = sizeof(ch1) / sizeof(char);
     listchar_RailInsert(charlink, ch, chlen);
     listchar_RailInsert(charlink1, ch1, chlen1);
     printf("输出的两个单链表的第一个相同的后缀字母为：\n");
     findCommon(charlink,charlink1);
     int del[] = { -2,-2,-3,3,4,5,7,-7 };
     int dellen = sizeof(del) / sizeof(int);
     list_RailInsert1(link5, del, dellen);
     printf("建立的单链表为：\n"); arrayList(link5);
     printf("输出删除绝对值相同的元素后的单链表为：\n");
     delCommonValue(link5,7);
     printf("判断链表是否有环：%d", isCycle(link5));
}