c语言pop逆置单链表,C语言实现单链表
實現單鏈表的以下操作：
list.h：
#ifndef __LIST_H__
#define __LIST_H__
#include
#include
#include
typedef int DataType;
typedef struct Node
{
DataType _data;
struct Node *_pNext;
}Node,*pNode;
// 初始化單鏈表
void InitList(pNode* pHead);
// 在單鏈表的尾部插入一個節點
void PushBack(pNode* pHead, DataType data);
// 刪除單鏈表的最后一個節點
void PopBack(pNode* pHead);
// 在單鏈表的頭部插入值為data的結點
void PushFront(pNode* pHead, DataType data);
// 刪除單鏈表的第一個結點
void PopFront(pNode* pHead);
// 在單鏈表中查找值為data的結點，找到了返回該結點的地址，否則返回NULL
Node* Find(pNode pHead, DataType data);
// 在單鏈表pos位置后插入值為data的結點
void Insert(pNode pos, DataType data);
// 在單鏈表中刪除位置為pos的結點
void Erase(pNode* pHead, pNode pos);
// 移除單鏈表中第一個值為data的結點
void Remove(pNode* pHead, DataType data);
// 移除單鏈表中所有值為data的結點
void RemoveAll(pNode* pHead, DataType data);
// 獲取單鏈表總結點的總個數
size_t Size(pNode pHead);
// 判斷結點是否為空
DataType Empty(pNode pHead);
// 返回單鏈表的最后一個結點的位置
pNode Back(pNode pHead);
// 返回單鏈表的第一個結點的位置
pNode Front(pNode pHead);
// 構建一個新節點
Node* BuyNode(DataType data);
// 正向打印單鏈表
void PrintList(pNode pHead);
//單鏈表實現約瑟夫環
void JosiphCircle(pNode *pHead,size_t M);
///面試題//
//12.24實現無頭單鏈表的以下操作：
// 逆序打印單鏈表
void PrintFromTail2Head(pNode pHead);
// 刪除單鏈表的非尾結點(不能遍歷單鏈表)
void DeleteNotTailNode(pNode pos);
// 使用遞歸實現從未到頭打印單鏈表
void PrintFromTail2Head(pNode pHead);
// 刪除單鏈表的非尾結點
void DeleteNotTailNode(pNode pos);
// 在單鏈表非頭結點前插入結點data
void InsertNotHeadNode(pNode pos, DataType data);
// 查找單鏈表的中間結點，要求只便利一次鏈表
pNode FindMidNode(pNode pHead);
// 查找單鏈表的倒數第K個結點，要求只遍歷一次鏈表
pNode FindLastKNode(pNode pHead, size_t k);
// 使用冒泡排序對單鏈表進行排序
void BubbleSort(pNode pHead);
// 判斷兩個單鏈表是否相交(鏈表不帶環)
int IsListCross(pNode L1, pNode L2);
// 若不帶環的單鏈表相交，求交點
pNode GetCrossNode(pNode PL1, pNode PL2);
//12.25實現鏈表的以下操作：
// 實現單鏈表的逆置：使用三個指針
pNode ReverseList(pNode pHead);
// 實現單鏈表的逆置：使用頭插法
void ReverseList_P(pNode* pHead);
// 合并兩個已序單鏈表，合并后依然有序
pNode MergeList(pNode pHead1, pNode pHead2);
// 判斷鏈表是否帶環，若帶環給出相遇點
pNode HasCircle(pNode pHead);
// 求環的長度
size_t GetCircleLen(pNode pMeetNode);
// 求環的入口點
pNode GetEnterNode(pNode pHead, pNode pMeetNode);
// 判斷鏈表是否相交，注意：鏈表可能帶環
int IsCrossWithCircle(pNode pHead1, pNode pHead2);
#endif //__LIST_H__
List.c：
#include "List.h"
void InitList(pNode *pHead)
{
assert(pHead);
*pHead = NULL;
}
// 在單鏈表的尾部插入一個節點
void PushBack(pNode* pHead, DataType data)
{
assert(pHead);
if(*pHead == NULL)
{
*pHead = BuyNode(data);
}
else
{
Node *pTailNode = *pHead;
while(pTailNode->_pNext)
{
pTailNode = pTailNode->_pNext;
}
pTailNode->_pNext = BuyNode(data);
}
}
//構建一個新節點
static Node* BuyNode(DataType data)
{
Node *pNewNode = (Node *)malloc(sizeof(Node));
if(pNewNode != NULL)
{
pNewNode->_data = data;
pNewNode->_pNext = NULL;
}
return pNewNode;
}
//刪除單鏈表的最后一個節點
void PopBack(pNode* pHead)
{
assert(pHead);
if(pHead == NULL)
{
return;
}
else if((*pHead)->_pNext == NULL)
{
free(*pHead);
*pHead = NULL;
}
else
{
Node *pPreNode = *pHead;
Node *pTailNode = *pHead;
while(pTailNode->_pNext)
{
pPreNode = pTailNode;
pTailNode = pTailNode->_pNext;
}
free(pTailNode);
pPreNode->_pNext = NULL;
}
}
// 正向打印單鏈表
void PrintList(pNode pHead)
{
Node *pCurNode = pHead;
while(pCurNode)
{
printf("%d->",pCurNode->_data);
pCurNode = pCurNode->_pNext;
}
printf("NULL\n");
}
// 在單鏈表的頭部插入值為data的結點
void PushFront(pNode* pHead, DataType data)
{
assert(pHead);
if(*pHead == NULL)
{
*pHead = BuyNode(data);
}
else
{
pNode pNewNode = BuyNode(data);
pNewNode->_pNext = *pHead;
*pHead = pNewNode;
}
}
// 刪除單鏈表的第一個結點
void PopFront(pNode* pHead)
{
assert(pHead);
if(*pHead == NULL)
{
return;
}
else if((*pHead)->_pNext == NULL)
{
free(*pHead);
*pHead = NULL;
}
else
{
Node *pDelNode = *pHead;
*pHead = (*pHead)->_pNext;
free(pDelNode);
}
}
// 在單鏈表中查找值為data的結點，找到了返回該結點的地址，否則返回NULL
Node* Find(pNode pHead, DataType data)
{
Node *pCurNode = pHead;
while(pCurNode)
{
if(pCurNode->_data == data)
{
return pCurNode;
}
pCurNode = pCurNode->_pNext;
}
return NULL;
}
//在單鏈表pos位置后插入值為data的結點
void Insert(pNode pos, DataType data)
{
Node *pNewNode = NULL;
if(pos == NULL)
{
return;
}
pNewNode = BuyNode(data);
if(pNewNode == NULL)
{
return;
}
pNewNode->_pNext = pos->_pNext;
pos->_pNext = pNewNode;
}
// 在單鏈表非頭結點前插入結點data
void InsertNotHeadNode(pNode pos, DataType data)
{
pNode pNewNode = BuyNode(pos->_data);
if(pNewNode == NULL)
{
return;
}
pNewNode->_pNext = pos->_pNext;
pos->_pNext = pNewNode;
pos->_data = data;
}
//在單鏈表中刪除位置為pos的結點
void Erase(pNode* pHead, pNode pos)
{
assert(pHead);
if(NULL == *pHead || NULL == pos)
{
return;
}
else if(*pHead == pos)
{
PopFront(pHead);
}
else
{
Node *pPreNode = *pHead;
while(pPreNode->_pNext != pos)
{
pPreNode = pPreNode->_pNext;
}
pPreNode->_pNext = pos->_pNext;
free(pos);
}
}
//移除單鏈表中第一個值為data的結點(非尾結點)
void Remove(pNode* pHead, DataType data)
{
pNode pPreNode = Find(*pHead,data);
if(pPreNode == NULL)
{
return;
}
else
{
pNode pDelNode = pPreNode->_pNext;
pPreNode->_data = pPreNode->_pNext->_data;
pPreNode->_pNext = pPreNode->_pNext->_pNext;
free(pDelNode);
}
}
//移除單鏈表中第一個值為data的結點
void Remove(pNode* pHead, DataType data)
{
pNode pPreNode = Find(*pHead,data);
assert(pHead);
if(pPreNode == NULL)
{
return;
}
else
{
Erase(pHead,pPreNode);
}
}
//移除單鏈表中所有值為data的結點(遞歸)
void RemoveAll(pNode* pHead, DataType data)
{
pNode pDelNode = NULL;
Remove(pHead,data);
pDelNode = Find(*pHead,data);
if(pDelNode == NULL)
{
return;
}
else
{
RemoveAll(pHead,data);
}
}
//移除單鏈表中所有值為data的結點
void RemoveAll(pNode* pHead, DataType data)
{
pNode pPre = *pHead;
pNode pCur = *pHead;
pCur = pPre->_pNext;
if(*pHead == NULL)
{
return;
}
while(pCur)
{
if(pCur->_data == data)
{
pPre->_pNext = pCur->_pNext;
free(pCur);
pCur = pPre->_pNext;
}
else
{
pPre = pCur;
pCur = pCur->_pNext;
}
}
if((*pHead)->_data == data)
{
pNode pTemp = *pHead;
*pHead = pTemp->_pNext;
free(pTemp);
}
}
//移除單鏈表中所有值為data的結點(非尾結點)
void RemoveAll(pNode* pHead, DataType data)
{
pNode pPreNode = *pHead;
while(pPreNode)
{
pPreNode = Find(pPreNode,data);
if(pPreNode == NULL)
{
return;
}
else
{
pNode pDelNode = pPreNode->_pNext;
pPreNode->_data = pPreNode->_pNext->_data;
pPreNode->_pNext = pPreNode->_pNext->_pNext;
free(pDelNode);
}
}
}
//刪除單鏈表的非尾結點(不能遍歷單鏈表)
void DeleteNotTailNode(pNode pos)
{
assert(pos);
if(pos->_pNext == NULL)
{
return;
}
else
{
pNode pDelNode = pos->_pNext;
pos->_data = pDelNode->_data;
pos->_pNext = pDelNode->_pNext;
free(pDelNode);
}
}
//逆序打印單鏈表
void PrintFromTail2Head(pNode pHead)
{
if(pHead == NULL)
{
return;
}
else
{
PrintFromTail2Head(pHead->_pNext);
printf("%d->",pHead->_data);
}
}
//獲取單鏈表總結點的總個數
size_t Size(pNode pHead)
{
int count = 0;
pNode pPreNode = pHead;
while(pPreNode)
{
count++;
pPreNode = pPreNode->_pNext;
}
return count;
}
// 判斷結點是否為空
DataType Empty(pNode pHead)
{
if(pHead == NULL)
{
return 0;
}
else
return 1;
}
//返回單鏈表的最后一個結點的位置
pNode Back(pNode pHead)
{
pNode pTailNode = pHead;
while(pTailNode->_pNext)
{
pTailNode = pTailNode->_pNext;
}
return pTailNode;
}
//返回單鏈表的第一個結點的位置
pNode Front(pNode pHead)
{
return pHead;
}
//單鏈表實現約瑟夫環
void JosiphCircle(pNode *pHead,size_t M)
{
int m = M;
pNode pCurNode = NULL;
assert(pHead);
if(*pHead == NULL)
{
return;
}
pCurNode = *pHead;
while(pCurNode != pCurNode->_pNext)
{
pNode pDelNode = NULL;
m = M;
while(--m)
{
pCurNode = pCurNode->_pNext;
}
pDelNode = pCurNode->_pNext;
pCurNode->_data = pDelNode->_data;
pCurNode->_pNext = pDelNode->_pNext;
free(pDelNode);
}
*pHead = pCurNode;
(*pHead)->_pNext = NULL;
}
// 查找單鏈表的中間結點，要求只遍歷一次鏈表
pNode FindMidNode(pNode pHead)
{
pNode pFast = NULL;
pNode pSlow = NULL;
if(pHead == NULL)
{
return NULL;
}
pFast = pHead;
pSlow = pHead;
while(pFast && pFast->_pNext)
{
pSlow = pSlow->_pNext;
pFast = pFast->_pNext->_pNext;
}
return pSlow;
}
// 查找單鏈表的倒數第K個結點，要求只遍歷一次鏈表
pNode FindLastKNode(pNode pHead, size_t k)
{
pNode pFast = NULL;
pNode pSlow = NULL;
if(pHead == NULL || k == 0)
{
return NULL;
}
pFast = pHead;
pSlow = pHead;
while(k--)
{
pFast = pFast->_pNext;
}
while(pFast)
{
pFast = pFast->_pNext;
pSlow = pSlow->_pNext;
}
return pSlow;
}
// 使用冒泡排序對單鏈表進行排序
void BubbleSort(pNode pHead)
{
pNode pTailNode = NULL;
pNode pPre = NULL;
pNode pCur = NULL;
int flag = 0;
if(pHead == NULL || pHead->_pNext == NULL)
{
return;
}
pPre = pHead;
pCur = pHead;
while(pHead != pTailNode)
{
pPre = pHead;
pCur = pPre->_pNext;
while(pCur != pTailNode)
{
if(pPre->_data > pCur->_data)
{
DataType temp = 0;
flag = 1;
temp = pPre->_data;
pPre->_data = pCur->_data;
pCur->_data = temp;
}
pPre = pCur;
pCur = pCur->_pNext;
}
if(flag == 0)
{
return;
}
pTailNode = pPre;
}
}
// 判斷兩個單鏈表是否相交(鏈表不帶環)
int IsListCross(pNode L1, pNode L2)
{
pNode pCurNode1 = NULL;
pNode pCurNode2 = NULL;
if(L1 == NULL || L2 == NULL)
{
return 0;
}
pCurNode1 = L1;
pCurNode2 = L2;
while(pCurNode1->_pNext)
{
pCurNode1 = pCurNode1->_pNext;
}
while(pCurNode2->_pNext)
{
pCurNode2 = pCurNode2->_pNext;
}
if(pCurNode1 == pCurNode2)//兩不帶環的單鏈表相交尾節點必相同
{
return 1;
}
else
return 0;
}
// 若不帶環的單鏈表相交，求交點
pNode GetCrossNode(pNode pL1, pNode pL2)
{
size_t s1 = 0;
size_t s2 = 0;
int gap = 0;
if(IsListCross(pL1,pL2) == 0)
{
return NULL;
}
s1 = Size(pL1);
s2 = Size(pL2);
gap = s1 - s2;
if(gap < 0)
{
gap = -gap;
while(gap--)
{
pL2 = pL2->_pNext;
}
}
else
{
while(gap--)
{
pL1 = pL1->_pNext;
}
}
while(pL1 != pL2)
{
pL1 = pL1->_pNext;
pL2 = pL2->_pNext;
}
return pL1;
}
// 實現單鏈表的逆置：使用三個指針
pNode ReverseList(pNode pHead)
{
pNode pPreNode = NULL;
pNode pCurNode = NULL;
pNode pNextNode = NULL;
if(pHead == NULL || pHead->_pNext == NULL)
{
return NULL;
}
pPreNode = pHead;
pCurNode = pPreNode->_pNext;
pNextNode = pCurNode->_pNext;
while(pNextNode)
{
pCurNode->_pNext = pPreNode;
pPreNode = pCurNode;
pCurNode = pNextNode;
pNextNode = pNextNode->_pNext;
}
pCurNode->_pNext = pPreNode;
pHead->_pNext = NULL;
pHead = pCurNode;
return pHead;
}
// 實現單鏈表的逆置：使用頭插法
void ReverseList_P(pNode* pHead)
{
pNode pNewHead = NULL;
pNode pPreNode = NULL;
pNode pCurNode = NULL;
if(*pHead == NULL || (*pHead)->_pNext == NULL)
{
return;
}
pPreNode = *pHead;
pCurNode = (*pHead)->_pNext;
while(pCurNode)
{
pPreNode->_pNext = pNewHead;
pNewHead = pPreNode;
pPreNode = pCurNode;
pCurNode = pCurNode->_pNext;
}
pPreNode->_pNext = pNewHead;
pNewHead = pPreNode;
*pHead = pNewHead;
}
// 合并兩個已序單鏈表，合并后依然有序
pNode MergeList(pNode pHead1, pNode pHead2)
{
pNode pL1 = NULL;
pNode pL2 = NULL;
pNode pNewHead = NULL;
pNode pTailNode = NULL;
if(pHead1 == NULL)
{
return pHead2;
}
if(pHead2 == NULL)
{
return pHead1;
}
pL1 = pHead1;
pL2 = pHead2;
if(pL1->_data <= pL2->_data)
{
pNewHead = pL1;
pTailNode = pNewHead;
pL1 = pL1->_pNext;
}
else
{
pNewHead = pL2;
pTailNode = pNewHead;
pL2 = pL2->_pNext;
}
while(pL1 && pL2)
{
if(pL1->_data <= pL2->_data)
{
pTailNode->_pNext = pL1;
pL1 = pL1->_pNext;
}
else
{
pTailNode->_pNext = pL2;
pL2 = pL2->_pNext;
}
pTailNode = pTailNode->_pNext;
}
if(pL1 != NULL)
{
pTailNode->_pNext = pL1;
}
if(pL2 != NULL)
{
pTailNode->_pNext = pL2;
}
return pNewHead;
}
// 判斷鏈表是否帶環，若帶環給出相遇點
pNode HasCircle(pNode pHead)
{
pNode pFast = NULL;
pNode pSlow = NULL;
if(pHead == NULL)
{
return NULL;
}
pFast = pHead;
pSlow = pHead;
//環內點都是相遇點
while(pFast && pFast->_pNext)
{
pSlow = pSlow->_pNext;
pFast = pFast->_pNext->_pNext;
if(pSlow == pFast)
{
return pSlow;
}
}
return NULL;
}
// 求環的長度
size_t GetCircleLen(pNode pMeetNode)
{
pNode pCurNode = pMeetNode;
size_t count = 1;
while(pCurNode->_pNext != pMeetNode)
{
pCurNode = pCurNode->_pNext;
count++;
}
return count;
}
// 求環的入口點
pNode GetEnterNode(pNode pHead, pNode pMeetNode)
{
pNode pH = NULL;
pNode pM = NULL;
if(pHead == NULL || pMeetNode == NULL)
{
return NULL;
}
pH = pHead;
pM = pMeetNode;
while(pH != pM)
{
pH = pH->_pNext;
pM = pM->_pNext;
}
return pH;
}
// 判斷鏈表是否相交，注意：鏈表可能帶環
//(兩個鏈表都帶環或都不帶環)
int IsCrossWithCircle(pNode pHead1, pNode pHead2)
{
pNode pMeetNode1 = HasCircle(pHead1);
pNode pMeetNode2 = HasCircle(pHead2);
if(pMeetNode1 == NULL && pMeetNode2 == NULL)
{
pNode pCurNode1 = pHead1;
pNode pCurNode2 = pHead2;
if(pHead1 == NULL || pHead2 == NULL)
{
return 0;
}
while(pCurNode1->_pNext)
{
pCurNode1 = pCurNode1->_pNext;
}
while(pCurNode2->_pNext)
{
pCurNode2 = pCurNode2->_pNext;
}
if(pCurNode1 == pCurNode2)
{
return 1; //不帶環相交
}
}
else if(pMeetNode1 != NULL && pMeetNode2 != NULL)
{
pNode pCurNode = pMeetNode1;
while(pCurNode->_pNext != pMeetNode1)
{
if(pCurNode == pMeetNode2)
{
return 2; //帶環環外相交
}
pCurNode = pCurNode->_pNext;
}
if(pCurNode == pMeetNode2)
{
return 2; //帶環環內相交(環的入口點相交)
}
}
return 0;
}
總結
以上是生活随笔為你收集整理的c语言pop逆置单链表,C语言实现单链表的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： c语言商店自动销售,c语言商店商品管理系
- 下一篇： 蓝桥杯C语言指数计算,蓝桥杯 算式90