2. 程式人生 > >資料結構--連結串列的排序詳解

資料結構--連結串列的排序詳解

阿新 • • 發佈：2018-12-20

1、前言 
前面兩篇部落格，我已經把線性表的兩種基本的表示形式，做了一個基本的介紹和一些對比。但是，我突然發現在連結串列這裡我缺少一個很重要的內容，那就是對我們的連結串列進行排序，其實，在連線兩個連結串列的時候，就要求我們的那兩個連結串列是有序的。

2、連結串列排序—最簡單、直接的方式（直接採用冒泡或者選擇排序，而且不是交換結點，只交換資料域）
 

//線性表的排序,採用氣泡排序,直接遍歷連結串列
void Listsort(Node* & head) {
    int i = 0;
    int j = 0;
    //用於變數連結串列
    Node * L = head;
    //作為一個臨時量
    Node * p;
    Node * p1;
    //如果連結串列為空直接返回
    if (head->value == 0)return;

    for (i = 0; i < head->value - 1; i++) {
        L = head->next;
        for (j = 0; j < head->value - i - 1; j++) {
            //得到兩個值
            p = L;
            p1 = L->next;
            //如果前面的那個比後面的那個大，就交換它們之間的是資料域
            if (p->value > p1->value) {
                Elemtype temp = p->value;
                p->value = p1->value;
                p1->value = temp;
            }
            L = L->next;
        }
    }
}

因為排序中速度比較快的如快速排序是要求它們的資料域的地址是相連線的，它比較適合於順序結構，而鏈式結構的時候，我們就只有使用只會進行前後兩個比較多排序演算法，比如氣泡排序等。我們這裡是沒有交換結點的一種排序方式，這種方式簡單，明瞭，這樣就是陣列排序的時候是一樣的。後面我會寫通過交換結點的方式的排序。 
下面我們就討論討論這個排序演算法的時間複雜度了，因為它是使用氣泡排序的，它的時間只要消耗在那兩重迴圈，所以時間複雜度為：O(n*n),這個效率實在是太低，下面我們對這個想(ˇˍˇ) 想～通過另外一種方式來實現連結串列的排序

3、另外一種連結串列排序方式 
我們在討論排序演算法的時候，都是把資料存放在陣列中進行討論的，在順序結構下，我們可以採取很多高效的排序演算法，那麼這個就是我們另外一種對連結串列排序的方式，先把連結串列的內容存放到陣列中（時間為O(n)），然後，我們在對那個陣列進行排序（最快為nlog(n)），最後，存放連結串列中（時間為O(n)）。通過計算，我們可以得到它的時間複雜為（O(nlogn)）,這個速度已經和順序結構下差不多了，可以接受。
 

void Listsort_1(Node* & head) {
    int i = 0;
    int j = 0;
    //用於變數連結串列
    Node * L = head;
    //如果連結串列為空直接返回
    if (head->value == 0)return;
    Elemtype * copy = new Elemtype[head->value];
    //變數連結串列，存放陣列
    for (i = 0; i < head->value; i++) {
        L = L->next;
        copy[i] = L->value;
    }
    //呼叫STL中的sort函式
    sort(copy, copy + head->value);
    L = head;
    //存放回連結串列中
    for (i = 0; i < head->value; i++) {
        L = L->next;
          L->value= copy[i];
    }
}

4、先我們通過採取增大資料量的方式，比較兩種排序在效率如何

è¿éåå¾çæè¿°

 

如圖所示，在資料量為10000的時候，明顯第二種排序演算法消耗的時間比第一種快了28倍左右。

5、下面通過交換結點實現連結串列的排序 
首先我們編寫交換結點的函式，結點的交換主要就是考慮結點的指標域的問題，其中相鄰兩個結點是一種特殊的情況，要拿出來特別考慮。我們先畫出結點交換的思路圖，如下圖 
首先我們給出相鄰兩個結點交換的思路： 
 

è¿éåå¾çæè¿°

下面是普通情況下的交換如下圖 

è¿éåå¾çæè¿°

 

//引數為頭結點和需要交換的兩個結點的位置（起點為1）
void swap_node(Node * & head,int i,int j) {
    //位置不合法
    if (i<1 || j<1 || i>head->value || j >head->value) {
        cout << "請檢查位置是否合法" << endl;
        return;
    }
    //同一個位置不用交換
    if (i == j)
    {
        return;
    }
    //相鄰兩個交換比較簡單
    if (abs(i - j) == 1) {
        //位置靠前的那個結點的前一個結點
        Node * pre;
        if (i < j)
            pre = getitem(head, i);
        else
            pre = getitem(head, j);

        //儲存第一個結點
        Node * a = pre->next;
        //儲存第二結點
        Node * b = a->next;
        //改變pre下一個結點的值
        pre->next = b;
        //必須先把b的下一個結點值給a先
        a->next = b->next;
        //讓b的下一個結點等於a
        b->next = a;
        return;
    }

    //第一個結點前一個結點
    Node * a = getitem(head, i);
    //第二個結點的前一個結點
    Node * b = getitem(head, j);
    //第一個結點
    Node * p = a->next;
    //第二個結點
    Node * q = b->next;
    //第一個結點的下一個結點
    Node * p_next = p->next;
    //第二結點的下一個結點
    Node * q_next = q->next;

    //a的下一個結點指向第二個結點q
    a->next = q;
    //第二結點的下一個結點指向第一個結點的下一個結點
    q->next = p_next;
    //b的下一個結點指向第一個結點p
    b->next = p;
    //第一個結點的下一個結點指向第二個結點的下一個結點
    p->next = q_next;

}

 排序時候的程式碼，切記交換結點都是前後結點交換，所以交換完成後，L就已經被移動到下一個結點了，故不要再執行：L=L->next

 

//線性表的排序，交換結點
void Listsort_Node(Node* & head) {
    int i = 0;
    int j = 0;
    //用於變數連結串列
    Node * L = head;
    //作為一個臨時量
    Node * p;
    Node * p1;
    //如果連結串列為空直接返回
    if (head->value == 0)return;
    int flag = 0;
    cout << head->value << endl;
    for (i = 0; i < head->value - 1; i++) {
        L = head->next;
        for (j = 0; j < head->value - 1 - i; j++) {
            //如果我們交換了結點，那麼我們就已經在交換結點的時候，把L移動到下一個結點了，所以不要
            //再執行：L = L->next;，否則會報錯的
            if (L->value > L->next->value) {
                flag = 1;
                swap_node(head, j + 1, j + 2);

            }
            if (flag == 1) {
                flag = 0;
            }
            else {
                L = L->next;
            }

        }   
    }
}

好了，今天的就寫到這裡了，今天通過寫交換結點，發現連結串列真的很容易忽悠人，我就被忽悠了一個小時，才知道那個結點已經被移動到下一個結點了。

最後，補充一個實現連結串列反轉的好方法（感覺你在標頭檔案裡面計算一下連結串列的長度可以帶來很多遍歷的）

 

void rollback(Node * & head) {
    //先知道了最後一個元素和第一個元素的位置
    int end = head->value;
    int start = 1;
    //兩邊同時開工
    //進行調換
    while (1) {
        if (end == start)
            return;
        swap_node(head, end, start);
        --end;
        ++start;
    }
}

希望大家，對我寫的程式碼做出一些評價。我想想還是直接貼個完成的程式碼出來好了，調轉程式碼也在裡面了

 

#include<iostream>
#include<ctime>
#include<cstdlib>
#include<windows.h>
#include<algorithm>
using namespace std;
typedef int Elemtype;

//鏈式結構，我們打算在連結串列中新增一個
//儲存長度的頭結點，加入這個結點可以方便我們對結點做一些
//基本的操作，結點儲存的是線性表的長度
struct Node
{
    //結點的值,如果是頭結點，儲存是連結串列的長度
    Elemtype value;
    //下一個結點的地址
    Node * next;

};

//建立一個空連結串列，每個頭結點就代表一個連結串列
void InitList(Node * & head) {
    head = new Node();
    head->value = 0;
    head->next = NULL;
}
//銷燬一個連結串列
void DestroyList(Node * & head) {
    delete head;
    head = NULL;
}

//清空整個列表
void ClearList(Node * & head) {
    head->value = 0;
    head->next = NULL;
}

//插入函式
bool Listinsert(Node * & head, int i, Elemtype value) {

    //插入到前面的方法
    int j = 0;
    Node * L = head;
    //如果插入的位置不合法，直接返回錯誤提示
    if (i<1 || i>head->value + 1)return false;

    //得到插入位置的前一個結點
    while (j < i - 1) {
        L = L->next;
        ++j;
    }

    //s是一個臨時結點
    Node * s = new Node();
    s->value = value;    //先對臨時結點賦值
    s->next = L->next;   //讓臨時結點下一個位置指向當前需要插入前一個結點的下一個位置
    L->next = s;          //讓前一個結點下一個位置指向臨時結點，完成
                          //線性表的長度加一
    ++head->value;
    return true;
}
//得到某個位置上的值
Node * getitem(Node * & head, int i) {
    //我們要求程式返回特定位置上的值
    //我們一樣是從頭結點開始尋找該位置
    int j = 0;
    Node * L = head;
    //想要的那個位置是否合法
    if (i<1 || i >head->value)return NULL;

    //同樣是先得到前一個結點
    while (j < i - 1) {
        L = L->next;
        ++j;
    }
    //value = L->next->value;
    return L;
}
//線性表的排序,採用氣泡排序,直接遍歷連結串列
void Listsort(Node* & head) {
    int i = 0;
    int j = 0;
    //用於變數連結串列
    Node * L = head;
    //作為一個臨時量
    Node * p;
    Node * p1;
    //如果連結串列為空直接返回
    if (head->value == 0)return;

    for (i = 0; i < head->value - 1; i++) {
        L = head->next;
        for (j = 0; j < head->value - i - 1; j++) {
            //得到兩個值
            p = L;
            p1 = L->next;
            //如果前面的那個比後面的那個大，就交換它們之間的是資料域
            if (p->value > p1->value) {
                Elemtype temp = p->value;
                p->value = p1->value;
                p1->value = temp;
            }
            L = L->next;
        }
    }
}
//通過陣列來完成我的排序
void Listsort_by_array(Node* & head) {
    int i = 0;
    int j = 0;
    //用於變數連結串列
    Node * L = head;
    //如果連結串列為空直接返回
    if (head->value == 0)return;
    Elemtype * copy = new Elemtype[head->value];
    //變數連結串列，存放陣列
    for (i = 0; i < head->value; i++) {
        L = L->next;
        copy[i] = L->value;
    }
    //呼叫STL中的sort函式
    sort(copy, copy + head->value);
    L = head;
    //存放回連結串列中
    for (i = 0; i < head->value; i++) {
        L = L->next;
        L->value = copy[i];
    }
}

//引數為頭結點和需要交換的兩個結點的位置（起點為1）
void swap_node(Node * & head,int i,int j) {
    //位置不合法
    if (i<1 || j<1 || i>head->value || j >head->value) {
        cout << "請檢查位置是否合法" << endl;
        return;
    }
    //同一個位置不用交換
    if (i == j)
    {
        return;
    }
    //相鄰兩個交換比較簡單
    if (abs(i - j) == 1) {
        //位置靠前的那個結點的前一個結點
        Node * pre;
        if (i < j)
            pre = getitem(head, i);
        else
            pre = getitem(head, j);

        //儲存第一個結點
        Node * a = pre->next;
        //儲存第二結點
        Node * b = a->next;
        //改變pre下一個結點的值
        pre->next = b;
        //必須先把b的下一個結點值給a先
        a->next = b->next;
        //讓b的下一個結點等於a
        b->next = a;
        return;
    }

    //第一個結點前一個結點
    Node * a = getitem(head, i);
    //第二個結點的前一個結點
    Node * b = getitem(head, j);
    //第一個結點
    Node * p = a->next;
    //第二個結點
    Node * q = b->next;
    //第一個結點的下一個結點
    Node * p_next = p->next;
    //第二結點的下一個結點
    Node * q_next = q->next;

    //a的下一個結點指向第二個結點q
    a->next = q;
    //第二結點的下一個結點指向第一個結點的下一個結點
    q->next = p_next;
    //b的下一個結點指向第一個結點p
    b->next = p;
    //第一個結點的下一個結點指向第二個結點的下一個結點
    p->next = q_next;

}
//反轉
void rollback(Node * & head) {
    //先知道了最後一個元素和第一個元素的位置
    int end = head->value;
    int start = 1;
    //兩邊同時開工
    //進行調換
    while (1) {
        if (end <= start)
            return;
        swap_node(head, end, start);
        --end;
        ++start;
    }
}
void print(Node * & head);
//線性表的排序,採用氣泡排序,直接遍歷連結串列
//線性表的排序，交換結點
void Listsort_node(Node* & head) {
    int i = 0;
    int j = 0;
    //用於變數連結串列
    Node * L = head;
    //作為一個臨時量
    Node * p;
    Node * p1;
    //如果連結串列為空直接返回
    if (head->value == 0)return;
    int flag = 0;

    for (i = 0; i < head->value - 1; i++) {
        L = head->next;
        for (j = 0; j < head->value - 1 - i; j++) {
            //如果我們交換了結點，那麼我們就已經在交換結點的時候，把L移動到下一個結點了，所以不要
            //再執行：L = L->next;，否則會報錯的
            if (L->value > L->next->value) {
                flag = 1;
                swap_node(head, j + 1, j + 2);

            }
            if (flag == 1) {
                flag = 0;
            }
            else {
                L = L->next;
            }

        }   
    }
}

void print(Node * & head) {
    //輸出我們只需要傳入頭結點，然後迴圈判斷當前結點下一個結點是否為空，
    //這樣就可以輸出所有內容
    Node * L = head;
    while (L->next) {
        L = L->next;
        cout << L->value << " ";
    }
    cout << endl;
}
int main() {
    //連結串列的頭結點，不存放任何值，首先初始化頭結點
    Node * head;

    Node * head_array;
    Node * head_node;
    Node * head_roll;
    srand((int)time(NULL));     //每次執行種子不同，生成不同的隨機數
    //建立一個連結串列

    InitList(head); 
    InitList(head_array);
    InitList(head_node);
    InitList(head_roll);

    int i;
    cout << "請輸入需要插入元素個數" << endl;
    int n;
    cin >> n;//5
    //cout << "請輸入" << n << "個值" << endl;
    for (i = 0; i < n; i++) {
        Elemtype temp;
        temp = rand();
        if (!Listinsert(head, i + 1, temp)) {
            cout << "插入元素失敗" << endl;
        }
        if (!Listinsert(head_array, i + 1, temp)) {
            cout << "插入元素失敗" << endl;
        }
        if (!Listinsert(head_node, i + 1, temp)) {
            cout << "插入元素失敗" << endl;
        }
        if (!Listinsert(head_roll, i + 1, temp)) {
            cout << "插入元素失敗" << endl;
        }

    }
    cout << "初始化結果" << endl;
    print(head);
    cout << "反轉結果" << endl;
    rollback(head_roll);
    print(head_roll);
    cout << "氣泡排序（資料域交換）" << endl;
    Listsort(head);
    print(head);
    cout << "借陣列為媒介進行排序（資料域交換）" << endl;
    Listsort_by_array(head_array);
    print(head_array);
    cout << "氣泡排序（結點交換）" << endl;
    Listsort_node(head_node);
    print(head_node);
    system("pause");
    return 0;

}

執行環境：vs2015 
輸出結果： 
 

è¿éåå¾çæè¿°

來源： https://blog.csdn.net/qq_35644234/article/details/53222603 

相關推薦

資料結構---拓撲排序詳解

前言 The time of test,family is best. Name:Willam Time:2017/3/6 1、拓撲排序的介紹 對一個有向無環圖(Directed Acyclic Graph簡稱DAG)G進行拓撲排序，是將G中所有頂

資料結構--連結串列的排序詳解

1、前言  前面兩篇部落格，我已經把線性表的兩種基本的表示形式，做了一個基本的介紹和一些對比。但是，我突然發現在連結串列這裡我缺少一個很重要的內容，那就是對我們的連結串列進行排序，其實，在連線兩個連結串列的時候，就要求我們的那兩個連結串列是有序的。 2、連結串列排序—最簡單、直接的方式

資料結構 1 線性表詳解 連結串列、 棧 、 佇列 結合JAVA 詳解

## 前言 其實在學習資料結構之前，我也是從來都沒了解過這門課，但是隨著工作的慢慢深入，之前學習的東西實在是不夠用，並且太皮毛了。太淺，只是懂得一些淺層的，我知道這個東西怎麼用，但是要優化、或者是解析，就不知道該咋弄了。比如JAVA 最有名的幾個容器: - List - Set - MAP - Queue

前端也需要了解的資料結構-連結串列

前言 最近被小夥伴問到連結串列是什麼,連結串列作為一種常見的資料結構,但是很多前端coder對此並不瞭解,寫下這篇文章,介紹下連結串列的js實現,不瞭解連結串列的同學也可以做個參考 單向連結串列 和陣列區別，地址離散。它在記憶體地址中可以離散的分配，由於它是離散的分配，所以他可以

js資料結構 -- 連結串列, 雙向連結串列，迴圈連結串列

陣列作為js常用的資料結構，存取元素都非常的方便，但是其內部的實現原理跟其他計算機語言對陣列的實現都是一樣的。 由於陣列在記憶體中的儲存是連續的，所以當在陣列的開頭或者中間插入元素時，內部都需要去移動其他元素的位置，這個移動元素的成本很高。 連結串列也是儲存有序的元素集合，但不同

資料結構連結串列題目1：查詢、插入、刪除基本操作 解析

1.連結串列的查詢插入刪除 有問題的程式碼： #include<iostream> #define ok 0 #define error -1 using namespace std; class ListNode { public: int data; ListNode

資料結構連結串列題目2：交換位置、3：合併

利用查詢、提取資料、插入、刪除、輸出等函式，順利搞定第二題 #include<iostream> #define ok 0 #define error -1 using namespace std; class ListNode { public: int data; List

Python資料結構-連結串列

1）概念：連結串列是一種物理儲存單元上非連續、非順序的儲存結構，資料元素的邏輯順序是通過連結串列中的指標連結次序實現的。連結串列由一系列結點（連結串列中每一個元素稱為結點）組成，結點可以在執行時動態生成。每個結點包括兩個部分：一個是儲存資料元素的資料域，另一個是儲存下一個結點地址的指標域。 相比於線性表順序結

資料結構--連結串列

    定義         n個節點離散分配         彼此通過指標相連        &n

java中的資料結構——連結串列

連結串列 連結串列也是線性資料結構，與陣列相比，在記憶體分配、內部結構及資料插入和刪除的操作上均有不同。 連結串列用途廣泛，適用於許多通用的資料庫，也可以取代陣列，作為其他儲存結構的基礎。 在連結串列中，每個資料項都被包含在鏈節點中，一個鏈節點是某個類的物件，這個類叫做Link。因為一個

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

這是普通的連結串列實現, 連結串列結點不直接持有資料, 而是通過void *指標來間接的指向資料. 其實現位於 src/adlist.h與src/adlist.c中, 關鍵定義如下: typedef struct listNode { struct listNode *prev

資料結構 - 連結串列

連結串列 　　之前講到的動態陣列、棧、佇列，底層都是依託靜態陣列，靠resize解決固定容量問題。而連結串列是一種真正的動態線性的資料結構。   　　*最簡單的動態資料結構 　　*更加深入理解引用 　　*更深入的理解遞迴 　　*輔組組成其他資料結構 　　 　　資料儲存在節點（Node

資料結構-連結串列-練習題1

題目 2.已知一個帶表頭結點的單鏈表，結點結構為data、link,假設該連結串列只給出了頭指標list。 在不改變連結串列的前提下，請設計一個儘可能高效的演算法，查詢連結串列中倒數第k個位置上的結點（k正為整數）。 若查詢成功，演算法輸出該結點的data域的值，並返回1

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

一、連結串列為什麼存在？       1）.陣列的缺陷                    無序列表：搜尋效能差，有序列表：插入效率低，並且兩個的刪除效率也很低，陣列在

資料結構-連結串列（java實現）

/** * 連結串列節點定義 * */ private class Node { private Object data; private Node next; public Node getNext() { return next;

資料結構—連結串列經典面試題

 連結串列面試題： 從尾到頭列印單鏈表 刪除一個無頭單鏈表的非尾節點（不能遍歷連結串列） 在無頭單鏈表的一個節點前插入一個節點（不能遍歷連結串列） 單鏈表實現約瑟夫環(JosephCircle) 逆置/反轉單鏈表 單鏈表排序（氣泡排序&快速排序） 合併

演算法導論---資料結構----連結串列篇

資料結構----連結串列 連結串列的每個元素都是一個物件x，x.key(鍵值),x.prev（上一個指標）, x.next（下一個指標）,x.head（表頭） 雙向連結串列：x.prev, x.next,x.head 單向連結串列：x.next，x.head 迴圈連結

資料結構——連結串列求兩集合的交集

#include <stdio.h> #include <malloc.h> typedef struct Node { int data; struct Node *next; }LNode,*LinkList; LNode *C

資料結構——連結串列（幾個拓展的做法）

#include <stdio.h>//注意放在c++中 #include <stdlib.h> #include <string.h> typedef struct as{ int date; struct

資料結構-連結串列

本章將討論另一種列表: 連結串列 . 解釋為什麼有時連結串列優於陣列, 還會實現一個基於物件的連結串列. 陣列的缺點 陣列不總是組織資料的最佳資料結構, 原因如下. 在很多程式語言中, 陣列的長度是固定的, 所以當陣列已被資料填滿時, 再要加入新的元素就會非常困難.