算法学习-排序算法

堆排序

堆排序是利用堆这种数据结构而设计的一种排序算法，堆结构是具有以下性质的完全二叉树：每个节点的值都大于或等于左右孩子节点的值，称为大根堆；或者每个节点的值都小于或等于其左右孩子的值，称为小根堆。

堆排序的基本思想：将待排序列构造成一个大根堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾的元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值，依次类推，反复执行，便能得到有序序列了。

代码如下：

package leetCode.test;

/**
 * 堆排序,额外空间复杂度O(1),时间复杂度O(N*logN)
 */
public class my_00_HeapSort {

    /**
     * 建立大根堆过程，新加入子节点与父节点进行对比，子节点值比父节点值大，进行交换，
     * 然后依次再跟上一层父节点值对比，到比上一层父节点值小或堆顶位置，则循环终止，建立大根堆过程结束
     * @param arr
     * @param index
     */
    public static void heapInsert(int[] arr,int index){
        while (arr[index]>arr[(index-1)/2]){
            swap(arr,index,(index-1)/2);
            index = (index-1)/2;
        }
    }

    /**
     * 大根堆堆顶位置值改变，重新调整堆为大根堆
     * @param arr
     * @param index
     * @param heapsize
     */
    public static void heapify(int[] arr,int index,int heapsize){
        int left = index*2+1;
        while (left<heapsize){
            //寻找左右子节点的最大值的下标
            int largest = left+1<heapsize&&arr[left+1]>arr[left]?left+1:left;
            //再跟父节点比较，得到最大值的下标
            largest = arr[largest]>arr[index]?largest:index;
            //如果父节点本身就是最大值，则不需要调整，跳过
            if(largest==index){
                break;
            }
            swap(arr,index,largest);
            index = largest;
            left=index*2+1;
        }
    }

    /**
     * 堆排序过程
     * @param arr
     */
    public static void heapSort(int[] arr){
        if(arr==null||arr.length<2){
            return;
        }
        //建立大根堆
        for (int i = 0; i < arr.length; i++) {
            heapInsert(arr,i);
        }
        //用一个变量来控制堆长度
        int heapSize = arr.length;
        //将堆顶的最大值与数组最后一个值交换，然后把最后一个元素剔除出堆，用heapsize控制
        swap(arr,0,--heapSize);
        while (heapSize>0){
//            重新建立大根堆
            heapify(arr,0,heapSize);
//            然后交换最后一个和堆顶最大值
            swap(arr,0,--heapSize);
        }
    }
    /**
     * 元素交换
     * @param arr
     * @param i
     * @param j
     */
    public static void swap(int[] arr,int i,int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }



}

快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。
快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

快速排序算法通过多次比较和交换来实现排序，其排序流程如下：

• 首先设定一个分界值，通过该分界值将数组分成左右两部分。
• 将大于或等于分界值的数据集中到数组右边，小于分界值的数据集中到数组的左边。此时，左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值。
• 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
• 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左、右两个部分各数据排序完成后，整个数组的排序也就完成了。
  

快速排序的期望复杂度是O(nlogn)，但最坏情况下可能就会变成O(n^2)，最坏情况就是每次将一组数据划分为两组的时候，分界线都选在了边界上，使得划分了和没划分一样，最后就变成了普通的选择排序了。

下面是随机快速排序，在范围内，随机将一个元素与r位置元素替换，代码如下：

/**
 * 随机快速排序，大样本情况，长期期望时间复杂度O(nlogn)，额外空间复杂度O(logn)
 */
public class my_00_QuickSort {


    public static void quickSort(int[] arr) {
//        基础判断
        if (arr == null || arr.length < 2) {
            return;
        }
//        快排入口
        quickSort(arr, 0, arr.length - 1);
    }

    /**
     * 通过递归不断对数组进行分区
     *
     * @param arr
     * @param l
     * @param r
     */
    public static void quickSort(int[] arr, int l, int r) {
        if (l < r) {
            //随机将数组中一元素与r位置元素进行替换，原始快速排序中，最坏情况为有序数组，时间复杂度O(n^2)，随机情况是将数组打乱，大样本情况下长期期望值，时间复杂度O(nlogn)
            swap(arr, l + (int) (Math.random() * (r - l + 1)), r);
            int[] p = partition(arr, l, r);
            quickSort(arr, l, p[0] - 1);
            quickSort(arr, p[1] + 1, r);
        }
    }


    /**
     * 将数组最后一个位置r做为数组划分值，小于arr[r]放在数组左边，等于放在中间，大于放在右边
     * 用less 和 more 变量作为小于与大于区域的边界指针
     *
     * @param arr
     * @param l
     * @param r
     * @return
     */
    public static int[] partition(int[] arr, int l, int r) {

        int less = l - 1;
        int more = r;
        while (l < more) {
            if (arr[l] < arr[r]) {
                //将小于r位置值替换到左边，小于区域less扩大1，遍历指针l增加1
                swap(arr, ++less, l++);
            } else if (arr[l] > arr[r]) {
                //将小于r位置值替换到左边，大于区域扩大1，遍历指针l不动，替换过来未知继续判断
                swap(arr, --more, l);
            } else {
                //等于，遍历指针增加1
                l++;
            }
        }
//        将r位置值替换到中间
        swap(arr, more, r);
//        返回三个区域边界的下标
        return new int[]{less + 1, more};

    }

    public static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

}