单链表中的一些经典问题--约瑟夫环,逆序,查找,复杂链表复制,链表带环问题

对于单链表中一些经典问题的总结,所涉及的问题主要包括以下几点:
     1. 从尾到头打印单链表-->2. 删除无头单链表的非尾结点-->3. 在无头单链表pos位置前插入值为结点data的结点-->4. 用单链表模拟实现约瑟夫环-->5. 使用冒泡排序方法对单链表进行排序-->6. 单链表的逆置--三个指针-->7. 单链表的逆置--头插法-->8. 合并两个有序链表，合并之后依然有序-->9. 查找链表的中间结点，要求只能遍历一次链表-->10. 查找链表的倒数第K个结点(遍历一次链表)--->11. 删除链表的倒数第K个结点-->12. 判断单链表是否相交？链表不带环 -->13. 求不带环单链表相交交点-->14. 判断链表是否带环-->15. 求环的长度-->16. 求环的入口点-->17. 判断链表是否带环，链表可能带环-->18. 复杂链表的复制-->19. 求两个已排单链表中相同的数据
下面是一些C语言代码的实现:
slist.c

#define _CRT_SECURE_NO_WARNINGS 0;
#include "slist.h"

// 链表初始化
void SListInit(pNode* pHead)
{
assert(pHead);
*pHead = NULL;
}
// 获取结点
pNode BuySListNode(DataType data)
{
pNode pNewNode = (pNode)malloc(sizeof(Node));
if (NULL == pNewNode)
exit(EXIT_FAILURE);

pNewNode->_pNext = NULL;
pNewNode->_data = data;
return pNewNode;
}

//打印单链表
void printSList(pNode pHead)
{
pNode pCur= pHead;
if (NULL == pHead)
return;

while (pCur)
{
printf("%d->", pCur->_data);
pCur=pCur->_pNext;
}
printf("NULL\n");
}
// 尾插
void SListPushBack(pNode* pHead, DataType data)
{
assert(pHead);
pNode pCur = NULL;
pNode pNewNode = BuySListNode(data);
if (NULL == *pHead)
{
*pHead = pNewNode;
}
else
{
pCur = *pHead;
while (pCur->_pNext)
{
pCur = pCur->_pNext;
}
pCur->_pNext = pNewNode;
}
}

// 从尾到头打印单链表
void PrintListFromTail2Head(pNode pHead)
{
pNode pCur = pHead;
if (pCur)
{
PrintListFromTail2Head(pCur->_pNext);
printf("%d->", pCur->_data);
}
}

// 删除无头单链表的非尾结点，要求：不能遍历链表
void DeleteNotTailNode(pNode pos)
{
pNode pCur = NULL;
if (NULL == pos || NULL==pos->_pNext)
return;

pCur = pos->_pNext;
pos->_data=pos->_pNext->_data;
pos->_pNext = pos->_pNext->_pNext;
free(pCur);
}
// 在无头单链表pos位置前插入值为结点data的结点 (不遍历链表)
void InsertPosFront(pNode pos, DataType data)
{
pNode pNewNode = NULL;
if (NULL == pos)
return;

pNewNode = BuySListNode(pos->_data);
pNewNode->_pNext = pos->_pNext;
pos->_pNext = pNewNode;
pos->_data = data;
}

// 用单链表模拟实现约瑟夫环
void JosephCircle(pNode* pHead, const int M)
{
assert(pHead);
pNode pCur = NULL;
int count = 0;
SListPushBack(pHead, 1);    //开始构环
SListPushBack(pHead, 2);
SListPushBack(pHead, 3);
SListPushBack(pHead, 4);
pCur = *pHead;
while (pCur->_pNext)
{
pCur = pCur->_pNext;
}
pCur->_pNext = *pHead;

pCur = *pHead;
while (pCur->_pNext!=pCur)
{
count = M;       //报数 -->删结点
while (--count)
{
pCur = pCur->_pNext;
}
DeleteNotTailNode(pCur);
}
pCur->_pNext = NULL;   // 解环
*pHead = pCur;
}

// 求链表中结点的个数
int SListSize(pNode pHead)
{
int count = 0;
if (NULL == pHead)
return count;
else
{
while (pHead)
{
count++;
pHead = pHead->_pNext;
}
return count;
}
}
// 使用冒泡排序方法对单链表进行排序
void BubbleSort(pNode pHead)
{
int ret = 0;
int i = 0,j = 0,cur=0;
pNode pCur = NULL;
if (NULL == pHead)
return;

ret = SListSize(pHead);

for (i = 0; i < ret - 1; i++)
{
cur = 0;
pCur = pHead;
for (j = 0; j < ret - 1 - i; j++)
{
if ((pCur->_data)>(pCur->_pNext->_data))
{
cur = 1;
int tmp = pCur->_data;
pCur->_data = pCur->_pNext->_data;
pCur->_pNext->_data = tmp;
}
pCur = pCur->_pNext;
}

if (cur == 0)
return;
}
}

// 单链表的逆置--三个指针
void ReverseSList(pNode* pHead)
{
assert(pHead);
pNode pCur = NULL;
pNode pPre = NULL;
pNode pNext = NULL;
if (NULL == pHead)
return;

pCur = *pHead;
while (pCur)
{
pNext = pCur->_pNext;
pCur->_pNext = pPre;
pPre = pCur;
pCur = pNext;
}
*pHead = pPre;
}
// 头插
void SListPushFront(pNode* pHead, DataType data)
{
assert(pHead);
pNode pNewNode = BuySListNode(data);

pNewNode->_pNext = *pHead;
*pHead = pNewNode;
}
// 单链表的逆置--头插法
pNode ReverseSListOP(pNode pHead)
{
pNode pNewNode = NULL;
pNode pCur = pHead;

while (pCur)
{
SListPushFront(&pNewNode,pCur->_data);
pCur = pCur->_pNext;
}
return pNewNode;
}

// 合并两个有序链表，合并之后依然有序
pNode MergeSList(pNode pHead1, pNode pHead2)
{
pNode pCur1 = NULL;
pNode pCur2 = NULL;
pNode pNewNode = NULL;
pNode pTail = NULL;
if (NULL == pHead1)     //链表1为空的话返回链表2
return pHead2;
if (NULL == pHead2)    //链表2为空的话返回链表1
return pHead1;

pCur1 = pHead1;
pCur2 = pHead2;
if ((pCur1->_data) < (pCur2->_data))    //比较两个头结点大小,让pNewNode指针指向值小的结点
{
pNewNode = pCur1;
pCur1 = pCur1->_pNext;
}
else
{
pNewNode = pCur2;
pCur2 = pCur2->_pNext;
}

pTail = pNewNode;
while (pCur1 && pCur2)                //开始合并后面的结点
{
if ((pCur1->_data) < (pCur2->_data))
{
pTail->_pNext = pCur1;
pTail = pTail->_pNext;
pCur1 = pCur1->_pNext;
}
else
{
pTail->_pNext = pCur2;
pTail = pTail->_pNext;
pCur2 = pCur2->_pNext;
}
}
if (pCur1)                          //链表1不为空
{
pTail->_pNext = pCur1;
}
if (pCur2)                         //链表2不为空
{
pTail->_pNext = pCur2;
}

return pNewNode;
}

// 查找链表的中间结点，要求只能遍历一次链表
pNode FindMiddleNode(pNode pHead)
{
assert(pHead);
pNode pFast = pHead;
pNode pSlow = pHead;

while (pFast && pFast->_pNext)
{
pSlow = pSlow->_pNext;
pFast = pFast->_pNext->_pNext;
}
return pSlow;
}
// 查找链表的倒数第K个结点，要求只能遍历链表一次
pNode FindLastKNode(pNode pHead, int K)
{
assert(pHead);
pNode pSlow = pHead;
pNode pFast = pHead;
if (K<0 || K>SListSize(pHead))
return NULL;

while (K--)
{
pFast = pFast->_pNext;
}
while (pFast)
{
pFast = pFast->_pNext;
pSlow = pSlow->_pNext;
}
return pSlow;
}
// 删除链表的倒数第K个结点，要求只能遍历链表一次
void DeleteLastKNode(pNode *pHead, int K)
{
assert(pHead);
pNode pCur = NULL;
pNode pTest = NULL;
pCur=FindLastKNode(*pHead, K);
if (NULL == pCur)
return;

if (pCur == *pHead)  //假如是删除头结点
{
*pHead = pCur->_pNext;
free(pCur);
pCur = NULL;
return;
}
else            //删除其他结点
{
pTest = *pHead;
while (pTest->_pNext != pCur)
{
pTest = pTest->_pNext;
}
pTest->_pNext = pCur->_pNext;
free(pCur);
}
}
// 判断单链表是否相交？链表不带环 --(三种情况: 1-
4000
->尾点相交2-->中间任意位置结点相交, 3-->头结点相交)
pNode IsCrossWithoutCircle(pNode pHead1, pNode pHead2)
{
int size = 0;
pNode pCur1 = NULL;
pNode pCur2 = NULL;
if (NULL == pHead1 || NULL==pHead2)
return NULL;

pCur1 = pHead1;
pCur2 = pHead2;
size = SListSize(pHead1) - SListSize(pHead2);
if (size > 0)
{
while (size--)
{
pCur1 = pCur1->_pNext;
}

while (pCur1 && pCur2)
{
if (pCur1 == pCur2)
return pCur1;

pCur1 = pCur1->_pNext;
pCur2 = pCur2->_pNext;
}
return NULL;

}
else if (size < 0)
{
while (size++)
{
pCur2 = pCur2->_pNext;
}

while (pCur1 && pCur2)
{
if (pCur1 == pCur2)
return pCur1;

pCur1 = pCur1->_pNext;
pCur2 = pCur2->_pNext;
}
return NULL;
}
else
{
while (pCur1 && pCur2)
{
if (pCur1 == pCur2)
return pCur1;

pCur1 = pCur1->_pNext;
pCur2 = pCur2->_pNext;
}
return NULL;
}
}
// 求不带环单链表相交交点
pNode GetCrossNode(pNode pHead1, pNode pHead2)
{
pNode pCur=IsCrossWithoutCircle(pHead1, pHead2);
return pCur;
}
// 判断链表是否带环
pNode IsCircle(pNode pHead)
{
pNode pFast = NULL;
pNode pSlow = NULL;
if (NULL == pHead)
return NULL;

pFast = pHead;
pSlow = pHead;
while (pFast && pFast->_pNext)
{
pFast = pFast->_pNext->_pNext;
pSlow = pSlow->_pNext;
if (pFast == pSlow)
return pSlow;
}
return NULL;
}
// 求环的长度
int GetCircleLen(pNode pHead)
{
pNode pRet=IsCircle(pHead);
pNode pCur = pRet;
int count = 1;
if (NULL == pRet)
return 0;

while (pCur->_pNext != pRet)
{
count++;
pCur = pCur->_pNext;
}
return count;
}

// 求环的入口点
pNode GetEnterNode(pNode pHead)
{
pNode pRet=IsCircle(pHead);
pNode pCur1 = pHead;
pNode pCur2 = pRet;
if (NULL == pRet)
return NULL;

while (pCur1 != pCur2)
{
pCur1 = pCur1->_pNext;
pCur2 = pCur2->_pNext;
}
return pCur2;
}

// 判断链表是否相交,若相交求交点
pNode IsListCrossWithCircle(pNode pHead1, pNode pHead2)
{
pNode pCur1 = IsCircle(pHead1);   //判断是否带环
pNode pCur2 = IsCircle(pHead2);
if (NULL == pCur1 && NULL == pCur2)  //两个都不带环
{
pNode pRet=IsCrossWithoutCircle(pHead1, pHead2);
return pRet;
}
else if (pCur1 != NULL && pCur2 != NULL)  //两个都带环 (可能情况:环内相交,环外相交)
{
pNode pEnterNode1= GetEnterNode(pHead1);
pNode pEnterNode2 = GetEnterNode(pHead2);
int count1 = 1;
int count2 = 1;
int size = 0;
pNode pCur3 = pHead1;
pNode pCur4 = pHead2;
if (pEnterNode1 == pEnterNode2)  //环外相交
{
while (pHead1 != pEnterNode1)
{
count1++;
pHead1 = pHead1->_pNext;
}
while (pHead2 != pEnterNode1)
{
count2++;
pHead2 = pHead2->_pNext;
}
size = count1 - count2;

if (size > 0)
{
while (size--)
{
pCur3 = pCur3->_pNext;
}

while (pCur3 && pCur4)
{
if (pCur3 == pCur4)
return pCur3;

pCur3 = pCur3->_pNext;
pCur4 = pCur4->_pNext;
}
return NULL;
}
else if (size < 0)
{
while (size++)
{
pCur4 = pCur4->_pNext;
}

while (pCur4 && pCur3)
{
if (pCur3 == pCur4)
return pCur3;

pCur3 = pCur3->_pNext;
pCur4 = pCur4->_pNext;
}
return NULL;
}
}
else                          //环内相交
{
pNode pE1 = pEnterNode1;
pNode pE2 = pEnterNode2;
do
{
if (pE1 == pE2)
return pE1;

pE1 = pE1->_pNext;
pE2 = pE2->_pNext->_pNext;
}while (pE1!= pEnterNode1);

return NULL;
}
}
else                          //其他情况
return NULL;
}
// 复杂链表初始化
void CListNodeInit(PCListNode* pHead)
{
assert(pHead);
*pHead = NULL;
}
// 复杂链表获取结点
PCListNode BuyCListNode(DataType data)
{
PCListNode pNewNode = (PCListNode)malloc(sizeof(CListNode));
if (NULL == pNewNode)
exit(EXIT_FAILURE);

pNewNode->_pNext = NULL;
pNewNode->_pRandom = NULL;
pNewNode->data = data;
return pNewNode;
}
//复杂链表的尾插
void CListNodePushBack(PCListNode *pHead, DataType data)
{
assert(pHead);
PCListNode pCur = NULL;
PCListNode pNewNode = BuyCListNode(data);
if (NULL == *pHead)
{
*pHead = pNewNode;
}
else
{
pCur = *pHead;
while (pCur->_pNext)
{
pCur = pCur->_pNext;
}
pCur->_pNext = pNewNode;
}
}
// 复杂链表的复制
PCListNode CopyComplexList(PCListNode pHead)
{
PCListNode p1 = NULL;
PCListNode p2 = NULL;
PCListNode pCur = NULL;
PCListNode pNewNode = NULL;
PCListNode pNext = NULL;
if (NULL == pHead)
return NULL;

pCur = pHead;
while (pCur)
{
pNewNode = BuyCListNode(pCur->data);    //复制数据到data
pNewNode->_pNext = pCur->_pNext;
pCur->_pNext = pNewNode;
pCur = pNewNode->_pNext;
}

p1 = pHead;
while (p1)                        //给random赋值
{
p2 = p1->_pNext;
if (p1->_pRandom != NULL)
p2->_pRandom = p1->_pRandom->_pNext;

p1 = p2->_pNext;
}
pNewNode = pHead->_pNext;
p2 = pNewNode;
p1 = pHead;
while (p2->_pNext)                                //拆除
{
pNext = p2->_pNext;
p1->_pNext = pNext;
p2->_pNext = pNext->_pNext;
p1 = pNext;
p2 = pNext->_pNext;
}
p1->_pNext = NULL;
p2->_pNext = NULL;

return pNewNode;
}

//两个已排单链表中相同的数据
pNode UnionSet(pNode pHead1, pNode pHead2)
{
pNode pNewNode = NULL;
pNode pCur1 = NULL;
pNode pCur2 = NULL;
pNode pTail = NULL;
int data = 0;
if (NULL == pHead1 || NULL == pHead2)
return NULL;

pCur1 = pHead1;
pCur2 = pHead2;
pTail = pNewNode;
while (pCur1 && pCur2)
{
if ((pCur1->_data) < (pCur2->_data))
{
pCur1 = pCur1->_pNext;
}
else if ((pCur1->_data) > (pCur2->_data))
{
pCur2 = pCur2->_pNext;
}
else
{
if (NULL == pNewNode)           //判断新结点是否为空
{
pNewNode = BuySListNode(pCur2->_data);
pTail = pNewNode;
pCur1 = pCur1->_pNext;
pCur2 = pCur2->_pNext;
}
else                           //新链表非空
{
pTail = pTail->_pNext;
pTail = BuySListNode(pCur1->_data);
pCur1 = pCur1->_pNext;
pCur2 = pCur2->_pNext;
}
}
}
return pNewNode;
}

test.c

#define _CRT_SECURE_NO_WARNINGS 0;
#include "slist.h"

void testSListPushBack()
{
pNode pHead;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
}
void testPrintListFromTail2Head()
{
pNode pHead;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
PrintListFromTail2Head(pHead);
}

void testDeleteNotTailNode()
{
pNode pHead;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
DeleteNotTailNode(pHead->_pNext);
DeleteNotTailNode(pHead);
DeleteNotTailNode(pHead->_pNext->_pNext);

}
void testInsertPosFront()
{
pNode pHead;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
printSList(pHead);
InsertPosFront(pHead->_pNext->_pNext->_pNext->_pNext, 0);
printSList(pHead);
InsertPosFront(pHead, 0);
printSList(pHead);
InsertPosFront(pHead->_pNext->_pNext, 6);
printSList(pHead);

}
void testJosephCircle()
{
pNode pHead;
SListInit(&pHead);
JosephCircle(&pHead, 3);
printSList(pHead);

}
void testBubbleSort()
{
pNode pHead;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
SListPushBack(&pHead, 5);
SListPushBack(&pHead, 6);
SListPushBack(&pHead, 7);
printSList(pHead);
BubbleSort(pHead);
printSList(pHead);
}

void testReverseSList()
{
pNode pHead;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
printSList(pHead);
ReverseSList(&pHead);
printSList(pHead);
}
void testReverseSListOP()
{
pNode pHead;
pNode pCur = NULL;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
printSList(pHead);
pCur=ReverseSListOP(pHead);
printSList(pCur);
}

void testFindMiddleNode()
{
pNode pHead;
pNode pCur = NULL;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
printSList(pHead);
pCur=FindMiddleNode(pHead);
printf("%d\n", pCur->_data);
}
void testFindLastKNode()
{
pNode pHead;
pNode pCur = NULL;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
printSList(pHead);
pCur=FindLastKNode(pHead, 1);
pCur = FindLastKNode(pHead,3);
pCur = FindLastKNode(pHead, 4);
printf("%d\n", pCur->_data);
}
void testDeleteLastKNode()
{
pNode pHead;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
printSList(pHead);
DeleteLastKNode(&pHead, 4);
DeleteLastKNode(&pHead, 1);
DeleteLastKNode(&pHead, 3);
printSList(pHead);;
}
void testIsCrossWithoutCircle()
{
pNode pHead;
pNode pHead2;
pNode ret = NULL;
pNode pCur = NULL;
pNode pCur2 = NULL;
SListInit(&pHead);
SListInit(&pHead2);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);

SListPushBack(&pHead2, 1);
SListPushBack(&pHead2, 2);
SListPushBack(&pHead2, 3);
SListPushBack(&pHead2, 4);
pCur = pHead;
pCur2 = pHead2;
while (pCur->_pNext)
{
pCur = pCur->_pNext;
}
pCur->_pNext = pCur2;   //头结点相交场景
pCur->_pNext = pCur2->_pNext->_pNext;   //中间结点相交场景
while (pCur2->_pNext)
{
pCur2 = pCur2->_pNext;
}
pCur->_pNext = pCur2;      //尾点相交场景
ret=IsCrossWithoutCircle(pHead, pHead2);  //测试构造不相交场景
ret = IsCrossWithoutCircle(pHead, pHead2);//测试尾点相交场景
ret = IsCrossWithoutCircle(pHead, pHead2);//测试中间结点相交
ret = IsCrossWithoutCircle(pHead, pHead2);//测试头结点相交
ret = IsCrossWithoutCircle(pHead, pHead2);//测试一个链表位空

}

void testIsCircle()
{
pNode pHead;
pNode pRet = NULL;
pNode pCur = NULL;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
pCur = pHead;
while (pCur->_pNext)
{
pCur = pCur->_pNext;
}
pCur->_pNext = pHead; //指向头结点
pCur->_pNext = pHead->_pNext->_pNext;  //指向中间结点
pRet=IsCircle(pHead); //测试没有环的场景
pRet= IsCircle(pHead);//测试指向中间结点
pRet = IsCircle(pHead);//测试指向头结点
}
void testGetCircleLen()   //测试环的长度以及环的入口点
{
pNode pHead;
int ret = 0;
pNode pCur = NULL;
pNode pRet = NULL;
SListInit(&pHead);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);
pCur = pHead;
while (pCur->_pNext)
{
pCur = pCur->_pNext;
}
pCur->_pNext = pHead->_pNext->_pNext;  //指向中间结点
pCur->_pNext = pHead; //指向头结点
ret=GetCircleLen(pHead);
pRet = GetEnterNode(pHead);
}
void testIsListCrossWithCircle()
{
pNode pHead;
pNode pHead2;
pNode pRet = NULL;
pNode pCur1 = NULL;
pNode pCur2 = NULL;
SListInit(&pHead);
SListInit(&pHead2);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 2);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 4);

SListPushBack(&pHead2, 5);
SListPushBack(&pHead2, 6);
SListPushBack(&pHead2, 7);
SListPushBack(&pHead2, 8);
SListPushBack(&pHead2, 9);
SListPushBack(&pHead2, 0);
SListPushBack(&pHead2, 10);
pCur1 = pHead;
pCur2 = pHead2;
while (pCur1->_pNext)
{
pCur1 = pCur1->_pNext;
}
while (pCur2->_pNext)
{
pCur2 = pCur2->_pNext;
}
pCur2->_pNext = pHead2->_pNext->_pNext;//测试一个带环一个不带环
pCur2->_pNext = pHead2->_pNext->_pNext;        //测试两带环环内相交场景
pCur1->_pNext = pHead2->_pNext->_pNext->_pNext;
pCur2->_pNext = pHead2->_pNext->_pNext->_pNext;  //测试两带环环外相交场景
pCur1->_pNext = pHead2->_pNext->_pNext;
pCur1->_pNext = pHead;  //测试两带环链表不相交场景
pCur2->_pNext = pHead2;
pCur1->_pNext = pCur2->_pNext;//不带环中间结点相交
pCur1->_pNext = pHead2; //不带环指向头结点
pCur1->_pNext = pCur2;  //不带环尾结点相交
pRet=IsListCrossWithCircle(pHead, pHead2);
}
void testCopyComplexList()
{
PCListNode pHead;
PCListNode pCur = NULL;
PCListNode pRet = NULL;
CListNodeInit(&pHead);
CListNodePushBack(&pHead, 1);
CListNodePushBack(&pHead, 2);
CListNodePushBack(&pHead, 3);
CListNodePushBack(&pHead, 4);
pCur = pHead;
pCur->_pRandom = pCur->_pNext->_pNext;          //给链表random赋值
pCur->_pNext->_pRandom = pCur;
pCur->_pNext->_pNext->_pRandom = pCur->_pNext->_pNext;
pCur->_pNext->_pNext->_pNext->_pRandom = NULL;
pRet=CopyComplexList(pHead);
}

void testMergeSList()
{
pNode pHead;
pNode pHead2;
pNode pRet = NULL;
SListInit(&pHead);
SListInit(&pHead2);
SListPushBack(&pHead, 11);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 5);
SListPushBack(&pHead, 7);
printSList(pHead);

SListPushBack(&pHead2, 1);
SListPushBack(&pHead2, 4);
SListPushBack(&pHead2, 6);
SListPushBack(&pHead2, 8);
SListPushBack(&pHead2, 10);
printSList(pHead2);
pRet=MergeSList(pHead, pHead2);
printSList(pRet);
}
void testUnionSet()
{
pNode pHead;
pNode pHead2;
pNode pRet = NULL;
SListInit(&pHead);
SListInit(&pHead2);
SListPushBack(&pHead, 1);
SListPushBack(&pHead, 3);
SListPushBack(&pHead, 5);
SListPushBack(&pHead, 7);
printSList(pHead);

SListPushBack(&pHead2, 1);
SListPushBack(&pHead2, 2);
SListPushBack(&pHead2, 3);
SListPushBack(&pHead2, 6);
SListPushBack(&pHead2, 7);
printSList(pHead2);
pRet=UnionSet(pHead, pHead2);
printSList(pRet);
}
void testSlist()
{
testSListPushBack();
testPrintListFromTail2Head();
testDeleteNotTailNode();
testInsertPosFront();
testJosephCircle();
testBubbleSort();
testReverseSList();
testReverseSListOP();
testFindMiddleNode();
testFindLastKNode();
testDeleteLastKNode();
testIsCrossWithoutCircle();
testIsCircle();
testGetCircleLen();
testIsListCrossWithCircle();
testCopyComplexList();
testMergeSList();
testUnionSet();

}
int main()
{
testSlist();
system("pause");
return 0;
}

slist.h

#pragma once

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

typedef int DataType;
typedef struct CListNode
{
DataType data;
struct CListNode* _pNext;
struct CListNode* _pRandom;
}CListNode, *PCListNode;

typedef struct ListNode
{
DataType _data;
struct ListNode* _pNext;
}Node,*pNode;

void SListInit(pNode* pHead);
void printSList(pNode pHead);
void SListPushBack(pNode* pHead, DataType data);
pNode BuySListNode(DataType data);
void PrintListFromTail2Head(pNode pHead);
void DeleteNotTailNode(pNode pos);
void InsertPosFront(pNode pos, DataType data);
void JosephCircle(pNode* pHead, const int M);
void BubbleSort(pNode pHead);
int SListSize(pNode pHead);
void ReverseSList(pNode* pHead);
pNode ReverseSListOP(pNode pH
a01f
ead);
void SListPushFront(pNode* pHead, DataType data);
pNode MergeSList(pNode pHead1, pNode pHead2);
pNode FindMiddleNode(pNode pHead);
pNode FindLastKNode(pNode pHead, int K);
void DeleteLastKNode(pNode *pHead, int K);
pNode IsCrossWithoutCircle(pNode pHead1, pNode pHead2);
pNode IsCircle(pNode pHead);
int GetCircleLen(pNode pHead);
pNode GetEnterNode(pNode pHead);
pNode IsListCrossWithCircle(pNode pHead1, pNode pHead2);
void CListNodeInit(PCListNode* pHead);
PCListNode BuyCListNode(DataType data);
void CListNodePushBack(PCListNode *pHead, DataType data);
PCListNode CopyComplexList(PCListNode pHead);
pNode UnionSet(pNode pHead1, pNode pHead2);

顺序表和链表的一些区别:
1--->顺序表支持随机访问,而单链表并不支持;
2-->顺序表插入和删除数据效率很低,时间复杂度为o(N)(尾插尾删除外),单链表插入和删除效率更高;
3-->顺序表CPU高速缓存效率更高,单链表CPU高速缓存效率低;
4--->顺序表尾插尾删还是很方便滴;
5-->链表容易造成内存碎片