數據結構學習筆記06排序 (快速排序、表排序、基數排序)

1.快速排序

不穩定

分而治之

 

找主元pivot，小於主元划分為一個子集，大於主元的划分為一個子集

然后進行遞歸

最好情況：每次主元正好中分，T(N) = O( NlogN )

 

選主元 的方法有很多，這里用 取頭、中、尾的中位數。

　　直接選A[0]為pivot，時間復雜度T ( N ) = O( N ) + T ( N–1 ) = O( N ) + O ( N–1 ) + T( N–2 ) = = O( N ) + O ( N–1 ) + …+ O( 1 ) = O( N^2 )

　　隨機取pivot：rand()函數 也很費

　　取頭、中、尾的中位數……

子集划分

i指向8,j指向7.

8>6,i不動,7>6,j--;j指向2,2<6,j不動 交換8和2;

i++,i指向1,1<6,i++;i指向4,4<6,i++;i指向9,9>6,i不動;

j--,j指向5,5<6，j不動，交換5和9;

i++,i指向0,0<6,i++;i指向3,3<6,i++;i指向9,9>6,i不動;

j--,j指向3,3<6,j不動.

i>j,結束,6放到i位置，即6和9交換

如果有元素正好等於pivot怎么辦：
　　停下來交換：會產生很多不必要的交換。(一串相等的序列)
　　不理它，繼續移動指針：pivot位置靠近一段，最糟糕會在最右邊端，和pivot取A[0]一樣，O( N^2 )

　　綜合考慮，選第一種，停下來交換。

小規模數據的處理
　　快速排序的問題
　　　　用遞歸……
　　　　對小規模的數據（例如N不到100）可能還不如插入排序快
　　解決方案
　　　　當遞歸的數據規模充分小，則停止遞歸，直接調用簡單排序（例如插入排序）
　　　　在程序中定義一個Cutoff的閾值

#include <stdio.h>
typedef int ElementType;

void Swap( ElementType *a, ElementType *b )
{
    ElementType t = *a;
    *a = *b; 
    *b = t;
}

void InsertionSort(ElementType A[], int N)
{     
    int i;
    for (int P = 1; P < N; P++ ) {
        ElementType temp = A[P];     //取出未排序序列中第一個元素
        for (i = P; i > 0 && A[i-1] > temp; i-- )
            A[i] = A[i-1];     //依次與已排序序列中元素比較並右移
        A[i] = temp; 
    }
}

/* 快速排序 */
ElementType Median3( ElementType A[], int Left, int Right )
{ 
    int Center = (Left+Right) / 2;
    if ( A[Left] > A[Center] )
        Swap( &A[Left], &A[Center] );
    if ( A[Left] > A[Right] )
        Swap( &A[Left], &A[Right] );
    if ( A[Center] > A[Right] )
        Swap( &A[Center], &A[Right] );
    /* 此時A[Left] <= A[Center] <= A[Right] */
    Swap( &A[Center], &A[Right-1] ); /* 將基准Pivot藏到右邊*/
    /* 只需要考慮A[Left+1] … A[Right-2] */
    return  A[Right-1];  /* 返回基准Pivot */
}
 
void Qsort( ElementType A[], int Left, int Right )
{ /* 核心遞歸函數 */ 
     int Pivot, Cutoff = 50, Low, High;//閾值的定義
       
     if ( Cutoff <= Right-Left ) { /* 如果序列元素充分多，進入快排 */
          Pivot = Median3( A, Left, Right ); /* 選基准 */ 
          Low = Left; High = Right-1;
          while (1) { /*將序列中比基准小的移到基准左邊，大的移到右邊*/
               while ( A[++Low] < Pivot ) ;
               while ( A[--High] > Pivot ) ;
               if ( Low < High ) Swap( &A[Low], &A[High] );
               else break;
          }
          Swap( &A[Low], &A[Right-1] );   /* 將基准換到正確的位置 */ 
          Qsort( A, Left, Low-1 );    /* 遞歸解決左邊 */ 
          Qsort( A, Low+1, Right );   /* 遞歸解決右邊 */  
     }
     else InsertionSort( A+Left, Right-Left+1 ); /* 元素太少，用簡單排序 */ 
}
 
void QuickSort( ElementType A[], int N )
{ /* 統一接口 */
     Qsort( A, 0, N-1 );
}

int main()
{
    int a[] = {34,8,64,51,32,21};
    QuickSort(a, 6);
    for(int i = 0; i < 6; i++)
        printf("%d ",a[i]);
    return 0;
}

QuickSort

 

 2.表排序

間接排序

 

 

 

 

定義一個指針數組(下標)作為“表”（table）　

如果僅要求按順序輸出，則輸出：A[ table[0] ], A[ table[1] ], ……, A[ table[N-1] ]

 

物理排序

　

 

 

 

 

N個數字的排列由若干個獨立的環組成

用temp記錄初值 ，每次換位子修改table值，用if ( table[i] == i )判斷一個環的結束

 

復雜度

　　最好情況：初始即有序
　　最壞情況：
　　有[N / 2]向下取整 個環，每個環包含2個元素
　　需要[N / 2]向下取整 次元素移動
　　T = O( m N ) ，m 是每個A元素的復制時間。

 

3.基數排序

桶排序：假設我們有N 個學生，他們的成績是0到100之間的整數（於是有M = 101 個不同的成績值）。如何在線性時間內將學生按成績排序？

   T(N, M) = O( M+N )

　　當M>>N時，桶排序不合算

次位優先LSB

假設我們有N = 10 個整數，每個整數的值在0到999之間（於是有M = 1000 個不同的值）。

輸入序列: 64, 8, 216, 512, 27, 729, 0, 1, 343, 125
用“次位優先”（Least Significant Digit）　　T=O(P(N+B))

多關鍵字的排序

一副撲克牌是按2種關鍵字排序的

 

#include <stdio.h> 
#include <stdlib.h>

typedef int ElementType;

/* 基數排序 - 次位優先 */
 
/* 假設元素最多有MaxDigit個關鍵字，基數全是同樣的Radix */
#define MaxDigit 4
#define Radix 10
 
/* 桶元素結點 */
typedef struct Node *PtrToNode;
struct Node {
    int key;
    PtrToNode next;
};
 
/* 桶頭結點 */
struct HeadNode {
    PtrToNode head, tail;
};
typedef struct HeadNode Bucket[Radix];
  
int GetDigit ( int X, int D )
{ /* 默認次位D=1, 主位D<=MaxDigit */
    int d, i;
     
    for (i=1; i<=D; i++) {
        d = X % Radix;
        X /= Radix;
    }
    return d;
}
 
void LSDRadixSort( ElementType A[], int N )
{ /* 基數排序 - 次位優先 */
     int D, Di, i;
     Bucket B;
     PtrToNode tmp, p, List = NULL; 
      
     for (i=0; i<Radix; i++) /* 初始化每個桶為空鏈表 */
         B[i].head = B[i].tail = NULL;
     for (i=0; i<N; i++) { /* 將原始序列逆序存入初始鏈表List */
         tmp = (PtrToNode)malloc(sizeof(struct Node));
         tmp->key = A[i];
         tmp->next = List;
         List = tmp;
     }
     /* 下面開始排序 */ 
     for (D=1; D<=MaxDigit; D++) { /* 對數據的每一位循環處理 */
         /* 下面是分配的過程 */
         p = List;
         while (p) {
             Di = GetDigit(p->key, D); /* 獲得當前元素的當前位數字 */
             /* 從List中摘除 */
             tmp = p; p = p->next;
             /* 插入B[Di]號桶尾 */
             tmp->next = NULL;
             if (B[Di].head == NULL)
                 B[Di].head = B[Di].tail = tmp;
             else {
                 B[Di].tail->next = tmp;
                 B[Di].tail = tmp;
             }
         }
         /* 下面是收集的過程 */
         List = NULL; 
         for (Di=Radix-1; Di>=0; Di--) { /* 將每個桶的元素順序收集入List */
             if (B[Di].head) { /* 如果桶不為空 */
                 /* 整桶插入List表頭 */
                 B[Di].tail->next = List;
                 List = B[Di].head;
                 B[Di].head = B[Di].tail = NULL; /* 清空桶 */
             }
         }
     }
     /* 將List倒入A[]並釋放空間 */
     for (i=0; i<N; i++) {
        tmp = List;
        List = List->next;
        A[i] = tmp->key;
        free(tmp);
     } 
}

int main()
{
    int a[] = {34,8,64,51,32,21};
    LSDRadixSort(a, 6);
    for(int i = 0; i < 6; i++)
        printf("%d ",a[i]);
    return 0;
}

#include <stdio.h> 
#include <stdlib.h>

typedef int ElementType;

/* 基數排序 - 主位優先 */
 
/* 假設元素最多有MaxDigit個關鍵字，基數全是同樣的Radix */
 
#define MaxDigit 4
#define Radix 10
 
/* 桶元素結點 */
typedef struct Node *PtrToNode;
struct Node{
    int key;
    PtrToNode next;
};
 
/* 桶頭結點 */
struct HeadNode {
    PtrToNode head, tail;
};
typedef struct HeadNode Bucket[Radix];
  
int GetDigit ( int X, int D )
{ /* 默認次位D=1, 主位D<=MaxDigit */
    int d, i;
     
    for (i=1; i<=D; i++) {
        d = X%Radix;
        X /= Radix;
    }
    return d;
}
 
void MSD( ElementType A[], int L, int R, int D )
{ /* 核心遞歸函數: 對A[L]...A[R]的第D位數進行排序 */
     int Di, i, j;
     Bucket B;
     PtrToNode tmp, p, List = NULL; 
     if (D==0) return; /* 遞歸終止條件 */
      
     for (i=0; i<Radix; i++) /* 初始化每個桶為空鏈表 */
         B[i].head = B[i].tail = NULL;
     for (i=L; i<=R; i++) { /* 將原始序列逆序存入初始鏈表List */
         tmp = (PtrToNode)malloc(sizeof(struct Node));
         tmp->key = A[i];
         tmp->next = List;
         List = tmp;
     }
     /* 下面是分配的過程 */
     p = List;
     while (p) {
         Di = GetDigit(p->key, D); /* 獲得當前元素的當前位數字 */
         /* 從List中摘除 */
         tmp = p; p = p->next;
         /* 插入B[Di]號桶 */
         if (B[Di].head == NULL) B[Di].tail = tmp;
         tmp->next = B[Di].head;
         B[Di].head = tmp;
     }
     /* 下面是收集的過程 */
     i = j = L; /* i, j記錄當前要處理的A[]的左右端下標 */
     for (Di=0; Di<Radix; Di++) { /* 對於每個桶 */
         if (B[Di].head) { /* 將非空的桶整桶倒入A[], 遞歸排序 */
             p = B[Di].head;
             while (p) {
                 tmp = p;
                 p = p->next;
                 A[j++] = tmp->key;
                 free(tmp);
             }
             /* 遞歸對該桶數據排序, 位數減1 */
             MSD(A, i, j-1, D-1);
             i = j; /* 為下一個桶對應的A[]左端 */
         } 
     } 
}
 
void MSDRadixSort( ElementType A[], int N )
{ /* 統一接口 */
    MSD(A, 0, N-1, MaxDigit); 
}

int main()
{
    int a[] = {34,8,64,51,32,21};
    MSDRadixSort(a, 6);
    for(int i = 0; i < 6; i++)
        printf("%d ",a[i]);
    return 0;
}