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);