认识O(NlogN)的排序

Studying~

已于 2023-07-03 07:34:17 修改

阅读量77

点赞数 1

文章标签： java 算法排序算法

于 2023-05-29 10:20:15 首次发布

本文链接：https://blog.csdn.net/weixin_73936404/article/details/130911762

版权

文章通过Java代码展示了归并排序的实现，并解释了其时间复杂度为O(N*logN)，优于选择排序、冒泡排序和插入排序。同时，文中还探讨了如何利用Master公式计算递归算法的时间复杂度。另外，文章介绍了求解逆序对问题和小和问题的归并排序变体，并对比了不同版本的快速排序算法，包括其时间复杂度和空间复杂度。

摘要由CSDN通过智能技术生成

public class Master {
    public static int max(int[] arr){
        return getMax(arr, 0 , arr.length - 1);
    }

    public static int getMax(int[] arr, int L, int R){
        if (L == R){
            return arr[L];
        }

        //使用此方法可以防止溢出
        //因为R+L可能出现溢出情况，  但是R没溢出，L没溢出，所以R-L一定不会溢出
        //>>1代表除以2  >>2代表除以4，以此类推， <<1代表乘以2
        int mid = L + ((R-L)>>1);
        int leftMax = getMax(arr, L, mid);
        int rightMax = getMax(arr, mid + 1, R);
        return Math.max(leftMax, rightMax);
    }
}

以上诉代码展开详讲Master公式可以利用Master公式来计算递归算法的时间复杂度

其中T(N) 表示母问题使用的数据量规模

a*T(N/b) a表示调用子问题的次数 T(N/b)表示子问题使用的数据量规模，每个子问题数据量规模应相同

O(N^d)表示其余算式使用的时间

import java.util.Arrays;

/**
 * @ProjectName: study3
 * @FileName: Sorts2
 * @author:HWJ
 * @Data: 2023/5/28 14:15
 */
public class Sorts2 {
    public static void main(String[] args) {
        int[] num = {-25, -25, 41, 20, -25, 117, -4, -155, -45, 58, 75, 123, -28, -22, -25, 145, 75, -50, -114,
                -156, -138, 98, -76,
                88, 22, 118, 173, -115, 198, -6, 56, -41, -98, -78, -43, 78, -21, 52, 20, -32, 152, 79, 14};
        mergeSort(num);
        System.out.println(Arrays.toString(num));;
    }

    public static void mergeSort(int[] arr){//归并排序
        if (arr == null || arr.length < 2){
            return;
        }
        sort(arr, 0, arr.length-1);
    }
    public static void merge(int[] arr, int l, int mid, int r){
        int p1 = l;
        int p2 = mid+1;
        int i = 0; //给help数组使用的指针
        int[] help = new int[r-l+1];
        //若两边子数组此时都没有遍历完成，则寻找两个子数组当前索引位置的最小值，赋给help,直到某一个子数组遍历完毕
        //对剩下的子数组将其所有值依次赋给help
        //最后将排好序的help数组，重新赋值给原数组
        while(p1 <= mid && p2 <= r){
            help[i++] = arr[p1] <= arr[p2] ? arr[p1++]:arr[p2++];
        }
        while(p1<=mid){
            help[i++] = arr[p1++];
        }
        while(p2<=r){
            help[i++] = arr[p2++];
        }
        for (int j = 0; j < help.length; j++) {
            arr[j+l] = help[j];
        }
    }
    public static void sort(int[] arr, int l, int r){
        if (l == r){
            return;
        }
        int mid = l + ((r-l)>>1);
        sort(arr, l, mid);
        sort(arr, mid+1, r);
        merge(arr, l, mid, r);//不断的对子数组进行排序
    }
}

根据代码知，T(N) = 2*T(N/2) + O(N)

满足

知复杂度为 O(N*logN)

选择排序，冒泡排序和插入排序浪费了大量的比较行为，而归并排序没有浪费这些比较行为

小和问题的代码：

import java.util.Arrays;

/**
 * @ProjectName: study3
 * @FileName: ex2
 * @author:HWJ
 * @Data: 2023/5/28 20:12
 * 求小和问题
 */
public class ex2 {
    public static void main(String[] args) {
        int[] num = {1,3,4,2,5};
        System.out.println(mergeSort(num));
        System.out.println(Arrays.toString(num));
    }
    public static int mergeSort(int[] arr){
        if (arr == null || arr.length < 2){
            return 0;
        }
        return sort(arr, 0, arr.length - 1);
    }
    public static int sort(int[] arr, int l, int r){
        if (l==r){
            return 0;
        }
        int mid = l + ((r-l)>>1);
        return sort(arr, l, mid) +
                sort(arr, mid+1, r) +
                merge(arr, l, mid, r);
    }
    //既要排好序，也要求小和


    public static int merge(int[] arr, int l, int mid, int r){
        int total = 0;
        int p1 = l;
        int p2 = mid + 1;
        int i = 0;
        int[] help = new int[r-l+1];
        while(p1 <= mid && p2 <= r){
            //一定要排好序，这样才能使用此方法arr[p1] * (r-p2+1)，
            // 因为是排好序的arr[p2]>arr[p1]则arr[p2]后面的数也一定大于arr[p1]
            // arr[p1] < arr[p2]这里排序时，等于情况先排序arr[p2]，
            // 如果排了arr[p1】，我们此时并不知道arr[p2]后面有多少大于arr[p1]的数，就会导致少算
            total += arr[p1] < arr[p2] ? arr[p1] * (r-p2+1) : 0;
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while(p1 <= mid){
            help[i++] = arr[p1++];
        }
        while(p2 <= r){
            help[i++] = arr[p2++];
        }
        for (int j = 0; j < help.length; j++) {
            arr[j+l] = help[j];
        }
        return total;
    }

}

求逆序对数目问题：

import java.util.Arrays;

/**
 * @ProjectName: study3
 * @FileName: ex3
 * @author:HWJ
 * @Data: 2023/5/28 21:20
 * 逆序对问题
 */
public class ex3 {
    public static void main(String[] args) {
        int[] num = {3,2,4,5,0};
        System.out.println(mergeSort(num));
        System.out.println(Arrays.toString(num));
    }
    public static int mergeSort(int[] arr){
        if (arr == null || arr.length < 2){
            return 0;
        }
        return sort(arr, 0, arr.length - 1);

    }
    public static int sort(int[] arr, int l, int r){
        if (l == r){
            return 0;
        }
        int mid = l + ((r-l)>>1);
        return sort(arr, l, mid)+
        sort(arr, mid+1, r)+
        merge(arr, l, mid, r);
    }
    public static int merge(int[] arr, int l, int mid, int r){
        int[] help = new int[r-l+1];
        int i = 0;
        int p1 = l;
        int p2 = mid + 1;
        int res = 0;
        while (p1 <= mid && p2 <= r){
            //这里求逆序对， 所以按照大的在前的方式进行排序
            // arr[p1] > arr[p2]这里排序时，等于情况先排序arr[p2]，
            // 如果排了arr[p1】，我们此时并不知道arr[p2]后面有多少小于于arr[p1]的数，就会导致少算
            res += arr[p1] > arr[p2] ? 1:0;
            help[i++] = arr[p1] > arr[p2] ? arr[p1++] : arr[p2++];
        }
        while(p1<=mid){
            help[i++] = arr[p1++];
        }
        while(p2<=r){
            help[i++] = arr[p2++];
        }
        for (int j = 0; j < help.length; j++) {
            arr[j+l] = help[j];
        }
        return res;
    }
}

引出快排：

import java.util.Arrays;

/**
 * @ProjectName: study3
 * @FileName: ex4
 * @author:HWJ
 * @Data: 2023/5/28 21:46
 */
public class ex4 {
    public static void main(String[] args) {
        int[] num = {3,5,6,7,4,3,5,8};
        int[] num2 = {3,5,6,7,4,3,5,8,9,5,0,2,4,5};
        sort(num, 5);
        System.out.println(Arrays.toString(num));
        sort2(num2, 5);
        System.out.println(Arrays.toString(num2));
    }
    public static void sort(int[] arr, int num){//第一题
        //<=num 在左边 其余的在右边
        int p1 = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] <= num){
                swap(arr, i, ++p1);
            }
        }
    }
    public static void sort2(int[] arr, int num){//荷兰旗问题
        //<=num 在左边 大于的在右边
        int p1 = -1;
        int p2 = arr.length;
        for (int i = 0; i < arr.length && i < p2; i++) {
            //当等于区域和大于区域相遇时，停止循环
            //即i==p2
            if (arr[i] < num){
                swap(arr, i, ++p1);
            }
            if (arr[i] > num){
                //将大于的放在右边，并且i不变
                swap(arr, i--, --p2);
            }
        }
    }


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

}

基于以上两个问题的快排1和快排2 快排是时间复杂度为O(N^2)的算法

快排3

随机选择某一个数将其放在数组最后，并作为划分标准

使用数学可证明其算法的时间复杂度为复杂度为O(N*logN)的算法

import java.util.Arrays;

/**
 * @ProjectName: study3
 * @FileName: QuickSort
 * @author:HWJ
 * @Data: 2023/5/28 21:45
 */
public class QuickSort {
    public static void main(String[] args) {
        int[] num = {3,5,6,7,4,3,5,8,9,5,0,2,4,5};
        quickSort3(num, 0, num.length-1);
        System.out.println(Arrays.toString(num));
    }
    public static void quickSort1(int[] arr, int l, int r){ //快排1
        if (l < r){
            int k = partition1(arr, l, r);
            quickSort1(arr, l, k-1);
            quickSort1(arr, k+1, r);
        }
    }
    //返回分界值的索引，此效率最慢
    public static int partition1(int[] arr, int l, int r){
        int p1 = l-1;
        for (int i = l; i < r; i++) {
            if (arr[i] <= arr[r]){
                swap(arr, i, ++p1);
            }
        }
        swap(arr, r, ++p1);
        return p1;
    }

    public static void quickSort2(int[] arr, int l, int r){ //快排2
        if (l < r){
            int[] k = partition2(arr, l, r);
            quickSort2(arr, l, k[0]-1);
            quickSort2(arr, k[1]+1, r);
        }
    }
    public static int[] partition2(int[] arr, int l, int r){
        int p1 = l-1;
        int p2 = r;
        int index = l;
        int p[] = new int[2];
        while(index < p2){
            if (arr[index] < arr[r]){
                swap(arr, index++, ++p1);
            }else if (arr[index] > arr[r]){
                swap(arr, index, --p2);
            }else{
                index++;
            }
        }
        swap(arr, r, p2);
        p[0] = ++p1;
        p[1] = p2;
        return p;
    }

    public static void quickSort3(int[] arr, int l, int r){ //快排3,时间复杂度比前两个低
        if (l < r){
            //随机选择一个值作为分界值
            //并将这给随机选择的值，和最后一个位置上的值作为交换
            int t = l + (int) ((r-l+1)*Math.random());
            swap(arr, t, r);
            int[] k = partition3(arr, l, r);
            quickSort3(arr, l, k[0]-1);//找到需要再次快排的索引位置
            quickSort3(arr, k[1]+1, r);
        }
    }
    // int p[] = new int[2];
    // 返回两个值，第一个值为等于区域的左边界， 第二个值为等于区域的右边界
    public static int[] partition3(int[] arr, int l, int r){
        int p1 = l-1;
        int p2 = r;
        int index = l;
        int p[] = new int[2];
        while(index < p2){
            if (arr[index] < arr[r]){
                swap(arr, index++, ++p1);
            }else if (arr[index] > arr[r]){
                swap(arr, index, --p2);
            }else{
                index++;
            }
        }
        swap(arr, r, p2);
        p[0] = ++p1;
        p[1] = p2;
        return p;
    }


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



}

快排1和快排2时间复杂度相同，快排3时间复杂度最快，快排2和快排3算法类似