数据结构（八）——Java实现七大排序

一、插入排序

1.直接插入排序

    public static void insertSort(int []arr){for (int i = 0; i < arr.length; i++) {int j = i-1;int tmp = arr[i];for (; j >=0 ; j--) {if(arr[j] > tmp){arr[j+1] = arr[j];}else{break;}}arr[j+1] = tmp;}}

直接插入排序特性总结

1. 元素集合越接近有序，直接插入排序算法的时间效率越高。

2. 时间复杂度：O(N^2) 。

3. 空间复杂度：O(1)，它是一种稳定的排序算法。

4. 稳定性：稳定

2.希尔排序

  public static void shell(int[] array,int gap) {for (int i = gap; i < array.length; i++) {int tmp = array[i];int j = i-gap;for (; j >= 0;j-=gap) {if(array[j] > tmp) {array[j+gap] = array[j];}else {break;}}array[j+gap] = tmp;}}public static void shellSort(int[] array) {int gap = array.length;while (gap > 1) {gap /= 2;shell(array,gap);}}

希尔排序特性总结

1.希尔排序是对直接插入排序的优化。
2.当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。

3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定，如果没有特殊说明，我们通常就取

时间复杂度为O(n^1.3)。
时间复杂度：O(n^1.3)

空间复杂度：O(1)

4. 稳定性：不稳定

二、选择排序

1.直接选择排序

 public static void selectSort(int[] array){int i = 0;int minindex = i;for (i = 0; i < array.length; i++) {for (int j = i+1; j <array.length ; j++) {if(array[j] < array[minindex]){//更新minindex的值minindex = j;}}//处理两个下标值一样的情况if (i != minindex){swap(array,minindex,i);}}}public static void swap(int[] array,int i,int j){int tmp = array[i];array[i] = array[j];array[j] =tmp;}

直接选择排序的特性总结

1. 直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用。

2. 时间复杂度：O(N^2) 。

3. 空间复杂度：O(1) 。

4. 稳定性：不稳定

2.堆排序

ps：排升序要建大堆，排降序建小堆。

 public static void heapSort(int[] array) {//堆排序createBigHeap(array);//O(n)int end = array.length-1;while (end > 0) {swap(array,0,end);shiftDown(array,0,end);end--;}}private static void createBigHeap(int[] array) {//创建大根堆for (int parent = (array.length-1-1)/2; parent >= 0 ; parent--) {shiftDown(array,parent,array.length);}}private static void shiftDown(int[] array,int parent,int len) {//向下调整int child = (2 * parent) + 1;while (child < len) {if (child + 1 < len && array[child] < array[child + 1]) {child++;}if (array[child] > array[parent]) {swap(array, child, parent);parent = child;child = 2 * parent + 1;} else {break;}}}

堆排序特性总结

1. 堆排序使用堆来选数，效率就高了很多。

2. 时间复杂度：O(N*logN) 。

3. 空间复杂度：O(1) 。

4. 稳定性：不稳定

三、交换排序

ps：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

1.冒泡排序

冒泡排序基本思想就是相邻元素挨个比较，遇到比自己小的就交换，直到最后元素有序。

    public static void bubbleSort(int[] array) {//最外层控制的是趟数for (int i = 0; i < array.length-1; i++) {boolean flg = false;for (int j = 0; j < array.length-1-i; j++) {if(array[j] > array[j+1]) {swap(array,j,j+1);flg = true;}}if(flg == false) {break;}}}

冒泡排序的特性总结

1. 冒泡排序是一种非常容易理解的排序

2. 时间复杂度：O(N^2)

3. 空间复杂度：O(1)

4. 稳定性：稳定

2.快速排序

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

1、Hoare法

Hoare法的基本思想就是假设我们选array[0]，作为我们的临时节点tmp，定义两个指针变量left和right，先让right从右往左走，找到第一个小于tmp的元素下标，然后left从前往后遍历，找到第一个大于tmp元素的下标，然后交换这两个下标元素的值，当循环结束后，把我们的tmp和left下标交换，那么得到的结果就是tmp左边元素都比tmp小，tmp右边的元素都比tmp大。

private static int partitionHoare(int[] array,int left,int right) {//hoare法int i = left;int pivot = array[left];while (left < right) {//left < right &&  这个条件不能少 预防后面都比基准大while (left < right && array[right] >= pivot) {right--;}//代码走到这里表示right下标的值 小于pivotwhile (left < right && array[left] <= pivot) {left++;}//left下标的值 大于pivotswap(array,left,right);}//交换 和 原来的leftswap(array,left,i);return left;}

2、挖坑法

挖坑法的基本思想就是把第一个元素取出来，形成一个坑位，然后定义两个指针left和right，先让right从右往左走，找到第一个比tmp小的元素，如果找到，那么把这个元素放到tmp的位置，同理，left从前往后遍历，找到比tmp大的元素的下标，然后用这个元素覆盖array[right],循环结束以后，将tmp放在array[left]的位置，最后返回left便是我们的基准！

private static int partition2(int[] array,int left,int right) {//挖坑法,优先使用int pivot = array[left];while (left < right) {//left < right &&  这个条件不能少 预防后面都比基准大while (left < right && array[right] >= pivot) {right--;}array[left] = array[right];//right下标的值 小于pivotwhile (left < right && array[left] <= pivot) {left++;}array[right] = array[left];}//交换 和 原来的leftarray[left] = pivot;return left;}

快速排序总结