當前位置：首頁 > 编程资源 > 编程问答 >内容正文

编程问答

排序分析

發(fā)布時間：2024/8/23 编程问答 22 豆豆

生活随笔收集整理的這篇文章主要介紹了排序分析小編覺得挺不錯的,現(xiàn)在分享給大家,幫大家做個參考.

九大基礎(chǔ)排序總結(jié)與對比

標簽：?數(shù)據(jù)結(jié)構(gòu)排序算法九大排序 2016-06-07 15:43?12646人閱讀?評論(6)?收藏?舉報 ?分類： data structure

版權(quán)聲明：本文為博主原創(chuàng)文章，未經(jīng)博主允許不得轉(zhuǎn)載。

目錄(?)[+]

請尊重個人勞動成果，轉(zhuǎn)載注明出處，謝謝！?
http://blog.csdn.net/amazing7/article/details/51603682

一、對比分析圖

均按從小到大排列
k代表數(shù)值中的”數(shù)位”個數(shù)
n代表數(shù)據(jù)規(guī)模
m代表數(shù)據(jù)的最大值減最小值

穩(wěn)定性：穩(wěn)定排序算法會讓原本有相等鍵值的紀錄維持相對次序。也就是如果一個排序算法是穩(wěn)定的，當有兩個相等鍵值的紀錄R和S，且在原本的列表中R出現(xiàn)在S之前，在排序過的列表中R也將會是在S之前。

二、冒泡排序

概述

　　冒泡排序通過重復(fù)地走訪過要排序的數(shù)列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來，直到?jīng)]有再需要交換的元素為止（對n個項目需要O(n^2)的比較次數(shù)）。這個算法的名字由來是因為越小的元素會經(jīng)由交換慢慢“浮”到數(shù)列的頂端。

實現(xiàn)步驟

比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。　

對每一對相鄰元素做同樣的工作，從開始第一對到結(jié)尾的最后一對。這步做完后，最后的元素會是最大的數(shù)。

針對所有的元素重復(fù)以上的步驟，除了最后一個。

持續(xù)每次對越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。　

　　冒泡排序為一列數(shù)字進行排序的過程　

實現(xiàn)性能

最差時間復(fù)雜度

O(n^2)

最優(yōu)時間復(fù)雜度

O(n)　

平均時間復(fù)雜度

O(n^2)

最差空間復(fù)雜度

總共O(n)，需要輔助空間O(1)

Java實現(xiàn)

三、選擇排序

選擇排序

　　常用的選擇排序方法有簡單選擇排序和堆排序，這里只說簡單選擇排序，堆排序后面再說。

簡單選擇排序

　　設(shè)所排序序列的記錄個數(shù)為n，i　取　1,2,…,n-1　。?
　　從所有n-i+1個記錄（Ri,Ri+1,…,Rn）中找出排序碼最小（或最大）的記錄，與第i個記錄交換。執(zhí)行n-1趟后就完成了記錄序列的排序。

以排序數(shù)組｛3，2，1，4，6，5｝為例

簡單選擇排序性能

　　在簡單選擇排序過程中，所需移動記錄的次數(shù)比較少。最好情況下，即待排序記錄初始狀態(tài)就已經(jīng)是正序排列了，則不需要移動記錄。　?
　　最壞情況下，即待排序記錄初始狀態(tài)是按第一條記錄最大，之后的記錄從小到大順序排列，則需要移動記錄的次數(shù)最多為3（n-1）。

　　簡單選擇排序過程中需要進行的比較次數(shù)與初始狀態(tài)下待排序的記錄序列的排列情況無關(guān)。?
　　當i=1時，需進行n-1次比較；當i=2時，需進行n-2次比較；依次類推，共需要進行的比較次數(shù)是(n-1)+(n-2)+…+2+1=n(n-1)/2，即進行比較操作的時間復(fù)雜度為O(n^2)，進行移動操作的時間復(fù)雜度為O(n)。　

　　簡單選擇排序是不穩(wěn)定排序。

簡單選擇排序Java實現(xiàn)

四、希爾排序

概述

　　希爾排序法(縮小增量法) 屬于插入類排序，是將整個無序列分割成若干小的子序列分別進行插入排序的方法。

　　把記錄按下標的一定增量分組，對每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含的關(guān)鍵詞越來越多，當增量減至1時，整個文件恰被分成一組，算法便終止。

希爾排序是基于插入排序的以下兩點性質(zhì)而提出改進方法的：

插入排序在對幾乎已經(jīng)排好序的數(shù)據(jù)操作時，效率高，即可以達到線性排序的效率。
但插入排序一般來說是低效的，因為插入排序每次只能將數(shù)據(jù)移動一位。

實現(xiàn)過程

　　先取一個正整數(shù)d1小于n，把所有序號相隔d1的數(shù)組元素放一組，組內(nèi)進行直接插入排序；然后取d2小于d1，重復(fù)上述分組和排序操作；直至di=1，即所有記錄放進一個組中排序為止。

　　例如，假設(shè)有這樣一組數(shù)[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我們以步長為5開始進行排序，我們可以通過將這列表放在有5列的表中來更好地描述算法，這樣他們就應(yīng)該看起來是這樣：

13 14 94 33 82?
25 59 94 65 23?
45 27 73 25 39?
10

然后我們對每列進行排序：

10 14 73 25 23?
13 27 94 33 39?
25 59 94 65 82?
45

　　將上述四行數(shù)字，依序接在一起時我們得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ].這時10已經(jīng)移至正確位置了，然后再以3為步長進行排序：

10 14 73?
25 23 13?
27 94 33?
39 25 59?
94 65 82?
45

排序之后變?yōu)?#xff1a;

10 14 13?
25 23 33?
27 25 59?
39 65 73?
45 94 82?
94

最后以1步長進行排序（此時就是簡單的插入排序了）。

實現(xiàn)效率

　　希爾排序是一個不穩(wěn)定的排序，其時間復(fù)雜度受步長（增量）的影響。

　　空間復(fù)雜度：　Ｏ(1)

　　時間復(fù)雜度：　平均 O(n^1.3)?
　　　　　　　　　最好　O(n)?
　　　　　　　　　最壞　O(n^2)

Java實現(xiàn)

五、歸并排序

１.概述

　　歸并排序，是創(chuàng)建在歸并操作上的一種有效的排序算法該算法是采用分治法（Divide and Conquer）的一個非常典型的應(yīng)用，且各層分治遞歸可以同時進行。

　　即先使每個子序列有序，再將兩個已經(jīng)排序的序列合并成一個序列的操作。若將兩個有序表合并成一個有序表，稱為二路歸并。

例如：

設(shè)有數(shù)列{6，202，100，301，38，8，1}?
初始狀態(tài)：6,202,100,301,38,8，1?
第一次歸并后：{6,202},{100,301},{8,38},{1}，比較次數(shù)：3；?
第二次歸并后：{6,100,202,301}，{1,8,38}，比較次數(shù)：4；?
第三次歸并后：{1,6,8,38,100,202,301},比較次數(shù)：4；?
總的比較次數(shù)為：3+4+4=11,；?
逆序數(shù)為14；

　　　　　　歸并排序示意圖

２.效率

　　歸并排序速度僅次于快速排序，為穩(wěn)定排序算法（即相等的元素的順序不會改變），一般用于對總體無序，但是各子項相對有序的數(shù)列.　

　　時間復(fù)雜度為O(nlogn)?　?
　　?
　　空間復(fù)雜度為?O(n)　

歸并排序比較占用內(nèi)存，但卻是一種效率高且穩(wěn)定的算法。

3.迭代實現(xiàn)

3.１實現(xiàn)原理

①申請空間，使其大小為兩個已經(jīng)排序序列之和，該空間用來存放合并后的序列

②設(shè)定兩個指針，最初位置分別為兩個已經(jīng)排序序列的起始位置

③比較兩個指針所指向的元素，選擇相對小的元素放入到合并空間，并移動指針到下一位置

④重復(fù)步驟③直到某一指針到達序列尾

⑤將另一序列剩下的所有元素直接復(fù)制到合并序列尾

3.２Java代碼

<code class="hljs cs has-numbering" style="display: block; padding: 0px; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; word-wrap: normal; background: transparent;">public static void main(String[] args) { int [] arr ={6,5,3,1,8,7,2,4}; merge_sort(arr); for(int i : arr){ System.out.println(i); } } public static void merge_sort(int[] arr) { int len = arr.length; //用于合并的臨時數(shù)組 int[] result = new int[len]; int block, start; //兩兩合并后塊大小變大兩倍 (注意最后一次block等于len) for(block = 1; block <=len ; block *= 2) { //把整個數(shù)組分成很多個塊，每次合并處理兩個塊 for(start = 0; start <len; start += 2 * block) { int low = start; int mid = (start + block) < len ? (start + block) : len; int high = (start + 2 * block) < len ? (start + 2 * block) : len; //兩個塊的起始下標及結(jié)束下標 int start1 = low, end1 = mid; int start2 = mid, end2 = high; //開始對兩個block進行歸并排序 while (start1 < end1 && start2 < end2) { result[low++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++]; } while(start1 < end1) { result[low++] = arr[start1++]; } while(start2 < end2) { result[low++] = arr[start2++]; } } //每次歸并后把結(jié)果result存入arr中，以便進行下次歸并 int[] temp = arr; arr = result; result = temp; } }</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li><li style="box-sizing: border-box; padding: 0px 5px;">10</li><li style="box-sizing: border-box; padding: 0px 5px;">11</li><li style="box-sizing: border-box; padding: 0px 5px;">12</li><li style="box-sizing: border-box; padding: 0px 5px;">13</li><li style="box-sizing: border-box; padding: 0px 5px;">14</li><li style="box-sizing: border-box; padding: 0px 5px;">15</li><li style="box-sizing: border-box; padding: 0px 5px;">16</li><li style="box-sizing: border-box; padding: 0px 5px;">17</li><li style="box-sizing: border-box; padding: 0px 5px;">18</li><li style="box-sizing: border-box; padding: 0px 5px;">19</li><li style="box-sizing: border-box; padding: 0px 5px;">20</li><li style="box-sizing: border-box; padding: 0px 5px;">21</li><li style="box-sizing: border-box; padding: 0px 5px;">22</li><li style="box-sizing: border-box; padding: 0px 5px;">23</li><li style="box-sizing: border-box; padding: 0px 5px;">24</li><li style="box-sizing: border-box; padding: 0px 5px;">25</li><li style="box-sizing: border-box; padding: 0px 5px;">26</li><li style="box-sizing: border-box; padding: 0px 5px;">27</li><li style="box-sizing: border-box; padding: 0px 5px;">28</li><li style="box-sizing: border-box; padding: 0px 5px;">29</li><li style="box-sizing: border-box; padding: 0px 5px;">30</li><li style="box-sizing: border-box; padding: 0px 5px;">31</li><li style="box-sizing: border-box; padding: 0px 5px;">32</li><li style="box-sizing: border-box; padding: 0px 5px;">33</li><li style="box-sizing: border-box; padding: 0px 5px;">34</li><li style="box-sizing: border-box; padding: 0px 5px;">35</li><li style="box-sizing: border-box; padding: 0px 5px;">36</li><li style="box-sizing: border-box; padding: 0px 5px;">37</li><li style="box-sizing: border-box; padding: 0px 5px;">38</li><li style="box-sizing: border-box; padding: 0px 5px;">39</li><li style="box-sizing: border-box; padding: 0px 5px;">40</li></ul>

4.遞歸實現(xiàn)

4.１實現(xiàn)原理

假設(shè)序列共有n個元素

①將序列每相鄰兩個數(shù)字進行歸并操作，形成floor(n/2)個序列，排序后每個序列包含兩個元素。

②將上述序列再次歸并，形成floor(n/4)個序列，每個序列包含四個元素

③重復(fù)步驟②，直到所有元素排序完畢

4.２Java代碼

<code class="hljs cs has-numbering" style="display: block; padding: 0px; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; word-wrap: normal; background: transparent;">public static void main(String[] args) { int [] arr ={6,5,3,1,8,7,2,4}; int len = arr.length; int[] reg = new int[len]; merge_sort_recursive(arr,reg,0,len-1); for(int i : arr){ System.out.println(i); } } static void merge_sort_recursive(int[] arr, int[] reg, int start, int end) { if (start >= end) return; int len = end - start, mid = (len >> 1) + start; int start1 = start, end1 = mid; int start2 = mid + 1, end2 = end; //遞歸到子序列只有一個數(shù)的時候，開始逐個返回 merge_sort_recursive(arr, reg, start1, end1); merge_sort_recursive(arr, reg, start2, end2); //-------合并操作，必須在遞歸之后（子序列有序的基礎(chǔ)上）---- int k = start; while (start1 <= end1 && start2 <= end2) reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++]; while (start1 <= end1) reg[k++] = arr[start1++]; while (start2 <= end2) reg[k++] = arr[start2++]; //借用reg數(shù)組做合并，然后把數(shù)據(jù)存回arr中 for (k = start; k <= end; k++) arr[k] = reg[k]; }</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li><li style="box-sizing: border-box; padding: 0px 5px;">10</li><li style="box-sizing: border-box; padding: 0px 5px;">11</li><li style="box-sizing: border-box; padding: 0px 5px;">12</li><li style="box-sizing: border-box; padding: 0px 5px;">13</li><li style="box-sizing: border-box; padding: 0px 5px;">14</li><li style="box-sizing: border-box; padding: 0px 5px;">15</li><li style="box-sizing: border-box; padding: 0px 5px;">16</li><li style="box-sizing: border-box; padding: 0px 5px;">17</li><li style="box-sizing: border-box; padding: 0px 5px;">18</li><li style="box-sizing: border-box; padding: 0px 5px;">19</li><li style="box-sizing: border-box; padding: 0px 5px;">20</li><li style="box-sizing: border-box; padding: 0px 5px;">21</li><li style="box-sizing: border-box; padding: 0px 5px;">22</li><li style="box-sizing: border-box; padding: 0px 5px;">23</li><li style="box-sizing: border-box; padding: 0px 5px;">24</li><li style="box-sizing: border-box; padding: 0px 5px;">25</li><li style="box-sizing: border-box; padding: 0px 5px;">26</li><li style="box-sizing: border-box; padding: 0px 5px;">27</li><li style="box-sizing: border-box; padding: 0px 5px;">28</li><li style="box-sizing: border-box; padding: 0px 5px;">29</li><li style="box-sizing: border-box; padding: 0px 5px;">30</li></ul>

六、快速排序

基本思想

　　快速排序（Quicksort）是對冒泡排序的一種改進，又稱劃分交換排序（partition-exchange sort。

　　快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分為兩個子序列（sub-lists）。

步驟為：

①．從數(shù)列中挑出一個元素，稱為”基準”（pivot）

②．重新排序數(shù)列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的后面（相同的數(shù)可以到任一邊）。在這個分區(qū)結(jié)束之后，該基準就處于數(shù)列的中間位置。這個稱為分區(qū)（partition）操作。

③．遞歸地（recursive）把小于基準值元素的子數(shù)列和大于基準值元素的子數(shù)列排序

使用快速排序法對一列數(shù)字進行排序的過程

排序效率

　　在平均狀況下，排序n個項目要Ο(n log n)次比較。在最壞狀況下則需要Ο(n2)次比較，但這種狀況并不常見。事實上，快速排序通常明顯比其他Ο(n log n)算法更快，因為它的內(nèi)部循環(huán)（inner loop）可以在大部分的架構(gòu)上很有效率地被實現(xiàn)出來。

最差時間復(fù)雜度 Ο(n^2)　

最優(yōu)時間復(fù)雜度 Ο(n log n)　

平均時間復(fù)雜度Ο(n log n)　

最差空間復(fù)雜度根據(jù)實現(xiàn)的方式不同而不同

Java實現(xiàn)

運行結(jié)果：

分析：

取８為中值，紅色箭頭表示low，綠色箭頭表示high

①從high開始向前掃描到第一個比８小的值與８交換。

②從low向后掃描第一比8大的值與8交換。

③重復(fù)①②過程只到，high=low完成一次快速排序，然后遞歸子序列。

七、堆排序

淺析堆

　　堆排序(Heapsort)是指利用堆這種數(shù)據(jù)結(jié)構(gòu)所設(shè)計的一種排序算法，它是選擇排序的一種。可以利用數(shù)組的特點快速定位指定索引的元素。堆分為大根堆和小根堆，是完全二叉樹。大根堆的要求是每個節(jié)點的值都不大于其父節(jié)點的值。

　　由于堆中每次都只能刪除第0個數(shù)據(jù)，通過　取出第０個數(shù)據(jù)再執(zhí)行堆的刪除操作、重建堆（實際的操作是將最后一個數(shù)據(jù)的值賦給根結(jié)點，然后再從根結(jié)點開始進行一次從上向下的調(diào)整。），然后再取，如此重復(fù)實現(xiàn)排序。

堆的操作：

在堆的數(shù)據(jù)結(jié)構(gòu)中，堆中的最大值總是位于根節(jié)點。堆中定義以下幾種操作：

最大堆調(diào)整（Max_Heapify）：將堆的末端子節(jié)點作調(diào)整，使得子節(jié)點永遠小于父節(jié)點
創(chuàng)建最大堆（Build_Max_Heap）：將堆所有數(shù)據(jù)重新排序
堆排序（HeapSort）：移除位在第一個數(shù)據(jù)的根節(jié)點，并做最大堆調(diào)整的遞歸運算

堆的存儲：

通常堆是通過一維數(shù)組來實現(xiàn)的。在數(shù)組起始位置為0的情形中：

父節(jié)點i的左子節(jié)點在位置(2*i+1);　
父節(jié)點i的右子節(jié)點在位置(2*i+2);
子節(jié)點i的父節(jié)點在位置floor((i-1)/2);

Java代碼實現(xiàn)

<code class="hljs java has-numbering" style="display: block; padding: 0px; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; word-wrap: normal; background: transparent;"> public class HeapSort { private static int[] sort = new int[]{1,0,10,20,3,5,6,4,9,8,12,17,34,11}; public static void main(String[] args) { buildMaxHeapify(sort); heapSort(sort); print(sort); } private static void buildMaxHeapify(int[] data){ //沒有子節(jié)點的才需要創(chuàng)建最大堆，從最后一個的父節(jié)點開始 int startIndex = getParentIndex(data.length - 1); //從尾端開始創(chuàng)建最大堆，每次都是正確的堆 for (int i = startIndex; i >= 0; i--) { maxHeapify(data, data.length, i); } } /** * 創(chuàng)建最大堆 * @param data * @param heapSize需要創(chuàng)建最大堆的大小，一般在sort的時候用到，因為最多值放在末尾，末尾就不再歸入最大堆了 * @param index當前需要創(chuàng)建最大堆的位置 */ private static void maxHeapify(int[] data, int heapSize, int index){ // 當前點與左右子節(jié)點比較 int left = getChildLeftIndex(index); int right = getChildRightIndex(index); int largest = index; if (left < heapSize && data[index] < data[left]) { largest = left; } if (right < heapSize && data[largest] < data[right]) { largest = right; } //得到最大值后可能需要交換，如果交換了，其子節(jié)點可能就不是最大堆了，需要重新調(diào)整 if (largest != index) { int temp = data[index]; data[index] = data[largest]; data[largest] = temp; maxHeapify(data, heapSize, largest); } } /** * 排序，最大值放在末尾，data雖然是最大堆，在排序后就成了遞增的 * @param data */ private static void heapSort(int[] data) { //末尾與頭交換，交換后調(diào)整最大堆 for (int i = data.length - 1; i > 0; i--) { int temp = data[0]; data[0] = data[i]; data[i] = temp; maxHeapify(data, i, 0); } } /** * 父節(jié)點位置 * @param current * @return */ private static int getParentIndex(int current){ return (current - 1) >> 1; } /** * 左子節(jié)點position注意括號，加法優(yōu)先級更高 * @param current * @return */ private static int getChildLeftIndex(int current){ return (current << 1) + 1; } /** * 右子節(jié)點position * @param current * @return */ private static int getChildRightIndex(int current){ return (current << 1) + 2; } private static void print(int[] data){ for (int i = 0; i < data.length; i++) { System.out.print(data[i] + " |"); } } } </code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li><li style="box-sizing: border-box; padding: 0px 5px;">10</li><li style="box-sizing: border-box; padding: 0px 5px;">11</li><li style="box-sizing: border-box; padding: 0px 5px;">12</li><li style="box-sizing: border-box; padding: 0px 5px;">13</li><li style="box-sizing: border-box; padding: 0px 5px;">14</li><li style="box-sizing: border-box; padding: 0px 5px;">15</li><li style="box-sizing: border-box; padding: 0px 5px;">16</li><li style="box-sizing: border-box; padding: 0px 5px;">17</li><li style="box-sizing: border-box; padding: 0px 5px;">18</li><li style="box-sizing: border-box; padding: 0px 5px;">19</li><li style="box-sizing: border-box; padding: 0px 5px;">20</li><li style="box-sizing: border-box; padding: 0px 5px;">21</li><li style="box-sizing: border-box; padding: 0px 5px;">22</li><li style="box-sizing: border-box; padding: 0px 5px;">23</li><li style="box-sizing: border-box; padding: 0px 5px;">24</li><li style="box-sizing: border-box; padding: 0px 5px;">25</li><li style="box-sizing: border-box; padding: 0px 5px;">26</li><li style="box-sizing: border-box; padding: 0px 5px;">27</li><li style="box-sizing: border-box; padding: 0px 5px;">28</li><li style="box-sizing: border-box; padding: 0px 5px;">29</li><li style="box-sizing: border-box; padding: 0px 5px;">30</li><li style="box-sizing: border-box; padding: 0px 5px;">31</li><li style="box-sizing: border-box; padding: 0px 5px;">32</li><li style="box-sizing: border-box; padding: 0px 5px;">33</li><li style="box-sizing: border-box; padding: 0px 5px;">34</li><li style="box-sizing: border-box; padding: 0px 5px;">35</li><li style="box-sizing: border-box; padding: 0px 5px;">36</li><li style="box-sizing: border-box; padding: 0px 5px;">37</li><li style="box-sizing: border-box; padding: 0px 5px;">38</li><li style="box-sizing: border-box; padding: 0px 5px;">39</li><li style="box-sizing: border-box; padding: 0px 5px;">40</li><li style="box-sizing: border-box; padding: 0px 5px;">41</li><li style="box-sizing: border-box; padding: 0px 5px;">42</li><li style="box-sizing: border-box; padding: 0px 5px;">43</li><li style="box-sizing: border-box; padding: 0px 5px;">44</li><li style="box-sizing: border-box; padding: 0px 5px;">45</li><li style="box-sizing: border-box; padding: 0px 5px;">46</li><li style="box-sizing: border-box; padding: 0px 5px;">47</li><li style="box-sizing: border-box; padding: 0px 5px;">48</li><li style="box-sizing: border-box; padding: 0px 5px;">49</li><li style="box-sizing: border-box; padding: 0px 5px;">50</li><li style="box-sizing: border-box; padding: 0px 5px;">51</li><li style="box-sizing: border-box; padding: 0px 5px;">52</li><li style="box-sizing: border-box; padding: 0px 5px;">53</li><li style="box-sizing: border-box; padding: 0px 5px;">54</li><li style="box-sizing: border-box; padding: 0px 5px;">55</li><li style="box-sizing: border-box; padding: 0px 5px;">56</li><li style="box-sizing: border-box; padding: 0px 5px;">57</li><li style="box-sizing: border-box; padding: 0px 5px;">58</li><li style="box-sizing: border-box; padding: 0px 5px;">59</li><li style="box-sizing: border-box; padding: 0px 5px;">60</li><li style="box-sizing: border-box; padding: 0px 5px;">61</li><li style="box-sizing: border-box; padding: 0px 5px;">62</li><li style="box-sizing: border-box; padding: 0px 5px;">63</li><li style="box-sizing: border-box; padding: 0px 5px;">64</li><li style="box-sizing: border-box; padding: 0px 5px;">65</li><li style="box-sizing: border-box; padding: 0px 5px;">66</li><li style="box-sizing: border-box; padding: 0px 5px;">67</li><li style="box-sizing: border-box; padding: 0px 5px;">68</li><li style="box-sizing: border-box; padding: 0px 5px;">69</li><li style="box-sizing: border-box; padding: 0px 5px;">70</li><li style="box-sizing: border-box; padding: 0px 5px;">71</li><li style="box-sizing: border-box; padding: 0px 5px;">72</li><li style="box-sizing: border-box; padding: 0px 5px;">73</li><li style="box-sizing: border-box; padding: 0px 5px;">74</li><li style="box-sizing: border-box; padding: 0px 5px;">75</li><li style="box-sizing: border-box; padding: 0px 5px;">76</li><li style="box-sizing: border-box; padding: 0px 5px;">77</li><li style="box-sizing: border-box; padding: 0px 5px;">78</li><li style="box-sizing: border-box; padding: 0px 5px;">79</li><li style="box-sizing: border-box; padding: 0px 5px;">80</li><li style="box-sizing: border-box; padding: 0px 5px;">81</li><li style="box-sizing: border-box; padding: 0px 5px;">82</li><li style="box-sizing: border-box; padding: 0px 5px;">83</li><li style="box-sizing: border-box; padding: 0px 5px;">84</li><li style="box-sizing: border-box; padding: 0px 5px;">85</li><li style="box-sizing: border-box; padding: 0px 5px;">86</li><li style="box-sizing: border-box; padding: 0px 5px;">87</li><li style="box-sizing: border-box; padding: 0px 5px;">88</li><li style="box-sizing: border-box; padding: 0px 5px;">89</li><li style="box-sizing: border-box; padding: 0px 5px;">90</li><li style="box-sizing: border-box; padding: 0px 5px;">91</li><li style="box-sizing: border-box; padding: 0px 5px;">92</li><li style="box-sizing: border-box; padding: 0px 5px;">93</li></ul>

八、桶排序

1.概念

桶排序（Bucket sort）或所謂的箱排序，是一個排序算法。

　　假設(shè)有一組長度為N的待排關(guān)鍵字序列K[1….n]。首先將這個序列劃分成M個的子區(qū)間(桶) 。然后基于某種映射函數(shù) ，將待排序列的關(guān)鍵字k映射到第i個桶中(即桶數(shù)組B的下標 i) ，那么該關(guān)鍵字k就作為B[i]中的元素。接著對每個桶B[i]中的所有元素進行比較排序(可以使用快排)。然后依次枚舉輸出B[0]….B[M]中的全部內(nèi)容即是一個有序序列。

桶排序的步驟：

①設(shè)置一個定量的數(shù)組當作空桶子。

②尋訪序列，并且把項目一個一個放到對應(yīng)的桶子去。

③對每個不是空的桶子進行排序。

④從不是空的桶子里把項目再放回原來的序列中。

２.性能

數(shù)據(jù)結(jié)構(gòu)?數(shù)組　?
最差時間復(fù)雜度　 O(n^2)?
平均時間復(fù)雜度　O(n+k)?
最差空間復(fù)雜度　O(n*k)

　　平均情況下桶排序以線性時間運行，桶排序是穩(wěn)定的，排序非常快,但是同時也非常耗空間,基本上是最耗空間的一種排序算法。

　　對N個關(guān)鍵字進行桶排序的時間復(fù)雜度分為兩個部分：

①循環(huán)計算每個關(guān)鍵字的桶映射函數(shù)，這個時間復(fù)雜度是O(N)。

②利用先進的比較排序算法對每個桶內(nèi)的所有數(shù)據(jù)進行排序，其時間復(fù)雜度為 ∑ O(Ni*logNi) 。其中Ni 為第i個桶的數(shù)據(jù)量。

　　很顯然，第②部分是桶排序性能好壞的決定因素。盡量減少桶內(nèi)數(shù)據(jù)的數(shù)量是提高效率的唯一辦法(因為基于比較排序的最好平均時間復(fù)雜度只能達到O(N*logN)了)。因此，我們需要盡量做到下面兩點：　　

① 映射函數(shù)f(k)能夠?qū)個數(shù)據(jù)平均的分配到M個桶中，這樣每個桶就有[N/M]個數(shù)據(jù)量。　?
　　?
②盡量的增大桶的數(shù)量。極限情況下每個桶只能得到一個數(shù)據(jù)，這樣就完全避開了桶內(nèi)數(shù)據(jù)的“比較”排序操作。當然，做到這一點很不容易，數(shù)據(jù)量巨大的情況下，f(k)函數(shù)會使得桶集合的數(shù)量巨大，空間浪費嚴重。這就是一個時間代價和空間代價的權(quán)衡問題了。

3.java實現(xiàn)

　　對０～１之間的一組浮點數(shù)進行升序排序：

BucketSort.java

測試代碼：

輸出結(jié)果：

九、基數(shù)排序

原理

　　基數(shù)排序（Radix sort）是一種非比較型整數(shù)排序算法，其原理是將整數(shù)按位數(shù)切割成不同的數(shù)字，然后按每個位數(shù)分別比較。由于整數(shù)也可以表達字符串（比如名字或日期）和特定格式的浮點數(shù)，所以基數(shù)排序也不是只能使用于整數(shù)。

　　將所有待比較數(shù)值（正整數(shù)）統(tǒng)一為同樣的數(shù)位長度，數(shù)位較短的數(shù)前面補零。然后，從最低位開始，依次進行一次排序。這樣從最低位排序一直到最高位排序完成以后，數(shù)列就變成一個有序序列。

效率

　　基數(shù)排序的時間復(fù)雜度是O(k·n)，其中n是排序元素個數(shù)，k是數(shù)字位數(shù)。注意這不是說這個時間復(fù)雜度一定優(yōu)于O(n·log(n))，k的大小取決于數(shù)字位的選擇和待排序數(shù)據(jù)所屬數(shù)據(jù)類型的全集的大小；k決定了進行多少輪處理，而n是每輪處理的操作數(shù)目。

　　基數(shù)排序基本操作的代價較小，k一般不大于logn，所以基數(shù)排序一般要快過基于比較的排序，比如快速排序。

　　最差空間復(fù)雜度是O(k·n)

Java實現(xiàn)

　　現(xiàn)在有數(shù)組：278，109，63,930,589,184,505,269,8,83　。根據(jù)各位數(shù)將數(shù)組劃分為10個鏈表(當然其中的某些鏈表可能不含有元素)?
　　?
第一次分配：

0:930?
1:?
2:?
3:63,83?
4:184?
5:505?
6：?
7:?
8:278,8?
9:109,589,269

第一次收集后的數(shù)組：

930,63,83,184,505，278,8,109,589,269

第二次分配：

0:505,8,109?
1:?
2:?
3:930?
4:?
5:?
6：63,269?
7:278?
8:83,184，589?
9:

第二次收集后的數(shù)組：

505,8,109，930，63,269，278，83,184，589

第三次分配：

0:8,63,83?
1:109,184?
2:278,269?
3:?
4:?
5:505,589?
6:?
7:?
8:?
9:930

最后得到序列：

8,63,83,109,184，269,278,505,589,930

基數(shù)排序其實是利用多關(guān)鍵字先達到局部有序，再調(diào)整達到全局有序。

代碼實現(xiàn)：

<code class="hljs cpp has-numbering" style="display: block; padding: 0px; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; word-wrap: normal; background: transparent;">public class Test { public static void main(String[] args) { int[] array = {278,109,63,930,589,184,505,269,8,83}; radixSort(array); for(double a : array){ System.out.println(a); } } public static void radixSort(int[] array){ //------------------------------------------確定排序的趟數(shù)---------------------------------- int max=array[0]; for(int i=1;i<array.length;i++){ if(array[i]>max){ max=array[i]; } } int time=0; while(max>0){ max/=10; time++; } //----------------------------------------初始化10個鏈表用戶分配時暫存------------------------------- List<List<Integer>> list=new ArrayList<List<Integer>>(); for(int i=0;i<10;i++){ List<Integer> item=new ArrayList<Integer>(); list.add(item); } //-----------------------------------------進行time次分配和收集------------------------------------- for(int i=0;i<time;i++){ //分配元素; for(int j=0;j<array.length;j++){ int index = array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i); list.get(index).add(array[j]); } //收集元素; int count=0; for(int k=0;k<10;k++){ if(list.get(k).size()>0){ for(int a : list.get(k)){ array[count]=a; count++; } //清除數(shù)據(jù)，以便下次收集 list.get(k).clear(); } } } } }</code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li><li style="box-sizing: border-box; padding: 0px 5px;">10</li><li style="box-sizing: border-box; padding: 0px 5px;">11</li><li style="box-sizing: border-box; padding: 0px 5px;">12</li><li style="box-sizing: border-box; padding: 0px 5px;">13</li><li style="box-sizing: border-box; padding: 0px 5px;">14</li><li style="box-sizing: border-box; padding: 0px 5px;">15</li><li style="box-sizing: border-box; padding: 0px 5px;">16</li><li style="box-sizing: border-box; padding: 0px 5px;">17</li><li style="box-sizing: border-box; padding: 0px 5px;">18</li><li style="box-sizing: border-box; padding: 0px 5px;">19</li><li style="box-sizing: border-box; padding: 0px 5px;">20</li><li style="box-sizing: border-box; padding: 0px 5px;">21</li><li style="box-sizing: border-box; padding: 0px 5px;">22</li><li style="box-sizing: border-box; padding: 0px 5px;">23</li><li style="box-sizing: border-box; padding: 0px 5px;">24</li><li style="box-sizing: border-box; padding: 0px 5px;">25</li><li style="box-sizing: border-box; padding: 0px 5px;">26</li><li style="box-sizing: border-box; padding: 0px 5px;">27</li><li style="box-sizing: border-box; padding: 0px 5px;">28</li><li style="box-sizing: border-box; padding: 0px 5px;">29</li><li style="box-sizing: border-box; padding: 0px 5px;">30</li><li style="box-sizing: border-box; padding: 0px 5px;">31</li><li style="box-sizing: border-box; padding: 0px 5px;">32</li><li style="box-sizing: border-box; padding: 0px 5px;">33</li><li style="box-sizing: border-box; padding: 0px 5px;">34</li><li style="box-sizing: border-box; padding: 0px 5px;">35</li><li style="box-sizing: border-box; padding: 0px 5px;">36</li><li style="box-sizing: border-box; padding: 0px 5px;">37</li><li style="box-sizing: border-box; padding: 0px 5px;">38</li><li style="box-sizing: border-box; padding: 0px 5px;">39</li><li style="box-sizing: border-box; padding: 0px 5px;">40</li><li style="box-sizing: border-box; padding: 0px 5px;">41</li><li style="box-sizing: border-box; padding: 0px 5px;">42</li><li style="box-sizing: border-box; padding: 0px 5px;">43</li><li style="box-sizing: border-box; padding: 0px 5px;">44</li><li style="box-sizing: border-box; padding: 0px 5px;">45</li><li style="box-sizing: border-box; padding: 0px 5px;">46</li><li style="box-sizing: border-box; padding: 0px 5px;">47</li><li style="box-sizing: border-box; padding: 0px 5px;">48</li><li style="box-sizing: border-box; padding: 0px 5px;">49</li><li style="box-sizing: border-box; padding: 0px 5px;">50</li><li style="box-sizing: border-box; padding: 0px 5px;">51</li><li style="box-sizing: border-box; padding: 0px 5px;">52</li></ul>

運行結(jié)果：

十、插入排序

概述

　　將一個數(shù)據(jù)插入到已經(jīng)排好序的有序數(shù)據(jù)中，從而得到一個新的、個數(shù)加一的有序數(shù)據(jù)，算法適用于少量數(shù)據(jù)的排序，是穩(wěn)定的排序方法。

　　插入排序又分為　直接插入排序　和折半插入排序。

直接插入排序

　　把待排序的紀錄按其關(guān)鍵碼值的大小逐個插入到一個已經(jīng)排好序的有序序列中，直到所有的紀錄插入完為止，得到一個新的有序序列。

Java實現(xiàn)

　?
　　備注很清楚，我就不多說了．．．．

效率分析

　　空間復(fù)雜度O(1) 　?
　　?
　　平均時間復(fù)雜度O(n^2)

最差情況：反序，需要移動n*(n-1)/2個元素，運行時間為O(n^2)。?
　　?
最好情況：正序，不需要移動元素，運行時間為O(n)．

折半插入排序　

　　直接插入排序中要把插入元素與已有序序列元素依次進行比較，效率非常低。　?
　　?
　　折半插入排序,使用使用折半查找的方式尋找插入點的位置, 可以減少比較的次數(shù),但移動的次數(shù)不變, 時間復(fù)雜度和空間復(fù)雜度和直接插入排序一樣，在元素較多的情況下能提高查找性能。

Java實現(xiàn)

<code class="hljs livecodeserver has-numbering" style="display: block; padding: 0px; color: inherit; box-sizing: border-box; font-family: 'Source Code Pro', monospace;font-size:undefined; white-space: pre; border-top-left-radius: 0px; border-top-right-radius: 0px; border-bottom-right-radius: 0px; border-bottom-left-radius: 0px; word-wrap: normal; background: transparent;">private static void binaryInsertSort(int[] a) { //從數(shù)組的第二個位置開始遍歷值 for(int i = 1; i < a.length; i++) { int key = a[i]; //暫存要插入的值 int pre = 0; //有序序列開始和結(jié)尾下標申明 int last = i - 1; // 折半查找出插入位置 a[pre] while(pre <= last) { int mid = (pre + last) / 2; if(key < a[mid]) { last = mid - 1; } else { pre = mid + 1; } } //a[i]已經(jīng)取出來存放在key中，把下標從pre + 1到 i-1的元素依次后移 for(int j = i; j >= pre + 1; j--) { a[j] = a[j - 1]; } //把值插入空白位置 a[pre] = key; } } </code><ul class="pre-numbering" style="box-sizing: border-box; position: absolute; width: 50px; top: 0px; left: 0px; margin: 0px; padding: 6px 0px 40px; border-right-width: 1px; border-right-style: solid; border-right-color: rgb(221, 221, 221); list-style: none; text-align: right; background-color: rgb(238, 238, 238);"><li style="box-sizing: border-box; padding: 0px 5px;">1</li><li style="box-sizing: border-box; padding: 0px 5px;">2</li><li style="box-sizing: border-box; padding: 0px 5px;">3</li><li style="box-sizing: border-box; padding: 0px 5px;">4</li><li style="box-sizing: border-box; padding: 0px 5px;">5</li><li style="box-sizing: border-box; padding: 0px 5px;">6</li><li style="box-sizing: border-box; padding: 0px 5px;">7</li><li style="box-sizing: border-box; padding: 0px 5px;">8</li><li style="box-sizing: border-box; padding: 0px 5px;">9</li><li style="box-sizing: border-box; padding: 0px 5px;">10</li><li style="box-sizing: border-box; padding: 0px 5px;">11</li><li style="box-sizing: border-box; padding: 0px 5px;">12</li><li style="box-sizing: border-box; padding: 0px 5px;">13</li><li style="box-sizing: border-box; padding: 0px 5px;">14</li><li style="box-sizing: border-box; padding: 0px 5px;">15</li><li style="box-sizing: border-box; padding: 0px 5px;">16</li><li style="box-sizing: border-box; padding: 0px 5px;">17</li><li style="box-sizing: border-box; padding: 0px 5px;">18</li><li style="box-sizing: border-box; padding: 0px 5px;">19</li><li style="box-sizing: border-box; padding: 0px 5px;">20</li><li style="box-sizing: border-box; padding: 0px 5px;">21</li><li style="box-sizing: border-box; padding: 0px 5px;">22</li><li style="box-sizing: border-box; padding: 0px 5px;">23</li><li style="box-sizing: border-box; padding: 0px 5px;">24</li></ul>

直接插入排序是，比較一個后移一個；?
折半插入排序是，先找到位置，然后一起移動；

十一、補充

1. 快排的partition函數(shù)

　　作用：給定一個數(shù)組arr[]和數(shù)組中任意一個元素a，重排數(shù)組使得a左邊都小于它，右邊都不小于它。

2. 冒泡排序的改進

思路：

①、加一個標志位，當某一趟冒泡排序沒有元素交換時，則冒泡結(jié)束，元素已經(jīng)有序，可以有效的減少冒泡次數(shù)。

②、記錄每一次元素交換的位置，當元素交換的位置在第0個元素時，則排序結(jié)束。

3.快排優(yōu)化

① 快速排序在處理小規(guī)模數(shù)據(jù)時的表現(xiàn)不好，這個時候可以改用插入排序。

②對于一個每個元素都完全相同的一個序列來講，快速排序也會退化到 O(n^2)。要將這種情況避免到，可以這樣做：

　　在分區(qū)的時候，將序列分為 3 堆，一堆小于中軸元素，一堆等于中軸元素，一堆大于中軸元素，下次遞歸調(diào)用快速排序的時候，只需對小于和大于中軸元素的兩堆數(shù)據(jù)進行排序，中間等于中軸元素的一堆已經(jīng)放好。

頂

總結(jié)

以上是生活随笔為你收集整理的排序分析的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

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