c++基础值链表基本操作

SeqListD.c

#include"SeqListD.h"

void InitList(PNode* pHead)
{
assert(pHead);
*pHead=NULL;
}
Node *BuyNode(DataType data)
{
Node *pNewNode=(Node*)malloc(sizeof(Node));
if(pNewNode!=NULL)
pNewNode->_data=data;
pNewNode->_pNext=NULL;
return pNewNode;
}

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);
}
}
void PrintList(PNode pHead)
{
Node*pCurNode=pHead;
while(pCurNode)
{
printf("%d->",pCurNode->_data);
pCurNode=pCurNode->_pNext;
}
printf("NULL\n");
}

void PopBack(PNode* pHead)
{
Node*pTailNode=*pHead;
if(NULL==pTailNode)//本来就为空
{
return;
}
else if(NULL==pTailNode->_pNext)//只有一个结点
{
free(pTailNode);
pTailNode=NULL;
}
else//有好多个结点
{
while(pTailNode->_pNext->_pNext)
{
pTailNode=pTailNode->_pNext;
}
free(pTailNode->_pNext);
pTailNode->_pNext=NULL;
}
}

void PushFront(PNode* pHead, DataType data)
{
assert(pHead);
if(NULL==*pHead)//空链表
{
*pHead=BuyNode(data);
}
else
{
Node* pNewNode=BuyNode(data);
pNewNode->_pNext=*pHead;
*pHead=pNewNode;
}
}

void PopFront(PNode* pHead)
{
Node* pDelNode=*pHead;
assert(pHead);
if(NULL==*pHead)
{
return;
}
else if(NULL==pDelNode->_pNext)
{
free(pDelNode);
pDelNode=NULL;
}
else
{
*pHead=pDelNode->_pNext;
free(pDelNode);
}
}

Node* Find(PNode pHead, DataType data)
{
Node*pCurNode=pHead;
while(pCurNode)
{
if(pCurNode->_data==data)
{
return pCurNode;
}
pCurNode=pCurNode->_pNext;
}
return NULL;
}

void Insert(PNode pos, DataType data)
{
Node*pNewNode=BuyNode(data);
if(NULL==pos)
{
return;
}
if(NULL==pNewNode)
return;
pNewNode->_pNext=pos->_pNext;
pos->_pNext=pNewNode;
}

void Erase(PNode* pHead, PNode pos)
{

assert(pHead);
assert(pos);
if((NULL==*pHead)&&(pos==NULL))
{
return;
}
else if(*pHead==pos)
{
PopFront(pHead);
}
else
{
Node*pNewNode=*pHead;
while(pNewNode->_pNext!=pos)
{
pNewNode=pNewNode->_pNext;
}
pNewNode->_pNext=pos->_pNext;
free(pos);
}
}

void PrintFromTail2Head(PNode pHead)
{
if(pHead!=NULL)
{
PrintFromTail2Head(pHead->_pNext);
printf("%d->",pHead->_data);
}
}

void DeleteNotTailNode(PNode pos)
{
Node*pDelNode;
if(NULL==pos || pos->_pNext==NULL)
return;
pDelNode=pos->_pNext;
pos->_data=pDelNode->_data;
pos->_pNext=pDelNode->_pNext;
free(pDelNode);
}
void Remove(PNode* pHead, DataType data)
{
Node* pPreNode = Find(*pHead,data);
assert(pHead);
if(pPreNode == NULL)
{
return;
}
else
{
Erase(pHead,pPreNode);
}
}
void RemoveAll(PNode* pHead, DataType data)
{
Node* pPreNode = Find(*pHead,data);
while(pPreNode)
{
Node* pPreNode = Find(*pHead,data);
assert(pHead);
if(pPreNode == NULL)
{
return;
}
else
{
Erase(pHead,pPreNode);
}
}
}
size_t Size(PNode pHead)
{
int count=0;
Node* pPreNode=pHead;
while(pPreNode)
{
count++;
pPreNode=pPreNode->_pNext;
}
printf("%d\n",count);
}
int Empty(PNode pHead)
{
if(pHead==NULL)
{
return 1;
}
else
{
return 0;
}
}

PNode Back(PNode pHead)
{
Node* pCurNode=pHead;
while(pCurNode->_pNext)
{
pCurNode=pCurNode->_pNext;
}
return pCurNode;
}

PNode Front(PNode pHead)
{
Node* pCurNode=pHead;
return pCurNode;
}
void Text1()
{
Node* Node,Node1;
int ret=0;
InitList(&Node);
PushBack(&Node, 1);
PushBack(&Node, 2);
PushBack(&Node, 3);
PushBack(&Node, 4);
//PopBack(&Node);
PushFront(&Node, 5);
PushBack(&Node, 2);
PushBack(&Node, 2);
PushFront(&Node, 6);
// PopFront(&Node);
//Insert(Node, 4);
//Erase(&Node,Node);
//DeleteNotTailNode(Node->_pNext);
// Remove(&Node, 2);
RemoveAll(&Node,2);

PrintList(Node);
// PrintFromTail2Head(Node);
Size(Node);
ret = Empty(Node);
if(ret=0)
{
printf("链表为空\n");
}
else
{
printf("链表不为空\n");
}
printf("%x\n",Back(Node));
printf("%x\n",Front(Node));

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

SeqListD.h

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

typedef int DataType;

#define NULL 0
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);

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

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

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

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

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

///////////////面试题//////////////////////////////
// 逆序打印单链表
void PrintFromTail2Head(PNode pHead);

// 删除单链表的非尾结点(不能遍历单链表)
void DeleteNotTailNode(PNode pos);