前言

數(shù)據(jù) data 結(jié)構(gòu)(structure)是一門 研究組織數(shù)據(jù)方式的學(xué)科，有了編程語言也就有了數(shù)據(jù)結(jié)構(gòu).學(xué)好數(shù)據(jù)結(jié)構(gòu)才可以編寫出更加漂亮,更加有效率的代碼。

• 要學(xué)習(xí)好數(shù)據(jù)結(jié)構(gòu)就要多多考慮如何將生活中遇到的問題,用程序去實(shí)現(xiàn)解決.
• 程序 = 數(shù)據(jù)結(jié)構(gòu) + 算法
• 數(shù)據(jù)結(jié)構(gòu)是算法的基礎(chǔ), 換言之，想要學(xué)好算法，需要把數(shù)據(jù)結(jié)構(gòu)學(xué)到位

數(shù)據(jù)結(jié)構(gòu)與算法【Java】05---排序算法

1、排序算法介紹

• 排序也稱排序算法(SortAlgorithm)，排序是將?一組數(shù)據(jù)?，依?指定的順序?進(jìn)行?排列?的過程
• 有很多種不同的排序算法，每一種都有各自的優(yōu)勢和限制
• 下面我們會一一分析不同種的排序算法并比較他們之間的區(qū)別

2、排序的分類

內(nèi)部排序:

指將需要處理的所有數(shù)據(jù)都加載到 內(nèi)部存儲器( 內(nèi)存)中進(jìn)行排序。

外部排序法：

數(shù)據(jù)量過大，無法全部加載到內(nèi)存中，需要借助 外部存儲( 文件等)進(jìn)行排序。

3、算法的時間復(fù)雜度

3.1、度量一個程序(算法)執(zhí)行時間的兩種方法

• 事后統(tǒng)計：實(shí)際運(yùn)行程序統(tǒng)計時間，但是容易受計算機(jī)的軟硬件環(huán)境影響
• 事前統(tǒng)計：分析時間復(fù)雜度

3.2、時間頻度

• 介紹：一個算法中的語句執(zhí)行次數(shù)稱為語句頻度或時間頻度。記為 T(n)

• 舉例說明：

  1、比如計算1-100所有數(shù)字之和, 我們設(shè)計兩種算法：

  （1）T(n)=n+1

? （2）?T(n)=1

?2、時間頻度的表示

? （1）忽略常數(shù)項(xiàng)

? 結(jié)論:

? 2n+20 和 2n 隨著n 變大，執(zhí)行曲線無限接近, 20可以忽略

? 3n+10 和 3n 隨著n 變大，執(zhí)行曲線無限接近, 10可以忽略

? （2）忽略低次項(xiàng)

? 結(jié)論:

? 2n^2+3n+10 和 2n^2 隨著n 變大, 執(zhí)行曲線無限接近, 可以忽略 3n+10

? n^2+5n+20 和 n^2 隨著n 變大,執(zhí)行曲線無限接近, 可以忽略 5n+20

? （3）忽略系數(shù)

? 結(jié)論:

? 隨著n值變大，5n^2+7n 和 3n^2 + 2n ，執(zhí)行曲線重合, 說明 這種情況下, 5和3可以忽略。

? 而n^3+5n 和 6n^3+4n ，執(zhí)行曲線分離，說明多少次方式關(guān)鍵

3.3、時間復(fù)雜度

?

.一般情況下， 算法中的基本操作語句的重復(fù)執(zhí)行次數(shù)是問題規(guī)模 n 的某個函數(shù)，用 T(n)表示，若有某個輔

助函數(shù) f(n)，使得當(dāng) n 趨近于無窮大時，T(n) / f(n) 的極限值為不等于零的常數(shù)，則稱 f(n)是 T(n)的同數(shù)量級函數(shù)。

記作 T(n)= Ｏ( f(n) )，稱Ｏ( f(n) ) 為算法的漸進(jìn)時間復(fù)雜度，簡稱時間復(fù)雜度。

T(n) 不同，但時間復(fù)雜度可能相同。 如：T(n)=n2+7n+6 與 T(n)=3n2+2n+2 它們的 T(n) 不同，但時間復(fù)雜
度相同，都為 O(n2 )。

計算時間復(fù)雜度的方法：
（1） 用常數(shù) 1 代替運(yùn)行時間中的所有加法常數(shù) T(n)=n2+7n+6 => T(n)=n2+7n+1
（2）修改后的運(yùn)行次數(shù)函數(shù)中，只保留最高階項(xiàng) T(n)=n2+7n+1 => T(n) = n2
（3）去除最高階項(xiàng)的系數(shù) T(n) = n2 => T(n) = n2 => O(n2)

3.4、常見的時間復(fù)雜度

常數(shù)階O(1)

對數(shù)階O(log2n)

線性階O(n)

線性對數(shù)階O(nlog2n)

平方階O(n^2)

立方階O(n^3)

k次方階O(n^k)

指數(shù)階O(2^n)

說明：

• 常見的算法時間復(fù)雜度由小到大依次為：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n2)＜Ο(n3)＜ Ο(nk) ＜Ο(2n) ，隨著問題規(guī)模n的不斷增大，上述時間復(fù)雜度不斷增大，算法的執(zhí)行效率越低
• 從圖中可見，我們應(yīng)該盡可能避免使用指數(shù)階的算法

舉例說明

1.常數(shù)階O(1)

無論代碼執(zhí)行了多少行，只要是沒有循環(huán)等復(fù)雜結(jié)構(gòu)，那這個代碼的時間復(fù)雜度就都是O(1)

上述代碼在執(zhí)行的時候，它消耗的時候并不隨著某個變量的增長而增長，那么無論這類代碼有多長，即使有幾萬幾十萬行，都可以用O(1)來表示它的時間復(fù)雜度

2.對數(shù)階O(log2n)

在while循環(huán)里面，每次都將?i?乘以 2，乘完之后，?i?距離 n 就越來越近了。假設(shè)循環(huán)x次之后，?i?就大于 2 了，此時這個循環(huán)就退出了，也就是說 2 的 x 次方等于 n，那么 x = log2n也就是說當(dāng)循環(huán) log2n 次以后，這個代碼就結(jié)束了。

因此這個代碼的時間復(fù)雜度為：O(log2n) 。 O(log2n) 的這個2 時間上是根據(jù)代碼變化的，?i?=?i?* 3 ，則是 O(log3n) .

3.線性階O(n)

這段代碼，for循環(huán)里面的代碼會執(zhí)行n遍，因此它消耗的時間是隨著n的變化而變化的，因此這類代碼都可以用O(n)來表示它的時間復(fù)雜度

4.線性對數(shù)階O(nlog2n)

線性對數(shù)階O(nlogN) 其實(shí)非常容易理解，將時間復(fù)雜度為O(logn)的代碼循環(huán)N遍的話，那么它的時間復(fù)雜度就是 n * O(logN)，也就是了O(nlogN)

5.平方階O(n^2)

平方階O(n2) 就更容易理解了，如果把 O(n) 的代碼再嵌套循環(huán)一遍，它的時間復(fù)雜度就是 O(n2)，這段代碼其實(shí)就是嵌套了2層n循環(huán)，它的時間復(fù)雜度就是 O(n*n)，即 O(n2) 如果將其中一層循環(huán)的n改成m，那它的時間復(fù)雜度就變成了?O(m*n)

6.立方階O(n^3)、 k次方階O(n^k)

O(n3)相當(dāng)于三層n循環(huán)，其它的類似

3.5、平均時間復(fù)雜度和最壞時間復(fù)雜度

平均時間復(fù)雜度是指所有可能的輸入實(shí)例均以等概率出現(xiàn)的情況下，該算法的運(yùn)行時間

最壞情況下的時間復(fù)雜度稱最壞時間復(fù)雜度。一般討論的時間復(fù)雜度均是最壞情況下的時間復(fù)雜度。 這樣做的原因是：最壞情況下的時間復(fù)雜度是算法在任何輸入實(shí)例上運(yùn)行時間的界限，這就保證了算法的運(yùn)行時間不會比最壞情況更長

平均時間復(fù)雜度和最壞時間復(fù)雜度是否一致，和算法有關(guān)

4、算法的空間復(fù)雜度

• 類似于時間復(fù)雜度的討論，一個算法的空間復(fù)雜度(Space Complexity)定義為該算法所耗費(fèi)的存儲空間，它也是問題規(guī)模n的函數(shù)

• 空間復(fù)雜度(Space Complexity)是對一個算法在運(yùn)行過程中臨時占用存儲空間大小的量度。有的算法需要占用的臨時工作單元數(shù)與解決問題的規(guī)模n有關(guān)，它隨著n的增大而增大，當(dāng)n較大時，將占用較多的存儲單元，例如快速排序和歸并排序算法就屬于這種情況

• 在做算法分析時，主要討論的是時間復(fù)雜度。從用戶使用體驗(yàn)上看，更看重的程序執(zhí)行的速度。一些緩存產(chǎn)品(redis, memcache)和算法(基數(shù)排序)本質(zhì)就是用空間換時間.

5、冒泡排序

5.1、冒泡排序簡介

冒泡排序（Bubble Sorting）的基本思想是：通過對待排序序列從前向后（從下標(biāo)較小的元素開始）,?依次比較?相鄰元素的值，若發(fā)現(xiàn)逆序則?交換?，使值較大的元素逐漸從前移向后部，就象水底下的氣泡一樣逐漸向上冒。

優(yōu)化：因?yàn)榕判虻倪^程中，各元素不斷接近自己的位置，如果一趟比較下來沒有進(jìn)行過交換，就說明序列有序，因此要在排序過程中設(shè)置

一個標(biāo)志?flag?判斷元素是否進(jìn)行過交換。從而減少不必要的比較。

5.2、冒泡排序過程演示

• 圖解過程

• 過程分析

  (1) 一共進(jìn)行數(shù)組的大小?-?1 （?arr.length - 1?）次 大的循環(huán)

  (2)每一趟排序的次數(shù)在逐漸的減少

  (3) 優(yōu)化思路：如果我們發(fā)現(xiàn)在某趟排序中，沒有發(fā)生一次交換， 可以提前結(jié)束冒泡排序

動態(tài)圖

?

5.3、冒泡排序代碼實(shí)現(xiàn)

未優(yōu)化

public class Test {public static void main(String[] args) {int arr[] = {3, 9, -1, 10, 20};//冒泡排序，時間復(fù)雜度O(n2)//定義一個臨時變量int temp = 0;for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - 1 - i; j++) {//如果前面的數(shù)比后面的大，就交換if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}System.out.println("第" + (i + 1) + "趟排序后的數(shù)組");System.out.println(Arrays.toString(arr));}} }

結(jié)果展示：

優(yōu)化

?

public class Test {public static void main(String[] args) {int arr[] = {3, 9, -1, 10, 20};//冒泡排序，時間復(fù)雜度O(n2)int temp = 0;//定義一個臨時變量boolean flag = false;//表示變量，表示是否進(jìn)行過交換for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - 1 - i; j++) {//如果前面的數(shù)比后面的大，就交換if (arr[j] > arr[j + 1]) {flag = true;temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}System.out.println("第" + (i + 1) + "趟排序后的數(shù)組");System.out.println(Arrays.toString(arr));if (!flag) {//在一趟排序中，一次交換都沒有發(fā)生過,!flag也可以寫成flag==falsebreak;} else {flag = false;//重置flag,進(jìn)行下一次判斷}}} }

結(jié)果展示：

封裝成方法

public class BubbleSort {public static void main(String[] args) {int arr[] = {3, 9, -1, 10, 20};//測試冒泡排序System.out.println("排序前的數(shù)組");System.out.println(Arrays.toString(arr));bubbleSort(arr);System.out.println("排序后的數(shù)組");System.out.println(Arrays.toString(arr));}//將前面的冒泡排序封裝成一個方法public static void bubbleSort(int arr[]){//冒泡排序，時間復(fù)雜度O(n2)int temp = 0;//定義一個臨時變量boolean flag = false;//表示變量，表示是否進(jìn)行過交換for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - 1 - i; j++) {//如果前面的數(shù)比后面的大，就交換if (arr[j] > arr[j + 1]) {flag = true;temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}//System.out.println("第" + (i + 1) + "趟排序后的數(shù)組");//System.out.println(Arrays.toString(arr));if (!flag) {//在一趟排序中，一次交換都沒有發(fā)生過,!flag也可以寫成flag==falsebreak;} else {flag = false;//重置flag,進(jìn)行下一次判斷}}}}

?

結(jié)果展示：

測試冒泡排序O(n2）的速度

為了測試冒泡排序O(n2）的速度，我們隨機(jī)生成80000個數(shù)據(jù)進(jìn)行排序，由于打印80000個數(shù)據(jù)很不方便，我們就輸出排序前后的時間

?

//測試一下冒泡排序的速度O(n^2), 給80000個數(shù)據(jù)，測試 //創(chuàng)建要給80000個的隨機(jī)的數(shù)組 int[] arr = new int[80000]; for(int i =0; i < 80000;i++) {arr[i] = (int)(Math.random() * 8000000); //生成一個[0, 8000000) 數(shù) }Date data1 = new Date(); SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); String date1Str = simpleDateFormat.format(data1); System.out.println("排序前的時間是=" + date1Str);//測試冒泡排序 bubbleSort(arr);Date data2 = new Date(); String date2Str = simpleDateFormat.format(data2); System.out.println("排序后的時間是=" + date2Str);

結(jié)果展示：

6、選擇排序

6.1、選擇排序簡介

選擇排序也屬于內(nèi)部排序法，是從欲排序的數(shù)據(jù)中，按指定的規(guī)則選出某一元素，再依規(guī)定交換位置后達(dá)到排序的目的

排序思想：

第一次從arr[0]~arr[n-1]中選取最小值，與arr[0]交換， 第二次從arr[1]~arr[n-1]中選取最小值，與arr[1]交換， 第三次從arr[2]~arr[n-1]中選取最小值，與arr[2]交換，…， 第i次從arr[i-1]~arr[n-1]中選取最小值，與arr[i-1]交換，…, 第n-1次從arr[n-2]~arr[n-1]中選取最小值，與arr[n-2]交換， 總共通過n-1次，得到一個按排序碼從小到大排列的有序序列。

?

6.2、選擇排序過程演示

• 過程圖解

• 過程分析

• 選擇排序一共有 數(shù)組大小 - 1（?arr.length-1?） 輪排序

  2. 每1輪排序，又是一個循環(huán), 循環(huán)的規(guī)則(代碼)

  2.1先假定當(dāng)前這個數(shù)是最小數(shù)

  2.2 然后和后面的每個數(shù)進(jìn)行比較，如果發(fā)現(xiàn)有比當(dāng)前數(shù)更小的數(shù)，就重新確定最小數(shù)，并得到下標(biāo)

  2.3 當(dāng)遍歷到數(shù)組的最后時，就得到本輪最小數(shù)和下標(biāo)

  2.4 交換

動態(tài)圖

?

6.3、選擇排序代碼實(shí)現(xiàn)

優(yōu)化+封裝

?

public class SelectSort {public static void main(String[] args) {int [] arr = {100,35,120,7};System.out.println("排序前");System.out.println(Arrays.toString(arr));selectSort(arr);System.out.println("排序后");System.out.println(Arrays.toString(arr));}//選擇排序的方法public static void selectSort(int [] arr){for (int i = 0; i < arr.length - 1; i++) {int minIndex = i;int min = arr[i];for (int j = i+1; j < arr.length; j++) {if (min > arr[j]){//說明假定的最小值不是最小minIndex = j;//重置min和minIndexmin = arr[j];}}//交換，將最小值依次放在最前面//優(yōu)化：如果假定的最小值就是真實(shí)的最小值，那么就不進(jìn)行交換（這里假定的最小值是上一輪交換后的下一個值）if (minIndex != i){arr[minIndex] = arr[i];arr[i] = min;}//System.out.println("第"+(i+1)+"輪后");//System.out.println(Arrays.toString(arr));}} }

結(jié)果展示

測試選擇排序O(n2）的速度

測試方法同冒泡排序中的方法，我們在測試之前通過分析可以得出選擇排序交換是找到最小（大）值才進(jìn)行交換，而冒泡排序是相鄰元素之間進(jìn)行比較交換，所以選擇排序的交換次數(shù)應(yīng)該比冒泡排序少，速度應(yīng)該更快。

7、插入排序

7.1、插入排序簡介

插入式排序?qū)儆趦?nèi)部排序法，是對于欲排序的元素以插入的方式找尋該元素的適當(dāng)位置，以達(dá)到排序的目的。

排序思想：

插入排序（Insertion Sorting）的基本思想是：把 把 n 個待排序的元素看成為一個有序表和一個無序表，開始時 有

序表中只包含一個元素，無序表中包含有 n-1 個元素，排序過程中每次從無序表中取出第一個元素，把它的排

序碼依次與有序表元素的排序碼進(jìn)行比較，將它插入到有序表中的適當(dāng)位置，使之成為新的有序表。

7.2、插入排序過程演示

• 過程圖解

動態(tài)圖

?

7.3、插入排序代碼實(shí)現(xiàn)

插入排序

public class InsertSort {public static void main(String[] args) {int [] arr = {23,56,189,77,-1,0};insertSort(arr);}//插入排序public static void insertSort(int [] arr){for (int i = 1; i < arr.length ; i++) {//定義待插入的數(shù)int insertVal = arr[i];int insertIndex = i - 1;// 給insertVal 找到插入的位置// 說明// 1. insertIndex >= 0 保證在給insertVal 找插入位置，不越界// 2. insertVal < arr[insertIndex] 待插入的數(shù)，還沒有找到插入位置// 3. 就需要將 arr[insertIndex] 后移while (insertIndex >=0 && insertVal < arr[insertIndex]){arr[insertIndex + 1] = arr[insertIndex];insertIndex--;}// 當(dāng)退出while循環(huán)時，說明插入的位置找到, insertIndex + 1//這里我們判斷是否需要賦值(加上if語句就是優(yōu)化)if (insertVal + 1 != i) {arr[insertIndex + 1] = insertVal;}System.out.println("第"+i+"輪插入");System.out.println(Arrays.toString(arr));}}}

結(jié)果：

測試插入排序O(n2）的速度

?

public static void main(String[] args) {// 創(chuàng)建要給80000個的隨機(jī)的數(shù)組int[] arr = new int[80000];for (int i = 0; i < 80000; i++) {arr[i] = (int) (Math.random() * 8000000); // 生成一個[0, 8000000) 數(shù)}System.out.println("插入排序前");Date data1 = new Date();SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String date1Str = simpleDateFormat.format(data1);System.out.println("排序前的時間是=" + date1Str);insertSort(arr); //調(diào)用插入排序算法Date data2 = new Date();String date2Str = simpleDateFormat.format(data2);System.out.println("排序后的時間是=" + date2Str);}

測試結(jié)果：本機(jī)耗時約為1s

8、希爾排序

8.1、簡單插入排序存在的問題

我們看簡單的插入排序可能存在的問題.

數(shù)組 arr = {2,3,4,5,6,1} 這時需要插入的數(shù) 1( 最小), 這樣的過程是：

{2,3,4,5,6,6}

{2,3,4,5,5,6}

{2,3,4,4,5,6}

{2,3,3,4,5,6}

{2,2,3,4,5,6}

{1,2,3,4,5,6}

結(jié)論: 當(dāng) 需要插入的數(shù)是較小的數(shù)時， 后移的次數(shù)明顯增多，對 效率有影響.

8.2、希爾排序簡介

希爾排序是希爾（Donald Shell）于 1959 年提出的一種排序算法。

希爾排序也是一種 插入排序，它是簡單插入排序經(jīng)過改進(jìn)之后的一個 更高效的版本，也稱為?縮小增量排序

• 排序思想

  希爾排序是把記錄按下標(biāo)的一定增量分組，對每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含

  的關(guān)鍵詞越來越多， 當(dāng)增量減至 1 時，整個文件恰被分成一組，算法便終止

8.3、希爾排序過程演示

動態(tài)圖

?

8.4、希爾排序代碼實(shí)現(xiàn)

希爾排序時， 對有序序列在插入時采用 交換法, 并測試排序速度.（速度較慢但易于理解）

希爾排序時， 對有序序列在插入時采用 移動法, 并測試排序速度（速度較快但不易理解）

交換法

public class ShellSort {public static void main(String[] args) {int [] arr = {8,9,1,7,2,3,5,4,6,0};shellSort(arr);}//希爾排序public static void shellSort(int [] arr){int temp = 0;int count = 0;//分組for (int gap = arr.length/2;gap > 0; gap /= 2){//遍歷各組for (int i = gap;i < arr.length;i++){//遍歷各組中的所有元素（共gap組，每組有arr.length/gap個元素，步長是gap）//j -= gap,之前插入排序是index--,因?yàn)槊看我耙徊?#xff0c;現(xiàn)在是希爾排序，有間隔，所以是j -= gapfor (int j = i - gap; j >= 0 ; j -= gap) {//如果當(dāng)前元素大于加上步長后的那個元素，說明交換if (arr[j] > arr[j+gap]) {temp = arr[j];arr[j] = arr[j + gap];arr[j + gap] = temp;}}}System.out.println("希爾排序第"+ (++count) +"輪："+ Arrays.toString(arr));}} }

結(jié)果：

速度測試：本機(jī)耗時約為5s,可以看到交換法并沒有對簡單插入排序的速度進(jìn)行提升，接下來我們來看移動法

移位法（重點(diǎn)）

//希爾排序移動法 public static void shellSort2(int [] arr){int count = 0;//增量gap,并逐步縮小增量for (int gap = arr.length/2;gap > 0; gap /= 2){//從第gap個元素開始，逐個對其所在的組進(jìn)行直接插入排序for (int i = gap; i < arr.length; i++) {int j = i;int temp = arr[j];if(arr[j] < arr[j -gap]){while (j - gap >= 0 && temp < arr[j - gap]){//移動arr[j] = arr[j - gap];j -= gap;}//當(dāng)退出while循環(huán)后，就給temp找到插入的位置arr[j] = temp;}}System.out.println("希爾排序第"+ (++count) +"輪："+ Arrays.toString(arr));}}

結(jié)果：

速度測試：本機(jī)耗時不到1s,確實(shí)提升了簡單插入排序的速度

9、快速排序

9.1、快速排序簡介

快速排序（Quicksort）是對?冒泡排序?的一種改進(jìn)。基本思想是：通過一趟排序?qū)⒁判虻臄?shù)據(jù)?分割?成獨(dú)立的兩

部分，其中一部分的所有數(shù)據(jù)都比另外一部分的所有數(shù)據(jù)都要小，然后再按此方法對這兩部分?jǐn)?shù)據(jù)分別進(jìn)行快速排

序， 整個排序過程可以遞歸進(jìn)行，以此達(dá)到整個數(shù)據(jù)變成有序序列

9.2、快速排序過程演示

動態(tài)圖

?

9.3、快速排序代碼實(shí)現(xiàn)

要求：對?10,7,2,4,7,62,3,4,2,1,8,9,19?進(jìn)行從小到大的排序，要求使用快速排序法

代碼實(shí)現(xiàn)

public class QuickSort {public static void main(String[] args){int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};quickSort(arr, 0, arr.length-1);System.out.println("arr="+ Arrays.toString(arr));}public static void quickSort(int[] arr,int low,int high){int i,j,temp,t;if(low>high){return;}i=low;j=high;//temp就是基準(zhǔn)位，這里基準(zhǔn)位取的是低半?yún)^(qū)的第一個數(shù)據(jù)temp = arr[low];while (i<j) {//先看右邊，依次往左遞減while (temp<=arr[j]&&i<j) {j--;}//再看左邊，依次往右遞增while (temp>=arr[i]&&i<j) {i++;}//如果滿足條件則交換if (i<j) {t = arr[j];arr[j] = arr[i];arr[i] = t;}}//最后將基準(zhǔn)位與i和j相等位置的數(shù)字交換，因?yàn)檫@里基準(zhǔn)位取的是低半?yún)^(qū)的第一個數(shù)據(jù)arr[low] = arr[i];arr[i] = temp;//遞歸調(diào)用左半數(shù)組quickSort(arr, low, j-1);//遞歸調(diào)用右半數(shù)組quickSort(arr, j+1, high);}}

結(jié)果：

快速排序速度測試O(nlogn)

分析

• 快速排序是基于一種叫做“二分”的思想，快速排序之所比較快，因?yàn)橄啾让芭菖判?#xff0c;每次交換是跳躍式的。

• 每次排序的時候設(shè)置一個基準(zhǔn)點(diǎn)，將小于等于基準(zhǔn)點(diǎn)的數(shù)全部放到基準(zhǔn)點(diǎn)的左邊，將大于等于基準(zhǔn)點(diǎn)的數(shù)全部放到基準(zhǔn)點(diǎn)的右邊。

• 這樣在每次交換的時候就不會像冒泡排序一樣每次只能在相鄰的數(shù)之間進(jìn)行交換，交換的距離就大的多了。

• 因此總的比較和交換次數(shù)就少了，速度自然就提高了。

• 當(dāng)然在最壞的情況下，仍可能是相鄰的兩個數(shù)進(jìn)行了交換。因此快速排序的最差時間復(fù)雜度和冒泡排序是一樣的都是O(N2)，它的平均時間復(fù)雜度為O(NlogN)。

• 快速排序理論上速度是優(yōu)于希爾排序的

10、歸并排序

10.1、歸并排序簡介

歸并排序（MERGE-SORT）是利用歸并的思想實(shí)現(xiàn)的排序方法，該算法采用經(jīng)典的?分治?（divide-and-conquer ）

策略（分治法將問題分(divide)成一些 小的問題然后遞歸求解，而治(conquer)的階段則將分的階段得到的各答案"修

補(bǔ)"在一起，即分而治之)。

10.2、歸并排序過程演示

（1）歸并排序示意圖1

（2）歸并排序示意圖2

來看看治階段，我們需要將兩個已經(jīng)有序的子序列合并成一個有序序列，比如上圖中的最后一次合并，要將

[4,5,7,8]和[1,2,3,6]兩個已經(jīng)有序的子序列，合并為最終序列[1,2,3,4,5,6,7,8]，來看下實(shí)現(xiàn)步驟

動態(tài)圖

?

10.3、歸并排序代碼實(shí)現(xiàn)

代碼實(shí)現(xiàn)

public class MergetSort {public static void main(String[] args) {int arr[] = {8,4,5,7,1,3,6,2};int temp[] = new int[arr.length]; //歸并排序需要一個額外空間mergeSort(arr, 0, arr.length - 1, temp);System.out.println("歸并排序后="+ Arrays.toString(arr));}//分+合方法public static void mergeSort(int[] arr, int left, int right, int[] temp) {if(left < right) {int mid = (left + right) / 2; //中間索引//向左遞歸進(jìn)行分解mergeSort(arr, left, mid, temp);//向右遞歸進(jìn)行分解mergeSort(arr, mid + 1, right, temp);//合并merge(arr, left, mid, right, temp);}}//合并的方法/**** @param arr 排序的原始數(shù)組* @param left 左邊有序序列的初始索引* @param mid 中間索引* @param right 右邊索引* @param temp 做中轉(zhuǎn)的數(shù)組*/public static void merge(int[] arr, int left, int mid, int right, int[] temp) {int i = left; // 初始化i, 左邊有序序列的初始索引int j = mid + 1; //初始化j, 右邊有序序列的初始索引int t = 0; // 指向temp數(shù)組的當(dāng)前索引//(一)//先把左右兩邊(有序)的數(shù)據(jù)按照規(guī)則填充到temp數(shù)組//直到左右兩邊的有序序列，有一邊處理完畢為止while (i <= mid && j <= right) {//繼續(xù)//如果左邊的有序序列的當(dāng)前元素，小于等于右邊有序序列的當(dāng)前元素//即將左邊的當(dāng)前元素，填充到 temp數(shù)組//然后 t++, i++if(arr[i] <= arr[j]) {temp[t] = arr[i];t += 1;i += 1;} else { //反之,將右邊有序序列的當(dāng)前元素，填充到temp數(shù)組temp[t] = arr[j];t += 1;j += 1;}}//(二)//把有剩余數(shù)據(jù)的一邊的數(shù)據(jù)依次全部填充到tempwhile( i <= mid) { //左邊的有序序列還有剩余的元素，就全部填充到temptemp[t] = arr[i];t += 1;i += 1;}while( j <= right) { //右邊的有序序列還有剩余的元素，就全部填充到temptemp[t] = arr[j];t += 1;j += 1;}//(三)//將temp數(shù)組的元素拷貝到arr//注意，并不是每次都拷貝所有t = 0;int tempLeft = left; ////第一次合并 tempLeft = 0 , right = 1 // tempLeft = 2 right = 3 // tL=0 ri=3//最后一次 tempLeft = 0 right = 7while(tempLeft <= right) {arr[tempLeft] = temp[t];t += 1;tempLeft += 1;}}}

結(jié)果：

歸并排序速度測試O(nlogn)

11、桶排序

11.1、桶排序簡介

• 桶排序(Bucket sort)是將待排序集合中處于同一個值域的元素存入同一個桶中，也就是根據(jù)元素值特性將集合拆分為多個區(qū)域，則拆分后形成的多個桶，從值域上看是處于有序狀態(tài)的。對每個桶中元素進(jìn)行排序，則所有桶中元素構(gòu)成的集合是已排序的。

• 如果桶的大小劃分得足夠小，到達(dá)每個元素之間的最小差值，則可以保證每一個桶里面所有的數(shù)據(jù)都是一樣的，入桶后的數(shù)據(jù)也就不需要再次進(jìn)行排序，這種情況也就是桶排序時間復(fù)雜度最優(yōu)的情況即O ( n ) .一般情況下桶排序的時間復(fù)雜度為O ( n + k) ，其中n為元素個數(shù)，k為桶個數(shù)。

11.2、桶排序過程演示

排序思想

• 確定桶的大小與個數(shù)，一般根據(jù)要排序的元素的值域區(qū)間取定。
• 設(shè)計一種方式使元素能映射至對應(yīng)值域的桶的索引。
• 遍歷所有元素，將它們?nèi)胪啊?/li>
• 每個桶內(nèi)元素排序。
• 從桶內(nèi)依次提取各元素重新排列

過程演示

動態(tài)圖

?

11.3、桶排序代碼實(shí)現(xiàn)

代碼

public static void main(String[] args) {int[] arr = { 1, 45, 32, 23, 22, 31, 47, 24, 4, 15 };bucketsort(arr);}public static void bucketsort(int[] arr) {ArrayList bucket[] = new ArrayList[5];// 聲明五個桶for (int i = 0; i < bucket.length; i++) {bucket[i] = new ArrayList<Integer>();// 確定桶的格式為ArrayList}for (int i = 0; i < arr.length; i++) {int index = arr[i] / 10;// 確定元素存放的桶號bucket[index].add(arr[i]);// 將元素存入對應(yīng)的桶中}for (int i = 0; i < bucket.length; i++) {// 遍歷每一個桶bucket[i].sort(null);// 對每一個桶排序for (int i1 = 0; i1 < bucket[i].size(); i1++) {// 遍歷桶中的元素并輸出System.out.print(bucket[i].get(i1) + " ");}}}}

結(jié)果：

桶排序速度測試

?

public class BucketSort {public static void main(String[] args) {// int[] arr = { 1, 45, 32, 23, 22, 31, 47, 24, 4, 15 }; // bucketsort(arr);int[] arr = new int[80000];for (int i = 0; i < 80000; i++) {arr[i] = (int) (Math.random() * 80000); // 生成一個[0, 8000000) 數(shù)}System.out.println("排序前");Date data1 = new Date();SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");String date1Str = simpleDateFormat.format(data1);System.out.println("排序前的時間是=" + date1Str);bucketsort(arr);Date data2 = new Date();String date2Str = simpleDateFormat.format(data2);System.out.println("排序后的時間是=" + date2Str);}public static void bucketsort(int[] arr) {ArrayList bucket[] = new ArrayList[80000];// 聲明五個桶for (int i = 0; i < bucket.length; i++) {bucket[i] = new ArrayList<Integer>();// 確定桶的格式為ArrayList}for (int i = 0; i < arr.length; i++) {int index = arr[i] / 10;// 確定元素存放的桶號bucket[index].add(arr[i]);// 將元素存入對應(yīng)的桶中}for (int i = 0; i < bucket.length; i++) {// 遍歷每一個桶bucket[i].sort(null);// 對每一個桶排序for (int i1 = 0; i1 < bucket[i].size(); i1++) {// 遍歷桶中的元素并輸出System.out.print(bucket[i].get(i1) + " ");}}}}

12、基數(shù)排序

12.1、基數(shù)排序簡介

? 1.基數(shù)排序（radix sort）屬于“分配式排序”（distribution sort），又稱“桶子法”（bucket sort）或 bin sort，顧

? 名思義，它是通過鍵值的各個位的值，將要排序的元素分配至某些“桶”中，達(dá)到排序的作用

基數(shù)排序法是屬于穩(wěn)定性的排序，基數(shù)排序法的是效率高的 穩(wěn)定性排序法

基數(shù)排序(Radix Sort)是桶排序的擴(kuò)展

基數(shù)排序是 1887 年赫爾曼·何樂禮發(fā)明的。它是這樣實(shí)現(xiàn)的：將整數(shù)按位數(shù)切割成不同的數(shù)字，然后按每個
位數(shù)分別比較。

12.2、基數(shù)排序過程演示

• 排序思想：
  • 將所有待比較數(shù)值統(tǒng)一為同樣的數(shù)位長度，數(shù)位較短的數(shù)前面補(bǔ)零然后，從最低位開始，依次進(jìn)行一次排序這樣從最低位排序一直到最高位排序完成以后, 數(shù)列就變成一個有序序列

動態(tài)圖

?

12.3、基數(shù)排序代碼實(shí)現(xiàn)

按每一輪具體分析（推導(dǎo)過程）

public class RadixSort {public static void main(String[] args) {int arr[] = {53,3,542,748,14,214};radixSort(arr);}//基數(shù)排序public static void radixSort(int [] arr){//定義一個二維數(shù)組，表示是10個桶，每一個桶代表一個一維數(shù)組//說明//1. 二維數(shù)組包含10個一維數(shù)組//2. 為了防止在放入數(shù)的時候，數(shù)據(jù)溢出，則每個一維數(shù)組(桶)，大小定為arr.length//3. 很明顯基數(shù)排序是使用空間換時間的經(jīng)典算法int[][] bucket = new int[10][arr.length];//為了記錄每個桶中，實(shí)際存放了多少個數(shù)據(jù),我們定義一個一維數(shù)組來記錄各個桶的每次放入的數(shù)據(jù)個數(shù)//比如：bucketElementCounts[0] , 記錄的就是 bucket[0] 桶的放入數(shù)據(jù)個數(shù)int [] bucketElementCounts = new int[10];//第一輪排序,針對每個元素的個位進(jìn)行排序for (int i = 0; i < arr.length; i++) {//取出每個元素的個位的值int digitOfElement = arr[i]%10;//放入到對應(yīng)的桶中bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[i];bucketElementCounts[digitOfElement]++;}//按照這個桶的順序(一維數(shù)組的下標(biāo)依次取出數(shù)據(jù)，放入原來數(shù)組)int index = 0;//遍歷每一個桶，并將桶中的數(shù)據(jù)放入到原數(shù)組for (int k = 0; k < bucketElementCounts.length; k++) {//如果桶中有數(shù)據(jù)，我們才放入到原數(shù)組if (bucketElementCounts[k]!=0){//說明第k個桶有數(shù)據(jù)//循環(huán)該桶（即第k個一位數(shù)組）for (int j = 0; j < bucketElementCounts[k]; j++) {//取出元素放入到arr中arr[index++] = bucket[k][j];//第k個桶里面的第j個元素}}//第1輪處理后，需要將每個 bucketElementCounts[k] = 0 ！！！！bucketElementCounts[k] = 0;}System.out.println("第1輪，對個位的排序處理 arr =" + Arrays.toString(arr));//第2輪(針對每個元素的十位進(jìn)行排序處理)for (int j = 0; j < arr.length; j++) {// 取出每個元素的十位的值int digitOfElement = arr[j] / 10 % 10; //748 / 10 => 74 % 10 => 4// 放入到對應(yīng)的桶中bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];bucketElementCounts[digitOfElement]++;}// 按照這個桶的順序(一維數(shù)組的下標(biāo)依次取出數(shù)據(jù)，放入原來數(shù)組)index = 0;// 遍歷每一桶，并將桶中是數(shù)據(jù)，放入到原數(shù)組for (int k = 0; k < bucketElementCounts.length; k++) {// 如果桶中，有數(shù)據(jù)，我們才放入到原數(shù)組if (bucketElementCounts[k] != 0) {// 循環(huán)該桶即第k個桶(即第k個一維數(shù)組), 放入for (int j = 0; j < bucketElementCounts[k]; j++) {// 取出元素放入到arrarr[index++] = bucket[k][j];}}//第2輪處理后，需要將每個 bucketElementCounts[k] = 0 ！！！！bucketElementCounts[k] = 0;}System.out.println("第2輪，對十位的排序處理 arr =" + Arrays.toString(arr));//第3輪(針對每個元素的百位進(jìn)行排序處理)for (int j = 0; j < arr.length; j++) {// 取出每個元素的十位的值int digitOfElement = arr[j] / 100 % 10; //748 / 100 => 7// 放入到對應(yīng)的桶中bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];bucketElementCounts[digitOfElement]++;}// 按照這個桶的順序(一維數(shù)組的下標(biāo)依次取出數(shù)據(jù)，放入原來數(shù)組)index = 0;// 遍歷每一桶，并將桶中是數(shù)據(jù)，放入到原數(shù)組for (int k = 0; k < bucketElementCounts.length; k++) {// 如果桶中，有數(shù)據(jù)，我們才放入到原數(shù)組if (bucketElementCounts[k] != 0) {// 循環(huán)該桶即第k個桶(即第k個一維數(shù)組), 放入for (int j = 0; j < bucketElementCounts[k]; j++) {// 取出元素放入到arrarr[index++] = bucket[k][j];}}//第3輪處理后，需要將每個 bucketElementCounts[k] = 0 ！！！！bucketElementCounts[k] = 0;}System.out.println("第3輪，對百位的排序處理 arr =" + Arrays.toString(arr));} }

結(jié)果：

最終代碼

import java.util.Arrays;public class RadixSort {public static void main(String[] args) {int arr[] = {53,3,542,748,14,214};radixSort(arr);}//基數(shù)排序public static void radixSort(int [] arr){//根據(jù)前面的推導(dǎo)過程，我們可以得到最終的基數(shù)排序代碼//得到數(shù)組中最大的數(shù)int max = arr[0]; //假設(shè)第一數(shù)就是最大數(shù)for(int i = 1; i < arr.length; i++) {if (arr[i] > max) {max = arr[i];}}//得到最大數(shù)是幾位數(shù)int maxLength = (max + "").length();//定義一個二維數(shù)組，表示是10個桶，每一個桶代表一個一維數(shù)組//說明//1. 二維數(shù)組包含10個一維數(shù)組//2. 為了防止在放入數(shù)的時候，數(shù)據(jù)溢出，則每個一維數(shù)組(桶)，大小定為arr.length//3. 很明顯基數(shù)排序是使用空間換時間的經(jīng)典算法int[][] bucket = new int[10][arr.length];//為了記錄每個桶中，實(shí)際存放了多少個數(shù)據(jù),我們定義一個一維數(shù)組來記錄各個桶的每次放入的數(shù)據(jù)個數(shù)//比如：bucketElementCounts[0] , 記錄的就是 bucket[0] 桶的放入數(shù)據(jù)個數(shù)int [] bucketElementCounts = new int[10];//這里使用循環(huán)處理一下for (int i = 0, n = 1; i < maxLength; i++,n*=10) {//(針對每個元素的對應(yīng)位進(jìn)行排序處理)， 第一次是個位，第二次是十位，第三次是百位..for (int m = 0; m < arr.length; m++) {//取出每個元素的個位的值int digitOfElement = arr[m] / n % 10;//放入到對應(yīng)的桶中bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[m];bucketElementCounts[digitOfElement]++;}//按照這個桶的順序(一維數(shù)組的下標(biāo)依次取出數(shù)據(jù)，放入原來數(shù)組)int index = 0;//遍歷每一個桶，并將桶中的數(shù)據(jù)放入到原數(shù)組for (int k = 0; k < bucketElementCounts.length; k++) {//如果桶中有數(shù)據(jù)，我們才放入到原數(shù)組if (bucketElementCounts[k]!=0){//說明第k個桶有數(shù)據(jù)//循環(huán)該桶（即第k個一位數(shù)組）for (int j = 0; j < bucketElementCounts[k]; j++) {//取出元素放入到arr中arr[index++] = bucket[k][j];//第k個桶里面的第j個元素}}//第i+1輪處理后，需要將每個 bucketElementCounts[k] = 0 ！！！！bucketElementCounts[k] = 0;}System.out.println("第"+(i+1)+"輪，對個位的排序處理 arr =" + Arrays.toString(arr));}} }

?

結(jié)果：

基數(shù)排序速度測試O(n*k)

12.4、基數(shù)排序說明

基數(shù)排序是對傳統(tǒng)桶排序的擴(kuò)展，速度很快.

基數(shù)排序是經(jīng)典的空間換時間的方式，占用內(nèi)存很大, 當(dāng)對海量數(shù)據(jù)排序時，容易造成 OutOfMemoryError 。

基數(shù)排序是穩(wěn)定的。

[注:假定在待排序的記錄序列中，存在多個具有相同的關(guān)鍵字的記錄，若經(jīng)過排序，這些

記錄的相對次序保持不變，即在原序列中，r[i]=r[j]，且 r[i]在 r[j]之前，而在排序后的序列中，r[i]仍在 r[j]之前，

則稱這種排序算法是穩(wěn)定的；否則稱為不穩(wěn)定的]

有負(fù)數(shù)的數(shù)組，我們不用基數(shù)排序來進(jìn)行排序, 如果要支持負(fù)數(shù)，參考:?https://code.i-harness.com/zh-CN/q/e98fa9

13、計數(shù)排序

13.1、計數(shù)排序簡介

• 計數(shù)排序是一個非基于比較的排序算法，元素從未排序狀態(tài)變?yōu)橐雅判驙顟B(tài)的過程，是由額外空間的輔助和元素本身的值決定的。

• 該算法于1954年由 Harold H. Seward 提出。

• 它的優(yōu)勢在于在對一定范圍內(nèi)的整數(shù)排序時，它的復(fù)雜度為Ο(n+k)（其中k是整數(shù)的范圍），快于任何比較排序算法。

• 當(dāng)然這是一種犧牲空間換取時間的做法，而且當(dāng)?O(k)>O(nlogn)?的時候其效率反而不如基于比較的排序，因?yàn)榛诒容^的排序的時間復(fù)雜度在理論上的下限是?O(nlogn)?。

13.2、計數(shù)排序過程演示

排序思想

根據(jù)待排序集合中最大元素和最小元素的差值范圍，申請額外空間；

遍歷待排序集合，將每一個元素出現(xiàn)的次數(shù)記錄到元素值對應(yīng)的額外空間內(nèi)；

對額外空間內(nèi)數(shù)據(jù)進(jìn)行計算，得出每一個元素的正確位置；

將待排序集合每一個元素移動到計算得出的正確位置上

排序示意圖

詳解過程圖：

先假設(shè) 20 個數(shù)列為：{9, 3, 5, 4, 9, 1, 2, 7, 8，1，3, 6, 5, 3, 4, 0, 10, 9, 7, 9}。

讓我們先遍歷這個無序的隨機(jī)數(shù)組，找出最大值為 10 和最小值為 0。這樣我們對應(yīng)的計數(shù)范圍將是 0 ~ 10。然后每一個整數(shù)按照其值對號入座，對應(yīng)數(shù)組下標(biāo)的元素進(jìn)行加1操作。

比如第一個整數(shù)是 9，那么數(shù)組下標(biāo)為 9 的元素加 1，如下圖所示。

第二個整數(shù)是 3，那么數(shù)組下標(biāo)為 3 的元素加 1，如下圖所示。

繼續(xù)遍歷數(shù)列并修改數(shù)組......。最終，數(shù)列遍歷完畢時，數(shù)組的狀態(tài)如下圖。

數(shù)組中的每一個值，代表了數(shù)列中對應(yīng)整數(shù)的出現(xiàn)次數(shù)。

有了這個統(tǒng)計結(jié)果，排序就很簡單了，直接遍歷數(shù)組，輸出數(shù)組元素的下標(biāo)值，元素的值是幾，就輸出幾次。比如統(tǒng)計結(jié)果中的 1 為 2，就是數(shù)列中有 2 個 1 的意思。這樣我們就得到最終排序好的結(jié)果。

0, 1, 1, 2, 3, 3, 3, 4, 4, 5, 5, 6, 7, 7, 8, 9, 9, 9, 9, 10

動態(tài)演示：

?

13.3、計數(shù)排序代碼實(shí)現(xiàn)

代碼

public class CountingSort {public static void main(String[] args) {int []num ={7,4,9,3,2,1,8,6,5,10};long startTime=System.currentTimeMillis();int min=Integer.MAX_VALUE;int max=Integer.MIN_VALUE;//先找出數(shù)組中的最大值與最小值for(int i=0;i<num.length;i++) {if(num[i]<min)min=num[i];if(num[i]>max)max=num[i];}//創(chuàng)建一個長度為max-min+1長度的數(shù)組來進(jìn)行計數(shù)int []figure=new int [max-min+1];for(int i=0;i<num.length;i++) {//計算每個數(shù)據(jù)出現(xiàn)的次數(shù)figure[num[i]-min]++;}int begin=0;//創(chuàng)建一個新的數(shù)組來存儲已經(jīng)排序完成的結(jié)果int []num1=new int [num.length];for(int i=0;i<figure.length;i++) {//循環(huán)將數(shù)據(jù)pop出來if(figure[i]!=0) {for(int j=0;j<figure[i];j++) {num1[begin++]=min+i;}}}System.out.println("數(shù)據(jù)范圍:"+min+"~"+max);System.out.println("計數(shù)結(jié)果: ");for(int i=0;i<num.length;i++)System.out.println(" "+num[i]+"出現(xiàn)"+figure[num[i]-min]+"次");System.out.print("排序結(jié)果: ");for(int i=0;i<num1.length;i++)System.out.print(num1[i]+" ");System.out.println();long endTime=System.currentTimeMillis();System.out.println("程序運(yùn)行時間： "+(endTime-startTime)+"ms");}}

結(jié)果：

14、堆排序

14.1、堆排序簡介

? 1.堆排序是利用堆這種數(shù)據(jù)結(jié)構(gòu)而設(shè)計的一種排序算法，堆排序是一種選擇排序，它的最壞，最好，平均時間復(fù)雜度均為 O(nlogn)，它 是不穩(wěn)定排序。

堆是具有以下性質(zhì)的完全二叉樹：每個結(jié)點(diǎn)的值都大于或等于其左右孩子結(jié)點(diǎn)的值，稱為大根堆（或大頂堆）, 注意 : 沒有

要求結(jié)點(diǎn)的左孩子的值和右孩子的值的大小關(guān)系。

每個結(jié)點(diǎn)的值都小于或等于其左右孩子結(jié)點(diǎn)的值，稱為小根堆（或小頂堆）

一般升序采用大根堆，降序采用小根堆

14.2、堆排序過程演示

堆排序的基本思想是：

將待排序序列構(gòu)造成一個大根堆

此時，整個序列的最大值就是堆頂?shù)母?jié)點(diǎn)。

將其與末尾元素進(jìn)行交換，此時末尾就為最大值。

然后將剩余 n-1 個元素重新構(gòu)造成一個堆，這樣會得到 n 個元素的次小值。如此反復(fù)執(zhí)行，便能得到一個有序
序列了。

步驟圖解

要求：給你一個數(shù)組 {4,6,8,5,9} , 要求使用堆排序法，將數(shù)組升序排序。

• 步驟一 構(gòu)造初始堆。將給定無序序列構(gòu)造成一個大根堆（一般升序采用大根堆，降序采用小根堆)。
• 原始的數(shù)組 [4, 6, 8, 5, 9]

.假設(shè)給定無序序列結(jié)構(gòu)如下

.此時我們從最后一個非葉子結(jié)點(diǎn)開始（葉結(jié)點(diǎn)自然不用調(diào)整，第一個非葉子結(jié)點(diǎn)?arr.length/2-1=5/2-1=1?，也就是下面的 6 結(jié)點(diǎn)），從左至右，從下至上進(jìn)行調(diào)整。

3.找到第二個非葉節(jié)點(diǎn) 4，由于[4,9,8]中 9 元素最大，4 和 9 交換。

4.這時，交換導(dǎo)致了子根[4,5,6]結(jié)構(gòu)混亂，繼續(xù)調(diào)整，[4,5,6]中 6 最大，交換 4 和 6。

此時，我們就將一個無序序列構(gòu)造成了一個大頂堆.

• 步驟二 將堆頂元素與末尾元素進(jìn)行交換，使末尾元素最大。然后繼續(xù)調(diào)整堆，再將堆頂元素與末尾元素交換得到第二大元素。如此反復(fù)進(jìn)行交換、重建、交換

1.將堆頂元素 9 和末尾元素 4 進(jìn)行交換

2.重新調(diào)整結(jié)構(gòu)，使其繼續(xù)滿足堆定義

3.再將堆頂元素 8 與末尾元素 5 進(jìn)行交換，得到第二大元素 8

4.后續(xù)過程，繼續(xù)進(jìn)行調(diào)整，交換，如此反復(fù)進(jìn)行，最終使得整個序列有序

動態(tài)演示

?

再簡單總結(jié)下堆排序的基本思路：

1).將無序序列構(gòu)建成一個堆，根據(jù)升序降序需求選擇大根堆或小根堆;

2).將堆頂元素與末尾元素交換，將最大元素"沉"到數(shù)組末端;

3).重新調(diào)整結(jié)構(gòu)，使其滿足堆定義，然后繼續(xù)交換堆頂元素與當(dāng)前末尾元素，反復(fù)執(zhí)行調(diào)整+交換步驟，直到整個序列有序

14.3、堆排序代碼實(shí)現(xiàn)

堆排序的理解還是比較困難的，尤其是代碼實(shí)現(xiàn)過程，下面提供兩種代碼實(shí)現(xiàn)，大家可以選擇適合自己的實(shí)現(xiàn)方法來理解堆排序

代碼實(shí)現(xiàn)（一）

import java.util.Arrays;public class HeapSort {public static void main(String[] args) {//升序--->大頂堆long startTime=System.currentTimeMillis();int arr[] = {5,3,7,1,4,6,2};heapSort(arr);long endTime=System.currentTimeMillis();System.out.println("程序運(yùn)行時間： "+(endTime-startTime)+"ms");}//編寫一個堆排序的方法public static void heapSort(int arr[]) {int temp = 0;//完成我們最終代碼//將無序序列構(gòu)建成一個堆，根據(jù)升序降序需求選擇大頂堆或小頂堆for(int i = arr.length / 2 -1; i >=0; i--) {adjustHeap(arr, i, arr.length);}/** 2).將堆頂元素與末尾元素交換，將最大元素"沉"到數(shù)組末端;3).重新調(diào)整結(jié)構(gòu)，使其滿足堆定義，然后繼續(xù)交換堆頂元素與當(dāng)前末尾元素，反復(fù)執(zhí)行調(diào)整+交換步驟，直到整個序列有序。*/for(int j = arr.length-1;j >0; j--) {//交換temp = arr[j];arr[j] = arr[0];arr[0] = temp;adjustHeap(arr, 0, j);}System.out.println("數(shù)組=" + Arrays.toString(arr));}//將一個數(shù)組(二叉樹), 調(diào)整成一個大頂堆/*** 功能： 完成 將 以 i 對應(yīng)的非葉子結(jié)點(diǎn)的樹調(diào)整成大頂堆* 舉例 int arr[] = {4, 6, 8, 5, 9}; => i = 1 => adjustHeap => 得到 {4, 9, 8, 5, 6}* 如果我們再次調(diào)用 adjustHeap 傳入的是 i = 0 => 得到 {4, 9, 8, 5, 6} => {9,6,8,5, 4}* @param arr 待調(diào)整的數(shù)組* @param i 表示非葉子結(jié)點(diǎn)在數(shù)組中索引* @param length 表示對多少個元素繼續(xù)調(diào)整， length 是在逐漸的減少*/public static void adjustHeap(int arr[], int i, int length) {int temp = arr[i];//先取出當(dāng)前元素的值，保存在臨時變量//開始調(diào)整//說明//1. k = i * 2 + 1 k 是 i結(jié)點(diǎn)的左子結(jié)點(diǎn)for(int k = i * 2 + 1; k < length; k = k * 2 + 1) {if(k+1 < length && arr[k] < arr[k+1]) { //說明左子結(jié)點(diǎn)的值小于右子結(jié)點(diǎn)的值k++; // k 指向右子結(jié)點(diǎn)}if(arr[k] > temp) { //如果子結(jié)點(diǎn)大于父結(jié)點(diǎn)arr[i] = arr[k]; //把較大的值賦給當(dāng)前結(jié)點(diǎn)i = k; //!!! i 指向 k,繼續(xù)循環(huán)比較} else {break;//!}}//當(dāng)for 循環(huán)結(jié)束后，我們已經(jīng)將以i 為父結(jié)點(diǎn)的樹的最大值，放在了 最頂(局部)arr[i] = temp;//將temp值放到調(diào)整后的位置} }

?

結(jié)果：

代碼實(shí)現(xiàn)（二）

?

//交換數(shù)組中的元素public static void swap(int[]num ,int i,int j) {int temp=num[i];num[i]=num[j];num[j]=temp;}//將待排序的數(shù)組構(gòu)建成大根堆public static void buildbigheap(int []num,int end) {//從最后一個非葉子節(jié)點(diǎn)開始構(gòu)建,依照從下往上,從右往左的順序for(int i=end/2;i>=0;i--) {adjustnode(i, end, num);}}//調(diào)整該節(jié)點(diǎn)及其以下的所有節(jié)點(diǎn)public static void adjustnode(int i,int end,int []num) {int left=2*i+1;int right=2*i+2;int big=i;//判斷小分支那個是大元素if(left<end&#[i]<num[left])i=left;if(right<end&#[i]<num[right])i=right;if(i!=big) {//交換順序之后需要繼續(xù)校驗(yàn)swap(num, i, big);//重新校驗(yàn),防止出現(xiàn)交換之后根節(jié)點(diǎn)小于孩子節(jié)點(diǎn)的情況adjustnode(i, end, num);}}public static void main(String[] args) {int []num ={5,3,7,1,4,6,2};long startTime=System.currentTimeMillis(); //第一次構(gòu)建大根堆buildbigheap(num, num.length);for(int j=num.length-1;j>0;j--) {System.out.print("第"+(num.length-j)+"次排序前: ");for(int k=0;k<num.length;k++) {System.out.print(num[k]+" ");}//交換隊(duì)頭已經(jīng)排序得到的最大元素與隊(duì)尾元素swap(num, 0, j);System.out.print("第"+(num.length-j)+"次排序后: ");for(int k=0;k<num.length;k++) {System.out.print(num[k]+" ");}System.out.println();//交換結(jié)束之后,大根堆已經(jīng)被破壞,需要開始重新構(gòu)建大根堆buildbigheap(num,j);}long endTime=System.currentTimeMillis(); System.out.println("程序運(yùn)行時間： "+(endTime-startTime)+"ms"); }

結(jié)果：

15、十大排序算法總結(jié)

15.1、十大排序算法分類

（1）按照是否是比較算法分類

（2）按照算法是否穩(wěn)定分類

如何區(qū)分算法是否穩(wěn)定？

通俗來講就是數(shù)據(jù)相對于原來的相對位置沒有發(fā)生變化

15.2、十大算法的平均時間復(fù)雜度

下面這張圖說明了各個排序算法的時間復(fù)雜度等各項(xiàng)衡量算法的指標(biāo)，希望大家記住！！！

術(shù)語解釋：

1）穩(wěn)定：如果 a 原本在 b 前面，而 a=b，排序之后 a 仍然在 b 的前面；

2) 不穩(wěn)定：如果 a 原本在 b 的前面，而 a=b，排序之后 a 可能會出現(xiàn)在 b 的后面；

3) 內(nèi)排序：所有排序操作都在內(nèi)存中完成；

4) 外排序：由于數(shù)據(jù)太大，因此把數(shù)據(jù)放在磁盤中，而排序通過磁盤和內(nèi)存的數(shù)據(jù)傳輸才能進(jìn)行；

5) 時間復(fù)雜度： 一個算法執(zhí)行所耗費(fèi)的時間。

6) 空間復(fù)雜度：運(yùn)行完一個程序所需內(nèi)存的大小。

7) n: 數(shù)據(jù)規(guī)模

8) k: “桶”的個數(shù)

9) In-place: 不占用額外內(nèi)存

10) Out-place: 占用額外內(nèi)存

到這里關(guān)于十大排序算法的知識到這里就結(jié)束了。

總結(jié)

以上是生活随笔為你收集整理的数据结构与算法【Java】05---排序算法总结的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

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