詳解C++實現鏈表的排序算法

一、鏈表排序

最簡單、直接的方式(直接采用冒泡或者選擇排序,而且不是交換結點,隻交換數據域)

//線性表的排序,采用冒泡排序,直接遍歷鏈表
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),這個效率實在是太低,下面我們對這個想(ˇˍˇ) 想~通過另外一種方式來實現鏈表的排序

二、另外一種鏈表排序方式

我們在討論排序算法的時候,都是把數據存放在數組中進行討論的,在順序結構下,我們可以采取很多高效的排序算法,那麼這個就是我們另外一種對鏈表排序的方式,先把鏈表的內容存放到數組中(時間為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];
    }
}

三、比較兩種排序的效率

這裡寫圖片描述

如圖所示,在數據量為10000的時候,明顯第二種排序算法消耗的時間比第一種快瞭28倍左右。

四、下面通過交換結點實現鏈表的排序

首先我們編寫交換結點的函數,結點的交換主要就是考慮結點的指針域的問題,其中相鄰兩個結點是一種特殊的情況,要拿出來特別考慮。我們先畫出結點交換的思路圖,如下圖

首先我們給出相鄰兩個結點交換的思路:

這裡寫圖片描述

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

這裡寫圖片描述

//參數為頭結點和需要交換的兩個結點的位置(起點為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

輸出結果:

這裡寫圖片描述

以上就是詳解C++實現鏈表的排序算法的詳細內容,更多關於C++ 鏈表排序算法的資料請關註WalkonNet其它相關文章!