排序算法----快速排序（鏈表形式）

單鏈表形式實現排序算法。

這個快速排序主要利用遞歸調用。包含4個文件，頭文件QuickSort.h，fatal.h，庫函數QuickSort.c，測試文件TestQuickSort。

QuickSort.h

 

typedef long ElementType;
#ifndef _List_H//如果沒有編譯過
#include<stdbool.h>
struct Node;
typedef struct Node *PtrToNode;
typedef PtrToNode List;
typedef PtrToNode Position;
List MakeEmpty(List L);
void DeleteList(List L);
bool IsEmpty(List L);
bool IsLast(Position P, List L);
void Insert(ElementType X, List L, Position P);
Position Header(List L);
Position First(List L);
Position Advance(Position P);
ElementType Retrieve(Position P);
void PrintList(const List L);
void SwapWithNext(Position BeforeP, List L);
void Qsort(List L, List tail);//快速排序核心算法
void QuickSort(List L);//快速排序驅動程序
#endif // !_List_H

 

 

 

fatal.h

#include<stdio.h>
#include<stdlib.h>
#define Error(Str) FatalError(Str)
#define FatalError(Str) fprintf(stderr, "%s\n", Str), exit(1);

庫函數QuickSort.c

 

// 引用頭文件
#include "QuickSort.h"
#include<stdlib.h>
#include "fatal.h"

//結構體定義
struct Node
{
    ElementType Element;
    Position Next;
};

//初始化鏈表
List MakeEmpty(List L)
{
    if (L != NULL)
        DeleteList(L);//如果鏈表非空，則刪除鏈表
    L = malloc(sizeof(struct Node));
    if (L == NULL)
        FatalError("Out of memory!");
    L->Next = NULL;
    return L;
}

//刪除鏈表
void DeleteList(List L)
{
    Position P, Temp;
    P = L->Next;
    L->Next = NULL;
    while (P != NULL)
    {
        Temp = P->Next;
        free(P);
        P = Temp;
    }
}

//判斷鏈表是否為空
bool IsEmpty(List L)
{
    return L->Next == NULL;
}

//判斷當前指針P是否指向鏈表最后一個元素
bool IsLast(Position P, List L)
{
    return P->Next == NULL;
}



//插入元素X到位置P后面
void Insert(ElementType X, List L, Position P)
{
    Position  TmpCell;
    TmpCell = malloc(sizeof(struct Node));
    if (TmpCell == NULL)
        FatalError("Out of Space!!!");
    TmpCell->Element = X;
    TmpCell->Next = P->Next;
    P->Next = TmpCell;
}

//獲取鏈表頭
Position Header(List L)
{
    return L;
}

//獲取鏈表第一個元素的位置
Position First(List L)
{
    return L->Next;
}

//獲取位置P的下一個位置
Position Advance(Position P)
{
    return P->Next;
}

//提取位置P處結構里面的值
ElementType Retrieve(Position P)
{
    return P->Element;
}

//打印鏈表
void PrintList(const List L)
{
    Position P = Header(L);
    if (IsEmpty(L))
        printf("Empty list\n");
    else
    {
        do
        {
            P = Advance(P);
            printf("%d ", Retrieve(P));
        } while (!IsLast(P, L));
        printf("\n");
    }
}


//通過只調整指針來交換兩個相鄰的元素，BeforeP是要調換兩個元素的前一
//個指針
void SwapWithNext(Position BeforeP, List L)
{
    Position P, AfterP;
    if (BeforeP != NULL)
    {
        P = Advance(BeforeP);
        if (P != NULL)
        {
            AfterP = Advance(P);
            if (AfterP != NULL)
            {
                P->Next = AfterP->Next;
                BeforeP->Next = AfterP;
                AfterP->Next = P;
            }
        }
    }
}

//快速排序核心算法
void Qsort(List head, List tail)
{
    //將鏈表分成2、4、8。。。，我們只說明開始分成2兩條的情況
    //將鏈表分成兩條，小於樞紐元的鏈表1，大於等於樞紐元的鏈表2，鏈表1已經有了頭結點head，鏈表2以樞紐元為頭結點mid
    if (head->Next == tail || head->Next->Next == tail)
        return;//如果鏈表是空或者只有一個元素，則停止循環

    List mid = head->Next;//指向樞紐元的指針
    List p = head;//指向鏈表1,最后p指向鏈表1的尾元素
    List q = mid;//指向鏈表2，最后q指向鏈表2的尾元素
    ElementType pivot = mid->Element;//樞紐元
    List t = mid->Next;//探測指針，指向下一個元素，查詢是大於樞紐元還是小於樞紐元

    while (t != tail)//當探測指針指向鏈表尾節點，循環結束
    {
        if (t->Element < pivot)//當探測指針指向的元素<樞紐元，則把該元素接到鏈表1
            p = p->Next = t;
        else
            q = q->Next = t;//當探測指針指向的元素>=樞紐元，則把該元素接到鏈表2
        t = t->Next;//不管上一個元素大小如何，都要指向下一個元素
    }
    //當循環完整個鏈表，然后將鏈表1和2拼接起來
    p->Next = mid;//將小於樞紐元的鏈表1的尾節點指向樞紐元
    q->Next = tail;//將鏈表2的尾節點指向tail

    Qsort(head, mid);//對鏈表1進行同樣的循環，當滿足113行條件，則停止這個遞歸
    Qsort(mid, tail);//對鏈表2進行同樣的循環，當滿足113行條件，則停止這個遞歸
    //當兩個QuickSort都滿足113行時，跳出遞歸循環，程序結束
}

//快速排序驅動程序
void QuickSort(List L)
{
    Qsort(L, NULL);//調用排序算法，第二個是NULL
}

 

 

 

測試文件TestQuickSort：

 

#include<stdio.h>
#include "QuickSort.h"
#include"fatal.h"
#include<time.h>

int main()
{
    long  amount;      List L; Position P;
    L = MakeEmpty(NULL);//初始化鏈表
    P = L;
    if (L == NULL) Error("Out of Space!!!");
    printf("隨機生成多少位數:");
    scanf_s("%d", &amount);
    srand((unsigned)time(NULL));
    for (long i = 0; i < amount; i++)
    {
        Insert(rand() % 1000000, L, P);
        P = Advance(P);
    }
    //printf("排序前的結果：");
    //PrintList(L);
    QuickSort(L);//調用排序驅動程序
    printf("排序后的結果：");
    PrintList(L);
}