单向链表的基本操作（常见面试题详解）

一、什么是链表
     链表是一种常见的非常重要的数据结构，是动态进行存储分配的一种结构。其中数据元素的逻辑顺序是通过链表中的指针链接次序实现的，链表中的每一个元素都称为结点，链表就是由这一系列结点组成的，其结点可在运行时动态生成。每一个结点都是由两部分组成，一部分是存储数据元素的数据域，另一部分是存储下一结点地址的指针域。
    链表的类型有：单向链表、双向链表、循环链表。
    链表的优点：1、克服了数组预先知道数据大小的缺点；
                          2、动态管理内存空间，可充分利用内存空间；
                          3、可插入和移除表上任意位置的结点。
    链表的缺点：1、增加了指针域，空间开销大；
                          2、不能随机读取数据。



二、单向链表的基本操作
1、头插：从链表首部插入结点，只需要创建一块内存空间，将数据放进数据域，将原链表的首元素地址放进新创建的指针域当中。

void Pushfront(pList* plist, Datatype data)
{
assert(plist != NULL);
pNode p = NULL;
p =(pNode) malloc(sizeof(node_t));
if (p == NULL)
{
perror("malloc()");
exit(EXIT_FAILURE);
}
p->data = data;
p->next = NULL;
p->next = *plist;
*plist = p;
}

2、尾插：从链表尾部插入结点，需要创建一块内存空间，将地址放进原链表尾部的结点的指针域当中，然后将指针域制空即可。

void Pushback(pList* plist,Datatype data)
{
assert(plist != NULL);
pNode cur = *plist;
pNode p = NULL;
p =(pNode) malloc(sizeof(node_t));
if (p == NULL)
{
perror("malloc()");
exit(EXIT_FAILURE);
}
memset(p, 0, sizeof(node_t));
p->data = data;
if (cur == NULL)
{
*plist = p;
}
else
{
while (cur->next)
{
cur = cur->next;
}
cur->next = p;
}
}

3、头删：释放掉第一个结点，头指针指向下一个结点，即可。

void Popfront(pList* plist)
{
assert(plist != NULL);
pList cur = *plist;
if (cur == NULL)
{
return;
}
else
{
*plist = cur->next;
free(cur);
cur->next = NULL;
}
}

4、尾删：释放掉最后一个结点，将倒数第二个结点的指针置为空指针。

void Popback(pList* plist)
{
assert(plist != NULL);
pList fast = *plist;
pList slow = NULL;
if (*plist == NULL)
{
return;
}
while (fast!=NULL)
{
slow = fast;
fast = fast->next;
}
if (slow != NULL)
{
slow->next = NULL;
free(fast);
}
else
{
free(fast);
*plist = NULL;
}
}

5、销毁链表：逐个释放结点所占的内存空间。

void Destroy(pList* plist)
{
assert(plist != NULL);
pList cur = NULL;
while (*plist)
{
cur = (*plist)->next;
free(*plist);
*plist = NULL;
*plist = cur;
}
}

6、查找某一个结点。

pNode Find(pList plist, Datatype data)
{
pNode cur =plist;
while (cur)
{
if (cur->data == data)
{
return cur;
}
cur = cur->next;
}
return NULL;
}

7、链表的逆序：遍历一遍链表，将链表里每个结点的指针域里存放的地址更改为其上一个结点的地址，并将原链表的第一个结点的指针域存放空指针。

void Invert_list(pList *plist)
{
if (((*plist) == NULL) || ((*plist)->next == NULL))
{
return;
}
else
{
pList cur1 = *plist;
pList cur2 = (*plist)->next;
pList cur3 = (*plist)->next->next;
pList tmp = NULL;
while (1)
{
cur2->next = cur1;
cur1->next = tmp;
tmp = cur1;
if (cur3 == NULL)
{
break;
}
else
{
cur1 = cur2;
cur2 = cur3;
cur3 = cur3->next;
}
}
*plist = cur2;
}
}

8、顺序打印链表

void Display(pList plist)
{
pList cur = plist;
for (; cur != NULL; cur = cur->next)
{
printf("%d--->", cur->data);
}
printf("over\n");
}

9、逆序打印链表：最简便的方法莫过于递归实现。

void Invert_display(pList plist)
{
if(plist!=NULL)
{
Invert_display(plist->next);
printf("%d--->", plist->data);
}
else
{
return;
}
}

10、删除一个非尾结点：找到要删除的结点的下一个结点，将该节点的内容放进要删除的结点中，释放该结点。

void Del_Not_Tail(pNode pos)
{
assert(pos != NULL);
pNode cur = pos->next;
if (cur != NULL)
{
pos->next = cur->next;
pos->data = cur->data;
}
else
{
return;
}
free(cur);
cur = NULL;
}

11、在指定位置前插入一个结点：创建一个结点，将该结点插入到指定位置后，然后将指定位置的数据放入创建的结点中，指定位置的数据域存放需要新加入的数据。

void Insert_Front_Node(pNode pos, Datatype data)
{
assert(pos != NULL);
pNode p = NULL;
p = (pNode)malloc(sizeof(node_t));
if (p == NULL)
{
perror("malloc()");
exit(EXIT_FAILURE);
}
p->next = pos->next;
p->data = pos->data;
pos->data = data;
pos->next = p;
}

12、合并有序链表

pList Merge(pList* plist1, pList* plist2)
{
assert(plist1 != NULL);
assert(plist2 != NULL);
pList head = NULL;
pList p = NULL;
pList cur1 = *plist1;
pList cur2 = *plist2;
if (cur1->data < cur2->data)
{
head = cur1;
cur1 = cur1->next;
}
else
{
head = cur2;
cur2 = cur2->next;
}
p = head;
while ((cur1 != NULL) && (cur2 != NULL))
{
if (cur1->data < cur2->data)
{
p->next = cur1;
cur1 = cur1->next;
}
else
{
p->next = cur2;
cur2 = cur2->next;
}
p = p->next;
}
if (cur1 == NULL)
{
p->next = cur2;
}
else if (cur2 == NULL)
{
p->next = cur1;
}
return head;
}

13、约瑟夫环问题：一共有n个人，开始报数，报到第k个的人自杀，然后从下一个继续报数，问最后自杀的人是谁？
        通过链表，我们不仅可以找出最后自杀的人，还可以将n个人自杀的顺序找出来。遍历链表，利用计数器，每数到k,就将此时指针所指向的结点释放，将下一个结点挂到上一个节点上。

void JosephCycle(pList plist, int k)
{
pList cur1 = plist;
pList cur2 = plist;

if (k >= 2)
{
while (1)
{
int count = k;
pNode tmp = NULL;
if (cur1 == cur1->next)
{
printf("%d\n", cur1->data);
break;
}
while (--count > 0)
{
cur1 = cur2;
cur2 = cur2->next;
}
tmp = cur2;
printf("%d  ", tmp->data);
cur1->next = cur2->next;
cur2 = cur2->next;
free(tmp);
tmp = NULL;
}
}
else
{
return;
}
}

14、寻找链表的中间结点，要求只能遍历一次链表：用两个指针同时指向链表首部，利用循环，快指针一次走两步，慢指针一次走一步，直到快的指针走到链表尾部，此时慢的指针指向的结点就是中间结点。

pNode Find_Mid_Node(pList plist)
{
pList fast = plist;
pList slow = plist;

while (fast != NULL&&fast->next != NULL)
{
fast = fast->next->next;
slow = slow->next;
}

printf("中间结点为：%d\n", slow->data);
return slow;
}

15、对链表进行冒泡排序。

void BubbleSort(pList plist)
{
pList cur = plist;

if (plist == NULL || plist->next == NULL)
{
return;
}

for (; cur->next != NULL; cur = cur->next)
{
pList pre = plist;
Datatype tmp = 0;
for (pre ; pre->next != NULL; pre = pre->next)
{
if (pre->data > pre->next->data)
{
tmp=pre->data;
pre->data = pre->next->data;
pre->next->data = tmp;
}
}
}
}

16、删除倒数第k个元素：两个指针，快的指针先遍历k个结点，然后快慢指针同时走，每次遍历一个结点，知道快指针走到链表尾部，此时慢指针指向的结点就是倒数第k个结点。

void Del_K_Node(pList plist, int k)
{
pList cur1 = plist;
pList cur2 = plist;
int count = k;

if (k == 1)
{
cur1 = cur1->next;
while (cur1->next != NULL)
{
cur1 = cur1->next;
cur2 = cur2->next;
}
cur2->next = NULL;
free(cur1);
cur1 = NULL;
}
else if (k >= 2)
{
while (--count)
{
cur1 = cur1->next;
}
pList tmp = NULL;
while (cur1->next != NULL)
{
cur1 = cur1->next;
cur2 = cur2->next;
}
tmp = cur2->next;
cur2->data = tmp->data;
cur2->next = tmp->next;
free(tmp);
tmp = NULL;
}
else
{
return;
}
}

17、判断链表是否带环：两个指针，快指针每次走两步，慢指针每次走一步，当两个指针相遇，说明链表带环，否则，链表不带环。

pNode Check_Cycle(pList plist)
{
pList fast = plist;
pList slow = plist;

while ((fast != NULL) && (fast->next != NULL))
{
fast = fast->next->next;
slow = slow->next;
if (fast == slow)
{
return fast;
}
}
return NULL;
}

18、求带环链表的入口点（此问题后续详解）。

pNode Get_Circle_Entry_Node(pNode meet, pList plist)
{
assert(meet != NULL);
assert(plist != NULL);

pList cur = plist;
pNode node = meet;
while (cur != node)
{
cur = cur->next;
node = node->next;
}
return cur;
}

19、求带环链表的长度。

int Get_Circle_Length(pNode meet)
{
pNode node = meet;
Datatype count = 1;

meet = meet->next;
while (meet != node)
{
meet = meet->next;
count += 1;
}
return count;
}

20、判断两个不带环链表是否相交：只需判断两条链表的尾结点是否相同即可。

pNode Check_Cross(pList plist1, pList plist2)
{
assert(plist1 != NULL);
assert(plist2 != NULL);

pList cur1 = plist1;
pList cur2 = plist2;

while (cur1->next != NULL)
{
cur1 = cur1->next;
}
while (cur2->next != NULL)
{
cur2 = cur2->next;
}
if (cur1 == cur2)
{
return cur1;
}
else
{
return NULL;
}
}

21、求两个相交不带环链表的交点：将其中一条链表构成环，即就成了求环入口点问题。

pNode Check_Cross_Meet(pList plist1, pList plist2)
{
pList cur1 = plist1;
pList cur2 = plist2;
pNode meet = NULL;
pNode pre = NULL;
pNode node = Check_Cross(plist1, plist2);//判断两条链表是否相交

if (node == NULL)
{
return NULL;
}
node->next = cur1;//将其中一条链表的尾节点接到头结点，构成一个环
meet = Check_Cycle(plist2);//判断链表2是否已经带环
pre = Get_Circle_Entry_Node(meet, plist2);//求出环的入口点
node->next = NULL;//将环拆开
return pre;
}

三、完整代码如下：
Linklist.h

#ifndef __LINK_LIST_H__
#define __LINK_LIST_H__

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

typedef int Datatype;

typedef struct Node
{
Datatype data;
struct Node *next;
}node_t,*pList,*pNode;

void Initlist(pList* plist);//初始化

void Display(pList plist);//打印链表

void Pushfront(pList* plist, Datatype data);//头插

void Popfront(pList* plist);//头删

void Pushback(pList* plist, Datatype data);//尾插

void Popback(pList* plist);//尾删

void Destroy(pList* plist);//销毁链表

pNode Find(pList plist, Datatype data);//查找某个节点

void Invert_list(pList* plist);//链表的逆序

void Invert_display(pList plist);//链表的逆序打印

void Del_Not_Tail(pNode pos);//删除一个非尾节点

void Insert_Front_Node(pNode pos,Datatype data);//在指定位置前插入一个节点

pList Merge(pList* plist1, pList* plist2);//合并链表

void JosephCycle(pList plist,int k);//约瑟夫环

pNode Find_Mid_Node(pList plist);//寻找链表的中间节点，只能遍历一遍链表

void BubbleSort(pList plist);//链表进行冒泡排序

void Del_K_Node(pList plist, int k);//删除倒数第k个元素

pNode Check_Cycle(pList plist);//判断链表是否有环

pNode Get_Circle_Entry_Node(pNode meet, pList plist);//求带环链表的环入口点

int Get_Circle_Length(pNode meet);//求带环链表长度

pNode Check_Cross(pList plist1,pList plist2);//判断两个不带环的链表是否相交

pNode Check_Cross_Meet(pList plist1, pList plist2);//求两个相交不带环链表的交点

#endif

Linklist.c

#include "Linklist.h"

//链表的初始化
void Initlist(pList* plist)
{
plist = NULL;
}

//打印链表
void Display(pList plist)
{
pList cur = plist;
for (; cur != NULL; cur = cur->next)
{
printf("%d--->", cur->data);
}
printf("over\n");
}//头插
void Pushfront(pList* plist, Datatype data)
{
assert(plist != NULL);
pNode p = NULL;
p =(pNode) malloc(sizeof(node_t));
if (p == NULL)
{
perror("malloc()");
exit(EXIT_FAILURE);
}
p->data = data;
p->next = NULL;
p->next = *plist;
*plist = p;
}
//头删
void Popfront(pList* plist)
{
assert(plist != NULL);
pList cur = *plist;
if (cur == NULL)
{
return;
}
else
{
*plist = cur->next;
free(cur);
cur->next = NULL;
}
}

//尾插
void Pushback(pList* plist,Datatype data)
{
assert(plist != NULL);
pNode cur = *plist;
pNode p = NULL;
p =(pNode) malloc(sizeof(node_t));
if (p == NULL)
{
perror("malloc()");
exit(EXIT_FAILURE);
}
memset(p, 0, sizeof(node_t));
p->data = data;
if (cur == NULL)
{
*plist = p;
}
else
{
while (cur->next)
{
cur = cur->next;
}
cur->next = p;
}
}

//尾删
void Popback(pList* plist)
{
assert(plist != NULL);
pList fast = *plist;
pList slow = NULL;
if (*plist == NULL)
{
return;
}
while (fast!=NULL)
{
slow = fast;
fast = fast->next;
}
if (slow != NULL)
{
slow->next = NULL;
free(fast);
}
else
{
free(fast);
*plist = NULL;
}
}

//销毁链表
void Destroy(pList* plist)
{
assert(plist != NULL);
pList cur = NULL;
while (*plist)
{
cur = (*plist)->next;
free(*plist);
*plist = NULL;
*plist = cur;
}
}

//查找某个结点
pNode Find(pList plist, Datatype data)
{
pNode cur =plist;
while (cur)
{
if (cur->data == data)
{
return cur;
}
cur = cur->next;
}
return NULL;
}
//链表的逆序
void Invert_list(pList *plist)
{
if (((*plist) == NULL) || ((*plist)->next == NULL))
{
return;
}
else
{
pList cur1 = *plist;
pList cur2 = (*plist)->next;
pList cur3 = (*plist)->next->next;
pList tmp = NULL;
while (1)
{
cur2->next = cur1;
cur1->next = tmp;
tmp = cur1;
if (cur3 == NULL)
{
break;
}
else
{
cur1 = cur2;
cur2 = cur3;
cur3 = cur3->next;
}
}
*plist = cur2;
}
}

//链表的逆序打印
void Invert_display(pList plist)
{
if(plist!=NULL)
{
Invert_display(plist->next);
printf("%d--->", plist->data);
}
else
{
return;
}
}

//删除一个非尾结点
void Del_Not_Tail(pNode pos)
{
assert(pos != NULL);
pNode cur = pos->next;
if (cur != NULL)
{
pos->next = cur->next;
pos->data = cur->data;
}
else
{
return;
}
free(cur);
cur = NULL;
}

//在指定位置前插入一个结点
void Insert_Front_Node(pNode pos, Datatype data)
{
assert(pos != NULL);
pNode p = NULL;
p = (pNode)malloc(sizeof(node_t));
if (p == NULL)
{
perror("malloc()");
exit(EXIT_FAILURE);
}
p->next = pos->next;
p->data = pos->data;
pos->data = data;
pos->next = p;
}

//合并有序链表
pList Merge(pList* plist1, pList* plist2)
{
assert(plist1 != NULL);
assert(plist2 != NULL);
pList head = NULL;
pList p = NULL;
pList cur1 = *plist1;
pList cur2 = *plist2;
if (cur1->data < cur2->data)
{
head = cur1;
cur1 = cur1->next;
}
else
{
head = cur2;
cur2 = cur2->next;
}
p = head;
while ((cur1 != NULL) && (cur2 != NULL))
{
if (cur1->data < cur2->data)
{
p->next = cur1;
cur1 = cur1->next;
}
else
{
p->next = cur2;
cur2 = cur2->next;
}
p = p->next;
}
if (cur1 == NULL)
{
p->next = cur2;
}
else if (cur2 == NULL)
{
p->next = cur1;
}
return head;
}

//约瑟夫环
void JosephCycle(pList plist, int k)
{
pList cur1 = plist;
pList cur2 = plist;

if (k >= 2)
{
while (1)
{
int count = k;
pNode tmp = NULL;
if (cur1 == cur1->next)
{
printf("%d\n", cur1->data);
break;
}
while (--count > 0)
{
cur1 = cur2;
cur2 = cur2->next;
}
tmp = cur2;
printf("%d  ", tmp->data);
cur1->next = cur2->next;
cur2 = cur2->next;
free(tmp);
tmp = NULL;
}
}
else
{
return;
}
}

//寻找链表的中间结点，只遍历一次链表
pNode Find_Mid_Node(pList plist)
{
pList fast = plist;
pList slow = plist;

while (fast != NULL&&fast->next != NULL)
{
fast = fast->next->next;
slow = slow->next;
}

printf("中间结点为：%d\n", slow->data);
return slow;
}

//链表进行冒泡排序
void BubbleSort(pList plist)
{
pList cur = plist;

if (plist == NULL || plist->next == NULL)
{
return;
}

for (; cur->next != NULL; cur = cur->next)
{
pList pre = plist;
Datatype tmp = 0;
for (pre ; pre->next != NULL; pre = pre->next)
{
if (pre->data > pre->next->data)
{
tmp=pre->data;
pre->data = pre->next->data;
pre->next->data = tmp;
}
}
}
}

//删除倒数第k个元素
void Del_K_Node(pList plist, int k)
{
pList cur1 = plist;
pList cur2 = plist;
int count = k;

if (k == 1)
{
cur1 = cur1->next;
while (cur1->next != NULL)
{
cur1 = cur1->next;
cur2 = cur2->next;
}
cur2->next = NULL;
free(cur1);
cur1 = NULL;
}
else if (k >= 2)
{
while (--count)
{
cur1 = cur1->next;
}
pList tmp = NULL;
while (cur1->next != NULL)
{
cur1 = cur1->next;
cur2 = cur2->next;
}
tmp = cur2->next;
cur2->data = tmp->data;
cur2->next = tmp->next;
free(tmp);
tmp = NULL;
}
else
{
return;
}
}

//判断链表是否带环
pNode Check_Cycle(pList plist)
{
pList fast = plist;
pList slow = plist;

while ((fast != NULL) && (fast->next != NULL))
{
fast = fast->next->next;
slow = slow->next;
if (fast == slow)
{
return fast;
}
}
return NULL;
}

//求带环链表的环入口点
pNode Get_Circle_Entry_Node(pNode meet, pList plist)
{
assert(meet != NULL);
assert(plist != NULL);

pList cur = plist;
pNode node = meet;
while (cur != node)
{
cur = cur->next;
node = node->next;
}
return cur;
}

//求带环链表的长度
int Get_Circle_Length(pNode meet)
{
pNode node = meet;
Datatype count = 1;

meet = meet->next;
while (meet != node)
{
meet = meet->next;
count += 1;
}
return count;
}

//判断两个不带环链表是否相交
pNode Check_Cross(pList plist1, pList plist2)
{
assert(plist1 != NULL);
assert(plist2 != NULL);

pList cur1 = plist1;
pList cur2 = plist2;

while (cur1->next != NULL)
{
cur1 = cur1->next;
}
while (cur2->next != NULL)
{
cur2 = cur2->next;
}
if (cur1 == cur2)
{
return cur1;
}
else
{
return NULL;
}
}

//求两个相交不带环链表的交点
pNode Check_Cross_Meet(pList plist1, pList plist2)
{
pList cur1 = plist1;
pList cur2 = plist2;
pNode meet = NULL;
pNode pre = NULL;
pNode node = Check_Cross(plist1, plist2);//判断两条链表是否相交

if (node == NULL)
{
return NULL;
}
node->next = cur1;//将其中一条链表的尾节点接到头结点，构成一个环
meet = Check_Cycl
a78f
e(plist2);//判断链表2是否已经带环
pre = Get_Circle_Entry_Node(meet, plist2);//求出环的入口点
node->next = NULL;//将环拆开
return pre;
}

test.c

#include "Linklist.h"

void test1()//头插  头删  销毁
{
pList plist = NULL;
Initlist(&plist);
Pushfront(&plist, 1);
Pushfront(&plist, 2);
Pushfront(&plist, 3);
Pushfront(&plist, 4);
Pushfront(&plist, 5);
Display(plist);

Destroy(&plist);
Display(plist);

/*Popfront(&plist);
Display(plist);
Popfront(&plist);
Display(plist);
Popfront(&plist);
Display(plist);
Popfront(&plist);
Display(plist);
Popfront(&plist);
Display(plist);*/
}

void test2()//尾插  尾删
{
pList plist = NULL;
Initlist(&plist);
Pushback(&plist, 1);
Pushback(&plist, 2);
Pushback(&plist, 3);
Pushback(&plist, 4);
Pushback(&plist, 5);
Display(plist);
Popback(&plist);
Display(plist);
Popback(&plist);
Display(plist);
Popback(&plist);
Display(plist);
Popback(&plist);
Display(plist);
Popback(&plist);
Display(plist);
}

void test3()   //查找   逆序  逆序打印
{
pList plist = NULL;
Initlist(&plist);
Pushfront(&plist, 1);
Pushfront(&plist, 2);
Pushfront(&plist, 3);
Pushfront(&plist, 4);
Pushfront(&plist, 5);
Display(plist);
pNode ret=Find(plist,6);
printf("%d\n", ret->data);
Invert_list(&plist);
Display(plist);

Invert_display(plist);
}

void test4()   //删除一个非尾结点
{
pList plist = NULL;
pNode pnode = NULL;
Initlist(&plist);
Pushfront(&plist, 1);
Pushfront(&plist, 2);
Pushfront(&plist, 3);
Pushfront(&plist, 4);
Pushfront(&plist, 5);
Display(plist);

pnode = Find(plist, 4);

Del_Not_Tail(pnode);

Display(plist);
}

void test5()   //在指定位置前增加一个结点
{
pList plist = NULL;
pNode pnode = NULL;
Initlist(&plist);
Pushfront(&plist, 1);
Pushfront(&plist, 2);
//Pushfront(&plist, 3);
Pushfront(&plist, 4);
Pushfront(&plist, 5);
Display(plist);

pnode = Find(plist,2);

Insert_Front_Node(pnode, 3);

Display(plist);
}

void test6()   //合并有序链表
{
pList plist1 = NULL;
pList plist2 = NULL;
pList head = NULL;
Initlist(&plist1);
Initlist(&plist2);
Pushfront(&plist1, 10);
Pushfront(&plist2, 9);
Pushfront(&plist1, 8);
Pushfront(&plist2, 7);
Pushfront(&plist1, 6);
Pushfront(&plist2, 5);
Pushfront(&plist1, 4);
Pushfront(&plist2, 3);
Pushfront(&plist1, 2);
Pushfront(&plist2, 1);
Display(plist1);
Display(plist2);

head=Merge(&plist1, &plist2);
Display(head);

Display(plist1);
Display(plist2);
}

void test7()   //约瑟夫环
{
pList plist = NULL;
Initlist(&plist);
Pushfront(&plist, 10);
Pushfront(&plist,9);
Pushfront(&plist, 8);
Pushfront(&plist, 7);
Pushfront(&plist, 6);
Pushfront(&plist, 5);
Pushfront(&plist, 4);
Pushfront(&plist, 3);
Pushfront(&plist, 2);
Pushfront(&plist, 1);
Display(plist);

Find(plist, 10)->next = plist;

JosephCycle(plist,1);
}

void test8()   //寻找链表的中间结点，只遍历一次链表
{
pList plist = NULL;
pNode pnode = NULL;
Initlist(&plist);
Pushfront(&plist, 10);
Pushfront(&plist, 9);
Pushfront(&plist, 8);
Pushfront(&plist, 7);
Pushfront(&plist, 6);
Pushfront(&plist, 5);
Pushfront(&plist, 4);
Pushfront(&plist, 3);
Pushfront(&plist, 2);
Pushfront(&plist, 1);
Display(plist);

pnode=Find_Mid_Node(plist);
}

void test9()    //链表进行冒泡排序
{
pList plist = NULL;
Initlist(&plist);
Pushfront(&plist, 9);
Pushfront(&plist, 5);
Pushfront(&plist, 2);
Pushfront(&plist, 6);
Pushfront(&plist, 8);
Pushfront(&plist, 1);
Pushfront(&plist, 4);
Pushfront(&plist, 7);
Pushfront(&plist, 10);
Pushfront(&plist, 3);
Display(plist);

BubbleSort(plist);
Display(plist);
}

void test10()    //删除倒数第k个元素
{
pList plist = NULL;
Initlist(&plist);
Pushfront(&plist, 10);
Pushfront(&plist, 9);
Pushfront(&plist, 8);
Pushfront(&plist, 7);
Pushfront(&plist, 6);
Pushfront(&plist, 5);
Pushfront(&plist, 4);
Pushfront(&plist, 3);
Pushfront(&plist, 2);
Pushfront(&plist, 1);
Display(plist);

Del_K_Node(plist,1);
Display(plist);
}

void test11()    //判断链表是否带环    求带环链表的环入口点   求带环链表的长度
{
pList plist = NULL;
pNode meet = NULL;
pNode entry = NULL;
int ret = 0;

Initlist(&plist);
Pushfront(&plist, 10);
Pushfront(&plist, 9);
Pushfront(&plist, 8);
Pushfront(&plist, 7);
Pushfront(&plist, 6);
Pushfront(&plist, 5);
Pushfront(&plist, 4);
Pushfront(&plist, 3);
Pushfront(&plist, 2);
Pushfront(&plist, 1);
Display(plist);

Find(plist, 10)->next = Find(plist,5);

meet=Check_Cycle(plist);
//printf("%d\n", ret);

entry = Get_Circle_Entry_Node(meet, plist);
printf("环入口点为：%d\n", entry->data);

ret = Get_Circle_Length(meet);
printf("链表长度为：%d\n", ret);
}

void test12()   //判断两个不带环链表是否相交    求两个相交的不带环链表的交点
{
pList plist1 = NULL;
pList plist2 = NULL;
pNode node = NULL;
pNode meet = NULL;

Initlist(&plist1);
Initlist(&plist2);

Pushfront(&plist1, 10);
Pushfront(&plist1, 9);
Pushfront(&plist1, 8);
Pushfront(&plist1, 7);
Pushfront(&plist1, 6);
Pushfront(&plist1, 4);
Pushfront(&plist1, 2);
Display(plist1);

Pushfront(&plist2, 5);
Pushfront(&plist2, 4);
Pushfront(&plist2, 3);
Pushfront(&plist2, 2);
Pushfront(&plist2, 1);
Display(plist2);

Find(plist2, 5)->next = Find(plist1, 6);
Display(plist1);
Display(plist2);

node=Check_Cross(plist1, plist2);

meet = Check_Cross_Meet(plist1, plist2);
printf("交点为：%d\n", meet->data);
}
int main()
{
test12();
return 0;
}