概述
最近在温习数据结构，现在针对排序算法写一篇随笔，其中附带原理说明和代码。
插入排序
直接插入排序(Straight Insertion Sort)的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表。开始时有序表中只包含1个元素，无序表中包含有n-1个元素，排序过程中每次 从无序表中取出第一个元素，将它插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。
假设{20,30,40,10,60,50}中的前3个数已经排列过，是有序的了；接下来对10进行排列。示意图如下：
图中将数列分为有序区和无序区。我们需要做的工作只有两个：(1)取出无序区中的第1个数，并找出它在有序区对应的位置。(2)将无序区的数据插入到有序区；若有必要的话，则对有序区中的相关数据进行移位。
时间复杂度和稳定性
直接插入排序的时间复杂度是O(N2)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？N-1！因此，直接插入排序的时间复杂度是O(N*N)。
直接插入排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的。
插入排序JAVA实现
1 import static javaTest.SortUtils.less; 2 3 /** 4 * ClassName InsertionSort.java 5 * author Rhett.wang 6 * version 1.0.0 7 * Description TODO 8 * createTime 2020年01月16日 16:00:00 9 */ 10 public class InsertionSort implements SortAlgorithm{ 11 public static void main(String[] args) { 12 Integer[] a= {22,14,35,45,67}; 13 InsertionSort sort =new InsertionSort(); 14 sort.sort(a); 15 16 } 17 /** 18 * Main method arrays sorting algorithms 19 * 20 * @param array - an array should be sorted 21 * @return a sorted array 22 */ 23 @Override 24 public <T extends Comparable<T>> T[] sort(T[] array) { 25 for (int j = 1; j < array.length; j++) { 26 27 // Picking up the key(Card) 28 T key = array[j]; 29 int i = j - 1; 30 31 while (i >= 0 && less(key, array[i])) { 32 array[i + 1] = array[i]; 33 i--; 34 } 35 // Placing the key (Card) at its correct position in the sorted subarray 36 array[i + 1] = key; 37 } 38 return array; 39 } 40 41 }
实现基类接口
1 import java.util.Arrays; 2 import java.util.List; 3 4 import static javafx.scene.input.KeyCode.T; 5 6 /** 7 * ClassName SortAlgorithm.java 8 * author Rhett.wang 9 * version 1.0.0 10 * Description TODO 11 * createTime 2020年01月16日 14:29:00 12 */ 13 public interface SortAlgorithm { 14 /** 15 * Main method arrays sorting algorithms 16 * 17 * @param unsorted - an array should be sorted 18 * @return a sorted array 19 */ 20 <T extends Comparable<T>> T[] sort(T[] unsorted); 21 22 23 /** 24 * Auxiliary method for algorithms what wanted to work with lists from JCF 25 * 26 * @param unsorted - a list should be sorted 27 * @return a sorted list 28 */ 29 default <T extends Comparable<T>> List<T> sort(List<T> unsorted){ 30 return Arrays.asList(sort(unsorted.toArray((T[]) new Comparable[unsorted.size()]))); 31 } 32 }
插入排序SCALA实现
1 /** 2 * ClassName InsertionSort.java 3 * author Rhett.wang 4 * version 1.0.0 5 * Description TODO 6 * createTime 2020年01月18日 11:25:00 7 */ 8 object InsertionSort { 9 def main(args: Array[String]) { 10 11 } 12 13 def sort(nums: Array[Int]): Array[Int] = { 14 for (j <- 0 until nums.length -1) { 15 var temp = nums(j) 16 var i = j - 1 17 while (i >= 0 && temp < nums(i)) { 18 nums(i + 1) = nums(i) 19 i-=1 20 } 21 nums(i + 1) = temp 22 } 23 nums 24 } 25 26 }
插入排序PYTHON实现
1 def insert_sort(collection): 2 """Pure implementation of the insertion sort algorithm in Python 3 :param collection: some mutable ordered collection with heterogeneous 4 comparable items inside 5 :return: the same collection ordered by ascending 6 Examples: 7 >>> insertion_sort([0, 5, 3, 2, 2]) 8 [0, 2, 2, 3, 5] 9 >>> insertion_sort([]) 10 [] 11 >>> insertion_sort([-2, -5, -45]) 12 [-45, -5, -2] 13 """ 14 for loop_index in range(1,len(collection)): 15 insertion_index=loop_index 16 while( 17 insertion_index>0 18 and collection[insertion_index -1] > collection[insertion_index-1] 19 ): 20 collection[insertion_index],collection[insertion_index -1] =( 21 collection[insertion_index -1], 22 collection[insertion_index], 23 ) 24 insertion_index -=1 25 return collection 26 27 if __name__=="__main__": 28 user_input= input("Enter numbers separated by a comma:\n").strip() 29 unsorted=[int(item) for item in user_input.split(",")] 30 print(insert_sort(unsorted))
希尔排序
希尔(Shell)排序又称为缩小增量排序，它是一种插入排序。它是直接插入排序算法的一种威力加强版。该方法因DL．Shell于1959年提出而得名，
把记录按步长 gap 分组，对每组记录采用直接插入排序方法进行排序。
随着步长逐渐减小，所分成的组包含的记录越来越多，当步长的值减小到 1 时，整个数据合成为一组，构成一组有序记录，则完成排序。
我们来通过演示图，更深入的理解一下这个过程。
在上面这幅图中：
初始时，有一个大小为 10 的无序序列。
在第一趟排序中，我们不妨设 gap1 = N / 2 = 5，即相隔距离为 5 的元素组成一组，可以分为 5 组。接下来，按照直接插入排序的方法对每个组进行排序。
在第二趟排序中，我们把上次的 gap 缩小一半，即 gap2 = gap1 / 2 = 2 (取整数)。这样每相隔距离为 2 的元素组成一组，可以分为 2 组。按照直接插入排序的方法对每个组进行排序。
在第三趟排序中，再次把 gap 缩小一半，即gap3 = gap2 / 2 = 1。 这样相隔距离为 1 的元素组成一组，即只有一组。按照直接插入排序的方法对每个组进行排序。此时，排序已经结束。
需要注意一下的是，图中有两个相等数值的元素 5 和 5 。我们可以清楚的看到，在排序过程中，两个元素位置交换了。
所以，希尔排序是不稳定的算法。
算法分析
算法性能
时间复杂度
步长的选择是希尔排序的重要部分。只要最终步长为1任何步长序列都可以工作。
算法最开始以一定的步长进行排序。然后会继续以一定步长进行排序，最终算法以步长为1进行排序。当步长为1时，算法变为插入排序，这就保证了数据一定会被排序。
Donald Shell 最初建议步长选择为N/2并且对步长取半直到步长达到1。虽然这样取可以比O(N2)类的算法（插入排序）更好，但这样仍然有减少平均时间和最差时间的余地。
可能希尔排序最重要的地方在于当用较小步长排序后，以前用的较大步长仍然是有序的。比如，如果一个数列以步长5进行了排序然后再以步长3进行排序，那么该数列不仅是以步长3有序，而且是以步长5有序。如果不是这样，那么算法在迭代过程中会打乱以前的顺序，那就
不会以如此短的时间完成排序了。
算法稳定性：由上文的希尔排序算法演示图即可知，希尔排序中相等数据可能会交换位置，所以希尔排序是不稳定的算法。
插入排序和希尔排序比较：
直接插入排序是稳定的；而希尔排序是不稳定的。
直接插入排序更适合于原始记录基本有序的集合。
希尔排序的比较次数和移动次数都要比直接插入排序少，当N越大时，效果越明显。
在希尔排序中，增量序列gap的取法必须满足：最后一个步长必须是 1 。
直接插入排序也适用于链式存储结构；希尔排序不适用于链式结构。
希尔排序JAVA实现
1 import java.util.Arrays; 2 3 import static javaTest.SortUtils.less; 4 5 /** 6 * ClassName ShellSort.java 7 * author Rhett.wang 8 * version 1.0.0 9 * Description TODO 10 * createTime 2020年01月18日 12:21:00 11 */ 12 public class ShellSort implements SortAlgorithm { 13 14 /** 15 * This method implements Generic Shell Sort. 16 * 17 * @param array the array to be sorted 18 */ 19 @Override 20 public <T extends Comparable<T>> T[] sort(T[] array) { 21 int gap = array.length / 2; 22 23 while (1 <= gap) { 24 // 把距离为 gap 的元素编为一个组，扫描所有组 25 for (int i = gap; i < array.length; i++) { 26 int j = 0; 27 T temp = array[i]; 28 29 // 对距离为 gap 的元素组进行排序 30 for (j = i - gap; j >= 0 &&less(temp,array[j]); j = j - gap) { 31 array[j + gap] = array[j]; 32 } 33 array[j + gap] = temp; 34 } 35 36 System.out.format("gap = %d:\t", gap); 37 printAll(array); 38 gap = gap / 2; // 减小增量 39 } 40 return array; 41 } 42 43 // 打印完整序列 44 public <T extends Comparable<T>> void printAll(T[] list) { 45 for (T value : list) { 46 System.out.print(value + "\t"); 47 } 48 System.out.println(); 49 } 50 51 /* Driver Code */ 52 public static void main(String[] args) { 53 Integer[] toSort = {4, 23, 6, 78, 1, 54, 231, 9, 12}; 54 55 ShellSort sort = new ShellSort(); 56 System.out.println(Arrays.toString(sort.sort(toSort))); 57 } 58 }
希尔排序SCALA实现
1 package scala 2 3 /** 4 * ClassName ShellSort.java 5 * author Rhett.wang 6 * version 1.0.0 7 * Description TODO 8 * createTime 2020年01月18日 13:25:00 9 */ 10 object ShellSort { 11 def main(args: Array[String]) { 12 var nums: Array[Int] = Array(2, 3, 8, 5, 4) 13 sort(nums) 14 nums.foreach(x => println(x)) 15 } 16 17 def sort(nums: Array[Int]): Array[Int] = { 18 var gap = nums.length / 2 19 while (1 <= gap) { 20 for (i <- gap until nums.length) { 21 var j = i 22 while (j >= 0 && nums(j-gap) > nums(j)) { 23 var temp = nums(j-gap)+nums(j) 24 nums(j - gap) =temp- nums(j-gap) 25 nums(j)=temp- nums(j-gap) 26 j=j-gap 27 } 28 } 29 gap = gap / 2 30 } 31 nums 32 } 33 }
希尔排序PYTHON实现
1 def shell_sort(collection): 2 gap = len(collection) // 2 3 while (1 <= gap): 4 for i in range(gap, len(collection)): 5 j = i 6 while (j >= 0 and collection[j - gap] > collection[j]): 7 tmp = collection[j - gap] + collection[j] 8 collection[j - gap] = tmp - collection[j - gap] 9 collection[j] = tmp - collection[j - gap] 10 j = j- gap 11 gap = gap // 2 12 return collection 13 if __name__=="__main__": 14 15 print(shell_sort([2, 3, 8, 5, 4, 9]))
简单选择排序
选择排序(Selection sort)是一种简单直观的排序算法。
它的基本思想是：首先在未排序的数列中找到最小(or最大)元素，然后将其存放到数列的起始位置；接着，再从剩余未排序的元素中继续寻找最小(or最大)元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
下面以数列{20,40,30,10,60,50}为例，演示它的选择排序过程(如下图)：
第1趟：i=0。找出a[1...5]中的最小值a[3]=10，然后将a[0]和a[3]互换。 数列变化：20,40,30,10,60,50 -- > 10,40,30,20,60,50
第2趟：i=1。找出a[2...5]中的最小值a[3]=20，然后将a[1]和a[3]互换。 数列变化：10,40,30,20,60,50 -- > 10,20,30,40,60,50
第3趟：i=2。找出a[3...5]中的最小值，由于该最小值大于a[2]，该趟不做任何处理。
第4趟：i=3。找出a[4...5]中的最小值，由于该最小值大于a[3]，该趟不做任何处理。
第5趟：i=4。交换a[4]和a[5]的数据。 数列变化：10,20,30,40,60,50 -- > 10,20,30,40,50,60。
时间复杂度和稳定性
选择排序的时间复杂度是O(N2)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？N-1！因此，选择排序的时间复杂度是O(N2)。
选择排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
选择排序JAVA实现
1 import java.util.Arrays; 2 3 import static javaTest.SortUtils.less; 4 import static javaTest.SortUtils.swap; 5 6 /** 7 * ClassName SelectionSort.java 8 * author Rhett.wang 9 * version 1.0.0 10 * Description TODO 11 * createTime 2020年01月18日 17:10:00 12 */ 13 public class SelectionSort implements SortAlgorithm { 14 public static void main(String[] args) { 15 Integer[] arr = {4, 23, 6, 78, 1, 54, 231, 9, 12}; 16 SelectionSort sort = new SelectionSort(); 17 System.out.println(Arrays.toString(sort.sort(arr))); 18 } 19 /** 20 * Main method arrays sorting algorithms 21 * 22 * @param unsorted - an array should be sorted 23 * @return a sorted array 24 */ 25 @Override 26 public <T extends Comparable<T>> T[] sort(T[] unsorted) { 27 int n=unsorted.length; 28 for(int i=0;i<n-1;i++){ 29 int min =i; 30 for(int j=i+1;j<n;j++){ 31 if(less(unsorted[j],unsorted[i])){ 32 min=j; 33 } 34 } 35 if(min != i){ 36 swap(unsorted,i,min); 37 } 38 } 39 return unsorted; 40 } 41 }
工具类SortUtils
1 /** 2 * ClassName SortUtils.java 3 * author Rhett.wang 4 * version 1.0.0 5 * Description TODO 6 * createTime 2020年01月16日 17:49:00 7 */ 8 import java.util.Arrays; 9 import java.util.List; 10 11 /** 12 * The class contains util methods 13 * 14 * @author Podshivalov Nikita (https://github.com/nikitap492) 15 **/ 16 final class SortUtils { 17 18 /** 19 * Helper method for swapping places in array 20 * 21 * @param array The array which elements we want to swap 22 * @param idx index of the first element 23 * @param idy index of the second element 24 */ 25 static <T> boolean swap(T[] array, int idx, int idy) { 26 T swap = array[idx]; 27 array[idx] = array[idy]; 28 array[idy] = swap; 29 return true; 30 } 31 32 33 /** 34 * This method checks if first element is less then the other element 35 * 36 * @param v first element 37 * @param w second element 38 * @return true if the first element is less then the second element 39 */ 40 static <T extends Comparable<T>> boolean less(T v, T w) { 41 return v.compareTo(w) < 0; 42 } 43 44 45 /** 46 * Just print list 47 * 48 * @param toPrint - a list which should be printed 49 */ 50 static void print(List<?> toPrint) { 51 toPrint.stream() 52 .map(Object::toString) 53 .map(str -> str + " ") 54 .forEach(System.out::print); 55 56 System.out.println(); 57 } 58 59 60 /** 61 * Prints an array 62 * 63 * @param toPrint - the array which should be printed 64 */ 65 static void print(Object[] toPrint) { 66 System.out.println(Arrays.toString(toPrint)); 67 } 68 69 70 /** 71 * Swaps all position from {@param left} to @{@param right} for {@param array} 72 * 73 * @param array is an array 74 * @param left is a left flip border of the array 75 * @param right is a right flip border of the array 76 */ 77 static <T extends Comparable<T>> void flip(T[] array, int left, int right) { 78 while (left <= right) { 79 swap(array, left++, right--); 80 } 81 } 82 }
选择排序SCALA实现
1 /** 2 * ClassName SelectionSort.java 3 * author Rhett.wang 4 * version 1.0.0 5 * Description TODO 6 * createTime 2020年01月18日 19:28:00 7 */ 8 object SelectionSort { 9 def main(args: Array[String]) { 10 var nums: Array[Int] = Array(2, 3, 8, 5, 4, 9) 11 sort(nums) 12 nums.foreach(x=>print(x)) 13 14 } 15 def sort(nums:Array[Int]):Array[Int]={ 16 for(i <- 0 until nums.length){ 17 var min:Int=i 18 var minVal=nums(i) 19 for(j <- i+1 to nums.length-1){ 20 if(nums(j) < minVal){ 21 min = j 22 minVal=nums(j) 23 } 24 } 25 val temp :Int=nums(i) 26 nums(i)=nums(min) 27 nums(min)=temp 28 } 29 nums 30 } 31 32 }
选择排序PYTHON实现
1 def selection_sort(arr): 2 for i in range(1, len(arr)): 3 key = arr[i] 4 j = i - 1 5 while j >= 0 and key < arr[j]: 6 arr[j + 1] = arr[j] 7 j -= 1 8 arr[j + 1] = key 9 return arr 10 if __name__=="__main__": 11 12 print(selection_sort([2, 3, 8, 5, 4, 9, 2, 1]))
冒泡排序
冒泡排序(Bubble Sort)，又被称为气泡排序或泡沫排序。
它是一种较简单的排序算法。它会遍历若干 次要排序的数列，每次遍历时，它都会从前往后依次的比较相邻两个数的大小；如果前者比后者大，则交换它们的位置。这样，一次遍历之后，最大的元素就在数列 的末尾！ 采用相同的方法再次遍历时，第二大的元素就被排列在最大元素之前。重复此操作，直到整个数列都有序为止！
下面以数列{20,40,30,10,60,50}为例，演示它的冒泡排序过程(如下图)
当i=5,j=0时，a[0]<a[1]。此时，不做任何处理！
当i=5,j=1时，a[1]>a[2]。此时，交换a[1]和a[2]的值；交换之后，a[1]=30，a[2]=40。
当i=5,j=2时，a[2]>a[3]。此时，交换a[2]和a[3]的值；交换之后，a[2]=10，a[3]=40。
当i=5,j=3时，a[3]<a[4]。此时，不做任何处理！
当i=5,j=4时，a[4]>a[5]。此时，交换a[4]和a[5]的值；交换之后，a[4]=50，a[3]=60。
于是，第1趟排序完之后，数列{20,40,30,10,60,50}变成了{20,30,10,40,50,60}。此时，数列末尾的值最大。
时间复杂度和稳定性
冒泡排序的时间复杂度是O(N2)。
假设被排序的数列中有N个数。遍历一趟的时间复杂度是O(N)，需要遍历多少次呢？N-1次！因此，冒泡排序的时间复杂度是O(N2)。
冒泡排序是稳定的算法，它满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
冒泡排序JAVA实现
1 import java.util.Arrays; 2 3 import static javaTest.SortUtils.less; 4 import static javaTest.SortUtils.swap; 5 6 /** 7 * ClassName BubbleSort.java 8 * author Rhett.wang 9 * version 1.0.0 10 * Description TODO 11 * createTime 2020年01月18日 20:06:00 12 */ 13 class BubbleSort implements SortAlgorithm { 14 /** 15 * This method implements the Generic Bubble Sort 16 * 17 * @param array The array to be sorted 18 * Sorts the array in increasing order 19 **/ 20 21 @Override 22 public <T extends Comparable<T>> T[] sort(T[] array) { 23 for (int i = 0, size = array.length; i < size - 1; ++i) { 24 boolean swapped = false; 25 for (int j = 0; j < size - 1 - i; ++j) { 26 if (less(array[j], array[j + 1])) { 27 swap(array, j, j + 1); 28 swapped = true; 29 } 30 } 31 if (!swapped) { 32 break; 33 } 34 } 35 return array; 36 } 37 38 // Driver Program 39 public static void main(String[] args) { 40 41 // Integer Input 42 Integer[] integers = {4, 23, 6, 78, 1, 54, 231, 9, 12}; 43 BubbleSort bubbleSort = new BubbleSort(); 44 bubbleSort.sort(integers); 45 46 // Output => 231, 78, 54, 23, 12, 9, 6, 4, 1 47 System.out.println(Arrays.toString(integers)); 48 49 50 // String Input 51 String[] strings = {"c", "a", "e", "b", "d"}; 52 //Output => e, d, c, b, a 53 System.out.println(Arrays.toString(strings)); 54 } 55 }
冒泡排序SCALA实现
1 import util.control.Breaks._ 2 /** 3 * ClassName BubbleSort.java 4 * author Rhett.wang 5 * version 1.0.0 6 * Description TODO 7 * createTime 2020年01月18日 20:23:00 8 */ 9 object BubbleSort { 10 def main(args: Array[String]) { 11 var nums: Array[Int] = Array(2, 3, 8, 5, 4, 9) 12 bubbleSort(nums) 13 nums.foreach(x=>print(x)) 14 } 15 16 def bubbleSort(array: Array[Int]) : Array[Int] = { 17 breakable { 18 for (i <- 0 to array.length - 1) { 19 var swap = false 20 21 for (j <- 0 to array.length - 2) { 22 if (array(j) > array(j + 1)) { 23 val temp = array(j) 24 array(j) = array(j + 1) 25 array(j + 1) = temp 26 swap = true 27 } 28 } 29 30 if (!swap) { 31 break 32 } 33 } 34 } 35 array 36 } 37 }
冒泡排序PYTHON实现
1 def bubble_sort(collection): 2 length = len(collection) 3 for i in range(length - 1): 4 swapped = False 5 for j in range(length - 1 - i): 6 if collection[j] > collection[j + 1]: 7 swapped = True 8 collection[j], collection[j + 1] = collection[j + 1], collection[j] 9 if not swapped: 10 break # Stop iteration if the collection is sorted. 11 return collection 12 if __name__=="__main__": 13 14 print(bubble_sort([2, 3, 8, 5, 4, 9, 2, 1]))
快速排序
快速排序(Quick Sort)使用分治法策略。
它的基本思想是：选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分；其中一部分的所有数据都比另外一部分的所有数据都要小。然后，再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
排序流程：
从数列中挑出一个基准值。
将所有比基准值小的摆放在基准前面，所有比基准值大的摆在基准的后面(相同的数可以到任一边)；在这个分区退出之后，该基准就处于数列的中间位置。
递归地把"基准值前面的子数列"和"基准值后面的子数列"进行排序
下面以数列a={30,40,60,10,20,50}为例，演示它的快速排序过程(如下图)：
上图只是给出了第1趟快速排序的流程。在第1趟中，设置x=a[i]，即x=30。
从"右 --> 左"查找小于x的数：找到满足条件的数a[j]=20，此时j=4；然后将a[j]赋值a[i]，此时i=0；接着从左往右遍历。
从"左 --> 右"查找大于x的数：找到满足条件的数a[i]=40，此时i=1；然后将a[i]赋值a[j]，此时j=4；接着从右往左遍历。
从"右 --> 左"查找小于x的数：找到满足条件的数a[j]=10，此时j=3；然后将a[j]赋值a[i]，此时i=1；接着从左往右遍历。
从"左 --> 右"查找大于x的数：找到满足条件的数a[i]=60，此时i=2；然后将a[i]赋值a[j]，此时j=3；接着从右往左遍历。
从"右 --> 左"查找小于x的数：没有找到满足条件的数。当i>=j时，停止查找；然后将x赋值给a[i]。此趟遍历结束！
按照同样的方法，对子数列进行递归遍历。最后得到有序数组。
快速排序的时间复杂度和稳定性
快速排序稳定性
快速排序是不稳定的算法，它不满足稳定算法的定义。
算法稳定性 -- 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
快速排序时间复杂度
快速排序的时间复杂度在最坏情况下是O(N2)，平均的时间复杂度是O(N*lgN)。
这句话很好理解：假设被排序的数列中有N个数。遍历一次的时间复杂度是O(N)，需要遍历多少次呢？至少lg(N+1)次，最多N次。
(01) 为什么最少是lg(N+1)次？快速排序是采用的分治法进行遍历的，我们将它看作一棵二叉树，它需要遍历的次数就是二叉树的深度，而根据完全二叉树的定义，它的深度至少是lg(N+1)。因此，快速排序的遍历次数最少是lg(N+1)次。
(02) 为什么最多是N次？这个应该非常简单，还是将快速排序看作一棵二叉树，它的深度最大是N。因此，快读排序的遍历次数最多是N次。
快速排序JAVA实现
1 import static Sorts.SortUtils.*; 2 3 /** 4 * @author Varun Upadhyay (https://github.com/varunu28) 5 * @author Podshivalov Nikita (https://github.com/nikitap492) 6 * @see SortAlgorithm 7 */ 8 class QuickSort implements SortAlgorithm { 9 10 /** 11 * This method implements the Generic Quick Sort 12 * 13 * @param array The array to be sorted 14 * Sorts the array in increasing order 15 **/ 16 17 @Override 18 public <T extends Comparable<T>> T[] sort(T[] array) { 19 doSort(array, 0, array.length - 1); 20 return array; 21 } 22 23 24 /** 25 * The sorting process 26 * 27 * @param left The first index of an array 28 * @param right The last index of an array 29 * @param array The array to be sorted 30 **/ 31 32 private static <T extends Comparable<T>> void doSort(T[] array, int left, int right) { 33 if (left < right) { 34 int pivot = randomPartition(array, left, right); 35 doSort(array, left, pivot - 1); 36 doSort(array, pivot, right); 37 } 38 } 39 40 /** 41 * Ramdomize the array to avoid the basically ordered sequences 42 * 43 * @param array The array to be sorted 44 * @param left The first index of an array 45 * @param right The last index of an array 46 * @return the partition index of the array 47 */ 48 49 private static <T extends Comparable<T>> int randomPartition(T[] array, int left, int right) { 50 int randomIndex = left + (int)(Math.random()*(right - left + 1)); 51 swap(array, randomIndex, right); 52 return partition(array, left, right); 53 } 54 55 /** 56 * This method finds the partition index for an array 57 * 58 * @param array The array to be sorted 59 * @param left The first index of an array 60 * @param right The last index of an array 61 * Finds the partition index of an array 62 **/ 63 64 private static <T extends Comparable<T>> int partition(T[] array, int left, int right) { 65 int mid = (left + right) / 2; 66 T pivot = array[mid]; 67 68 while (left <= right) { 69 while (less(array[left], pivot)) { 70 ++left; 71 } 72 while (less(pivot, array[right])) { 73 --right; 74 } 75 if (left <= right) { 76 swap(array, left, right); 77 ++left; 78 --right; 79 } 80 } 81 return left; 82 } 83 84 // Driver Program 85 public static void main(String[] args) { 86 87 // For integer input 88 Integer[] array = {3, 4, 1, 32, 0, 1, 5, 12, 2, 5, 7, 8, 9, 2, 44, 111, 5}; 89 90 QuickSort quickSort = new QuickSort(); 91 quickSort.sort(array); 92 93 //Output => 0 1 1 2 2 3 4 5 5 5 7 8 9 12 32 44 111 94 print(array); 95 96 String[] stringArray = {"c", "a", "e", "b", "d"}; 97 quickSort.sort(stringArray); 98 99 //Output => a b c d e 100 print(stringArray); 101 } 102 }
快速排序SCALA实现
1 object QuickSort { 2 /** 3 * 4 * @param array - a sequence of unsorted integers 5 * @return - sequence of sorted integers @array 6 */ 7 8 def quickSort(array: Array[Int]): Array[Int] = { 9 10 def quickSortImpl(array: Array[Int], first: Int, last: Int): Array[Int] = { 11 var pivot: Int = 0 12 var i: Int = 0 13 var j: Int = 0 14 var temp: Int = 0 15 16 if (first < last) { 17 pivot = first 18 i = first 19 j = last 20 21 while (i < j) { 22 while (array(i) <= array(pivot) && i < last) { 23 i += 1 24 } 25 26 while (array(j) > array(pivot)) { 27 j -= 1 28 } 29 30 if (i < j) { 31 temp = array(i) 32 array(i) = array(j) 33 array(j) = temp 34 } 35 } 36 37 temp = array(pivot) 38 array(pivot) = array(j) 39 array(j) = temp 40 quickSortImpl(array, first, j - 1) 41 quickSortImpl(array, j + 1, last) 42 } 43 44 array 45 } 46 47 quickSortImpl(array,0, array.length-1) 48 } 49 }
快速排序PYTHON实现
1 def quick_sort_3partition(sorting, left, right): 2 if right <= left: 3 return 4 a = i = left 5 b = right 6 pivot = sorting[left] 7 while i <= b: 8 if sorting[i] < pivot: 9 sorting[a], sorting[i] = sorting[i], sorting[a] 10 a += 1 11 i += 1 12 elif sorting[i] > pivot: 13 sorting[b], sorting[i] = sorting[i], sorting[b] 14 b -= 1 15 else: 16 i += 1 17 quick_sort_3partition(sorting, left, a - 1) 18 quick_sort_3partition(sorting, b + 1, right) 19 20 21 if __name__ == "__main__": 22 user_input = input("Enter numbers separated by a comma:\n").strip() 23 unsorted = [int(item) for item in user_input.split(",")] 24 quick_sort_3partition(unsorted, 0, len(unsorted) - 1) 25 print(unsorted)
归并排序
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分 治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶 段得到的各答案"修补"在一起，即分而治之)。
可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。
合并相邻有序子序列
再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。
归并排序JAVA实现
1 import static Sorts.SortUtils.print; 2 3 /** 4 * This method implements the Generic Merge Sort 5 * 6 * @author Varun Upadhyay (https://github.com/varunu28) 7 * @author Podshivalov Nikita (https://github.com/nikitap492) 8 * @see SortAlgorithm 9 */ 10 11 class MergeSort implements SortAlgorithm { 12 13 /** 14 * This method implements the Generic Merge Sort 15 * 16 * @param unsorted the array which should be sorted 17 * @param <T> Comparable class 18 * @return sorted array 19 */ 20 @Override 21 @SuppressWarnings("unchecked") 22 public <T extends Comparable<T>> T[] sort(T[] unsorted) { 23 doSort(unsorted, 0, unsorted.length - 1); 24 return unsorted; 25 } 26 27 /** 28 * @param arr The array to be sorted 29 * @param left The first index of the array 30 * @param right The last index of the array 31 * Recursively sorts the array in increasing order 32 **/ 33 private static <T extends Comparable<T>> void doSort(T[] arr, int left, int right) { 34 if (left < right) { 35 int mid = left + (right - left) / 2; 36 doSort(arr, left, mid); 37 doSort(arr, mid + 1, right); 38 merge(arr, left, mid, right); 39 } 40 41 } 42 43 /** 44 * This method implements the merge step of the merge sort 45 * 46 * @param arr The array to be sorted 47 * @param left The first index of the array 48 * @param mid The middle index of the array 49 * @param right The last index of the array 50 * merges two parts of an array in increasing order 51 **/ 52 53 private static <T extends Comparable<T>> void merge(T[] arr, int left, int mid, int right) { 54 int length = right - left + 1; 55 T[] temp = (T[]) new Comparable[length]; 56 int i = left; 57 int j = mid + 1; 58 int k = 0; 59 60 while (i <= mid && j <= right) { 61 if (arr[i].compareTo(arr[j]) <= 0) { 62 temp[k++] = arr[i++]; 63 } else { 64 temp[k++] = arr[j++]; 65 } 66 } 67 68 while (i <= mid) { 69 temp[k++] = arr[i++]; 70 } 71 72 while (j <= right) { 73 temp[k++] = arr[j++]; 74 } 75 76 System.arraycopy(temp, 0, arr, left, length); 77 } 78 79 // Driver program 80 public static void main(String[] args) { 81 82 // Integer Input 83 Integer[] arr = {4, 23, 6, 78, 1, 54, 231, 9, 12}; 84 MergeSort mergeSort = new MergeSort(); 85 mergeSort.sort(arr); 86 87 // Output => 1 4 6 9 12 23 54 78 231 88 print(arr); 89 90 // String Inpu 91 String[] stringArray = {"c", "a", "e", "b", "d"}; 92 mergeSort.sort(stringArray); 93 //Output => a b c d e 94 print(stringArray); 95 } 96 }
归并排序SCALA实现
1 object MergeSort { 2 3 /** 4 * 5 * @param array - a sequence of unsorted integers 6 * @return - sequence of sorted integers @array 7 */ 8 9 def mergeSort(array: Array[Int]): Array[Int] = { 10 11 def sort(array: Array[Int]): Array[Int] = { 12 MS(array, 0, array.length - 1) 13 } 14 15 def MS(array: Array[Int], low: Int, high: Int): Array[Int] = { 16 if (low < high) { 17 val mid = (low + high) / 2 18 MS(array, low, mid) 19 MS(array, mid + 1, high) 20 merge(array, low, mid, high) 21 } else { 22 array 23 } 24 } 25 26 def merge(array: Array[Int], low: Int, mid: Int, high: Int): Array[Int] = { 27 // copy subarrays 28 val left = array.slice(low, mid + 1) 29 val right = array.slice(mid + 1, high + 1) 30 31 var i = 0 32 var j = 0 33 var k = low 34 while (k < high + 1) { 35 // must check if empty to avoid exceptions 36 if (i > left.length - 1) { 37 array(k) = right(j) 38 j = j + 1 39 } else if (j > right.length - 1) { 40 array(k) = left(i) 41 i = i + 1 42 } else if (left(i) <= right(j)) { 43 array(k) = left(i) 44 i = i + 1 45 } else { 46 array(k) = right(j) 47 j = j + 1 48 } 49 k = k + 1 50 } 51 52 array 53 54 } 55 56 sort(array) 57 } 58 59 }
归并排序PYTHON实现
1 def merge_sort(collection): 2 """Pure implementation of the merge sort algorithm in Python 3 :param collection: some mutable ordered collection with heterogeneous 4 comparable items inside 5 :return: the same collection ordered by ascending 6 Examples: 7 >>> merge_sort([0, 5, 3, 2, 2]) 8 [0, 2, 2, 3, 5] 9 >>> merge_sort([]) 10 [] 11 >>> merge_sort([-2, -5, -45]) 12 [-45, -5, -2] 13 """ 14 15 def merge(left, right): 16 """merge left and right 17 :param left: left collection 18 :param right: right collection 19 :return: merge result 20 """ 21 result = [] 22 while left and right: 23 result.append((left if left[0] <= right[0] else right).pop(0)) 24 return result + left + right 25 26 if len(collection) <= 1: 27 return collection 28 mid = len(collection) // 2 29 return merge(merge_sort(collection[:mid]), merge_sort(collection[mid:])) 30 31 32 if __name__ == "__main__": 33 user_input = input("Enter numbers separated by a comma:\n").strip() 34 unsorted = [int(item) for item in user_input.split(",")] 35 print(*merge_sort(unsorted), sep=",")
总结
感谢网络大神的分享：
https://github.com/TheAlgorithms/
https://mp.weixin.qq.com/s?__biz=MzAxNjk4ODE4OQ==&mid=2247487903&idx=3&sn=f482041f5b560ca85db9ad51c33f07f3&chksm=9bed30edac9ab9fbb523b1ce15e545d126e2b6a651951f8ea672d5f6d05809b9ae8f99d81411&mpshare=1&scene=1&srcid=0113MrSScIDzFwL6luR7bevY&sharer_sharetime=1579050754003&sharer_shareid=d40e8d2bb00008844e69867bcfc0d895#rd