排序-JAVA

排序
排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
常见排序算法：插入排序（直接插入排序、希尔排序）
选择排序（选择排序、堆排序）
交换排序（冒泡排序、）
归并排序（归并排序）
直接插入排序【插入排序，初始数据越接近有序，时间效率越高。】
整个区间被分为 有序区间和无序区间每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入。

public static void insertSort(int[] array) { 
    for (int i = 1; i < array.length; i++) { 
    // 有序区间: [0, i) 
    // 无序区间: [i, array.length) int v = array[i]; 
    // 无序区间的第一个数 int j = i - 1;
    // 不写 array[j] == v 是保证排序的稳定性 
    for (; j >= 0 && array[j] > v; j--) {
         array[j + 1] = array[j];
          } 
          array[j + 1] = v; 
    }
 }

时间复杂度：最好【O（n）】;最坏【O(n^2) 】平均【O(n^2) 】
空间复杂度：O（1）；
稳定性：稳定
插入排序，初始数据越接近有序，时间效率越高。
希尔排序（基于插入排序的优化）
希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所 有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1 时，所有记录在统一组内排好序。

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

public static void shellSort(int[] array) {
    int gap = array.length;
    while (gap > 1) {
        insertSortGap(array, gap);
        gap = (gap / 3) + 1; // OR gap = gap / 2;
    }
    insertSortGap(array, 1);
}
//直接插入排序
private static void insertSortGap(int[] array, int gap) {
    for (int i = 1; i < array.length; i++) {
        int v = array[i];
        int j = i - gap;
            for (; j >= 0 && array[j] > v; j -= gap) {
                array[j + gap] = array[j];
            }
        array[j + gap] = v;
    }
}

时间复杂度：最好O(n) 平均O(n^1.3) 最坏O(n^2)
空间复杂度： O(1)
稳定性：不稳定
选择排序
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元 素排完 。

public static void selectSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
    // 无序区间: [0, array.length - i)
    // 有序区间: [array.length - i, array.length)
    int max = 0;
        for (int j = 1; j < array.length - i; j++) {
        if (array[j] > array[max]) {
            max = j;
        }
     }
    int t = array[max];
    array[max] = array[array.length - i - 1];
    array[array.length - i - 1] = t;
    }
}

时间复杂度 O(n^2)
空间复杂度 O(1)
稳定性：不稳定
堆排序
基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的 数。
注意： 排升序要建大堆；排降序要建小堆。

public static void heapSort(int[] array) {
    createHeap(array);
    for (int i = 0; i < array.length - 1; i++) {
    // 交换前
    // 无序区间: [0, array.length - i)
    // 有序区间: [array.length - i, array.length)
    swap(array, 0, array.length - 1);
    // 交换后
    // 无序区间: [0, array.length - i - 1)
    // 有序区间: [array.length - i - 1, array.length)
    // 无序区间长度: array.length - i - 1
    shiftDown(array, array.length - i - 1, 0);
    }
}
private void swap(int[] array, int i, int j) {
    int t = array[i];
    array[i] = array[j];
    array[j] = t;
}
private void createHeap(int[] array) {
    for (int i = (array.length - 1) / 2; i >= 0; i--) {
        shiftDown(array, array.length, i);
    }
}
public static void shiftDown(int[] array, int size, int index) {
    int left = 2 * index + 1;
    while (left < size) {
        int max = left;
        int right = 2 * index + 2;
        if (right < size) {
            if (array[right] > array[left]) {
            max = right;
            }
        }
        if (array[index] >= array[max]) {
            break;
        }
    int t = array[index];
    array[index] = array[max];
    array[max] = t;
    index = max;
    left = 2 * index + 1;
    }
}

时间复杂度O(n * log(n))
空间复杂度 O(1)
稳定性：不稳定
冒泡排序
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

public static void bubbleSort(int[] array) {
    for (int i = 0; i < array.length - 1; i++) {
            boolean isSorted = true;
                    for (int j = 0; j < array.length - i - 1; j++) {            // 相等不交换，保证稳定性           
                     if (array[j] > array[j + 1]) {    
                            swap(array, j, j + 1);
                             isSorted = false;         
                                }       
                                 } 
                  if (isSorted) {
                              break;       
                     }    
        } 
}

时间复杂度：最好O(n) 平均 O(n^2) 最坏 O(n^2)
空间复杂度：O(1)
稳定性：稳定