十大經典排序算法(Python,Java實現)
參照：http://www.javashuo.com/article/p-ghyjpxue-bt.htmlhtml
https://www.cnblogs.com/onepixel/articles/7674659.htmlgit
一.排序算法分類：
- 比較類排序：經過比較來決定元素間的相對次序，因爲其時間複雜度不能突破O(nlogn)，所以也稱爲非線性時間比較類排序。
- 非比較類排序：不經過比較來決定元素間的相對次序，它能夠突破基於比較排序的時間下界，以線性時間運行，所以也稱爲線性時間非比較類排
二.算法複雜度
注（相關概念）：
- 穩定：若是a本來在b前面，而a=b，排序以後a仍然在b的前面。
- 不穩定：若是a本來在b的前面，而a=b，排序以後 a 可能會出如今 b 的後面。
- 時間複雜度：對排序數據的總的操做次數。反映當n變化時，操做次數呈現什麼規律。
- 空間複雜度：是指算法在計算機內執行時所需存儲空間的度量，它也是數據規模n的函數。
- 內部排序：據記錄在內存中進行排序。（插入排序，希爾排序，冒泡排序等）【歸併排序既能夠實現內部排序，也能夠實現外部排序，如多路歸併排序等】
- 外部排序：通常數據量較大，排序過程當中須要訪問外存。（計數排序，桶排序，基數排序）
三.十大經典排序及實現（Python/Java）
1.冒泡排序（Bubble Sort）：
冒泡排序是一種簡單的排序算法。它重複地走訪過要排序的數列，一次比較兩個元素，若是它們的順序錯誤就把它們交換過來。走訪數列的工做是重複地進行直到沒有再須要交換，也就是說該數列已經排序完成。這個算法的名字由來是由於越小的元素會經由交換慢慢「浮」到數列的頂端。算法
1.1算法描述：
-
-
- 比較相鄰的元素。若是第一個比第二個大，就交換它們兩個；
- 對每一對相鄰元素做一樣的工做，從開始第一對到結尾的最後一對，這樣在最後的元素應該會是最大的數；
- 針對全部的元素重複以上的步驟，除了最後一個；
- 重複步驟1~3，直到排序完成。
-
1.2動圖演示：
1.3代碼實現：
Python實現：shell
1 def bubbleSort(arr): 2 for i in range(0, len(arr)): 3 for j in range(0, len(arr)-i-1): 4 if arr[j] > arr[j+1]: 5 arr[j], arr[j + 1] = arr[j + 1], arr[j] 6 return arr
Java實現：api
1 public static int[] bubbleSort(int[] array) { 2 if (array.length == 0) 3 return array; 4 for (int i = 0; i < array.length; i++) 5 for (int j = 0; j < array.length - 1 - i; j++) 6 if (array[j + 1] < array[j]) { 7 int temp = array[j + 1]; 8 array[j + 1] = array[j]; 9 array[j] = temp; 10 } 11 return array; 12 }
2.選擇排序（Selection Sort）：
選擇排序(Selection-sort)是一種簡單直觀的排序算法。它的工做原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，而後，再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。以此類推，直到全部元素均排序完畢。數組
2.1算法描述：
n個記錄的直接選擇排序可通過n-1趟直接選擇排序獲得有序結果。具體算法描述以下：數據結構
-
-
- 初始狀態：無序區爲R[1..n]，有序區爲空；
- 第i趟排序(i=1,2,3…n-1)開始時，當前有序區和無序區分別爲R[1..i-1]和R(i..n）。該趟排序從當前無序區中-選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R[i+1..n)分別變爲記錄個數增長1個的新有序區和記錄個數減小1個的新無序區；
- n-1趟結束，數組有序化了。
-
2.2動圖演示：
2.3代碼實現：
Python實現：app
1 def selectionSort(arr): 2 for i in range(len(arr) - 1): 3 # 記錄最小數的索引 4 minIndex = i 5 for j in range(i + 1, len(arr)): 6 if arr[j] < arr[minIndex]: 7 minIndex = j 8 # i 不是最小數時，將 i 和最小數進行交換 9 if i != minIndex: 10 arr[i], arr[minIndex] = arr[minIndex], arr[i] 11 return arr
Java實現： less
1 public static int[] selectionSort(int[] array){ 2 if(array.length==0){ 3 return array; 4 } 5 for(int i=0;i<array.length-1;i++){ 6 int minIndex=i; 7 for(int j=i;j<array.length;j++){ 8 if(array[j]<array[minIndex]){ 9 minIndex=j; 10 } 11 } 12 if(i!=minIndex) { 13 int temp = array[i]; 14 array[i]=array[minIndex]; 15 array[minIndex]=temp; 16 } 17 } 18 return array; 19 }
2.4算法分析：
表現最穩定的排序算法之一，由於不管什麼數據進去都是O(n2)的時間複雜度，因此用到它的時候，數據規模越小越好。惟一的好處可能就是不佔用額外的內存空間了吧。理論上講，選擇排序可能也是平時排序通常人想到的最多的排序方法了吧。dom
3.插入排序（Insertion Sort）：
插入排序（Insertion-Sort）的算法描述是一種簡單直觀的排序算法。它的工做原理是經過構建有序序列，對於未排序數據，在已排序序列中從後向前掃描，找到相應位置並插入。
3.1算法描述：
通常來講，插入排序都採用in-place在數組上實現。具體算法描述以下：
-
-
- 從第一個元素開始，該元素能夠認爲已經被排序；
- 取出下一個元素，在已經排序的元素序列中從後向前掃描；
- 若是該元素（已排序）大於新元素，將該元素移到下一位置；
- 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置；
- 將新元素插入到該位置後；
- 重複步驟2~5。
-
3.2動圖演示：
3.3代碼實現：
Python實現：
1 def insertionSort(arr): 2 if len(arr)==0: 3 return arr 4 for i in range(len(arr)-1): 5 preIndex = i 6 current = arr[i+1] 7 while preIndex >= 0 and arr[preIndex] > current: 8 arr[preIndex+1] = arr[preIndex] 9 preIndex-=1 10 arr[preIndex+1] = current 11 return arr
Java實現：
1 public static int[] insertionSort(int[] array) { 2 if (array.length == 0) 3 return array; 4 int current; 5 for (int i = 0; i < array.length - 1; i++) { 6 current = array[i + 1]; 7 int preIndex = i; 8 while (preIndex >= 0 && current < array[preIndex]) { 9 array[preIndex + 1] = array[preIndex]; 10 preIndex--; 11 } 12 array[preIndex + 1] = current; 13 } 14 return array; 15 }
3.4算法分析：
插入排序在實現上，一般採用in-place排序（即只需用到O(1)的額外空間的排序），於是在從後向前掃描過程當中，須要反覆把已排序元素逐步向後挪位，爲最新元素提供插入空間。
4.希爾排序（Shell Sort）：
1959年Shell發明，第一個突破O(n2)的排序算法，是簡單插入排序的改進版。它與插入排序的不一樣之處在於，它會優先比較距離較遠的元素。希爾排序又叫縮小增量排序。
4.1算法描述：
先將整個待排序的記錄序列分割成爲若干子序列分別進行直接插入排序，具體算法描述：
-
-
- 選擇一個增量序列t1，t2，…，tk，其中ti>tj，tk=1；
- 按增量序列個數k，對序列進行k 趟排序；
- 每趟排序，根據對應的增量ti，將待排序列分割成若干長度爲m 的子序列，分別對各子表進行直接插入排序。僅增量因子爲1 時，整個序列做爲一個表來處理，表長度即爲整個序列的長度。
-
4.2動圖演示：
4.3代碼實現：
Python實現：
1 def shellSort(arr): 2 import math 3 gap=1 4 while(gap < len(arr)/3): 5 gap = gap*3+1 6 while gap > 0: 7 for i in range(gap,len(arr)): 8 temp = arr[i] 9 j = i-gap 10 while j >=0 and arr[j] > temp: 11 arr[j+gap]=arr[j] 12 j-=gap 13 arr[j+gap] = temp 14 gap = math.floor(gap/3) 15 return arr
Java實現：
1 public static int[] ShellSort(int[] array) { 2 int len = array.length; 3 int temp, gap = len / 2; 4 while (gap > 0) { 5 for (int i = gap; i < len; i++) { 6 temp = array[i]; 7 int preIndex = i - gap; 8 while (preIndex >= 0 && array[preIndex] > temp) { 9 array[preIndex + gap] = array[preIndex]; 10 preIndex -= gap; 11 } 12 array[preIndex + gap] = temp; 13 } 14 gap /= 2; 15 } 16 return array; 17 }
4.4算法分析：
希爾排序的核心在於間隔序列的設定。既能夠提早設定好間隔序列，也能夠動態的定義間隔序列。動態定義間隔序列的算法是《算法（第4版）》的合著者Robert Sedgewick提出的。
5.歸併排序（Merge Sort）：
歸併排序是創建在歸併操做上的一種有效的排序算法。該算法是採用分治法（Divide and Conquer）的一個很是典型的應用。將已有序的子序列合併，獲得徹底有序的序列；即先使每一個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲2-路歸併。
5.1算法描述：
-
-
- 把長度爲n的輸入序列分紅兩個長度爲n/2的子序列；
- 對這兩個子序列分別採用歸併排序；
- 將兩個排序好的子序列合併成一個最終的排序序列。
-
5.2動圖演示：
5.3代碼實現：
Python實現：
1 def mergeSort(arr): 2 import math 3 if(len(arr)<2): 4 return arr 5 middle = math.floor(len(arr)/2) 6 left, right = arr[0:middle], arr[middle:] 7 return merge(mergeSort(left), mergeSort(right)) 8 9 def merge(left,right): 10 result = [] 11 while left and right: 12 if left[0] <= right[0]: 13 result.append(left.pop(0)); 14 else: 15 result.append(right.pop(0)); 16 while left: 17 result.append(left.pop(0)); 18 while right: 19 result.append(right.pop(0)); 20 return result
Java實現：
1 public static int[] MergeSort(int[] array) { 2 if (array.length < 2) return array; 3 int mid = array.length / 2; 4 int[] left = Arrays.copyOfRange(array, 0, mid); 5 int[] right = Arrays.copyOfRange(array, mid, array.length); 6 return merge(MergeSort(left), MergeSort(right)); 7 } 8 9 public static int[] merge(int[] left, int[] right) { 10 int[] result = new int[left.length + right.length]; 11 for (int index = 0, i = 0, j = 0; index < result.length; index++) { 12 if (i >= left.length) 13 result[index] = right[j++]; 14 else if (j >= right.length) 15 result[index] = left[i++]; 16 else if (left[i] > right[j]) 17 result[index] = right[j++]; 18 else 19 result[index] = left[i++]; 20 } 21 return result; 22 }
5.4算法分析：
歸併排序是一種穩定的排序方法。和選擇排序同樣，歸併排序的性能不受輸入數據的影響，但表現比選擇排序好的多，由於始終都是O(nlogn）的時間複雜度。代價是須要額外的內存空間。
6.快速排序（Quick Sort）：
選擇排序(Selection-sort)是一種簡單直觀的排序算法。它的工做原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，而後，再從剩餘未排序元素中繼續尋找最小（大）元素，而後放到已排序序列的末尾。以此類推，直到全部元素均排序完畢。
6.1算法描述：
快速排序使用分治法來把一個串（list）分爲兩個子串（sub-lists）。具體算法描述以下：
-
-
- 從數列中挑出一個元素，稱爲 「基準」（pivot）；
- 從新排序數列，全部元素比基準值小的擺放在基準前面，全部元素比基準值大的擺在基準的後面（相同的數能夠到任一邊）。在這個分區退出以後，該基準就處於數列的中間位置。這個稱爲分區（partition）操做；
- 遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。
-
6.2動圖演示：
6.3代碼實現：
Python實現：
1 def quicksort(arr): 2 if len(arr)<2: 3 return arr 4 5 pivot_index=0 6 pivot=arr[pivot_index] 7 less_pivot=[i for i in arr[pivot_index+1:] if i <=pivot] 8 great_pivot=[i for i in arr[pivot_index+1:] if i > pivot] 9 return quicksort(less_pivot)+[pivot]+quicksort(great_pivot)
1 def quickSort(arr, left=None, right=None): 2 left = 0 if not isinstance(left,(int, float)) else left 3 right = len(arr)-1 if not isinstance(right,(int, float)) else right 4 if left < right: 5 partitionIndex = partition(arr, left, right) 6 quickSort(arr, left, partitionIndex-1) 7 quickSort(arr, partitionIndex+1, right) 8 return arr 9 10 def partition(arr, left, right): 11 pivot = left 12 index = pivot+1 13 i = index 14 while i <= right: 15 if arr[i] < arr[pivot]: 16 swap(arr, i, index) 17 index+=1 18 i+=1 19 swap(arr,pivot,index-1) 20 return index-1 21 22 def swap(arr, i, j): 23 arr[i], arr[j] = arr[j], arr[i]
Java實現：
1 public static int[] QuickSort(int[] array, int start, int end) { 2 if (array.length < 1 || start < 0 || end >= array.length || start > end) return null; 3 int smallIndex = partition(array, start, end); 4 if (smallIndex > start) 5 QuickSort(array, start, smallIndex - 1); 6 if (smallIndex < end) 7 QuickSort(array, smallIndex + 1, end); 8 return array; 9 } 10 /** 11 * 快速排序算法——partition 12 * @param array 13 * @param start 14 * @param end 15 * @return 16 */ 17 public static int partition(int[] array, int start, int end) { 18 int pivot = (int) (start + Math.random() * (end - start + 1)); 19 int smallIndex = start - 1; 20 swap(array, pivot, end); 21 for (int i = start; i <= end; i++) 22 if (array[i] <= array[end]) { 23 smallIndex++; 24 if (i > smallIndex) 25 swap(array, i, smallIndex); 26 } 27 return smallIndex; 28 } 29 30 /** 31 * 交換數組內兩個元素 32 * @param array 33 * @param i 34 * @param j 35 */ 36 public static void swap(int[] array, int i, int j) { 37 int temp = array[i]; 38 array[i] = array[j]; 39 array[j] = temp; 40 }
7.堆排序（Heap Sort）：
堆排序（Heapsort）是指利用堆這種數據結構所設計的一種排序算法。堆積是一個近似徹底二叉樹的結構，並同時知足堆積的性質：即子結點的鍵值或索引老是小於（或者大於）它的父節點。
7.1算法描述：
-
-
- 將初始待排序關鍵字序列(R1,R2….Rn)構建成大頂堆，此堆爲初始的無序區；
- 將堆頂元素R[1]與最後一個元素R[n]交換，此時獲得新的無序區(R1,R2,……Rn-1)和新的有序區(Rn),且知足R[1,2…n-1]<=R[n]；
- 因爲交換後新的堆頂R[1]可能違反堆的性質，所以須要對當前無序區(R1,R2,……Rn-1)調整爲新堆，而後再次將R[1]與無序區最後一個元素交換，獲得新的無序區(R1,R2….Rn-2)和新的有序區(Rn-1,Rn)。不斷重複此過程直到有序區的元素個數爲n-1，則整個排序過程完成。
-
7.2動圖演示：
7.3代碼實現：
Python實現：
1 def buildMaxHeap(arr): 2 import math 3 for i in range(math.floor(len(arr)/2),-1,-1): 4 heapify(arr,i) 5 6 def heapify(arr, i): 7 left = 2*i+1 8 right = 2*i+2 9 largest = i 10 if left < arrLen and arr[left] > arr[largest]: 11 largest = left 12 if right < arrLen and arr[right] > arr[largest]: 13 largest = right 14 15 if largest != i: 16 swap(arr, i, largest) 17 heapify(arr, largest) 18 19 def swap(arr, i, j): 20 arr[i], arr[j] = arr[j], arr[i] 21 22 def heapSort(arr): 23 global arrLen 24 arrLen = len(arr) 25 buildMaxHeap(arr) 26 for i in range(len(arr)-1,0,-1): 27 swap(arr,0,i) 28 arrLen -=1 29 heapify(arr, 0) 30 return arr
Java實現：
1 //聲明全局變量，用於記錄數組array的長度； 2 static int len; 3 /** 4 * 堆排序算法 5 * 6 * @param array 7 * @return 8 */ 9 public static int[] HeapSort(int[] array) { 10 len = array.length; 11 if (len < 1) return array; 12 //1.構建一個最大堆 13 buildMaxHeap(array); 14 //2.循環將堆首位（最大值）與末位交換，而後在從新調整最大堆 15 while (len > 0) { 16 swap(array, 0, len - 1); 17 len--; 18 adjustHeap(array, 0); 19 } 20 return array; 21 } 22 /** 23 * 創建最大堆 24 * 25 * @param array 26 */ 27 public static void buildMaxHeap(int[] array) { 28 //從最後一個非葉子節點開始向上構造最大堆 29 for (int i = (len/2 - 1); i >= 0; i--) { //感謝 @讓我發會呆 網友的提醒，此處應該爲 i = (len/2 - 1) 30 adjustHeap(array, i); 31 } 32 } 33 /** 34 * 調整使之成爲最大堆 35 * 36 * @param array 37 * @param i 38 */ 39 public static void adjustHeap(int[] array, int i) { 40 int maxIndex = i; 41 //若是有左子樹，且左子樹大於父節點，則將最大指針指向左子樹 42 if (i * 2 < len && array[i * 2] > array[maxIndex]) 43 maxIndex = i * 2; 44 //若是有右子樹，且右子樹大於父節點，則將最大指針指向右子樹 45 if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex]) 46 maxIndex = i * 2 + 1; 47 //若是父節點不是最大值，則將父節點與最大值交換，而且遞歸調整與父節點交換的位置。 48 if (maxIndex != i) { 49 swap(array, maxIndex, i); 50 adjustHeap(array, maxIndex); 51 } 52 }
8.計數排序（Counting Sort）：
計數排序不是基於比較的排序算法，其核心在於將輸入的數據值轉化爲鍵存儲在額外開闢的數組空間中。 做爲一種線性時間複雜度的排序，計數排序要求輸入的數據必須是有肯定範圍的整數。
8.1算法描述：
-
-
- 找出待排序的數組中最大和最小的元素；
- 統計數組中每一個值爲i的元素出現的次數，存入數組C的第i項；
- 對全部的計數累加（從C中的第一個元素開始，每一項和前一項相加）；
- 反向填充目標數組：將每一個元素i放在新數組的第C(i)項，每放一個元素就將C(i)減去1。
-
8.2動圖演示：
8.3代碼實現：
Python實現：
1 def countingSort(arr, maxValue): 2 bucketLen = maxValue+1 3 bucket = [0]*bucketLen 4 sortedIndex =0 5 arrLen = len(arr) 6 for i in range(arrLen): 7 if not bucket[arr[i]]: 8 bucket[arr[i]]=0 9 bucket[arr[i]]+=1 10 for j in range(bucketLen): 11 while bucket[j]>0: 12 arr[sortedIndex] = j 13 sortedIndex+=1 14 bucket[j]-=1 15 return arr
Java實現：
1 /** 2 * 計數排序 3 * 4 * @param array 5 * @return 6 */ 7 public static int[] CountingSort(int[] array) { 8 if (array.length == 0) return array; 9 int bias, min = array[0], max = array[0]; 10 for (int i = 1; i < array.length; i++) { 11 if (array[i] > max) 12 max = array[i]; 13 if (array[i] < min) 14 min = array[i]; 15 } 16 bias = 0 - min; 17 int[] bucket = new int[max - min + 1]; 18 Arrays.fill(bucket, 0); 19 for (int i = 0; i < array.length; i++) { 20 bucket[array[i] + bias]++; 21 } 22 int index = 0, i = 0; 23 while (index < array.length) { 24 if (bucket[i] != 0) { 25 array[index] = i - bias; 26 bucket[i]--; 27 index++; 28 } else 29 i++; 30 } 31 return array; 32 }
8.4算法分析：
計數排序是一個穩定的排序算法。當輸入的元素是 n 個 0到 k 之間的整數時，時間複雜度是O(n+k)，空間複雜度也是O(n+k)，其排序速度快於任何比較排序算法。當k不是很大而且序列比較集中時，計數排序是一個頗有效的排序算法。
9.桶排序（Bucket Sort）：
桶排序是計數排序的升級版。它利用了函數的映射關係，高效與否的關鍵就在於這個映射函數的肯定。桶排序 (Bucket sort)的工做的原理：假設輸入數據服從均勻分佈，將數據分到有限數量的桶裏，每一個桶再分別排序（有可能再使用別的排序算法或是以遞歸方式繼續使用桶排序進行排）。
9.1算法描述：
-
-
- 設置一個定量的數組看成空桶；
- 遍歷輸入數據，而且把數據一個一個放到對應的桶裏去；
- 對每一個不是空的桶進行排序；
- 從不是空的桶裏把排好序的數據拼接起來。
-
9.2動圖演示：
9.3代碼實現：
Python實現：
1 def bucketSort(arr,bucketSize): 2 if(arr==None or len(arr)<2): 3 return arr 4 max_num=max(arr) 5 min_num=min(arr) 6 #獲取桶個數 7 bucketCount=(max_num-min_num)//bucketSize+1 8 #初始化桶（有幾個就初始化幾個） 9 bucketArr=[[] for i in range(bucketCount)] 10 #初始化結果 11 resultArr=[] 12 for i in range(len(arr)): 13 bucketArr[(arr[i]-min_num)//bucketSize].append(arr[i]) 14 for i in range(bucketCount): 15 if(bucketSize==1): 16 for j in range(len(bucketArr[i])): 17 resultArr.append(bucketArr[i][j]) 18 else: 19 if(bucketCount==1): 20 bucketSize-=1 21 temp=bucketSort(bucketArr[i],bucketSize) 22 for j in range(len(temp)): 23 resultArr.append(temp[j]) 24 return resultArr
Java實現：
1 /** 2 * 桶排序 3 * 4 * @param array 5 * @param bucketSize 6 * @return 7 */ 8 public static ArrayList<Integer> BucketSort(ArrayList<Integer> array, int bucketSize) { 9 if (array == null || array.size() < 2) 10 return array; 11 int max = array.get(0), min = array.get(0); 12 // 找到最大值最小值 13 for (int i = 0; i < array.size(); i++) { 14 if (array.get(i) > max) 15 max = array.get(i); 16 if (array.get(i) < min) 17 min = array.get(i); 18 } 19 int bucketCount = (max - min) / bucketSize + 1; 20 ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount); 21 ArrayList<Integer> resultArr = new ArrayList<>(); 22 for (int i = 0; i < bucketCount; i++) { 23 bucketArr.add(new ArrayList<Integer>()); 24 } 25 for (int i = 0; i < array.size(); i++) { 26 bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i)); 27 } 28 for (int i = 0; i < bucketCount; i++) { 29 if (bucketSize == 1) { // 若是帶排序數組中有重複數字時 30 for (int j = 0; j < bucketArr.get(i).size(); j++) 31 resultArr.add(bucketArr.get(i).get(j)); 32 } else { 33 if (bucketCount == 1) 34 bucketSize--; 35 ArrayList<Integer> temp = BucketSort(bucketArr.get(i), bucketSize); 36 for (int j = 0; j < temp.size(); j++) 37 resultArr.add(temp.get(j)); 38 } 39 } 40 return resultArr; 41 }
9.4算法分析：
桶排序最好狀況下使用線性時間O(n)，桶排序的時間複雜度，取決與對各個桶之間數據進行排序的時間複雜度，由於其它部分的時間複雜度都爲O(n)。很顯然，桶劃分的越小，各個桶之間的數據越少，排序所用的時間也會越少。但相應的空間消耗就會增大。
10.基數排序（Radix Sort）：
基數排序是按照低位先排序，而後收集；再按照高位排序，而後再收集；依次類推，直到最高位。有時候有些屬性是有優先級順序的，先按低優先級排序，再按高優先級排序。最後的次序就是高優先級高的在前，高優先級相同的低優先級高的在前。
10.1算法描述：
-
-
- 取得數組中的最大數，並取得位數；
- arr爲原始數組，從最低位開始取每一個位組成radix數組；
- 對radix進行計數排序（利用計數排序適用於小範圍數的特色）
-
10.2動圖演示：
10.3代碼實現：
Python實現：
1 def radixSort(arr): 2 if (arr==None or len(arr)<2): 3 return arr 4 max_num=max(arr) 5 maxDigit=0 6 while max_num>0: 7 max_num//=10 8 maxDigit+=1 9 mod=10 10 div=1 11 bucketList=[[] for i in range(10)] 12 for i in range(maxDigit): 13 for j in range(len(arr)): 14 num=(arr[j]%mod)//div 15 bucketList[num].append(arr[j]) 16 index=0 17 for j in range(len(bucketList)): 18 for k in range(len(bucketList[j])): 19 arr[index]=bucketList[j][k] 20 index+=1 21 bucketList[j].clear() 22 mod *= 10 23 div *= 10 24 return arr
Java實現：
1 /** 2 * 基數排序 3 * @param array 4 * @return 5 */ 6 public static int[] RadixSort(int[] array) { 7 if (array == null || array.length < 2) 8 return array; 9 // 1.先算出最大數的位數； 10 int max = array[0]; 11 for (int i = 1; i < array.length; i++) { 12 max = Math.max(max, array[i]); 13 } 14 int maxDigit = 0; 15 while (max != 0) { 16 max /= 10; 17 maxDigit++; 18 } 19 int mod = 10, div = 1; 20 ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>(); 21 for (int i = 0; i < 10; i++) 22 bucketList.add(new ArrayList<Integer>()); 23 for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) { 24 for (int j = 0; j < array.length; j++) { 25 int num = (array[j] % mod) / div; 26 bucketList.get(num).add(array[j]); 27 } 28 int index = 0; 29 for (int j = 0; j < bucketList.size(); j++) { 30 for (int k = 0; k < bucketList.get(j).size(); k++) 31 array[index++] = bucketList.get(j).get(k); 32 bucketList.get(j).clear(); 33 } 34 } 35 return array; 36 }
10.4算法分析：
基數排序基於分別排序，分別收集，因此是穩定的。但基數排序的性能比桶排序要略差，每一次關鍵字的桶分配都須要O(n)的時間複雜度，並且分配以後獲得新的關鍵字序列又須要O(n)的時間複雜度。假如待排數據能夠分爲d個關鍵字，則基數排序的時間複雜度將是O(d*2n) ，固然d要遠遠小於n，所以基本上仍是線性級別的。
基數排序的空間複雜度爲O(n+k)，其中k爲桶的數量。通常來講n>>k，所以額外空間須要大概n個左右。
相關文章
- 1. python 十大經典排序算法
- 2. Python實現十大經典排序 I
- 3. 十大經典排序算法之冒泡排序--JavaScript 實現
- 4. 用JavaScript實現十大經典排序算法--快速排序
- 5. 十大經典排序算法（python實現）（原創）
- 6. Python實現十大經典排序算法
- 7. 十大經典排序算法的python實現
- 8. Python實現十大經典排序算法（史上最簡單）。
- 9. 十大經典排序算法（Java實現）
- 10. 十大經典排序算法總結（Java實現+動畫）
- 更多相關文章...
- • ADO 排序 - ADO 教程
- • PHP 數組排序 - PHP教程
- • 算法總結-歸併排序
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
歡迎關注本站公眾號,獲取更多信息
