堆排序，归并排序

堆排序

1.介绍：对简单的选择排序的一种改进，改进效果非常明显，每次在选择最小记录的同时，并根据比较结果对其他记录做出相应的调整，那么排序效率就会提高很多。

定义：将待排序的序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将它移走（其实就是将其与堆数组的末尾元素进行交换，此时末尾元素就是最大值），然后将剩余的n-1个元素序列从新构造成一个堆，这样就会得到n个元素中的次大值。如此反复进行，就能得到一个有序序列。

public static void heapSort(int[] arr) {
    int i;
    //构建一个大顶堆
    for (i = (arr.length - 1) / 2; i >= 0; i--) {
        heapAdjust(arr, i, arr.length);
    }

    for (i = arr.length -1; i > 1; i--) {
        //将堆顶记录和未经排序的最后一个记录交换
        MyClass.swap(arr, 0, i);
        //从新调整为大顶堆,从第一个元素开始
        heapAdjust(arr, 0, i - 1);
    }

}

/**
 * 构造大顶堆
 *
 * @param arr
 * @param i 
 * @param length 数组的长度
 */

private static void heapAdjust(int[] arr, int i, int length) {
    int temp = arr[i];
    // +1 ，是因为数组从0下标开始，可以画图推导一下
    for (int j = 2 * i + 1; j < length ; j = j * 2 + 1) {
        //取出当前节点的左右节点的最大值
        if (j < length -1 && arr[j] < arr[j+1]) {
            ++j; //代表左右子节点最大值的下标
        }

        if (temp >= arr[j]) {
            break;
        }

        arr[i] = arr[j];

        i = j;//此时从新循环新的节点（刚跟i交换数据的那个节点后面的左，右节点）
    }

    //将原先堆顶的元素放到最后的位置，也就是j的位置。
    arr[i] = temp;
}

归并排序

1.介绍：将初始序列两两进行排序，然后在两两归并，如此重复，得到一个长度为n的有序序列为止。

public static void mergeSort(int[] arr) {
    int[] temp = new int[arr.length]; //临时数组
    sort(arr, temp, 0, arr.length - 1);
}

private static void sort(int[] arr, int[] temp, int left, int right) {

    if (left >= right) return;
    int center = (left + right) / 2;
    sort(arr, temp, left, center);
    sort(arr, temp, center + 1, right);
    merge(arr, temp, left, center, right);
}

/**
 * 将两个数组进行归并
 *
 * @param arr
 * @param left
 * @param center
 * @param right
 */
private static void merge(int[] arr, int[] temp, int left, int center, int right) {
//        int[] temp = new int[arr.length];
    int mid = center + 1;
    int p = left;
    int start = left;
    while (left <= center && mid <= right) {
        if (arr[left] <= arr[mid]) {
            temp[p++] = arr[left++];
        } else {
            temp[p++] = arr[mid++];
        }
    }

    //左边剩余数据依次放入临时数组中
    while (left <= center) {
        temp[p++] = arr[left++];
    }

    while (mid <= right) {
        temp[p++] = arr[mid++];
    }
    //复制数组

    while (start <= right) {
        arr[start] = temp[start++];
    }
}

快速排序

介绍：选取一个中间值，第一次排序，将比这个中间值大的所有数据放入后面，比它小的所有数据放入前面，再依次从该数后面和前面的数组中依次排序。

public static void quickSort(int[] arr) {
    sort(arr, 0, arr.length - 1);
}

private static void sort(int[] arr, int low, int high) {
    int pivot;
    if (low < high) {
        //计算出分量
        pivot = partition(arr, low, high);
        sort(arr, low, pivot - 1);
        sort(arr, pivot + 1, high);
    }
}

private static int partition(int[] arr, int low, int high) {
    int pivotKet = arr[low]; //初始化中枢值第一个元素
    while (low < high) {
        while (low < high && arr[high] >= pivotKet) { //最后元素小于中枢值
            high--;
        }
        //只是替换，优化不必要的交换
        //MyClass.swap(arr,low,high);
        arr[low] =  arr[high];

        while (low < high && arr[low] <= pivotKet) {
            low++;
        }
        //MyClass.swap(arr,low,high);
        arr[high] = arr[low];
    }
    arr[low] = pivotKet;
    return low;
}