java归并排序和快速排序

归并排序

归并排序基本思想

利用归并的思想,采用分治策略 (将问题分成一些小的相同的问题然后递归求解,再将分的阶段得到的各答案整合到一起)

归并排序的图解

java代码实现:

public static void sort(int[] arr){
    if(arr==null||arr.length<2){
        return;
    }
    process(arr,0,arr.length-1);
}

/**
     * 使arr[left...right]上变得有序
     * @param arr
     * @param left
     * @param right
     */
private static void process(int[] arr, int left, int right) {

    if(left==right){
        //只有一个数的时候,说明已经排好序了,直接返回
        return;
    }

    // 定一个中间位置(left+right)/2
    int mid = left+((right-left))>>1;
    // 让左边变得有序
    process(arr,left,mid);
    // 让右边变得有序
    process(arr,mid+1,right);
    // 让整体变得有序 merge 合并在一起,使整体变得有序
    merge(arr,left,mid,right);

}

private static void merge(int[] arr, int L, int M, int R) {
    int[] help = new int[R-L+1];
    int i = 0;
    // 左边的指针指向第一个位置
    int p1 = L;
    // 右边指针指向中间位置之后的那个位置
    int p2 = M+1;
    // 当左右两个指针都没越界  谁小谁拷贝
    while (p1<=M&&p2<=R){
        help[i++] = arr[p1]<=arr[p2]?arr[p1++]:arr[p2++];
    }
    // 任意一个越界,跳出循环 要么p1越界,要么p2越界 不可能出现同时越界

    // 以下两个while虽然顺序写,但只会中一个
    // 如果p1没有越界
    while(p1<=M){
        help[i++] = arr[p1++];
    }
    // 如果p2没有越界
    while(p2<=L){
        help[i++] = arr[p2++];
    }
    for (int j = 0; j < help.length; j++) {
        arr[L+j] = help[j];
    }
}

随机快排(快速排序)

随机快排思想

快速排序,说白了就是给基准数据找其正确索引位置的过程.就是把指定的数放在中间,不断调用

随机快排步骤

将数组中比指定划分值小的放在划分值左边,比当前值大的放在划分值右边

用两个区域对数组进行压缩,一边是小数区,一边是大数区

然后对左边的数执行这个步骤,对右边的数执行此步骤

最终让整个数组变得有序

java代码实现:

static void swap(int[] arr,int a,int b){
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

    /**
     *  arr[left....right]上做划分,拿arr[right]做划分值
     * @param arr
     * @param left
     * @param right
     * @return  当前arr中相等区域两端的位置
     */
    public static int[] partition(int[]arr,int left,int right){
        int N = arr.length;
        int lessRight = left-1; // 小于区的右边界
        int moreLeft = right; // 大于区的左边界
        int curIndex = 0; // 当前位置的下标
//        arr[right]的数作为划分值
        while (curIndex<moreLeft){
            // 当前数小于划分值
            if(arr[curIndex]<arr[right]){
                swap(arr,++lessRight,curIndex++); // 小于区的下一个位置和当前位置的数做交换之后小于区右扩,当前数跳下一个
            }
            // 当前数大于划分值
            else if (arr[curIndex]>arr[right]){
                swap(arr,--moreLeft,curIndex); // 大于区的前一个位置和当前位置值做交换,大于区左扩,当前位置不动

            }else{
                curIndex++;
            }
        }
        swap(arr,moreLeft,right); // 大于区第一个数和用于划分的值进行交换
        return new int[]{lessRight+1,moreLeft};
    }

    public static void sort(int[] arr){
        if(arr==null||arr.length<2){
            return;
        }
        process(arr,0,arr.length-1);
    }

    /**
     * 让arr在left到right上有序
     * @param arr
     * @param left
     * @param right
     */
    public static void process(int[]arr,int left,int right){
        if(left>=right){
            return;
        }
        int [] equalArea = partition(arr,left,right);
        // equalArea[0] 等于区第一个数
        // equalArea[1] 等于区最后一个数
        process(arr,left,equalArea[0]+1);
        process(arr,equalArea[1]+1,right);
    }