排序

---

一、插入排序

1 直接插入排序-原理

整个区间被分为
	1. 有序区间
	2. 无序区间
每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

2 实现

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;
   }
}

二、希尔排序

1 原理

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比

2 实现

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;
   }
}

三、选择排序

1 直接选择排序-原理

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。

2 实现

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;
   }
}

四、堆排序

1 原理

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。

注意： 排升序要建大堆；排降序要建小堆

2 实现

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 - i - 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;
   }
}

五、冒泡排序

1 原理

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

2 实现

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;
 }
 }
} 

六、快速排序

1 原理

1. 从待排序区间选择一个数，作为基准值(pivot)；
2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可以包含相等的）放到基准值的右边；
3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间的长度 == 0，代表没有数据。

2 实现

public static void quickSort(int[] array) {
 quickSortInternal(array, 0, array.length - 1);
}
// [left, right] 为待排序区间
private static void quickSortInternal(int[] array, int left, int right) {
 if (left == right) {
 return;
 }
 if (left > right) {
 return;
 }
 // 最简单的选择基准值的方式，选择 array[left] 作为基准值
 // pivotIndex 代表基准值最终停留的下标
 int pivotIndex = partition(array, left, right);
 // [left, pivotIndex - 1] 都是小于等于基准值的
 // [pivotIndex + 1, right] 都是大于等于基准值的
 quickSortInternal(array, left, pivotIndex - 1);
 quickSortInternal(array, pivotIndex + 1, right);
}

七、归并排序

1 原理

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

2 实现

private static void merge(int[] array, int low, int mid, int high) {
 int i = low;
 int j = mid;
 int length = high - low;
 int[] extra = new int[length];
 int k = 0;

 // 选择小的放入 extra
 while (i < mid && j < high) {
 // 加入等于，保证稳定性
 if (array[i] <= array[j]) {
 extra[k++] = array[i++];
 } else {
 extra[k++] = array[j++];
 }
 }

 // 将属于元素放入 extra
 while (i < mid) {
 extra[k++] = array[i++];
 }

 while (j < right) {
 extra[k++] = array[j++];
 }
  // 从 extra 搬移回 array
 for (int t = 0; t < length; t++) {
 // 需要搬移回原位置，从 low 开始
 array[low + t] = extra[t];
 }
} 

public static void mergeSort(int[] array) {
 mergeSortInternal(array, 0, array.length);
}
// 待排序区间为 [low, high)
private static void mergeSortInternal(int[] array, int low, int high) {
 if (low - 1 >= high) {
 return;
 }

 int mid = (low + high) / 2;
 mergeSortInternal(array, low, mid);
 mergeSortInternal(array, mid, high);

 merge(array, low, mid, high);
}