筆者最近學(xué)習(xí)算法，學(xué)了很久也只弄懂了幾個(gè)排序算法，在這里曬一下下，作為以后參考之用。

一、為什么要研究排序問(wèn)題

許多計(jì)算機(jī)科學(xué)家認(rèn)為，排序算法是算法學(xué)習(xí)中最基本的問(wèn)題，原因有以下幾點(diǎn)：

l??有時(shí)候應(yīng)用程序本身需要對(duì)信息進(jìn)行排序，如為了準(zhǔn)備客戶賬目，銀行需要對(duì)支票賬號(hào)進(jìn)行排序

l??很多算法將排序作為關(guān)鍵子程序

l??現(xiàn)在已經(jīng)有很多排序算法，它們采用各種技術(shù)

l??排序時(shí)一個(gè)可以證明其非平凡下界的問(wèn)題，并可以利用排序問(wèn)題的下界證明其他問(wèn)題的下界

l??在實(shí)現(xiàn)排序算法是很多工程問(wèn)題即浮出水面

二、排序問(wèn)題的形式化定義

輸入：由n個(gè)數(shù)組成的一個(gè)序列<a₁,a₂,……,a_n>

輸出：對(duì)輸入序列的一個(gè)排列（重排）<a₁’,a₂’,……,a_n’>,使得a₁’?≤a₂’?≤……≤a_n’

【說(shuō)明】在實(shí)際中，待排序的數(shù)很少是孤立的值，它們通常是成為激勵(lì)的數(shù)據(jù)集的一個(gè)部分，每個(gè)記錄有一個(gè)關(guān)鍵字key,是待排序的值，其他數(shù)據(jù)位衛(wèi)星數(shù)據(jù)，它們通常以key為中心傳遞。

三、相關(guān)概念

1.?????????排序的穩(wěn)定性：在待排序的文件中，若存在多個(gè)關(guān)鍵字相同的記錄，經(jīng)過(guò)排序后這些具有相同關(guān)鍵字的記錄之間的相對(duì)次序保持不變，該排序方法是穩(wěn)定的；若具有相同關(guān)鍵字的記錄之間的相對(duì)次序發(fā)生變化，則稱這種排序方法是不穩(wěn)定的。

A.???????穩(wěn)定排序：插入排序、冒泡排序、雞尾酒排序、計(jì)數(shù)排序、合并交換排序、歸并排序、基數(shù)排序、桶排序、鴿巢排序

B.????????不穩(wěn)定排序：選擇排序、堆排序、希爾排序、快速排序

2.?????????內(nèi)部、外部排序：在排序過(guò)程中，若整個(gè)文件都是放在內(nèi)存中處理，排序時(shí)不涉及數(shù)據(jù)的內(nèi)、外存交換，則稱之為內(nèi)部排序(簡(jiǎn)稱內(nèi)排序)；反之，若排序過(guò)程中要進(jìn)行數(shù)據(jù)的內(nèi)、外存交換，則稱之為外部排序。

3.?????待排文件的常用存儲(chǔ)方式：

A.?????順序表：對(duì)記錄本身進(jìn)行物理重排（即通過(guò)關(guān)鍵字之間的比較判定，將記錄移到合適的位置

B.?????鏈表：無(wú)須移動(dòng)記錄，僅需修改指針

C.?????用順序的方式存儲(chǔ)待排序的記錄，但同時(shí)建立一個(gè)輔助表：對(duì)輔助表的表目進(jìn)行物理重排（即只移動(dòng)輔助表的表目，而不移動(dòng)記錄本身）。

4.?????影響排序效果的因素

A.?????待排序的記錄數(shù)目n

B.?????記錄的大小(規(guī)模)

C.?????關(guān)鍵字的結(jié)構(gòu)及其初始狀態(tài)

D.????對(duì)穩(wěn)定性的要求

E.?????語(yǔ)言工具的條件

F.?????存儲(chǔ)結(jié)構(gòu)

G.????時(shí)間和輔助空間復(fù)雜度等

四、排序算法的分類（內(nèi)部排序）

1.?????????比較類排序：排序結(jié)果中各元素的次序基于輸入元素間的比較

A.???????比較排序算法的下界

比較排序可以被抽象為決策樹。一棵決策樹是一棵滿二叉樹，表示某排序算法作用于給定輸入所做的所有比較，而忽略控制結(jié)構(gòu)和數(shù)據(jù)移動(dòng)。

在決策樹中，對(duì)每個(gè)節(jié)點(diǎn)都注明i，j（1≤i，j≤n），對(duì)每個(gè)葉節(jié)點(diǎn)都注明排列<π(1),?π(2),……,?π(n)>。排序算法的執(zhí)行對(duì)應(yīng)于遍歷一條從根到葉節(jié)點(diǎn)的路徑。在每個(gè)內(nèi)節(jié)點(diǎn)作比較a_i≤a_j，其左子樹決定a_i≤a_j之后的比較，其右子樹決定a_i＞a_j之后的比較。當(dāng)?shù)竭_(dá)一個(gè)葉節(jié)點(diǎn)時(shí)排序算法就已經(jīng)確定了順序。要使排序算法能正確的工作，其必要條件是n個(gè)元素的n!種排列都要作為決策樹的一個(gè)葉節(jié)點(diǎn)出現(xiàn)。在決策樹中，從根到任意一個(gè)可達(dá)葉節(jié)點(diǎn)之間最長(zhǎng)路徑的長(zhǎng)度（決策樹的高度）表示對(duì)應(yīng)的排序算法中最壞情況下的比較次數(shù)。對(duì)于一棵高度為h，具有l個(gè)可達(dá)葉節(jié)點(diǎn)的決策樹有n!?≤l≤2^h，則有h≥lg(n!)=Ω(nlgn)

B.????????常見(jiàn)的比較類排序

a)?????????選擇類排序：選擇排序、堆排序

b)????????插入類排序：插入排序、二叉插入、兩路插入、希爾排序

c)?????????交換類排序：冒泡排序、雞尾酒排序、合并交換排序、快速排序

d)????????歸并排序

2.?????????非比較類排序：計(jì)數(shù)排序、基數(shù)排序、桶排序、鴿巢排序

五、常用的排序算法?

1.?????????比較類排序

A.???????選擇類排序

a)?????????選擇排序（Selection Sort）——原地排序、不穩(wěn)定排序

【思路】首先找出A中最小元素，并將其與A[0]中元素交換；接著找出A中次最小元素，并將其與A[1]中元素交換；對(duì)A中頭n-1個(gè)元素繼續(xù)這一過(guò)程

【代碼】

#region 選擇排序

/// <summary>
/// 選擇排序
/// 最差時(shí)間復(fù)雜度 Θ(n2)
/// 最優(yōu)時(shí)間復(fù)雜度 Θ(n2)
/// 平均時(shí)間復(fù)雜度 Θ(n2)
/// 原地排序
/// 【排序過(guò)程】
/// 1、首先在未排序序列中找到最小元素，存放到排序序列的起始位置
/// 2、然后，再?gòu)氖Ｓ辔磁判蛟刂欣^續(xù)尋找最小元素，然后放到排序序列末尾
/// 3、以此類推，直到所有元素均排序完畢。
/// </summary>
/// <param name="Array">待排序的數(shù)組</param>
public static void SelectionSort(int[] Array)
{
for (int i = 0; i < Array.Length; i++)
{
for (int j = i + 1; j < Array.Length; j++)
{
if (Array[j] < Array[i])
{
Swap(ref Array[i], ref Array[j]);//交換數(shù)據(jù)
}
}
}
}

#endregion

　　

【時(shí)間復(fù)雜度分析】選擇排序的比較操作為n(n ? 1) / 2次，交換操作介于0和n(n ? 1) / 2次之間，故其時(shí)間復(fù)雜度為Θ(n²)

b)?????????堆排序（Heap Sort）

?六、代碼

【二叉堆】（二叉）堆數(shù)據(jù)結(jié)構(gòu)是一種數(shù)組對(duì)象，可以被視為一棵完全二叉樹。二叉堆有兩種：大頂堆和小頂堆（最大堆和最小堆）。大頂堆中每個(gè)節(jié)點(diǎn)的值不大于其父節(jié)點(diǎn)的值，這樣，堆中最大的元素就存放在根節(jié)點(diǎn)中。

?

?

【思路】首先將輸入數(shù)組構(gòu)造成大頂堆；由于數(shù)組中最大元素為A[0]，將其與A[n]交換使其達(dá)到最終正確位置；在堆中除去A[n]，并將A[1…n]保持為大頂堆；重復(fù)上述過(guò)程，直到堆大小降為2。

【代碼】由思路知堆排序中應(yīng)包含構(gòu)造大頂堆和保持大頂堆子程序。MaxHeapify方法被用來(lái)保持大頂堆，其時(shí)間復(fù)雜度為O(lgn)

/// <summary>
/// 調(diào)整數(shù)組,保持大頂堆性質(zhì)
/// </summary>
/// <param name="Array">待保持大頂堆的數(shù)組</param>
/// <param name="i">大頂堆的根</param>
/// <param name="HeapSize">堆的大小</param>
private static void MaxHeapify(int[] Array, int i, int HeapSize)
{
int left = i * 2;
int right = left + 1;
int largest;
if (left < HeapSize && Array[left] > Array[right])
{
largest = left;
}
else
{
largest = i;
}
if (right < HeapSize && Array[right] > Array[largest])
{
largest = right;
}
if (largest != i)
{
Swap(ref Array[i], ref Array[largest]);
MaxHeapify(Array, largest, HeapSize);
}
}

/// <summary>
/// 調(diào)整數(shù)組,保持大頂堆性質(zhì)(迭代實(shí)現(xiàn))
/// </summary>
/// <param name="Array">待保持大頂堆的數(shù)組</param>
/// <param name="i">大頂堆的根</param>
/// <param name="HeapSize">堆的大小</param>
private static void MaxHeapifyWithoutRecursive(int[] Array, int i, int HeapSize)
{
while (i <= HeapSize)
{
int left = i * 2;
int right = left + 1;
int largest;
if (left < HeapSize && Array[left] > Array[right])
{
largest = left;
}
else
{
largest = i;
}
if (right < HeapSize && Array[right] > Array[largest])
{
largest = right;
}
if (largest != i)
{
Swap(ref Array[i], ref Array[largest]);
i = largest;
}
else
{
return;
}
}
}

　　

/// <summary>
/// 構(gòu)造大頂堆
/// </summary>
/// <param name="Array">待構(gòu)造大頂堆的數(shù)組</param>
private static void BuildMaxHeapify(int[] Array)
{
int HeapSize = Array.Length;
for (int i = (Array.Length - 1) / 2; i >= 0; i--)
{
// MaxHeapify(Array, i, HeapSize); //遞歸實(shí)現(xiàn)
MaxHeapifyWithoutRecursive(Array, i, HeapSize); //迭代實(shí)現(xiàn)
}
}

　　

堆排序代碼如下：?

?【時(shí)間復(fù)雜度分析】調(diào)用BuildMaxHeap時(shí)間為O(n)，n-1次調(diào)用MaxHeapify，每次時(shí)間為O(lgn)，故堆排序時(shí)間復(fù)雜度為O(nlgn)???

using System;namespace Algorithms {public class Sort{static Random random = new Random();#region 交換數(shù)據(jù)/// <summary>/// 交換數(shù)據(jù)/// </summary>/// <param name="a">待交換值a</param>/// <param name="b">待交換值b</param>/// <returns>是否成功</returns>public static bool Swap(ref int a, ref int b){if (!Equals(a, b)){a ^= b;b ^= a;a ^= b;return true;}else{return false;}}#endregion#region 交換類排序#region 冒泡排序/// <summary>/// 冒泡排序（Bubble Sort）/// </summary>/// 最壞時(shí)間復(fù)雜度 O(n2)/// 最優(yōu)時(shí)間復(fù)雜度 O(n)/// 平均時(shí)間復(fù)雜度 O(n2)/// 原地排序/// 不穩(wěn)定排序/// 【排序過(guò)程】/// 1、比較相鄰的元素。如果第一個(gè)比第二個(gè)大，就交換他們兩個(gè)。/// 2、對(duì)每一對(duì)相鄰元素作同樣的工作，從開始第一對(duì)到結(jié)尾的最后一對(duì)。在這一點(diǎn)，最后的元素應(yīng)該會(huì)是最大的數(shù)。 /// 3、針對(duì)所有的元素重復(fù)以上的步驟，除了最后一個(gè)。 /// 4、持續(xù)每次對(duì)越來(lái)越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對(duì)數(shù)字需要比較。 /// <param name="Array">待排序的數(shù)組</param>public static void BubbleSort(int[] Array){for (int i = 0; i < Array.Length; i++){for (int j = Array.Length - 1; j > i; --j){if (Array[j] < Array[j - 1]){Swap(ref Array[j], ref Array[j - 1]);}}}}#endregion#region 快速排序/// <summary>/// 快速排序劃分/// </summary>/// <param name="Array">待分劃的數(shù)組</param>/// <param name="p">待分劃數(shù)組下界</param>/// <param name="r">待分劃數(shù)組上界</param>/// <returns>分劃元素位置</returns>private static int Partition(int[] Array, int p, int r){int x = Array[r];int i = p - 1;for (int j = p; j < r; j++){if (Array[j] <= x){++i;Swap(ref Array[i], ref Array[j]);}}Swap(ref Array[i + 1], ref Array[r]);return i + 1;}/// <summary>/// 快速排序/// </summary>/// 最差時(shí)間復(fù)雜度 Θ(n2) /// 最優(yōu)時(shí)間復(fù)雜度 Θ(nlogn) /// 平均時(shí)間復(fù)雜度 Θ(nlogn) /// 原地排序/// 非穩(wěn)定排序/// 【排序過(guò)程】/// 1、從數(shù)列中挑出一個(gè)元素，稱為 "基準(zhǔn)"， /// 2、分割：重新排序數(shù)列，所有元素比基準(zhǔn)值小的擺放在基準(zhǔn)前面，所有元素比基準(zhǔn)值大的擺在基準(zhǔn)的后面（相同的數(shù)可以到任一邊）。在這個(gè)分割之后，該基準(zhǔn)是它的最后位置。 /// 3、遞歸地把小于基準(zhǔn)值元素的子數(shù)列和大于基準(zhǔn)值元素的子數(shù)列排序。 /// <param name="Array">待排序的數(shù)組</param>/// <param name="p">待排序數(shù)組下界</param>/// <param name="r">待排序數(shù)組上界</param>public static void QuickSort(int[] Array, int p, int r){if (p < r){int q = Partition(Array, p, r);QuickSort(Array, p, q - 1);QuickSort(Array, q, r);}}/// <summary>/// 快速排序劃分(隨機(jī)化)/// </summary>/// <param name="Array">待分劃的數(shù)組</param>/// <param name="p">待分劃數(shù)組下界</param>/// <param name="r">待分劃數(shù)組上界</param>/// <returns>分劃元素位置</returns>private static int RandomizedPartition(int[] Array, int p, int r){int i = random.Next(p, r + 1);Swap(ref Array[r], ref Array[i]);return Partition(Array, p, r);}/// <summary>/// 快速排序(隨機(jī)化)/// </summary>/// <param name="Array">待排序的數(shù)組</param>/// <param name="p">待排序數(shù)組下界</param>/// <param name="r">待排序數(shù)組上界</param>public static void RandomizedQuickSort(int[] Array, int p, int r){if (p < r){int q = RandomizedPartition(Array, p, r);RandomizedQuickSort(Array, p, q - 1);RandomizedQuickSort(Array, q, r);}}/// <summary>/// Hoare劃分/// </summary>/// <param name="Array">待分劃的數(shù)組</param>/// <param name="p">待分劃數(shù)組下界</param>/// <param name="r">待分劃數(shù)組上界</param>/// <returns>分劃元素位置</returns>private static int HoarePartition(int[] Array, int p, int r){int x = Array[p];int i = p - 1;int j = r + 1;while (true){do{--j;} while (Array[j] <= x);do{++i;} while (Array[i] >= x);if (i < j){int t = Array[i];Array[i] = Array[j];Array[j] = t;}else{return j;}}}#endregion#endregion#region 選擇類排序#region 選擇排序/// <summary>/// 選擇排序/// 最差時(shí)間復(fù)雜度 О(n2) /// 最優(yōu)時(shí)間復(fù)雜度 О(n2) /// 平均時(shí)間復(fù)雜度 О(n2) /// 原地排序/// 【排序過(guò)程】/// 1、首先在未排序序列中找到最小元素，存放到排序序列的起始位置/// 2、然后，再?gòu)氖Ｓ辔磁判蛟刂欣^續(xù)尋找最小元素，然后放到排序序列末尾/// 3、以此類推，直到所有元素均排序完畢。/// </summary>/// <param name="Array">待排序的數(shù)組</param>public static void SelectionSort(int[] Array){for (int i = 0; i < Array.Length; i++){for (int j = i + 1; j < Array.Length; j++){if (Array[j] < Array[i]){Swap(ref Array[i], ref Array[j]);}}}}#endregion#region 堆排序/// <summary>/// 調(diào)整數(shù)組,保持大頂堆性質(zhì)/// </summary>/// <param name="Array">待保持大頂堆的數(shù)組</param>/// <param name="i">大頂堆的根</param>/// <param name="HeapSize">堆的大小</param>private static void MaxHeapify(int[] Array, int i, int HeapSize){int left = i * 2;int right = left + 1;int largest;if (left < HeapSize && Array[left] > Array[right]){largest = left;}else{largest = i;}if (right < HeapSize && Array[right] > Array[largest]){largest = right;}if (largest != i){Swap(ref Array[i], ref Array[largest]);MaxHeapify(Array, largest, HeapSize);}}/// <summary>/// 調(diào)整數(shù)組,保持大頂堆性質(zhì)(迭代實(shí)現(xiàn))/// </summary>/// <param name="Array">待保持大頂堆的數(shù)組</param>/// <param name="i">大頂堆的根</param>/// <param name="HeapSize">堆的大小</param>private static void MaxHeapifyWithoutRecursive(int[] Array, int i, int HeapSize){while (i <= HeapSize){int left = i * 2;int right = left + 1;int largest;if (left < HeapSize && Array[left] > Array[right]){largest = left;}else{largest = i;}if (right < HeapSize && Array[right] > Array[largest]){largest = right;}if (largest != i){Swap(ref Array[i], ref Array[largest]);i = largest;}else{return;}}}/// <summary>/// 構(gòu)造大頂堆/// </summary>/// <param name="Array">待構(gòu)造大頂堆的數(shù)組</param>private static void BuildMaxHeapify(int[] Array){int HeapSize = Array.Length;for (int i = (Array.Length - 1) / 2; i >= 0; i--){// MaxHeapify(Array, i, HeapSize);MaxHeapifyWithoutRecursive(Array, i, HeapSize);}}/// <summary>/// 堆排序/// 最差時(shí)間復(fù)雜度 O(nlogn) /// 最優(yōu)時(shí)間復(fù)雜度 O(nlogn)/// 平均時(shí)間復(fù)雜度 Θ(nlogn)/// 原地排序/// 不穩(wěn)定排序/// 【排序過(guò)程】/// 1、建立一個(gè)大頂堆/// 2、把堆首（最大值）和堆尾互換 /// 3、把堆的尺寸縮小1，并保持大頂堆/// 4、重復(fù)2號(hào)步驟，直到堆的尺寸為1 /// </summary>/// <param name="Array">待排序的數(shù)組</param>public static void HeapSort(int[] Array){int HeapSize = Array.Length;BuildMaxHeapify(Array);for (int i = Array.Length - 1; i > 0; i--){int t;t = Array[0];Array[0] = Array[i];Array[i] = t;MaxHeapifyWithoutRecursive(Array, 0, --HeapSize);//MaxHeapify(Array, 0, --HeapSize);}}#endregion#endregion#region 插入類排序#region 插入排序/// <summary>/// 插入排序(非遞歸算法)/// 平均時(shí)間復(fù)雜度 Θ(n2) /// 原地排序/// 穩(wěn)定排序/// 【排序過(guò)程】/// 1、從第一個(gè)元素開始，該元素可以認(rèn)為已經(jīng)被排序 /// 2、取出下一個(gè)元素，在已經(jīng)排序的元素序列中從后向前掃描 /// 3、如果該元素（已排序）大于新元素，將該元素移到下一位置 /// 4、重復(fù)步驟3，直到找到已排序的元素小于或者等于新元素的位置 /// 5、將新元素插入到該位置中 /// 6、重復(fù)步驟2 /// </summary>/// <param name="Array">待排序的數(shù)組</param>public static void InsertionSort(int[] Array){for (int j = 1; j < Array.Length; j++){int key = Array[j];int i = j - 1;while (i >= 0 && Array[i] > key){Array[i + 1] = Array[i];--i;}Array[i + 1] = key;}}/// <summary>/// 插入排序(遞歸算法)/// </summary>/// <param name="Array">待排序的數(shù)組</param>/// <param name="length">要排序的長(zhǎng)度</param>public static void InsertionSort(int[] Array, int length){if (length == 0){return;}else{InsertionSort(Array, length - 1);}int key = Array[length];while (Array[length] >= key){Array[length + 1] = Array[length];--length;}Array[length] = key;}#endregion#region Shell排序/// <summary>/// Shell排序（遞減增量排序）/// </summary>/// 【排序過(guò)程】/// 1、取一個(gè)小于n的整數(shù)d1作為第一個(gè)增量，把文件的全部記錄分成d1個(gè)組。所有距離為d1的倍數(shù)的記錄放在同一個(gè)組中。/// 2、先在各組內(nèi)進(jìn)行直接插入排序；/// 3、然后，取第二個(gè)增量d2＜d1重復(fù)上述的分組和排序，直至所取的增量dt=1(dt＜dt-1＜…＜d2＜d1)為止。/// <param name="Array">待排序的數(shù)組</param>public static void shellsort(int[] Array){int temp;int increment; //增量 int length = Array.Length;for (increment = length / 2; increment > 0; increment /= 2){for (int i = increment; i < length; ++i){int j;temp = Array[i];for (j = i; j >= increment; j -= increment){if (temp < Array[j - increment])Array[j] = Array[j - increment];elsebreak;}Array[j] = temp;}}}#endregion#endregion#region 歸并類排序#region 歸并排序/// <summary>/// 歸并數(shù)組(使用哨兵)/// <para>歸并數(shù)組Array[lower,mid]與Array[mid+1,upper]</para>/// </summary>/// <param name="Array">待歸并的數(shù)組</param>/// <param name="lower">待歸并數(shù)組下界</param>/// <param name="mid">待歸并數(shù)組分界</param>/// <param name="upper">待歸并數(shù)組上界</param>private static void MergeWithSentinel(int[] Array, int lower, int mid, int upper){int n1 = mid - lower + 1;int n2 = upper - mid;int[] L = new int[n1 + 1];int[] R = new int[n2 + 1];int i = 0;int j = 0;for (i = 0; i < n1; i++){L[i] = Array[lower + i];}for (i = 0; i < n2; i++){R[i] = Array[mid + i + 1];}L[n1] = R[n2] = int.MaxValue;i = 0;for (int k = lower; k < upper; k++){if (L[i] < R[j]){Array[k] = L[i++];}else{Array[k] = R[j++];}}}/// <summary>/// 歸并數(shù)組(不使用哨兵)/// <para>歸并數(shù)組Array[lower,mid]與Array[mid+1,upper]</para>/// </summary>/// <param name="Array">待歸并的數(shù)組</param>/// <param name="lower">待歸并數(shù)組下界</param>/// <param name="mid">待歸并數(shù)組分界</param>/// <param name="upper">待歸并數(shù)組上界</param>private static void Merge(int[] Array, int lower, int mid, int upper){int n1 = mid - lower + 1;int n2 = upper - mid;int[] L = new int[n1];int[] R = new int[n2];int i = 0;int j = 0;for (i = 0; i < n1; i++){L[i] = Array[lower + i];}for (i = 0; i < n2; i++){R[i] = Array[mid + i + 1];}i = 0;for (int k = lower; k < upper; k++){if (L[i] < R[j]){Array[k] = L[i++];}else{Array[k] = R[j++];}if (i == n1){while (j < n2){Array[++k] = R[j++];}}if (j == n2){while (i < n1){Array[++k] = L[i++];}}}}/// <summary>/// 歸并排序/// </summary>/// 最差時(shí)間復(fù)雜度 Θ(nlogn) /// 最優(yōu)時(shí)間復(fù)雜度 Θ(n) /// 平均時(shí)間復(fù)雜度 Θ(nlogn)/// 非原地排序/// 穩(wěn)定排序/// 【排序過(guò)程】/// 1、申請(qǐng)空間，使其大小為兩個(gè)已經(jīng)排序序列之和，該空間用來(lái)存放合并后的序列 /// 2、設(shè)定兩個(gè)指針，最初位置分別為兩個(gè)已經(jīng)排序序列的起始位置 /// 3、比較兩個(gè)指針?biāo)赶虻脑?#xff0c;選擇相對(duì)小的元素放入到合并空間，并移動(dòng)指針到下一位置 /// 4、重復(fù)步驟3直到某一指針達(dá)到序列尾 /// 5、將另一序列剩下的所有元素直接復(fù)制到合并序列尾 /// <param name="Array">待排序的數(shù)組</param>/// <param name="lower">待排序數(shù)組下界</param>/// <param name="upper">待排序數(shù)組上界</param>public static void MergeSort(int[] Array, int lower, int upper){if (lower < upper){int mid = (lower + upper) / 2;MergeSort(Array, lower, mid);MergeSort(Array, mid + 1, upper);Merge(Array, lower, mid, upper);}}#endregion#endregion#region 非比較類排序#region 計(jì)數(shù)排序/// <summary>/// 獲取數(shù)組最大數(shù)/// </summary>/// <param name="Array">要取最大數(shù)的數(shù)組</param>/// <returns>數(shù)組最大數(shù)</returns>private static int GetLargest(int[] Array){int largest = 0;foreach (var i in Array){if (largest < i){largest = i;}}return largest;}/// <summary>/// 計(jì)數(shù)排序/// </summary>/// <param name="Array">待排序的數(shù)組</param>public static void CountingSort(int[] Array){int largest = GetLargest(Array) + 1;int[] B = new int[Array.Length];int[] C = new int[largest];for (int i = 0; i < largest; i++){C[i] = 0;}for (int j = 0; j < Array.Length; j++){++C[Array[j]];}for (int i = 1; i < largest; i++){C[i] += C[i - 1];}for (int j = Array.Length - 1; j >= 0; --j){B[C[Array[j]] - 1] = Array[j];C[Array[j]] = C[Array[j]] - 1;}for (int i = 0; i < Array.Length; i++){Array[i] = B[i];}}#endregion#endregion} }

原文鏈接：http://www.cnblogs.com/kingwolfofsky/archive/2011/07/23/2115129.html

附：自己的一個(gè)隨機(jī)排序

// 隨機(jī)排序一維數(shù)組

private void RandomSort(Integer[] arr) {
int temp = 0;
int rand = 0;
int tempLen = arr.length;
// 將數(shù)組進(jìn)行隨機(jī)排序
for (int i = 0; i < tempLen; i++) {
rand = (int) (Math.random() * tempLen) + i;
if (rand >= tempLen) {
rand = tempLen - 1;
}
temp = arr[i];
arr[i] = arr[rand];
arr[rand] = temp;
}
}

　　

　　

轉(zhuǎn)載于:https://www.cnblogs.com/08shiyan/archive/2011/07/24/2115536.html

總結(jié)

以上是生活随笔為你收集整理的排序算法[转]的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。

如果覺(jué)得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。