1.逆序打印单链表
void PrintSListFromTail2Head(PNode pHead)// 逆序打印单链表
{
PNode pCur = pHead;
PNode pRet = NULL;
if (pHead == NULL)
return;
if (pCur->p_next)
{
PrintSListFromTail2Head(pCur->p_next);
}
if (!(pCur->p_next))
{
printf("NULL<--");printf("%d", pCur->data);
}
else
printf("<-- %d ", pCur->data);
}
2.删除链表的非尾结点,要求:不能遍历链表
void DeleteListNotTailNode(PNode pos)// 删除链表的非尾结点,要求:不能遍历链表
{
PNode pCur = NULL;
if (pos == NULL)
{
printf("不存在该结点,无法删除!!!\n");
return;
}
//pCur是pos的下个节点
pCur = pos->p_next;
//将pCur的值赋值给pos
pos->data = pCur->data;
//将pCur的下个结点和pos链接上
pos->p_next = pCur->p_next;
//最后free掉pCur
free(pCur);
}
3. 在链表pos位置前插入值为data的结点
void InesrtPosFront(PNode pos, DataType data)// 在链表pos位置前插入值为data的结点
{
PNode pCur = NULL;
if(NULL==pos)
{
printf("链表中无该位置,无法插入!!!\n");
return;
}
//采用交换值的方法插入
pCur = BuyNewNode(data);
pCur->p_next = pos->p_next;
pos->p_next = pCur;
//将两个结点的值交换
{
DataType temp = pos->data;
pos->data = pCur->data;
pCur->data = temp;
}
}
4. 查找链表的中间结点,要求只能遍历一次链表
PNode FindMiddleNode(PNode pHead)// 查找链表的中间结点,要求只能遍历一次链表
{
PNode pSlow = pHead;
PNode pFast = pHead;
if (pHead == NULL)
return NULL;
//两个指针,快指针的速度是慢指针的2倍,快指针走到末尾时,慢指针刚好走到链表一半
while (pFast->p_next&&pFast->p_next->p_next)
{
pFast = pFast->p_next->p_next;
pSlow = pSlow->p_next;
}
if (pFast == NULL)//说明链表有奇数个结点,则返回最中间一个结点
{
return pSlow;
}
else //说明链表有偶数个结点,有两个中间结点,返回第其中一个结点
{
return pSlow; //返回中间第一个结点
#if 0
return pSlow->p_next; //返回中间第二个节点
#endif
}
}
5. 查找链表的倒数第K个结点,要求只能遍历一次链表
PNode FindLastKNode(PNode pHead, int K)// 查找链表的倒数第K个结点,要求只能遍历一次链表
{
PNode pSlow = pHead;
PNode pFast = pHead;
if (pHead == NULL)
{
printf("链表为空\n");
return NULL;
}
//先让快指针走k-1步,之后满指针和快指针一快走
while (--K)
{
pFast = pFast->p_next;
}
//快慢指针一块走
while (pFast->p_next)
{
pFast = pFast->p_next;
pSlow = pSlow->p_next;
}
return pSlow; //返回慢指针
}
6.删除链表的倒数第K个结点,要求只能遍历一次链表
void DeleteLastKNode(PNode pHead, int K)// 删除链表的倒数第K个结点,要求只能遍历一次链表
{
PNode pSlow = pHead;
PNode pFast = pHead;
PNode pRet = NULL;
if (pHead == NULL)
{
printf("链表为空!!!\n");
return NULL;
}
//利用FindLastKNode函数的方法,找到倒数第K个结点,再用替换法删除
while (--K)
{
pFast = pFast->p_next;
}
while (pFast->p_next)
{
pFast = pFast->p_next;
pSlow = pSlow->p_next;
}
pRet = pSlow->p_next;
pSlow->data = pRet->data;
pSlow->p_next = pRet->p_next;
free(pRet);
}
7.用单链表实现约瑟夫环(JosephCircle)
void JosephCircle(PNode* pHead, const int M)// 用单链表实现约瑟夫环
{
PNode pCur = NULL;
PNode pPre = NULL;
PNode pRet = NULL;
int count = M;
assert(pHead);
if (*pHead == NULL)
{
return;
}
pCur = (*pHead);
while (pCur->p_next)
{
pCur = pCur->p_next;
}
pCur->p_next = (*pHead);
pCur = *pHead;
while ((pCur->p_next)!=pCur)
{
count = M;
while (--count)
{
pPre = pCur;
pCur = pCur->p_next;
}
pRet = pCur;
pPre->p_next = pCur->p_next;
pCur = pCur->p_next;
free(pRet);
}
pCur->p_next = NULL; *pHead = pCur;
return;
}
8.链表的逆置–三个指针
void ReverseSList(PNode* pHead)// 链表的逆置--三个指针
{
PNode pPre = NULL;//前一个结点为NULL,也就是逆置后链表的最后一个结点的Next
PNode pMid = NULL; //中间结点
PNode pNext = NULL; //后一个结点,用来保存每次逆置时链表的头结点
assert(pHead);
if (*pHead == NULL)
{
printf("链表为空!!!\n");
return;
}
pMid = *pHead;//将头结点赋值给中间结点
while (pMid)
{
pNext = pMid->p_next;//先保存下次逆置时链表的头结点
pMid->p_next = pPre;//将当前结点插入到前一个结点的前面
pPre = pMid;//前一个结点后移
pMid = pNext;//当前结点后移
}
*pHead = pPre; //最后一个结点,将其置为头结点
return;
}
9. 链表的逆置–头插法
void ReverseSListOP(PNode *pHead)// 链表的逆置--头插法
{
PNode pCur = NULL;
PNode pNext = NULL;
if (*pHead == NULL)
{
printf("链表为空!!!\n");
return;
}
pCur = *pHead;
while ((*pHead)->p_next)
{
pNext = (*pHead)->p_next;
(*pHead)->p_next = pNext->p_next;
pNext->p_next = pCur;
pCur = pNext;
}
*pHead=pCur ;
}
10.用冒泡排序思想对单链表进行排序
void BubbleSort(PNode pHead)// 用冒泡排序思想对单链表进行排序
{
PNode pCur = NULL;
PNode pNext = NULL;
DataType Temp = 0;
PNode pRet = NULL;
if (pHead == NULL)
{
printf("链表为空!!!\n");
return;
}
pCur = pHead; //外层循环的遍历指针
while (pCur)
{
pRet = pHead;
while (pRet&&pRet->p_next) //内层循环两个比较的指针,当循环跳出时,
{ //说明最后两个结点已经比较完了
pNext = pRet->p_next;
if (pRet->data > pNext->data) //将大的和小的交换
{
Temp = pRet->data;
pRet->data = pNext->data;
pNext->data = Temp;
}
pRet = pRet->p_next; //指针后移
}
pCur = pCur->p_next;//外层循环指针后移
}
}
11. 合并两个有序单链表,合并后依然有序
PNode MergeSList(PNode pHead1, PNode pHead2)// 合并两个有序单链表,合并后依然有序
{
PNode pCur1 = NULL;
PNode pCur2= NULL;
PNode pCur = NULL;
PNode pHead = NULL;
if ((pHead1==NULL)&&(pHead2==NULL))return NULL;//判断如果两个链表都为空,退出
if ((pHead1 == NULL) || (pHead2 == NULL))
return pHead1 ? pHead2 : pHead1;
pCur1 = pHead1; pCur2 = pHead2;//将头指针赋值给各自的遍历指针
if (pCur1->data <= pCur2->data)//先找到第一个小的结点
{
pCur = pCur1; pCur1 = pHead1->p_next;//找到小的结点指针往后走一步
}
else
{
pCur = pCur2; pCur2 = pHead2->p_next;//找到小的结点指针往后走一步
}
pHead = pCur;//保存新链表的头指针
while (pCur1&&pCur2)
{
if (pCur1->data <= pCur2->data)
{
pCur->p_next = pCur1; //将小的赋值给新链表的p_next
pCur = pCur1;//新的结点往后走一步
pCur1 = pCur1->p_next;
}
else
{
pCur->p_next = pCur2;//将小的赋值给新链表的p_next
pCur = pCur2;//新的结点往后走一步
pCur2 = pCur2->p_next;
}
}
if (pCur1 == NULL)pCur->p_next = pCur2;
else pCur->p_next = pCur1;
return pHead;
}
12. 判断两个单链表是否相交—链表不带环
int IsSListCross(PNode pHead1, PNode pHead2)// 判断两个单链表是否相交---链表不带环
{
PNode pCur1 = pHead1;
PNode pCur2 = pHead2;
if (pHead1 == NULL||pHead2==NULL)
{
return 0;
}
while (pCur1->p_next)
{
pCur1 = pCur1->p_next;
}
while (pCur2->p_next)
{
pCur2 = pCur2->p_next;
}
if (pCur1 == pCur2)
return 1;
else return 0;
}
13.求两个单链表相交的交点—链表不带环
PNode GetCorssNode(PNode pHead1, PNode pHead2)// 求两个单链表相交的交点---链表不带环
{
PNode pCur1 = pHead1;
PNode pCur2 = pHead2;
int count1=0, count2 = 0;
int temp = 0;
if (!IsSListCross(pHead1, pHead2))
{
printf("链表不相交,无交点!!!\n");return NULL;
}
while (pCur1)
{
count1++;
pCur1 = pCur1->p_next;
}
while (pCur2)
{
count2++;
pCur2 = pCur2->p_next;
}
temp = count1 - count2;
pCur1 = pHead1;
pCur2 = pHead2;
while (temp)
{
if (temp > 0)
{
pCur1 = pCur1->p_next;
temp--;
}
else
{
pCur2 = pCur2->p_next;
temp++;
}
}
while (pCur1 != pCur2)
{
pCur1 = pCur1->p_next;
pCur2 = pCur2->p_next;
}
return pCur1; //return pCur2;
}
最后附上源码;
源码
- List.h
#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int DataType;
typedef struct node
{
DataType data;
struct node *p_next;
}Node ,*PNode;
void PrintSListFromTail2Head(PNode pHead);// 逆序打印单链表
void DeleteListNotTailNode(PNode pos);// 删除链表的非尾结点,要求:不能遍历链表
void InesrtPosFront(PNode pos, DataType data);// 在链表pos位置前插入值到data的结点
PNode FindMiddleNode(PNode pHead);// 查找链表的中间结点,要求只能遍历一次链表
PNode FindLastKNode(PNode pHead, int K);// 查找链表的倒数第K个结点,要求只能遍历一次链表
void DeleteLastKNode(PNode pHead, int K);// 删除链表的倒数第K个结点,要求只能遍历一次链表
void JosephCircle(PNode* pHead, const int M);// 用单链表实现约瑟夫环
void ReverseSList(PNode* pHead);// 链表的逆置--三个指针
void ReverseSListOP(PNode *pHead);// 链表的逆置--头插法
void BubbleSort(PNode pHead);// 用冒泡排序思想对单链表进行排序
PNode MergeSList(PNode pHead1, PNode pHead2);// 合并两个有序单链表,合并后依然有序
int IsSListCross(PNode pHead1, PNode pHead2);// 判断两个单链表是否相交---链表不带环
PNode GetCorssNode(PNode pHead1, PNode pHead2);// 求两个单链表相交的交点---链表不带环
- List.c
#include"List.h"
//非接口函数声明
PNode CreatSList();//创建单链表
void SListInit(PNode* pHead);//链表初始化
void SListPushBack(PNode* pHead, DataType data);// 尾插
PNode BuyNewNode(DataType data);//申请一个新结点
void PrintfSList(PNode pHead); //打印链表
PNode SListFindNode(PNode pHead, DataType data); //找到值为data的结点
//非接口函数实现
PNode CreatSList()//创建一个链表
{
int i = 0, n = 0;
PNode pCur = NULL;
PNode pHead = NULL;
PNode pRet = NULL;
DataType data;
printf("输入链表结点数:");
scanf("%d", &n); getchar();
for (i = 0; i < n; ++i)
{
if (i == 0)
{
scanf("%d", &data); getchar();
pHead = BuyNewNode(data);
pCur = pHead;
}
else
{
scanf("%d", &data);getchar();
pRet = BuyNewNode(data);
pCur->p_next = pRet;
pCur = pRet;
}
}
return pHead;
}
void SListInit(PNode* pHead)// 链表的初始化
{
*pHead = NULL;
}
void SListPushBack(PNode* pHead, DataType data)// 尾插
{
PNode pCur = NULL;
PNode pRet = NULL;
assert(pHead);
if (*pHead == NULL)
{
*pHead = BuyNewNode(data);
(*pHead)->p_next = NULL;
return;
}
else
{
pCur = *pHead;
while (pCur->p_next)
{
pCur = pCur->p_next;
}
pRet = BuyNewNode(data);
pCur->p_next = pRet;
pRet->p_next = NULL;
}
return;
}
void PrintfSList(PNode pHead) //打印链表
{
PNode pCur = pHead;
while (pCur)
{
printf("%d ->", pCur->data);
pCur = pCur->p_next;
}
printf("NULL");
printf("\n");
}
PNode BuyNewNode(DataType data)//创建一个新结点
{
PNode pCur = NULL;
pCur = (PNode)malloc(sizeof(Node));
pCur->data = data;
pCur->p_next = NULL;
return pCur;
}
PNode SListFindNode(PNode pHead,DataType data)// 在链表中查找值为data的元素,找到后返回值为data的结点
{
PNode pCur = pHead;
//检测链表是否为空
if (pHead == NULL)
{
printf("链表中无元素!!!\n");
return NULL;
}
//链表不为空
while (pCur)
{
if (pCur->data == data)
return pCur;
pCur = pCur->p_next;
}
return NULL;
}
//接口函数实现
void PrintSListFromTail2Head(PNode pHead)// 逆序打印单链表
{
PNode pCur = pHead;
PNode pRet = NULL;
if (pHead == NULL)
return;
if (pCur->p_next)
{
PrintSListFromTail2Head(pCur->p_next);
}
if (!(pCur->p_next))
{
printf("NULL<--");printf("%d", pCur->data);
}
else
printf("<-- %d ", pCur->data);
/*if(pCur==pHead)
printf("\n");*/
}
void DeleteListNotTailNode(PNode pos)// 删除链表的非尾结点,要求:不能遍历链表
{
PNode pCur = NULL;
if (pos == NULL)
{
printf("不存在该结点,无法删除!!!\n");
return;
}
//pCur是pos的下个节点
pCur = pos->p_next;
//将pCur的值赋值给pos
pos->data = pCur->data;
//将pCur的下个结点和pos链接上
pos->p_next = pCur->p_next;
//最后free掉pCur
free(pCur);
}
void InesrtPosFront(PNode pos, DataType data)// 在链表pos位置前插入值为data的结点
{
PNode pCur = NULL;
if(NULL==pos)
{
printf("链表中无该位置,无法插入!!!\n");
return;
}
//采用交换值的方法插入
pCur = BuyNewNode(data);
pCur->p_next = pos->p_next;
pos->p_next = pCur;
//将两个结点的值交换
{
DataType temp = pos->data;
pos->data = pCur->data;
pCur->data = temp;
}
}
PNode FindMiddleNode(PNode pHead)// 查找链表的中间结点,要求只能遍历一次链表
{
PNode pSlow = pHead;
PNode pFast = pHead;
if (pHead == NULL)
return NULL;
//两个指针,快指针的速度是慢指针的2倍,快指针走到末尾时,慢指针刚好走到链表一半
while (pFast->p_next&&pFast->p_next->p_next)
{
pFast = pFast->p_next->p_next;
pSlow = pSlow->p_next;
}
if (pFast == NULL)//说明链表有奇数个结点,则返回最中间一个结点
{
return pSlow;
}
else //说明链表有偶数个结点,有两个中间结点,返回第其中一个结点
{
return pSlow; //返回中间第一个结点
#if 0
return pSlow->p_next; //返回中间第二个节点
#endif
}
}
PNode FindLastKNode(PNode pHead, int K)// 查找链表的倒数第K个结点,要求只能遍历一次链表
{
PNode pSlow = pHead;
PNode pFast = pHead;
if (pHead == NULL)
{
printf("链表为空\n");
return NULL;
}
//先让快指针走k-1步,之后满指针和快指针一快走
while (--K)
{
pFast = pFast->p_next;
}
//快慢指针一块走
while (pFast->p_next)
{
pFast = pFast->p_next;
pSlow = pSlow->p_next;
}
return pSlow; //返回慢指针
}
void DeleteLastKNode(PNode pHead, int K)// 删除链表的倒数第K个结点,要求只能遍历一次链表
{
PNode pSlow = pHead;
PNode pFast = pHead;
PNode pRet = NULL;
if (pHead == NULL)
{
printf("链表为空!!!\n");
return NULL;
}
//利用FindLastKNode函数的方法,找到倒数第K个结点,再用替换法删除
while (--K)
{
pFast = pFast->p_next;
}
while (pFast->p_next)
{
pFast = pFast->p_next;
pSlow = pSlow->p_next;
}
pRet = pSlow->p_next;
pSlow->data = pRet->data;
pSlow->p_next = pRet->p_next;
free(pRet);
}
void JosephCircle(PNode* pHead, const int M)// 用单链表实现约瑟夫环
{
PNode pCur = NULL;
PNode pPre = NULL;
PNode pRet = NULL;
int count = M;
assert(pHead);
if (*pHead == NULL)
{
return;
}
pCur = (*pHead);
while (pCur->p_next)
{
pCur = pCur->p_next;
}
pCur->p_next = (*pHead);
pCur = *pHead;
while ((pCur->p_next)!=pCur)
{
count = M;
while (--count)
{
pPre = pCur;
pCur = pCur->p_next;
}
pRet = pCur;
pPre->p_next = pCur->p_next;
pCur = pCur->p_next;
free(pRet);
}
pCur->p_next = NULL; *pHead = pCur;
return;
}
void ReverseSList(PNode* pHead)// 链表的逆置--三个指针
{
PNode pPre = NULL;//前一个结点为NULL,也就是逆置后链表的最后一个结点的Next
PNode pMid = NULL; //中间结点
PNode pNext = NULL; //后一个结点,用来保存每次逆置时链表的头结点
assert(pHead);
if (*pHead == NULL)
{
printf("链表为空!!!\n");
return;
}
pMid = *pHead;//将头结点赋值给中间结点
while (pMid)
{
pNext = pMid->p_next;//先保存下次逆置时链表的头结点
pMid->p_next = pPre;//将当前结点插入到前一个结点的前面
pPre = pMid;//前一个结点后移
pMid = pNext;//当前结点后移
}
*pHead = pPre; //最后一个结点,将其置为头结点
return;
}
void ReverseSListOP(PNode *pHead)// 链表的逆置--头插法
{
PNode pCur = NULL;
PNode pNext = NULL;
if (*pHead == NULL)
{
printf("链表为空!!!\n");
return;
}
pCur = *pHead;
while ((*pHead)->p_next)
{
pNext = (*pHead)->p_next;
(*pHead)->p_next = pNext->p_next;
pNext->p_next = pCur;
pCur = pNext;
}
*pHead=pCur ;
}
void BubbleSort(PNode pHead)// 用冒泡排序思想对单链表进行排序
{
PNode pCur = NULL;
PNode pNext = NULL;
DataType Temp = 0;
PNode pRet = NULL;
if (pHead == NULL)
{
printf("链表为空!!!\n");
return;
}
pCur = pHead; //外层循环的遍历指针
while (pCur)
{
pRet = pHead;
while (pRet&&pRet->p_next) //内层循环两个比较的指针,当循环跳出时,
{ //说明最后两个结点已经比较完了
pNext = pRet->p_next;
if (pRet->data > pNext->data) //将大的和小的交换
{
Temp = pRet->data;
pRet->data = pNext->data;
pNext->data = Temp;
}
pRet = pRet->p_next; //指针后移
}
pCur = pCur->p_next;//外层循环指针后移
}
}
PNode MergeSList(PNode pHead1, PNode pHead2)// 合并两个有序单链表,合并后依然有序
{
PNode pCur1 = NULL;
PNode pCur2= NULL;
PNode pCur = NULL;
PNode pHead = NULL;
if ((pHead1==NULL)&&(pHead2==NULL))return NULL;//判断如果两个链表都为空,退出
if ((pHead1 == NULL) || (pHead2 == NULL))
return pHead1 ? pHead2 : pHead1;
pCur1 = pHead1; pCur2 = pHead2;//将头指针赋值给各自的遍历指针
if (pCur1->data <= pCur2->data)//先找到第一个小的结点
{
pCur = pCur1; pCur1 = pHead1->p_next;//找到小的结点指针往后走一步
}
else
{
pCur = pCur2; pCur2 = pHead2->p_next;//找到小的结点指针往后走一步
}
pHead = pCur;//保存新链表的头指针
while (pCur1&&pCur2)
{
if (pCur1->data <= pCur2->data)
{
pCur->p_next = pCur1; //将小的赋值给新链表的p_next
pCur = pCur1;//新的结点往后走一步
pCur1 = pCur1->p_next;
}
else
{
pCur->p_next = pCur2;//将小的赋值给新链表的p_next
pCur = pCur2;//新的结点往后走一步
pCur2 = pCur2->p_next;
}
}
if (pCur1 == NULL)pCur->p_next = pCur2;
else pCur->p_next = pCur1;
return pHead;
}
int IsSListCross(PNode pHead1, PNode pHead2)// 判断两个单链表是否相交---链表不带环
{
PNode pCur1 = pHead1;
PNode pCur2 = pHead2;
if (pHead1 == NULL||pHead2==NULL)
{
return 0;
}
while (pCur1->p_next)
{
pCur1 = pCur1->p_next;
}
while (pCur2->p_next)
{
pCur2 = pCur2->p_next;
}
if (pCur1 == pCur2)
return 1;
else return 0;
}
PNode GetCorssNode(PNode pHead1, PNode pHead2)// 求两个单链表相交的交点---链表不带环
{
PNode pCur1 = pHead1;
PNode pCur2 = pHead2;
int count1=0, count2 = 0;
int temp = 0;
if (!IsSListCross(pHead1, pHead2))
{
printf("链表不相交,无交点!!!\n");return NULL;
}
while (pCur1)
{
count1++;
pCur1 = pCur1->p_next;
}
while (pCur2)
{
count2++;
pCur2 = pCur2->p_next;
}
temp = count1 - count2;
pCur1 = pHead1;
pCur2 = pHead2;
while (temp)
{
if (temp > 0)
{
pCur1 = pCur1->p_next;
temp--;
}
else
{
pCur2 = pCur2->p_next;
temp++;
}
}
while (pCur1 != pCur2)
{
pCur1 = pCur1->p_next;
pCur2 = pCur2->p_next;
}
return pCur1; //return pCur2;
}
- Test.c
#include"List.h"
void testPrintSListFromTail2Head(PNode pHead) //测试逆序打印
{
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
PrintfSList(pHead);
PrintSListFromTail2Head(pHead);
}
void testDeleteListNotTailNode(PNode pHead)// 测试删除链表的非尾结点,要求:不能遍历链表
{
PNode pos = NULL;
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
pos = SListFindNode(pHead, 2);
PrintfSList(pHead);
DeleteListNotTailNode(pos);
PrintfSList(pHead);
}
void testInesrtPosFront(PNode pHead) //测试在链表pos位置前插入值到data的结点
{
PNode pos = NULL;
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
pos = SListFindNode(pHead, 3);
PrintfSList(pHead);
InesrtPosFront(pos, 10);
PrintfSList(pHead);
}
void testFindMiddleNode(PNode pHead)// 测试查找链表的中间结点,要求只能遍历一次链表
{
PNode pos = NULL;
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
PrintfSList(pHead);
pos= FindMiddleNode(pHead);
printf("%d\n", pos->data);
}
void testFindLastKNode(PNode pHead)// 测试查找链表的倒数第K个结点,要求只能遍历一次链表
{
PNode pos = NULL;
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
PrintfSList(pHead);
pos=FindLastKNode(pHead, 3);
printf("%d\n", pos->data);
}
void testDeleteLastKNode(PNode pHead)// 测试删除链表的倒数第K个结点,要求只能遍历一次链表
{
PNode pos = NULL;
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
PrintfSList(pHead);
DeleteLastKNode(pHead, 2);
PrintfSList(pHead);
}
void testJosephCircle(PNode pHead)// 测试用单链表实现约瑟夫环
{
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
PrintfSList(pHead);
JosephCircle(&pHead, 3);
PrintfSList(pHead);
}
void testReverseSList(PNode pHead)// 测试链表的逆置--三个指针
{
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
PrintfSList(pHead);
ReverseSList(&pHead);
PrintfSList(pHead);
}
void testReverseSListOP(PNode pHead)// 测试链表的逆置--头插法
{
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
PrintfSList(pHead);
ReverseSListOP(&pHead);
PrintfSList(pHead);
}
void testBubbleSort(PNode pHead)// 测试用冒泡排序思想对单链表进行排序
{
SListPushBack(&pHead, 5);
SListPushBack(&pHead, 6);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 10);
SListPushBack(&pHead, 5);
PrintfSList(pHead);
BubbleSort(pHead);
PrintfSList(pHead);
}
void testMergeSList(PNode pHead1, PNode pHead2)// 测试合并两个有序单链表,合并后依然有序
{
PNode pos = NULL;
SListPushBack(&pHead1, 1);
SListPushBack(&pHead1, 3);
SListPushBack(&pHead1, 6);
SListPushBack(&pHead1, 9);
SListPushBack(&pHead1, 10);
PrintfSList(pHead1);
SListPushBack(&pHead2, 2);
SListPushBack(&pHead2, 5);
SListPushBack(&pHead2, 6);
SListPushBack(&pHead2, 10);
SListPushBack(&pHead2, 12);
PrintfSList(pHead2);
pos=MergeSList(pHead1, pHead2);
PrintfSList(pos);
}
void testIsSListCross(PNode pHead1, PNode pHead2)// 测试判断两个单链表是否相交,并求交点---链表不带环
{
PNode pos = NULL;
PNode pos1 = NULL;
PNode pos2 = NULL;
SListPushBack(&pHead1, 1);
SListPushBack(&pHead1, 3);
SListPushBack(&pHead1, 6);
SListPushBack(&pHead1, 9);
SListPushBack(&pHead1, 10);
SListPushBack(&pHead1, 12);
pos1=SListFindNode(pHead1, 6);
SListPushBack(&pHead2, 2);
SListPushBack(&pHead2, 5);
SListPushBack(&pHead2, 7);
pos2 = SListFindNode(pHead2, 7);
pos2->p_next = pos1;
PrintfSList(pHead1);
PrintfSList(pHead2);
printf("%d\n",IsSListCross(pHead1,pHead2));
pos=GetCorssNode(pHead1,pHead2);// 求两个单链表相交的交点---链表不带环
printf("两链表的交点是%d\n", pos->data);
}
int main()
{
PNode pHead = NULL;
PNode pHead1 = NULL;
PNode pHead2 = NULL;
//testPrintSListFromTail2Head(pHead);printf("\n"); //逆序打印测试
//testDeleteListNotTailNode(pHead);//测试删除链表的非尾结点
//testInesrtPosFront(pHead);//测试在链表pos位置前插入值到data的结点
//testFindMiddleNode(pHead);//测试查找链表的中间结点,要求只能遍历一次链表
//testFindLastKNode(pHead);//测试查找链表的倒数第K个结点,要求只能遍历一次链表
//testDeleteLastKNode(pHead);//测试 删除链表的倒数第K个结点,要求只能遍历一次链表
//testJosephCircle(pHead);//测试用单链表实现约瑟夫环
//testReverseSList(pHead);//测试链表的逆置--三个指针
//testReverseSListOP(pHead);//测试链表的逆置--头插法
//testBubbleSort(pHead);//测试用冒泡排序思想对单链表进行排序
//testMergeSList(pHead1, pHead2);//测试合并两个有序单链表,合并后依然有序
//testIsSListCross(pHead1, pHead2);//测试判断两个单链表是否相交,求交点---链表不带环
system("pause");
return 0;
}