資料結構學習（C++）續——排序【3】交換排序 (轉)

資料結構學習（C++）續——排序【3】交換排序 (轉)[@more@]

【3】排序

基本思想是：兩兩比較待排序記錄的關鍵碼，如果發生逆序，則交換之，直到所有都排好為止。

起泡排序

起泡排序是比較相鄰的兩個記錄，逆序則交換。這樣的做法導致小的關鍵碼一層層的浮上來，因此得名。CSDN的論壇曾經討論過“冒泡”和“起泡”是不是一個東西，看來這是翻譯惹的禍，英文名都是Bubble Sort，具體寫的時候可以正著排，也可以倒著排。（嚴版是從後往前排，殷版是從前往後排，好在兩本書都翻譯為“起泡排序”，不然就正像某些人得出的結論——一個是從後往前排，一個是從前往後排）

template

void BubbleSort(T a[], int N, int& KCN, int& RMN)

{

  KCN = 0; RMN = 0; bool = true;

  for (int i = 1; i < N && exchange; i++)

  for (int j = N - 1; j >= i; j--)

  {

    exchange = false;

  if (++KCN && a[j - 1] > a[j]) { s(a[j - 1], a[j]); exchange = true; RMN += 3; }

  }

}

需要注意的是，不要寫成下面這個樣子，雖然結果是對的：

template

void BubbleSort2(T a[], int N)

{

  for (int i = 0; i < N; i++)

  for (int j = 1; j < N - i; j++)

  if (a[j - 1] > a[j]) swap(a[j - 1], a[j]);

}

測試結果：

Sort ascending  N=10000 TimeSpared: 0ms

KCN=9999  KCN/N=0.9999  KCN/N^2=9.999e-005 KCN/NlogN=0.07525

RMN=0  RMN/N=0  RMN/N^2=0  RMN/NlogN=0

Sort ranness N=10000 TimeSpared: 1161ms

KCN=45409094  KCN/N=4540.91  KCN/N^2=0.454091  KCN/NlogN=341.737

RMN=71526984  RMN/N=7152.7  RMN/N^2=0.71527  RMN/NlogN=538.294

Sort descending N=10000 TimeSpared: 1022ms

KCN=49995000  KCN/N=4999.5  KCN/N^2=0.49995  KCN/NlogN=376.25

RMN=149985000  RMN/N=14998.5  RMN/N^2=1.49985  RMN/NlogN=1128.75

可以看出，非常的差，還不如直插排序，真不知道為什麼人們對此津津樂道，難道是為了理解排序？另外還有一個有趣的現象，雖然逆序的KCN和RMN都比亂序的多，但是逆序花的時間卻比亂序少，從這裡可以看到流水線的作用，這裡可以給我們一個訊號，一個真正好的演算法需要充分利用的特性。增多記錄數目（N＝1000000）時，可以看出，在完全有序的情況下，起泡比直插要好一些，因為此時不需要移動記錄。

快速排序

真為這個演算法感到悲哀，連一個能表明演算法實質的名字（比如直插、表插）都沒有，也不像希爾排序是以發明人的名字命名的，難道就是因為它太快了？也許“快速”是對一個排序演算法最高的榮譽吧。

基本思想是：任取待排序列的某個記錄作為基準，按照該關鍵碼大小，將整個序列分成兩個序列——左側的所有記錄的關鍵碼都比基準小（或者等），右側的都比基準大，基準則放在兩個子序列之間，顯然這時基準放在了最後應該放置的位置。分別對左右子序列重複上面的過程，直到最後所有的記錄都放在相應的位置。

下面的例程不容易看懂，因為這是幾次改進之後的樣子：

template

int Partition(T a[], int left, int right, int& KCN, int& RMN)

{

  int pivotp= left; T pivot = a[left];//樞軸

  for (int i = left + 1; i <= right; i++)

  if (++KCN && a[i] < pivot && ++pivotpos != i)

{ swap(a[i], a[pivotpos]); RMN += 3;}

  swap(a[left], a[pivotpos]); RMN += 3;

return pivotpos;

}

將計算樞軸位置單獨作為一個，可以避免遞迴的時候儲存無用的臨時變數。當你決定使用遞迴的時候，都要注意這點——將一切可以放在遞迴外面的都放在外面。注意這個函式是怎樣達到我們“樞軸左邊都比它小，右邊都比它大”的目的的。

template

void QSRecurve(T a[], int left, int right, int& KCN, int& RMN)

{

  if (left < right)

  {

  int pivotpos = Partition(a, left, right, KCN, RMN);

    QSRecurve(a, left, pivotpos - 1, KCN, RMN);

    QSRecurve(a, pivotpos + 1, right, KCN, RMN);

  }

}

template

void QuickSort(T a[], int N, int& KCN, int& RMN)

{

  KCN = 0; RMN = 0;

  QSRecurve(a, 0, N - 1, KCN, RMN);

}

這兩個只能算個外殼了，尤其是最後一個。

測試結果：

Sort ascending  N=10000 TimeSpared: 1051ms

KCN=49995000  KCN/N=4999.5  KCN/N^2=0.49995  KCN/NlogN=376.25

RMN=29997  RMN/N=2.9997  RMN/N^2=0.00029997 RMN/NlogN=0.22575

Sort randomness N=10000 TimeSpared: 0ms

KCN=155655  KCN/N=15.5655  KCN/N^2=0.00155655 KCN/NlogN=1.17142

RMN=211851  RMN/N=21.1851  RMN/N^2=0.00211851 RMN/NlogN=1.59434

Sort descending N=10000 TimeSpared: 1082ms

KCN=49995000  KCN/N=4999.5  KCN/N^2=0.49995  KCN/NlogN=376.25

RMN=29997  RMN/N=2.9997  RMN/N^2=0.00029997 RMN/NlogN=0.22575

可以看到，平均非常好，但是在兩端的效能還不如直插。測試N＝100000的情況如下（千萬記住把正序和逆序的測試註釋掉，否則，到時候“當機”不要找我）

Sort randomness N=100000  TimeSpared: 110ms

KCN=2123221  KCN/N=21.2322  KCN/N^2=0.000212322KCN/NlogN=1.27831

RMN=3010848  RMN/N=30.1085  RMN/N^2=0.000301085RMN/NlogN=1.81271

確實非常的“快速”，但是它的最壞情況實在讓人不能放心，萬一……，並且由於使用堆疊遞迴，出了最壞情況沒準就崩潰了。為了減低這種不良傾向，改進辦法是“三者取中”，即選取待排序序列的第一個、最後一個、中間一個的關鍵碼居中的那個作為基準。只要改一下Partition函式就可以了。

template

int Partition(T a[], int left, int right, int& KCN, int& RMN)

{

  int mid = (left + right) / 2;:namespace prefix = o ns = "urn:schemas--com::office" />

  if (++KCN && a[left] > a[mid])

  {

  if (++KCN && a[left] > a[right])

  {

  if (++KCN && a[mid] > a[right]) { swap(a[mid], a[left]); RMN += 3; }

    else { swap(a[right], a[left]); RMN += 3; }

  }

  }

  else

  {

  if (++KCN && a[left] < a[right])

  {

  if (++KCN && a[mid] < a[right]) { swap(a[mid], a[left]); RMN += 3; }

    else { swap(a[right], a[left]); RMN += 3; }

  }

  }

  int pivotpos = left; T pivot = a[left];//樞軸

  for (int i = left + 1; i <= right; i++)

  if (++KCN && a[i] < pivot && ++pivotpos != i) { swap(a[i], a[pivotpos]); RMN += 3;}

  swap(a[left], a[pivotpos]); RMN += 3;

return pivotpos;

}

只是在原有的Partition函式上新增了粗體部分。下面是測試結果：

Sort ascending  N=10000 TimeSpared: 0ms

KCN=131343  KCN/N=13.1343  KCN/N^2=0.00131343 KCN/NlogN=0.988455

RMN=35424  RMN/N=3.5424  RMN/N^2=0.00035424 RMN/NlogN=0.266592

Sort randomness N=10000 TimeSpared: 0ms

KCN=154680  KCN/N=15.468  KCN/N^2=0.0015468  KCN/NlogN=1.16408

RMN=204093  RMN/N=20.4093  RMN/N^2=0.00204093 RMN/NlogN=1.53595

Sort descending N=10000 TimeSpared: 280ms

KCN=12517506  KCN/N=1251.75  KCN/N^2=0.125175  KCN/NlogN=94.2036

RMN=45006  RMN/N=4.5006  RMN/N^2=0.00045006 RMN/NlogN=0.338704

下面是N＝100000的測試結果，在逆序的時候還是很尷尬，不過還算說得過去。

Sort ascending  N=100000  TimeSpared: 60ms

KCN=1665551  KCN/N=16.6555  KCN/N^2=0.000166555KCN/NlogN=1.00276

RMN=393210  RMN/N=3.9321  RMN/N^2=3.9321e-005RMN/NlogN=0.236736

Sort randomness N=100000   TimeSpared: 110ms

KCN=1888590  KCN/N=18.8859  KCN/N^2=0.000188859KCN/NlogN=1.13704

RMN=2659857  RMN/N=26.5986  RMN/N^2=0.000265986RMN/NlogN=1.60139

Sort descending N=100000  TimeSpared: 42120ms

KCN=1250175006 KCN/N=12501.8  KCN/N^2=0.125018  KCN/NlogN=752.68

RMN=450006  RMN/N=4.50006  RMN/N^2=4.50006e-005RMN/NlogN=0.270931

然而實際上，我們花那麼多語句搞一個“三者取中”還不如直接“隨便選一個”來得高效，例如將下面的語句替換掉原來的粗體語句：

  swap(a[left], a[rnd(right-left)+left]); RMN += 3;

測試結果：

Sort ascending  N=100000  TimeSpared: 90ms

KCN=1917756  KCN/N=19.1776  KCN/N^2=0.000191776KCN/NlogN=1.1546

RMN=378810  RMN/N=3.7881  RMN/N^2=3.7881e-005RMN/NlogN=0.228066

Sort randomness N=100000  TimeSpared: 120ms

KCN=1979189  KCN/N=19.7919  KCN/N^2=0.000197919KCN/NlogN=1.19159

RMN=3175977  RMN/N=31.7598  RMN/N^2=0.000317598RMN/NlogN=1.91213

Sort descending N=100000  TimeSpared: 110ms

KCN=2069369  KCN/N=20.6937  KCN/N^2=0.000206937KCN/NlogN=1.24588

RMN=2574174  RMN/N=25.7417  RMN/N^2=0.000257417RMN/NlogN=1.54981

可以看到逆序的效率有了質的飛躍，隨機函式得自己寫，因為庫函式的rand()最大隻能輸出0x7fff，這是因為rand函式使用的是32bit的整數，為了不（最嚴重的是出負數），只能輸出那麼大。一個不太嚴格的隨機函式如下，最大輸出值是32bit的最大正整數：

int rnd(int n)

{

  static _int64 x;

  x = (2053 * x + 13849) % 0x7fffffff;

  return (int)x % n;

}

【附註】注意到隨機函式的最大輸出值問題，源自我在做一千萬整數排序測試的時候，發現對於亂序，快排的效能變得很差。感謝BlueSky2008給出瞭解答，這是相關的帖子。