C/C++實現鏈表的常用操作

劍指offer版本

• 創建一個結點
• 鏈接兩個結點（鏈表）
• 打印某個結點的值
• 打印pHead之后的鏈表
• 銷毀pHead之后的鏈表

//==================================================================
// 《劍指Offer——名企面試官精講典型編程題》代碼
// 作者：何海濤
//==================================================================

// 面試題6：從尾到頭打印鏈表
// 題目：輸入一個鏈表的頭結點，從尾到頭反過來打印出每個結點的值。
#include<iostream>
#include<stack>
using namespace std;

struct ListNode
{
    int  m_nValue;
    ListNode* m_pNext;
    ListNode(){

    }
};

// 創建一個結點
ListNode* CreateListNode(int value)
{
    ListNode* pNode = new ListNode();
    pNode->m_nValue = value;
    pNode->m_pNext = nullptr;

    return pNode;
}


// 鏈接兩個結點（鏈表）
void ConnectListNodes(ListNode* pCurrent, ListNode* pNext)
{
    if(pCurrent == nullptr)
    {
        printf("Error to connect two nodes.\n");
        exit(1);
    }

    pCurrent->m_pNext = pNext;
}

// 打印某個結點的值
void PrintListNode(ListNode* pNode)
{
    if(pNode == nullptr)
    {
        printf("The node is nullptr\n");
    }
    else
    {
        printf("The key in node is %d.\n", pNode->m_nValue);
    }
}

// 打印pHead之后的鏈表
void PrintList(ListNode* pHead)
{
    printf("PrintList starts.\n");

    ListNode* pNode = pHead;
    while(pNode != nullptr)
    {
        printf("%d\t", pNode->m_nValue);
        pNode = pNode->m_pNext;
    }

    printf("\nPrintList ends.\n");
}

// 銷毀從pHead開始之后的鏈表
void DestroyList(ListNode* pHead)
{
    ListNode* pNode = pHead;
    while(pNode != nullptr)
    {
        pHead = pHead->m_pNext;
        delete pNode;
        pNode = pHead;
    }
}

// 往鏈表的末尾添加一個結點
void AddToTail(ListNode** pHead, int value)
{
    ListNode* pNew = new ListNode();
    pNew->m_nValue = value;
    pNew->m_pNext = nullptr;

    if(*pHead == nullptr)
    {
        *pHead = pNew;
    }
    else
    {
        ListNode* pNode = *pHead;
        while(pNode->m_pNext != nullptr)
            pNode = pNode->m_pNext;

        pNode->m_pNext = pNew;
    }
}


// 找到第一個含有某值的結點並刪除該結點
void RemoveNode(ListNode** pHead, int value)
{
    if(pHead == nullptr || *pHead == nullptr)
        return;

    ListNode* pToBeDeleted = nullptr;
    // 第一個結點
    if((*pHead)->m_nValue == value)
    {
        pToBeDeleted = *pHead;
        *pHead = (*pHead)->m_pNext;
    }
    else
    {
        ListNode* pNode = *pHead;
        while(pNode->m_pNext != nullptr && pNode->m_pNext->m_nValue != value)
            pNode = pNode->m_pNext;

        if(pNode->m_pNext != nullptr && pNode->m_pNext->m_nValue == value)
        {
            pToBeDeleted = pNode->m_pNext;
            pNode->m_pNext = pNode->m_pNext->m_pNext;
        }
    }

    if(pToBeDeleted != nullptr)
    {
        delete pToBeDeleted;
        pToBeDeleted = nullptr;
    }
}

void PrintListReversingly_Iteratively(ListNode* pHead)
{
    std::stack<ListNode*> nodes;

    ListNode* pNode = pHead;
    while(pNode != nullptr)
    {
        nodes.push(pNode);
        pNode = pNode->m_pNext;
    }

    while(!nodes.empty())
    {
        pNode = nodes.top();
        printf("%d\t", pNode->m_nValue);
        nodes.pop();
    }
}

void PrintListReversingly_Recursively(ListNode* pHead)
{
    if(pHead != nullptr)
    {
        if (pHead->m_pNext != nullptr)
        {
            PrintListReversingly_Recursively(pHead->m_pNext);
        }

        printf("%d\t", pHead->m_nValue);
    }
}

// ====================測試代碼====================
void Test(ListNode* pHead)
{
    PrintList(pHead);
    PrintListReversingly_Iteratively(pHead);
    printf("\n");
    PrintListReversingly_Recursively(pHead);
}

// 1->2->3->4->5
void Test1()
{
    printf("\nTest1 begins.\n");

    // pNode1作為第一個結點，注意沒有頭結點
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode5 = CreateListNode(5);


    ConnectListNodes(pNode1, pNode2);
    ConnectListNodes(pNode2, pNode3);
    ConnectListNodes(pNode3, pNode4);
    ConnectListNodes(pNode4, pNode5);

    AddToTail(&pNode1, 10);
    Test(pNode1);

    DestroyList(pNode1);
}

// 只有一個結點的鏈表: 1
void Test2()
{
    printf("\nTest2 begins.\n");

    ListNode* pNode1 = CreateListNode(1);

    Test(pNode1);

    DestroyList(pNode1);
}

// 空鏈表
void Test3()
{
    printf("\nTest3 begins.\n");

    Test(nullptr);
}

int main(int argc, char* argv[])
{
    Test1();
    Test2();
    Test3();

    return 0;
}

大話數據結構版

• 初始化順序線性表
• 判斷鏈表是否空
• 清空鏈表
• 返回鏈表中結點個數
• 返回鏈表中第i個數據元素的值
• 返回L中第1個與e滿足關系的數據元素的位序
• 在L中第i個位置之前插入新的數據元素e，L的長度加1
• 刪除L的第i個數據元素，並用e返回其值，L的長度減1
• 依次對L的每個數據元素輸出
• 隨機產生n個元素的值，建立帶表頭結點的單鏈線性表L（頭插法）
• 隨機產生n個元素的值，建立帶表頭結點的單鏈線性表L（尾插法）

#include<iostream>
#include<stack>
#include "time.h"
using namespace std;

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;
// 結點值類型
typedef int ElemType;

Status visit(ElemType c){
    printf("%d ", c);
    return OK;
}

struct Node{
    ElemType data;
    Node* next;
};

// 定義鏈表
typedef struct Node* LinkList;

/* 初始化順序鏈表 */
// 注意傳遞進來的是指針，因為需修改實參的值
// 注意LinkList* L是一個指向指針的指針，因為LinkList本來就是一個指針
Status InitList(LinkList* L){

    // 產生頭結點
    *L = (LinkList)malloc(sizeof(Node));

    if(*L == NULL){
        return ERROR;
    }
    // 指針域暫時為空，因為還沒有結點，數據域則不用管
    (*L)->next = NULL;

    return OK;
}

Status ListEmpty(LinkList L){

    if(L->next != NULL){
        return FALSE;
    }
    return TRUE;
}


int ListLength(LinkList L){

    // 頭結點肯定是有的，不用判斷
    int i = 0;
    LinkList p = L->next;
    while(p != NULL){
        i++;
        p = p->next;
    }
    return i;
}

/* 初始條件：鏈表L已存在，將L重置為空表 */
Status ClearList(LinkList* L){
    LinkList q;
    LinkList p = (*L)->next;
    while(p != NULL){
        // 中間結點q
        q = p ->next;
        free(p);
        p = q;
    }
    // 頭結點指針域重置為空（即表示空表）
    (*L)->next = NULL;
    return OK;
}

/* 初始條件：鏈表L已存在，用e返回L中第i個結點的數據值 */
Status GetElem(LinkList L, int i, ElemType *e){
    // p指向鏈表第一個結點
    LinkList p = L->next;
    int j = 1;
    while(p != NULL){
        if(j == i){
            *e = p->data;
            return OK;
        }
        j++;
        p = p->next;
    }
    return ERROR;
}

int GetLocation(LinkList L, ElemType e){
    int i = 1;
    LinkList p = L->next;
    while(p != NULL){
        if(p->data == e){
            return i;
            break;
        }
        i++;
        p = p->next;
    }
    return ERROR;
}

/* 初始條件：L已存在，在L中的第i個位置插入一個值為e的結點 */
Status ListInsert(LinkList *L, int i, ElemType e){
    // p應該指向頭結點，因為此時鏈表可能為空
    // 可以理解為j是p之后的一個結點
    LinkList p = *L;
    int j = 1;
    // 插入的結點s
    LinkList s;

    // 注意和刪除結點寫法不一樣，因為當只有頭結點的時候，是空表，如果寫為p->next!=NULL則永遠都插不上
    while(p != NULL && j<i){
        p = p->next;
        j++;
    }
    if(p == NULL || j>i){
        return ERROR;
    }

    s = (LinkList)malloc(sizeof(Node));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return OK;
}

Status ListDelete(LinkList* L, int i, ElemType *e){
    // p應該指向頭結點，因為此時鏈表可能為空
    // 可以理解為j是p之后的一個結點
    LinkList p = *L;
    int j = 1;
    // 刪除的結點q
    LinkList q;

    while(p->next != NULL && j<i){
        p = p->next;
        j++;
    }
    if(p->next == NULL || j>i)
        return ERROR;
    q = p->next;
    p->next = q->next;
    *e = q->data;
    free(q);
    return OK;
}

Status ListTraverse(LinkList L){
    LinkList p = L->next;
    while(p != NULL){
        visit(p->data);
        p = p->next;
    }
    printf("\n");
    return OK;
}

// 插隊法建立一個鏈表
void CreateListHead(LinkList* L, int n){

    LinkList p;
    int i;
    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));
    (*L)->next = NULL;
    for(i = 1; i <= n; i++){
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100 + 1;
        p->next = (*L)->next;
        (*L)->next = p;
    }
}

void CreateListTail(LinkList* L, int n){
    LinkList p, r;
    int i;
    srand(time(0));
    *L = (LinkList)malloc(sizeof(Node));

    r = *L;
    for(i = 1; i <= n; i++){
        p = (LinkList)malloc(sizeof(Node));
        p->data = rand()%100 +1;
        r->next = p;
        r = p;
    }
    r->next = NULL;
}

int main(){

    LinkList L;
    int num;
    Status s;
    // 傳遞地址給函數，創建一個帶頭結點的“空鏈表”
    // 必須要初始化，分配一個頭節點內存，不然程序錯誤
    s = InitList(&L);
    printf("%d\n", s);

    // 插入元素
    for(int i = 1; i<=5; i++){
        ListInsert(&L, i, i);
    }
    ListInsert(&L, 10, 99);

    num = ListLength(L);
    printf("%d\n", num);

    // 遍歷元素
    ListTraverse(L);

    stack<LinkList> nodes;

    LinkList p = L->next;
    while(p != NULL){
       nodes.push(p);
       p = p->next;
    }
    while(!nodes.empty()){
        p = nodes.top();
        printf("%d ", p->data);
        nodes.pop();
    }

    return 0;

}

特別注意

  第一個劍指offer的版本是用C++寫的，與之后的大話數據結構的不一樣，后者是用C寫的。兩者在定義結構體的時候有一個小小的區別，但就引起了代碼巨大的區別。

  C++版本的代碼中，使用struct定義了一個結構體（類），沒有使用typedf為結構體更名，但是C版本的代碼中使用了typedef struct Node *LinkList;這句代碼，因此定義LinkList本來就是一個指針類型。從此之后，在C的各種鏈表操作函數中，將某一個結點聲明為LinkList p即可，但在C++版本中則需要聲明為ListNode* p，但兩者意思是一樣的。

  因此在劍指offer的57頁中，有句“我們要特別注意函數的第一個參數pHead是一個指向指針的指針，即ListNode** pHead”，這其實就是因為需要修改頭指針的值。如此，在C版本中的函數中，聲明為LinkList* L也是一個指向指針的指針，一個意思。

  兩者還有一個區別就是，劍指offer版本是沒有頭結點的，但是大話數據結構是有頭結點的。

  若要頭結點，則在程序開始的時候應該初始化一個只有頭結點的鏈表。

  只要涉及到修改頭結點/頭指針，都需要將參數設置為指向指針的指針。