八大排序算法详解

时间复杂度与空间复杂度对比：

1、冒泡排序（Bubble Sort）

冒泡排序 是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述

• 步骤1: 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 步骤2: 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 步骤3: 针对所有的元素重复以上的步骤，除了最后一个；
• 步骤4: 重复步骤1~3，直到排序完成。

1.2 代码展示

    public int[] BubbleSort(int[] arr){
        if(arr==null||arr.length==0)
            return arr;
        for(int i=0;i<arr.length;i++){
            for(int j=0;j<arr.length-1-i;j++){
                if(arr[j+1]>arr[j]){
                    int tmp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=tmp;
                }
            }
        }
        return arr;
    }

1.3 算法分析

平均时间复杂度：T(n)=O(n^2)
最好时间复杂度：T(n)=O(n)
最坏时间复杂度：T(n)=O(n^2)

2、选择排序（Selection Sort）

选择排序 是表现最稳定的排序算法之一 ，因为无论什么数据进去都是O(n2)的时间复杂度 ，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

选择排序(Selection-sort) 是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.1 算法描述
n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

• 步骤1：初始状态：无序区为R[1…n]，有序区为空；
• 步骤2：第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个的新无序区；
• 步骤3：n-1趟结束，数组有序化了。

2.2 代码展示

    public static int[] SelectionSort(int[] arr){
        if(arr==null||arr.length==0)
            return arr;
        for(int i=0;i<arr.length;i++){
            int minIndex=i;
            for(int j=i;j<arr.length;j++){
                if(arr[minIndex]>arr[j])
                    minIndex=j;
            }
            int tmp=arr[minIndex];
            arr[minIndex]=arr[i];
            arr[i]=tmp;
        }
        return arr;
    }

2.3 算法分析

平均时间复杂度：T(n)=O(n^2)
最好时间复杂度：T(n)=O(n^2)
最坏时间复杂度：T(n)=O(n^2)

3、插入排序（Insertion Sort）

插入排序（Insertion-Sort） 的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

3.1 算法描述
一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

• 步骤1: 从第一个元素开始，该元素可以认为已经被排序；
• 步骤2: 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 步骤3: 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 步骤4: 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 步骤5: 将新元素插入到该位置后；
• 步骤6: 重复步骤2~5。

3.2 代码展示

public static int[] InsectionSort(int[] arr){
        if(arr==null||arr.length==0)
            return arr;
        for(int i=0;i<arr.length-1;i++){
            int current=arr[i+1];
            int preindex=i;
            while (preindex>=0&&current<arr[preindex]){
                arr[preindex+1]=arr[preindex];
                preindex--;
            }
            arr[preindex+1]=current;
        }
        return arr;
    }

3.3 算法分析

平均时间复杂度：T(n)=O(n^2)
最好时间复杂度：T(n)=O(n)
最坏时间复杂度：T(n)=O(n^2)

4、希尔排序（Shell Sort）

希尔排序是希尔（Donald Shell） 于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

4.1 算法描述

• 步骤1：选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
• 步骤2：按增量序列个数k，对序列进行k 趟排序；
• 步骤3：每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1
  时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.2 代码展示

    public static int[] ShellSort(int[] array) {
        int len = array.length;
        int temp, gap = len / 2;
        while (gap > 0) {
            for (int i = gap; i < len; i++) {
                temp = array[i];
                int preIndex = i - gap;
                while (preIndex >= 0 && array[preIndex] > temp) {
                    array[preIndex + gap] = array[preIndex];
                    preIndex -= gap;
                }
                array[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        return array;
 }

4.3 算法分析

最好情况：T(n) = O(nlog2 n)
最坏情况：T(n) = O(nlog2 n)
平均情况：T(n) =O(nlog2n)

5、归并排序（Merge Sort）

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。
归并排序 是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

5.1 算法描述

• 步骤1：把长度为n的输入序列分成两个长度为n/2的子序列；
• 步骤2：对这两个子序列分别采用归并排序；
• 步骤3：将两个排序好的子序列合并成一个最终的排序序列。

5.2 代码展示

 public static int[] MergeSort(int[] arr){
        if(arr.length<2)
            return arr;
        int mid=arr.length/2;
        int[] left= Arrays.copyOfRange(arr,0,mid);
        int[] right=Arrays.copyOfRange(arr,mid,arr.length);
        return merge(MergeSort(left),MergeSort(right));
    }

    private static int[] merge(int[] left, int[] right) {
        int[] res=new int[left.length+right.length];
        for(int index=0,i=0,j=0;index<res.length;index++){
            if(i>=left.length)
                res[index]=right[j++];
            else if(j>=right.length)
                res[index]=left[i++];
            else if(left[i]>right[j])
                res[index]=right[j++];
            else
                res[index]=left[i++];
        }
        return res;
    }

5.3 算法分析

平均时间复杂度：T(n)=O(nlogn)
最好时间复杂度：T(n)=O(n)
最坏时间复杂度：T(n)=O(nlogn)

6、快速排序（Quick Sort）

快速排序 的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

6.1 算法描述
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 步骤1：从数列中挑出一个元素，称为 “基准”（pivot ）；
• 步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

6.2 代码展示

public static void quickSort(int[] arr, int low, int high) {
		int i, j, base;
		if (low > high) {
			return;
		}
		i = low;
		j = high;
		// base就是基准位
		base = arr[low];

		while (i < j) {
			// 先看右边，依次往左递减
			while (base <= arr[j] && i < j) {
				j--;
			}
			// 再看左边，依次往右递增
			while (base >= arr[i] && i < j) {
				i++;
			}
			// 如果满足条件则交换
			if (i < j) {
				int temp=arr[i];
				arr[i]=arr[j];
				arr[j]=temp;
			}
		}

		// 最后将基准为与i和j相等位置的数字交换
		arr[low] = arr[i];
		arr[i] = base;

		// 递归调用左半数组
		quickSort(arr, low, j - 1);
		// 递归调用右半数组
		quickSort(arr, j + 1, high);
	}

6.3 算法分析

平均时间复杂度：T(n)=O(nlogn)
最好时间复杂度：T(n)=O(nlogn)
最坏时间复杂度：T(n)=O(n^2)

7、堆排序（Heap Sort）

堆排序（Heapsort） 是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

7.1 算法描述

• 步骤1：将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
• 步骤2：将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
• 步骤3：由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

7.2 代码展示

	public static void heapSort(int[] array) {
		if (array.length == 0)
			return;

		// 建堆，从最后一个非叶子节点开始，而最后一个非叶子节点的下标为array.length/2-1
		int length = array.length;
		for (int i = length / 2 - 1; i >= 0; i--)
			heapify(array, length, i);

		for (int i = length - 1; i >= 0; i--) {
			int temp = array[0];
			array[0] = array[i];
			array[i] = temp;
			heapify(array, i, 0);
		}
	}

	static void heapify(int[] array, int length, int i) {
		int left = 2 * i + 1, right = 2 * i + 2;
		int largest = i;

		if (left < length && array[left] > array[largest]) {
			largest = left;
		}
		if (right < length && array[right] > array[largest]) {
			largest = right;
		}

		if (largest != i) {
			int temp = array[i];
			array[i] = array[largest];
			array[largest] = temp;
			heapify(array, length, largest);
		}
	}

平均时间复杂度：T(n)=O(nlogn)
最好时间复杂度：T(n)=O(nlogn)
最坏时间复杂度：T(n)=O(nlogn)