2. 程式人生 > 其它 >資料結構——連結串列

資料結構——連結串列

阿新 • • 發佈：2021-12-05

鎮樓圖

Pixiv:飛者

〇、連結串列構建前的細節問題

順序表構建時一定需要一個確定的長度嗎？

順序表也可以採用類似連結串列的方式增加節點，也就是每新增一個節點就開闢一塊記憶體(realloc)

這樣順序表可以不必增加len引數

是否帶頭節點？

在連結串列中通常要帶頭節點指明整個結構。

如果不帶，在涉及到表頭的操作時則需要修改首元素地址增加額外不必要的負擔

是否迴圈？

和順序表一樣，可做可不做

單鏈表還是雙鏈表？

連結串列的索引關係是通過指標來完成的

單鏈表只有一個指標會使得索引關係具有單向性，即除表頭表尾每個節點都只有後繼而無前驅

雙鏈表存在兩個指標會使得索引關係具有雙向性，即除表頭表尾每個節點都有後繼和前驅

（個人觀點：順序表是除表頭表尾都有前驅後繼，不過從圖的觀點來看，順序表可以認為是一種完全圖）

選擇什麼引數？

這裡我推薦加上cnt當前長度的引數

一、單鏈表

typedef struct{
    int value;
}element,*Element;

typedef struct __llnode{
    element data;//資料域
    struct __llnode *next;//指標域
}*llist_head,*llist_node,llist_size;

typedef struct{
	llist_head head;
    int cnt;
}llist;
/*一般情況得到上面的即可
  不過我增加了額外引數需要進一步封裝

基本操作

(1)建立單鏈表

void llist_create(llist &L){
    //作用：建立連結串列
    L.cnt = 0;
    L.head = (llist_head)malloc(sizeof(llist_size));
    L.head->next = NULL;
}

(2)輸入/輸出

void llist_input(llist &L,int n){
    //作用：輸入n個數據
    if(n < 0)return;
    llist_node p = L.head;
    L.cnt += n;
    while(p->next)p = p->next;
    while(n--){
        llist_node newnode = new llist_size;
        newnode->next = NULL;
        p->next = newnode;
        scanf("%d ",&newnode->data.value);
        p = p->next;
    }
}

 
void llist_output(llist &L){
    //作用：輸出連結串列
    llist_node p = L.head->next;
    while(p){
        printf("%d ",p->data.value);
        p = p->next;
    }
    printf("\n");
}

(3)判斷單鏈表是否為空

bool llist_ifempty(llist &L){
    //作用：判斷連結串列是否為空
	return (L.head->next) ? true : false ;
}

(4)獲取單鏈表長度（假設不存在cnt引數）

int llist_length(llist &L){
    //作用：獲取連結串列當前長度
    int count = 0;
    llist_node p = L.head->next;
    while(p){
        count++;
        p = p->next;
    }
    return count;
}

(5)前/後.插入位序為i的引數

void llist_insertpre1(llist &L,int pos,element e){
    //作用：前插入元素e
    if(pos < 1 || pos > L.cnt+1){
        printf("錯誤：超出範圍");
        return;
    }
    llist_node p = L.head;
    //一：pos-1將前插變為後插
    while(pos---1)p = p->next;
    llist_node newnode = (llist_node)malloc(sizeof(llist_size));
    newnode->data = e;
    newnode->next = p->next;
    p->next = newnode;
    L.cnt++;
}

void llist_insertpre2(llist L,int pos,element e){
    //作用：前插入元素e
    if(pos < 1 || pos > L.cnt){
        printf("錯誤：超出範圍");
        return;
    }
    llist_node p = L.head;
    /*二：假設得到的就是當前元素p
    然後需要前插newnode元素
    可以交換p和newnode的資料域
    這樣就變成了如何在newnode後插p的問題
    在已知p指標資訊的情況下
    該演算法時間複雜度降低為O(1)
    不過缺點是pos範圍從原來的[1,n+1]
    變為[1,n](n > 0)或Ø(n = 0)
    */
    while(pos--)p = p->next;
    llist_node newnode = (llist_node)malloc(sizeof(llist_size));
    newnode->data = p->data;
    p->data = e;
    newnode->next = p->next;
    p->next = newnode;
    L.cnt++;
}

void llist_insertpost(llist &L,int pos,element e){
    //作用：後插入元素e
    if(pos < 0 || pos > L.cnt){
        printf("錯誤：超出範圍");
        return;
    }
    llist_node p = L.head;
    for(int i = 0;i < pos;i++)p = p->next;
    llist_node newnode = (llist_node)malloc(sizeof(llist_size));
    newnode->data = e;
    newnode->next = p->next;
    p->next = newnode;
    L.cnt++;
}

(6)刪除位序為i的元素

void llist_delete(llist L,int pos){
    //作用：刪除元素e
    if(pos < 1 || pos > L.cnt){
        printf("錯誤：超出範圍");
        return;
    }
    llist_node p = L.head,d = L.head->next;
    while(pos---1){
        p = p->next;
        d = d->next;
    }
    p->next = d->next;
    free(d);
    L.cnt--;
}
/*還有一種演算法可以只得到要刪除元素的前一位p
然後只需要刪除p的後繼即可，無需前驅

其他操作

(1)反轉單鏈表

void llist_reverse(llist &L){
    //最簡單的是直接遞迴逆向輸出（不過多少不會有人接受這種演算法）
    //這裡採用改變索引關係得到
    llist_node p1 = L.head;
    llist_node p2 = L.head->next;
    llist_node t = NULL;
    while(p2){
        t = p2->next;
        p2->next = p1;
        p1 = p2;
        p2 = t;
    }
    L.head->next->next = NULL;
    L.head->next = p1;
}

(2)合併兩個有序連結串列

void llist_union(llist_node &p1,llist_node &p2,llist &L3){
    /*這個演算法我已經在順序表中闡述過了
    不過本次採用遞迴思路
    下一次佇列時我會闡述n次選擇思想
    */
    //注：L3必須為空連結串列
    if(!p1 && !p2)return;
    if(!p1){
        llist_insertpost(L3,L3.cnt,p2->data);
        llist_union(p1,p2->next,L3);
    }else if(!p2){
        llist_insertpost(L3,L3.cnt,p1->data);
        llist_union(p1->next,p2,L3);
    }else{
        if(p1->data.value > p2->data.value){
            llist_insertpost(L3,L3.cnt,p1->data);
            llist_union(p1->next,p2,L3);
        }else{
            llist_insertpost(L3,L3.cnt,p2->data);
            llist_union(p1,p2->next,L3);
        }
    }
}

二、做迴圈處理的連結串列

這裡不再使用程式碼演示，僅僅談我對於迴圈處理的看法

迴圈處理即最後一個元素的指標不指向NULL，而是指向頭節點或第一個節點

大幅提高遍歷的靈活性，可以從任意節點開始遍歷得到整個表，如約瑟夫環問題

涉及到與表尾與表頭的處理上有所變化，比如判斷空表、是否達到表尾等都有所變化

不過一般情況是不需要做迴圈處理的

三、雙鏈表

單鏈表在索引時只具有單向性，在部分操作上稍麻煩（如刪除元素時若不做特殊處理就無法得到前驅的尷尬）

雙鏈表在索引上具有雙向性，比如得知某一節點就能推出前驅和後繼

typedef struct{
    int value;
}element,*Element;

typedef struct __llnode{
    element data;//資料域
    struct __llnode *prior,*next;//指標域
}*llist_head,*llist_node,llist_size;

typedef struct{
	llist_head head;
    int cnt;
}llist;

基本操作

(1)建立雙鏈表

void llist_create(llist &L){
    L.cnt = 0;
    L.head = (llist_head)malloc(sizeof(llist_size));
    L.head->prior = NULL;
    L.head->next = NULL;
}

(2)輸入/輸出

void llist_input(llist &L,int n){
    //作用：輸入n個數據
    if(n < 0)return;
    llist_node p = L.head;
    L.cnt += n;
    while(p->next)p = p->next;
    while(n--){
        llist_node newnode = new llist_size;
        newnode->next = NULL;
        newnode->prior = p;
        p->next = newnode;
        scanf("%d ",&newnode->data.value);
        p = p->next;
    }
}

(3)判斷是否為空

bool llist_ifempty(llist &L){
    //作用：判斷連結串列是否為空
	return (L.head->next) ? true : false ;
}

(4)前/後插入

void llist_insertpre(llist &L,int pos,element e){
    //作用：前插入元素e
    if(pos < 1 || pos > L.cnt+1){
        printf("錯誤：超出範圍");
        return;
    }
    llist_node p = L.head;
    while(pos--)p = p->next;
    llist_node newnode = new llist_size;
    newnode->data = e;
    newnode->prior = p->prior;
    newnode->next = p;
    p->prior->next = newnode;
    p->prior = newnode;
    L.cnt++;
}

void llist_insertpost(llist &L,int pos,element e){
    //作用：後插入元素e
    if(pos < 0 || pos > L.cnt){
        printf("錯誤：超出範圍");
        return;
    }
    llist_node p = L.head;
    for(int i = 0;i < pos;i++)p = p->next;
    llist_node newnode = (llist_node)malloc(sizeof(llist_size));
    newnode->data = e;
    newnode->prior = p;
    newnode->next = p->next;
    p->next->prior = newnode;
    p->next = newnode;
    L.cnt++;
}

(5)刪除

void llist_delete(llist L,int pos){
    //作用：刪除元素e
    if(pos < 1 || pos > L.cnt){
        printf("錯誤：超出範圍");
        return;
    }
    llist_node p = L.head;
    while(pos--)p = p->next;
    p->prior->next = p->next;
    p->next->prior = p->prior;
    free(p);
    L.cnt--;
}

參考教程

郝斌 資料結構

C語言技術網 資料結構

參考書籍

《資料結構與演算法分析 C語言描述》

相關推薦

[redis] 資料結構 -- 連結串列

linkedlist 結構 typedef struct listNode { struct listNode *prev; // 前置節點 struct listNode *next; // 後置節點

redis資料結構-連結串列

每個連結串列節點使用一個adlist.h/listNode結構來表示：typedef struct listNode { // 前置節點

redis的資料結構——連結串列

一、前言 連結串列是一種常用的資料結構，大家肯定對它非常的熟悉。連結串列被內建在很多的高階語言中，但因為Redis是使用C語言實現的，而C語言並沒有這種資料結構，因此，Redis構建了自己的連結串列實現。連結串列在

資料結構 連結串列的頭插法逆置

頭插法逆置： L的next記錄的點是當前迴圈中p的上一個節點的地址，每當新一輪迴圈時，p到了上一次p的下一個位置的時候，只需要讓p.next指標指向L的next指向的位置(因為L.next記錄的是p上一個位置的地址)；接著p下移。

資料結構-連結串列

#include <iostream> #include <set> #include <unordered_set> #include <vector> #include <algorithm>

js-資料結構-連結串列

陣列 依次儲存 缺點： 對陣列做刪除或者插入的時候，可能需要移動大量的元素

資料結構-連結串列習題

判斷題 1.在單向連結串列中，頭指標中存放的是頭結點的內容。 TF 2.單向連結串列中的每個結點都需要動態分配記憶體空間。

c++資料結構連結串列和雙頭連結串列的實現

連結串列的基本概念不加以贅述，看看雙頭連結串列的定義如下: 在一個長度為L的連結串列List中,Input: head tail --->在List中查詢head和tail值的連結串列的節點,從tail節點往後的連結串列連線到List的頭部去，

重學資料結構-連結串列篇

一.如何實現LRU快取淘汰演算法 今天我們來聊聊“連結串列（Linked list）”這個資料結構。學習連結串列有什麼用呢？為了回答這個問題，我們先來討論一個經典的連結串列應用場景，那就是 LRU 快取淘汰演算法。

python資料結構——連結串列（無序列表）與簡單應用

技術標籤：python演算法連結串列列表資料結構python 簡單介紹 連結串列是一種無序列表，無序列表只需要維持元素之間的相對位置，但是並不需要在連續的記憶體空間中維護這些位置資訊。 連結串列裡的元素連線時靠每

JAVA資料結構--連結串列1

技術標籤：JAVA連結串列java資料結構 JAVA單向無頭連結串列 1.概念2.程式碼實現3.測試示例

資料結構--連結串列

技術標籤：資料結構筆記資料結構 連結串列 連結串列是一種物理儲存結構上非連續、非順序的儲存結構，資料元素的邏輯順序是通過連結串列中的指標連結次序實現的。常用的兩種連結串列結構：無頭單向非迴圈連結串列

資料結構——連結串列（無頭單向非迴圈連結串列+ 帶頭雙向迴圈連結串列）

之前學習連結串列一頭霧水，這講的什麼，黑人問號。現在重新學完連結串列，不錯不錯，有意思。這篇文章主要來說兩種連結串列，一是無頭+單向+非迴圈連結串列增刪查改，二是帶頭+雙向+迴圈連結串列增刪查。

TypeScript資料結構與演算法（5）最基礎的資料結構-連結串列-LinkedList

連結串列的概念，使用文字描述過於蒼白，用一張圖解釋： 從圖中可以看出連結串列的特性：

TypeScript資料結構與演算法（7）最基礎的資料結構-連結串列佇列-LinkedListQueue

使用連結串列來實現佇列，原始碼如下： import { Interface_Queue } from \"../Interface_Queue\";

資料結構——連結串列的簡單實現增刪改查以及合併（C語言）

技術標籤：資料結構資料結構連結串列 連結串列的簡單實現 什麼是連結串列程式碼的實現連結串列的結構體

資料結構 連結串列的各種刪除 (刪除連結串列中等於給定值 val 的所有節點）

技術標籤：資料結構 提示：文章寫完後，目錄可以自動生成，如何生成可參考右邊的幫助文件

核心資料結構-連結串列

連結串列作為一種常用的資料結構，核心中使用很多，常用的連結串列把資料結構放入連結串列，定義方式如下：

Redis的底層資料結構-連結串列

連結串列定義： typedefstruct listNode{ //前置節點 struct listNode *prev; //後置節點 struct listNode *next;

資料結構——連結串列

鎮樓圖 Pixiv:飛者 〇、連結串列構建前的細節問題 順序表構建時一定需要一個確定的長度嗎？