数据结构排序算法总结

常用的算法有插入排序、冒泡排序、选择排序、快速排序、归并排序、希尔排序、堆排序、计数排序和基数排序。下面对着九种常见排序方法进行总结：

排序方法

时间复杂度

空间复杂度

个人评价

插入排序

 

O(n^2)

 

O(1)

 

 

选择排序

冒泡排序

希尔排序

 

O(n log n)

 

快速排序

O( log n)

 

归并排序

O(n)

 

堆排序

O(1)

 

计数排序

O(n)

O(k)

 

堆排序

O(n)

 

1.插入排序、选择排序和冒泡排序

插入排序：将排序的记录按照大小，插入到前面已经排好序部分的适当位置，直到整个数组有序为止。实现的核心代码为：

for (int i = 1; i < n; i++) {int tmp = arr[i];int j = 0;for (j = i; j > 0 && arr[j - 1] > tmp; j--) {arr[j] = arr[j - 1];}arr[j] = tmp;     }

        选择排序：每次遍历数组都会将最大（或者为最小）的元素，将其放置到数组尾部已排好序部分的前面，尾部排好序的部分不断增大，直到整个数组有序为止。另一种思路是从头部开始构建排好序的数组。实现的核心代码为：

for(int i=0; i<n-1; i++){int min = arr[i];  int position =i;for(int j=i+1;j<n; j++){if(arr[j] <min){min=arr[j];  position = j;}}int tmp = arr[i];arr[i]=min;arr[position]=tmp;}

  冒泡排序：每次遍历数组做的操作是比较i号位置元素与i+1号元素的大小，如果i号为止的元素大于i+1号元素，那么交换两个的位置。这样每次遍历都会将"最大"的元素交换到尾部。经过n次遍历，这个数组就变成有序数组了。关键代码如下：

for (int i = 0; i < n - 1; i++) {for (int j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {int tmp = arr[j];arr[j]=arr[j+1];arr[j+1]=tmp;}}}

2. 希尔排序、快速排序、归并排序和堆排序

希尔排序：排序思想来源于选择排序，选择步长为di的元素为一组，将数组分为di个组，每组进行插入排序。然后步长改为di/2，重复以上操作。当步长为0时结束，此时数组就是有序的了。关键代码如下：

while (feet > 0) {for (int i = feet; i < arr.length; i++) {index = i;while (index >= feet) {if (arr[index - feet] > arr[index]) {swap(arr, index - feet, index);index -= feet;} else {break;}}}feet /= 2;     }

       快速排序：这是一种分治策略，首先选择一个元素a作为左右两部分的分界，大于a的放在数组的右部，小于a的放在数组的左部分，最后将a放在“中间位置”。依照这一思想分别对左部分和右部分做同样的操作。如此分下去，最后会得到一个有序的数组。

   public static void process(int[] arr, int left, int right) {if (left < right) {int random = left + (int) (Math.random() * (right - left + 1));swap(arr, random, right);int mid = partition(arr, left, right);process(arr, left, mid - 1);process(arr, mid + 1, right);}}public static int partition(int[] arr, int left, int right) {int pivot = left - 1;int index = left;while (index <= right) {if (arr[index] <= arr[right]) {swap(arr, ++pivot, index);}index++;}return pivot;}

       

归并排序：将两个或两个以上的有序表合并成一个有序表。初始时，把长度为n的数组看成n个长度为1的有序表，然后将相邻的有序表两两合并，形成长度为2的有序表。重复以上操作，直到只剩下两个有序表，最后合并这两个有序表可得到最终的排序后的数组。关键代码如下：

public static void process(int[] arr, int left, int right) {    if (left == right) {        return;    }    int mid = (left + right) / 2;    process(arr, left, mid);    process(arr, mid + 1, right);    merge(arr, left, mid, right);}public static void merge(int[] arr, int left, int mid, int right) {    int[] help = new int[right - left + 1];    int l = left;    int r = mid + 1;    int index = 0;    while (l <= mid && r <= right) {        if (arr[l] <= arr[r]) {            help[index++] = arr[l++];        } else {            help[index++] = arr[r++];        }    }    while (l <= mid) {        help[index++] = arr[l++];    }    while (r <= right) {        help[index++] = arr[r++];    }    for (int i = 0; i < help.length; i++) {        arr[left + i] = help[i];    }}

        堆排序：数组形式的完全二叉树。针对大根堆，每个节点的父节点的值大于任意一个子节点的值。这样我们就可以得到这个数组的最大值，然后将该最大值放在数组尾部排好序的部分，缩小大根堆的范围，根据这个原理，最后就可以得到一个有序的数组。

public int[] heapSort(int[] A, int n) {for (int i = n / 2; i >= 0; i--) {heapAdjust(A, i, n);}for (int i = n - 1; i > 0; i--) {swap(A, 0, i);  heapAdjust(A, 0, i);}return A;}void heapAdjust(int[] A, int index, int length) {int childLeft = 0;int temp = A[index];for (; index * 2 + 1 < length; index = childLeft) {childLeft = index * 2 + 1;if (childLeft != length - 1 && A[childLeft] < A[childLeft + 1]) {childLeft++;}if (temp > A[childLeft]) {break;} else {A[index] = A[childLeft];index = childLeft;}}A[index] = temp;}

    3.计数排序和基数排序 

计数排序：针对数组arr，得到这个数组的最大值max和最小值min，然后设置一个数组A（长度为max-min+1），A中i处元素代表min+i这个数出现的次数，遍历一遍数组arr后我们就可以填满A。最后只要遍历一遍数组A，就会得到一个排序后的数组了。

int min = arr[0];int max = arr[0];for (int i = 1; i < arr.length; i++) {min = Math.min(arr[i], min);  max = Math.max(arr[i], max);}int[] countArr = new int[max - min + 1];for (int i = 0; i < arr.length; i++) {countArr[arr[i] - min]++;}int index = 0;for (int i = 0; i < countArr.length; i++) {while (countArr[i]-- > 0) {arr[index++] = i + min;}}

基数排序：按照先按照每个数的个位进行排序合并成数组，然后再按照十位进行排序后合并数组，然后百位、千位.....直到得到有序数组。这里也用到了桶排序的概念。

public static void radixSort(int[] arr) {if (arr == null || arr.length < 2)  return;int negNum = 0;for (int i = 0; i < arr.length; i++)  negNum += arr[i] < 0 ? 1 : 0;int[] negArr = new int[negNum];int[] posArr = new int[arr.length - negNum];int negi = 0;  int posi = 0;for (int i = 0; i < arr.length; i++) {if (arr[i] < 0)  negArr[negi++] = -arr[i];else  posArr[posi++] = arr[i];}radixSortForPositive(negArr);radixSortForPositive(posArr);int index = 0;for (int i = negArr.length - 1; i >= 0; i--) arr[index++] = -negArr[i];for (int i = 0; i < posArr.length; i++)  arr[index++] = posArr[i];}

public static void radixSortForPositive(int[] arr) {ArrayList<LinkedList<Integer>> qArr1 = new ArrayList<LinkedList<Integer>>();ArrayList<LinkedList<Integer>> qArr2 = new ArrayList<LinkedList<Integer>>();for (int i = 0; i < 10; i++) {qArr1.add(new LinkedList<Integer>());qArr2.add(new LinkedList<Integer>());}for (int i = 0; i < arr.length; i++) {qArr1.get(arr[i] % 10).offer(arr[i]);}long base = 10;while (base <= Integer.MAX_VALUE) {for (int i = 0; i < 10; i++) {LinkedList<Integer> queue = qArr1.get(i);while (!queue.isEmpty()) {int value = queue.poll();qArr2.get((int) (value / base) % 10).offer(value);}}ArrayList<LinkedList<Integer>> tmp = qArr1;qArr1 = qArr2;qArr2 = tmp;base *= 10;}int index = 0;for (int i = 0; i < 10; i++) {LinkedList<Integer> queue = qArr1.get(i);while (!queue.isEmpty()) {arr[index++] = queue.poll();}}}