参照：https://www.cnblogs.com/wuxinyan/p/8615127.html
https://www.cnblogs.com/onepixel/articles/7674659.html
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1.3代码实现： Python实现：
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实现：
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 }
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：
Python实现：
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实现：
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 }
表现最稳定的排序算法之一，因为无论什么数据进去都是O(n2)的时间复杂度，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
插入排序（Insertion-Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：
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 }
插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。
1959年Shell发明，第一个突破O(n2)的排序算法，是简单插入排序的改进版。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：
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版）》的合著者Robert Sedgewick提出的。
归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
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 }
归并排序是一种稳定的排序方法。和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：
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 }
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
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 }
计数排序不是基于比较的排序算法，其核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
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 }
计数排序是一个稳定的排序算法。当输入的元素是 n 个 0到 k 之间的整数时，时间复杂度是O(n+k)，空间复杂度也是O(n+k)，其排序速度快于任何比较排序算法。当k不是很大并且序列比较集中时，计数排序是一个很有效的排序算法。
桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排）。
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 }
桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。
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 }
基数排序基于分别排序，分别收集，所以是稳定的。但基数排序的性能比桶排序要略差，每一次关键字的桶分配都需要O(n)的时间复杂度，而且分配之后得到新的关键字序列又需要O(n)的时间复杂度。假如待排数据可以分为d个关键字，则基数排序的时间复杂度将是O(d*2n) ，当然d要远远小于n，因此基本上还是线性级别的。
基数排序的空间复杂度为O(n+k)，其中k为桶的数量。一般来说n>>k，因此额外空间需要大概n个左右。
原文：https://www.cnblogs.com/lyq-biu/p/11359070.html