【C语言】链表 题

Slist.h

#pragma once

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

typedef int DataType;

typedef struct ListNode
{
DataType data;
struct ListNode *pNext;
}SListNode, *PSListNode;

//初始化单链表(对于无头结点单链表，该函数没有意义)
void InitList(PSListNode* pHead);

// 销毁单链表
void DestroyList(PSListNode* pHead);

// 尾插
void PushBack(PSListNode* pHead, DataType data);

// 尾出
void PopBack(PSListNode* pHead);

// 头插
void PushFront(PSListNode* pHead, DataType data);

// 头出
void PopFront(PSListNode* pHead);

// 查找元素data
PSListNode Find(PSListNode pHead, DataType data);

// 删除pos位置的结点
void  Erase(PSListNode* pHead, PSListNode pos);

// 在链表的pos位置插入元素data
void  Insert(PSListNode* pHead, PSListNode pos, DataType data);

//打印
void PrintList(PSListNode pHead);

// 从头至尾打印单链表
void PrintListTailToHead(PSListNode pHead);

// 链表的非头结点前插入元素data
void InsertNotHead(PSListNode pos, DataType data);

// 删除链表的非尾结点
void DelNotTailNode(PSListNode pos);

// 查找链表的中间结点，要求只遍历一次链表
PSListNode FindMidNode(PSListNode pHead);

// 约瑟夫环问题
PSListNode JosephusCircle(PSListNode pHead, int M);

//反转（逆置）单链表
void ReverseList(PSListNode *pHead);

//冒泡排序链表
void BubbleSort(PSListNode pHead);

//合并两个有序链表
PSListNode MergeList(PSListNode pList1, PSListNode pList2);

//删除链表的倒数第K个结点
void DelNodeK(PSListNode* pHead, int K);

//求环的长度
int GetCyleLen(PSListNode pMeetNode);

// 判断链表是否带环,若带环返回环入口点
PSListNode CheckCycle(PSListNode pHead);

//获取环入口点
PSListNode GetCircleEntryNode(PSListNode pHead, PSListNode pMeetNode);

//判断两个链表是否相交，假设两个链表都不带环
int CheckCross(PSListNode pList1Head, PSListNode pList2Head);

//判断两个链表是否相交
int IsListCroseWithCycle(PSListNode pL1, PSListNode pL2);

SList.c

#include "SList.h"

//初始化
void InitList(PSListNode* pHead)
{
*pHead = NULL;
}

//打印
void PrintList(PSListNode pHead)
{
PSListNode pCurNode = pHead;
while(pCurNode)
{
printf("%d->", pCurNode->data);
pCurNode = pCurNode->pNext;
}
printf("NULL\n");
}

PSListNode BuyNode(DataType data)
{
PSListNode pTemp = (PSListNode)malloc(sizeof(SListNode));
if(NULL == pTemp)
{
return NULL;
}
pTemp->data = data;
pTemp->pNext = NULL;
return pTemp;
}

//尾插
void PushBack(PSListNode* pHead, DataType data)
{
PSListNode pNode = *pHead;
if (NULL == *pHead)//当链表是空链表时
{
*pHead = BuyNode(data);
}
else
{
while(pNode->pNext)
{
pNode = pNode->pNext;
}

pNode->pNext = BuyNode(data);
}
}

// 尾出
void PopBack(PSListNode* pHead)
{
PSListNode pCurNode = *pHead;//当前结点
PSListNode pPreNode = pCurNode;//前一个结点
assert(pHead);
if(NULL == *pHead)
{
return;
}
else if((*pHead)->pNext == NULL)//只有一个结点的情况
{
free(*pHead);
*pHead = NULL;
return;
}
while (pCurNode->pNext)//找尾
{
pPreNode = pCurNode;
pCurNode = pPreNode->pNext;
}

free(pCurNode);
pPreNode->pNext = NULL;
}

//头插
void PushFront(PSListNode* pHead, DataType data)
{
PSListNode pNewNode = NULL;
assert(pHead);
if(NULL == *pHead)
{
return;
}
pNewNode = BuyNode(data);
if(pNewNode != NULL)
{
pNewNode->pNext = *pHead;
*pHead = pNewNode;
}
}

// 头出
void PopFront(PSListNode* pHead)
{
PSListNode pCurNode = *pHead;
assert(pHead);
if(NULL == *pHead)
{
return;
}
*pHead = pCurNode->pNext;
free(pCurNode);
}

// 查找元素data
PSListNode Find(PSListNode pHead, DataType data)
{
PSListNode pCurNode = pHead;
while(pCurNode)
{
if(data == pCurNode->data)
{
return pCurNode;
}
pCurNode = pCurNode->pNext;
}
return NULL;
}

// 删除pos位置的结点
void  Erase(PSListNode* pHead, PSListNode pos)
{
PSListNode pPreNode = *pHead;
assert(pHead);
assert(pos);
if(NULL == *pHead)
{
return;
}
if(pos == *pHead)//如果pos是头结点
{
*pHead =pos->pNext;
free(pos);
return;
}
while (pPreNode)
{
if(pPreNode->pNext == pos)
{
pPreNode->pNext = pos->pNext;
free(pos);
return;
}
pPreNode = pPreNode->pNext;
}
}

// 在链表的pos位置插入元素data
void  Insert(PSListNode* pHead, PSListNode pos, DataType data)
{
PSListNode pNewNode = NULL;
assert(pHead);
assert(pos);
if(NULL == *pHead)
{
return;
}
pNewNode = BuyNode(data);
if(NULL != pNewNode)
{
pNewNode->pNext = pos->pNext;
pos->pNext = pNewNode;
}
}

//销毁
void DestroyList(PSListNode* pHead)
{
PSListNode pPreNode = NULL;
PSListNode pCurNode = NULL;
assert(pHead);
pCurNode = *pHead;
while (pCurNode)
{
pPreNode = pCurNode;
pCurNode = pCurNode->pNext;
free(pPreNode);
}
*pHead =NULL;
}

// 从头至尾打印单链表
void PrintListTailToHead(PSListNode pHead)
{
if(NULL != pHead)
{
PrintListTailToHead(pHead->pNext);
printf("%d", pHead->data);
}
}

// 链表的非头结点前插入元素data
void InsertNotHead(PSListNode pos, DataType data)
{
PSListNode pNewNode = NULL;
assert(pos);
pNewNode = BuyNode(data);
if(NULL != pNewNode)
{
pNewNode->pNext = pos->pNext;
pos->pNext = pNewNode;
pos->data = data;
}
}

// 删除链表的非尾结点
void DelNotTailNode(PSListNode pos)
{
PSListNode pDelNode = NULL;
assert(pos);
assert(pos->pNext);
pDelNode = pos->pNext;
pos->data = pDelNode->pNext->data;
pos->pNext = pDelNode->pNext;
free(pDelNode);
}

// 查找链表的中间结点，要求只遍历一次链表
PSListNode FindMidNode(PSListNode pHead)
{
PSListNode pFast = pHead;
PSListNode pSlow = pHead;
while((pFast != NULL)&&(pFast->pNext != NULL))
{
pFast = pFast->pNext->pNext;
pSlow = pSlow->pNext;
}
return pSlow;
}

//约瑟夫环问题
PSListNode JosephusCircle(PSListNode pHead, int M)
{
PSListNode pNode = pHead;
PSListNode pDelNode = NULL;
int K = M;
if((NULL == pHead)||(M <= 0))
{
return NULL;
}

while(pNode->pNext != pNode)
{
K = M;
while(--K)
{
pNode = pNode->pNext;
}
pDelNode = pNode->pNext;
pNode->data = pDelNode->pNext->data;
pNode->pNext = pDelNode->pNext;
free(pDelNode);
}
return pNode;
}

//反转（逆置）单链表
void ReverseList(PSListNode *pHead)
{
PSListNode pPreNode = NULL;
PSListNode pCurNode = NULL;
PSListNode pNewHead = NULL;
assert(pHead);
if((NULL == *pHead)||(NULL == (*pHead)->pNext))
{
return;
}
pCurNode = *pHead;
while(pCurNode)
{
pPreNode = pCurNode;
pCurNode = pCurNode->pNext;
pPreNode->pNext = pNewHead;
pNewHead = pPreNode;
}
*pHead = pNewHead;
}

//冒泡排序链表
void BubbleSort(PSListNode pHead)
{
PSListNode pNode = NULL;
PSListNode pTailNode = NULL;
if(NULL == pHead)
{
return;
}
while(pHead != pTailNode)
{
pNode = pHead;
while(pNode->pNext != pTailNode)
{
if(pNode->data < pNode->pNext->data)
{
DataType temp = pNode->data;
pNode->data = pNode->pNext->data;
pNode->pNext->data = temp;
}
pNode = pNode->pNext;
}
pTailNode = pNode;
}
}

//合并两个有序链表
PSListNode MergeList(PSListNode pList1Head, PSListNode pList2Head)
{
PSListNode pNewHead = NULL;
PSListNode pList1Node = pList1Head;
PSListNode pList2Node = pList2Head;
PSListNode pNode = NULL;
PSListNode pTailNode = NULL;
if(NULL == pList1Head)//List1为空链表时
{
return pList2Head;
}
if(NULL == pList2Head)//List2为空链表时
{
return pList1Head;
}
if (pList1Node->data < pList2Node->data)
{
pNode = pList1Node;
pList1Node = pList1Node->pNext;
}
else
{
pNode = pList2Node;
pList2Node = pList2Head->pNext;
}
pNewHead = pNode;
pTailNode = pNode;
while(pList1Node && pList2Node)
{
if(pList1Node->data < pList2Node->data)
{
pNode = pList1Node;
pList1Node = pList1Node->pNext;
}
else
{
pNode = pList2Node;
pList2Node = pList2Node->pNext;
}
pTailNode->pNext = pNode;
pTailNode = pTailNode->pNext;
}
if(NULL == pList1Node)
{
pTailNode->pNext = pList2Node;
}
else
{
pTailNode->pNext = pList1Node;
}
return pNewHead;
}

//删除链表的倒数第K个结点
void DelNodeK(PSListNode* pHead, int K)
{
PSListNode pFast = NULL;
PSListNode pSlow = NULL;
if((pHead == NULL)||(K <= 0))
{
return;
}
pFast = *pHead;
pSlow = *pHead;
while(--K)
{
if(pFast == NULL)
{
return;
}
pFast = pFast->pNext;
}
while(pFast->pNext)
{
pFast = pFast->pNext;
pSlow = pSlow->pNext;
}
Erase(pHead, pSlow);
}

//求环的长度
int GetCyleLen(PSListNode pMeetNode)
{
int iLen = 1;
PSListNode pNode = NULL;
if(NULL == pMeetNode)
{
return 0;
}
while(pNode->pNext != pMeetNode)
{
iLen++;
}
return iLen;
}

// 判断链表是否带环,若带环返回相遇结点
PSListNode CheckCycle(PSListNode pHead)
{
PSListNode pFast = NULL;
PSListNode pSlow = NULL;
if(NULL == pHead)
{
return NULL;
}
while((pFast)&&(pFast->pNext))
{
pFast = pFast->pNext->pNext;
pSlow = pSlow->pNext;
if(pFast == pSlow)
{
return pSlow;
}
}
return NULL;
}

//获取环入口点
PSListNode GetCircleEntryNode(PSListNode pHead, PSListNode pMeetNode)
{
PSListNode pNode1 = pHead;
PSListNode pNodeM = pMeetNode;
if (pHead == NULL || pMeetNode == NULL)
{
return NULL;
}

while (pNode1 != pNodeM)
{
pNode1 = pNode1->pNext;
pNodeM = pNodeM->pNext;
}

return pNode1;
}

//判断两个链表是否相交(假设两个链表都不带环)
int CheckCross(PSListNode pList1Head, PSListNode pList2Head)
{
PSListNode pList1Node = pList1Head;
PSListNode pList2Node = pList2Head;
if((NULL == pList1Head)||(NULL == pList2Head))
{
return 0;
}
while (pList1Node->pNext)
{
pList1Node = pList1Node->pNext;
}
while(pList2Node->pNext)
{
pList2Node = pList2Node->pNext;
}
if(pList1Node == pList2Node)
{
return 1;//相交
}
return 0;//不相交
}

//判断两个链表是否相交
int IsListCroseWithCycle(PSListNode pList1Head, PSListNode pList2Head)
{
PSListNode pList1MeetNode = NULL;
PSListNode pList2MeetNode = NULL;
PSListNode pList1Node =pList1Head;
PSListNode pList2Node = pList2Head;
if ((NULL == pList1Head)||(NULL == pList2Head))
{
return 0;
}
pList1MeetNode = CheckCycle(pList1Head);
pList2MeetNode = CheckCycle(pList2Head);
if((NULL == pList1MeetNode)||(NULL == pList2MeetNode))//都不带环
{
while(pList1Node->pNext)
{
pList1Node = pList1Node->pNext;
}
while(pList2Node->pNext)
{
pList2Node = pList2Node->pNext;
}
if(pList1Node == pList2Node)
{
return 1;//相交
}
return 0;//不相交
}
if((NULL != pList1MeetNode)||(NULL != pList2MeetNode))//都带环
{
PSListNode pNode = pList1MeetNode;
while(pNode->pNext != pList1MeetNode)
{
if(pNode == pList2MeetNode)
{
return 1;
}
pNode = pNode->pNext;
}
if(pNode == pList2MeetNode)
{
return 1;
}
return 0;
}
return 0;
}