实现单链表及其基本操作

单链表的定义：

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针

(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。

单链表分为：1，有头单链表 2，无头单链表

本次主要针对无头单链表



链表的声明

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

typedef int DataType;
//带头单链表
typedef struct Node
{
DataType _data;
struct Node* _pNext;
}Node, *PNode;

链表的基本操作

注意：

在传入参数时，当需要修改pHead的指向时，需要传入二级指针PNode *pHead

当不需要改变pHead的指向时，只需传入一级指针PNode pHead即可。

// 初始化单链表
void InitList(PNode* pHead);
//销毁链表
void DestroyList(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);

// 判断结点是否为空
int Empty(PNode pHead);

// 返回单链表的最后一个结点的位置
PNode Back(PNode pHead);

// 返回单链表的第一个结点的位置
PNode Front(PNode pHead);

// 构建一个新节点
Node* BuyNode(DataType data);

// 正向打印单链表
void PrintList(PNode pHead);

链表基本功能实现

///////////////只要改变了单链表的内容(指针指向内容)，应使用PNode*二级指针。////////////////
///////////////不然的话，在函数中改变了pHead的内容，函数外pHead还是指向原来的地址//////////
// 构建一个新节点
Node* BuyNode(DataType data)
{
PNode pTemp = (PNode)malloc(sizeof(Node));

if (NULL != pTemp)
{
pTemp->_data = data;
pTemp->_pNext = NULL;
}

return pTemp;
}

// 初始化单链表
void InitList(PNode* pHead)
{
assert(NULL != pHead);
*pHead = NULL; //初始化为空
}

// 在单链表的尾部插入一个节点
void PushBack(PNode* pHead, DataType data)
{
PNode pNewNode = NULL;

assert(NULL != pHead);

if (!(pNewNode = BuyNode(data))) //创建节点失败
return ;

if (NULL == *pHead) //链表为空时
*pHead = pNewNode;
else //链表不为空
{
PNode pTailNode = Back(*pHead);
pTailNode->_pNext = pNewNode;
}
}

// 在单链表的头部插入值为data的结点
void PushFront(PNode* pHead, DataType data)
{
PNode pNewNode = NULL;

assert(NULL != pHead);

if (!(pNewNode = BuyNode(data)))//创建节点失败
return ;

if (NULL == *pHead) //链表为空时
*pHead = pNewNode;
else //链表不为空
{
pNewNode->_pNext = *pHead;
*pHead = pNewNode;
}
}
// 删除单链表的最后一个节点
void PopBack(PNode* pHead)
{
assert(NULL != pHead);

if (NULL == *pHead) //链表为空
return ;

if (NULL == (*pHead)->_pNext) //链表只有一个节点
{
free(*pHead); //删除节点
*pHead = NULL; //链表为空
}
else //链表节点大于等于2
{
PNode pDelNode = *pHead; //倒数第二个节点指针

while (NULL != pDelNode->_pNext->_pNext) //指向倒数第二个节点
pDelNode = pDelNode->_pNext;

free(pDelNode->_pNext); //删除最后一个节点
pDelNode->_pNext = NULL; //倒数第二个节点指向空。
}
}
// 删除单链表的第一个结点
void PopFront(PNode* pHead)
{
assert(NULL != pHead);

if (NULL == *pHead)
return ;
else
{
PNode pFirstNode = *pHead;

*pHead = (*pHead)->_pNext;
free(pFirstNode);
pFirstNode = NULL;
}
}

// 在单链表pos位置后插入值为data的结点
void Insert(PNode pos, DataType data)
{
PNode pNewNode = NULL;

assert(NULL != pos);

if (!(pNewNode = BuyNode(data)))
return ;

pNewNode->_pNext = pos->_pNext;
pos->_pNext = pNewNode;
}

// 在单链表中删除位置为pos的结点
void Erase(PNode* pHead, PNode pos)
{
PNode pPreNode = NULL;
assert(NULL != pHead); //看看是该用if（pos == NULL）好，还是assert好。
assert(NULL != pos);

pPreNode = *pHead; //pPreNode指向pos前一节点

if (NULL == *pHead) //当是空链表时
return ;

if (pos == *pHead) //pos为第一个节点时
PopFront(pHead);
else //pos为别的位置，并且链表不为空
{ //考虑pos不为链表内容情况
while (pPreNode && pPreNode->_pNext != pos) //pCurNode指向不为空且pCurNode->_pNext不等于pos
pPreNode = pPreNode->_pNext; //pCurNode指向下一节点

if (NULL != pPreNode) //pCurNode下一节点是pos
{
pPreNode->_pNext = pos->_pNext;
free(pos);
pos = NULL;
}
}
}

// 移除单链表中第一个值为data的结点
void Remove(PNode* pHead, DataType data)
{
PNode pDelNode = NULL;

assert(NULL != pHead);

if (pDelNode = Find(*pHead, data))
Erase(pHead, pDelNode);
}

// 移除单链表中所有值为data的结点
void RemoveAll(PNode* pHead, DataType data)
{
PNode pDelNode = NULL;

assert(NULL != pHead);

pDelNode = *pHead;

if (NULL == *pHead) //链表为空
return ;

if (NULL == (*pHead)->_pNext) //链表只有一个节点
{
if ((*pHead)->_data == data)
PopFront(pHead);
}
else
{ //思路：将本该删除的节点pDelNode替换为它的下一节点pTemp，然后释放pTemp。
while (pDelNode->_pNext)
if (pDelNode->_data == data)
{
PNode pTemp = pDelNode->_pNext;

pDelNode->_data = pTemp->_data;
pDelNode->_pNext = pTemp->_pNext;

free(pTemp);
pTemp = NULL;
}
else
pDelNode = pDelNode->_pNext;
}
}

//销毁链表
void DestroyList(PNode *pHead)
{
PNode pCurNode = NULL;

assert(NULL == pHead);

while (NULL != *pHead)
{
PNode pTemp = *pHead;
*pHead = (*pHead)->_pNext;
free(pTemp);
pTemp = NULL;
}
}

///////////////////////////////////////
// 在单链表中查找值为data的结点，找到了返回该结点的地址，否则返回NULL
Node* Find(PNode pHead, DataType data)
{
assert(NULL != pHead);

while (pHead)
if (pHead->_data == data)
break;
else
pHead = pHead->_pNext;

return pHead;
}

// 获取单链表总结点的总个数
size_t Size(PNode pHead)
{
size_t n = 0;

while (pHead) //当pHead不为空时
{
++n;
pHead = pHead->_pNext;
}

return n;
}

// 判断结点是否为空
int Empty(PNode pHead)
{
if (pHead) //pHead不是空链表
return 1;
return 0;
}

// 返回单链表的最后一个结点的位置
PNode Back(PNode pHead)
{
if (NULL != pHead) //pHead不是空链表
while (pHead->_pNext)
pHead = pHead->_pNext;

return pHead;
}

// 返回单链表的第一个结点的位置
PNode Front(PNode pHead)
{
return pHead;
}

// 正向打印单链表
void PrintList(PNode pHead)
{
PNode pCurNode = NULL;

assert(NULL != pHead);

pCurNode = pHead;

while (pCurNode)
{
printf("%d->", pCurNode->_data);
pCurNode = pCurNode->_pNext;
}

printf("<null>\n");
}