前往小程序,Get更优阅读体验!
立即前往
首页
学习
活动
专区
工具
TVP
发布
社区首页 >专栏 >算法之时间复杂度&几种排序算法探究 顶

算法之时间复杂度&几种排序算法探究 顶

作者头像
须臾之余
发布2019-08-22 10:04:06
4600
发布2019-08-22 10:04:06
举报
文章被收录于专栏:须臾之余

认识时间复杂度

常数时间的操作:一个操作如果和数据量没有关系,每次都是 固定时间内完成的操作,叫做常数操作。 时间复杂度为一个算法流程中,常数操作数量的指标。常用O (读作big O)来表示。具体来说,在常数操作数量的表达式中, 只要高阶项,不要低阶项,也不要高阶项的系数,剩下的部分 如果记为f(N),那么时间复杂度为O(f(N))。 评价一个算法流程的好坏,先看时间复杂度的指标,然后再分 析不同数据样本下的实际运行时间,也就是常数项时间。

例子一:

一个简单的理解时间复杂度的例子 一个有序数组A,另一个无序数组B,请打印B中的所有不在A中的数,A数 组长度为N,B数组长度为M。 算法流程1:对于数组B中的每一个数,都在A中通过遍历的方式找一下; 算法流程2:对于数组B中的每一个数,都在A中通过二分的方式找一下; 算法流程3:先把数组B排序,然后用类似外排的方式打印所有在A中出现 的数; 三个流程,三种时间复杂度的表达... 如何分析好坏?

例子二:

对数器的概念和使用 0,有一个你想要测的方法a, 1,实现一个绝对正确但是复杂度不好的方法b, 2,实现一个随机样本产生器 3,实现比对的方法 3,把方法a和方法b比对很多次来验证方法a是否正确。 4,如果有一个样本使得比对出错,打印样本分析是哪个方法出 错 5,当样本数量很多时比对测试依然正确,可以确定方法a已经 正确。

例子三

冒泡排序细节的讲解与复杂度分析 时间复杂度O(N^2),额外空间复杂度O(1)

代码语言:javascript
复制
/**
 * 冒泡排序
 */
public class BubbleSort {
    public static void main(int[] arr) {
        if(arr==null || arr.length<2){
            return;
        }
        for (int end=arr.length-1;end>0;end--){
            for (int i = 0; i < end; i++) {
                if (arr[i]>arr[i+1]){
                    swap(arr,i,i+1);
                }
            }
        }
    }
    private static void swap(int[] arr, int i, int j) {
        arr[i]=arr[i]^arr[j];
        arr[j]=arr[i]^arr[j];
        arr[i]=arr[i]^arr[j];
    }
    public static void main(String[] args) {
        int [] arr={1,4,23,6,78,9,0,2};
        main(arr);
        System.out.println(Arrays.toString(arr));
    }
}

例子四

选择排序的细节讲解与复杂度分析 时间复杂度O(N^2),额外空间复杂度O(1)

代码语言:javascript
复制
/**
 * 选择排序
 */
public class SelectionSort {
    public static void selectionSort(int[]arr){
       if (arr==null || arr.length<2){
           return;
       }
       for (int i=0;i<arr.length-1;i++){
            int minIndex=i;
           for (int j = i+1; j < arr.length; j++) {
               minIndex=arr[j]<arr[minIndex]?j:minIndex;
           }
           if(minIndex!=i){
               swap(arr,i,minIndex);
           }
       }
    }
    private static void swap(int[] arr, int i, int j) {
        arr[i]=arr[i]^arr[j];
        arr[j]=arr[i]^arr[j];
        arr[i]=arr[i]^arr[j];
    }
    public static void main(String[] args) {
        int [] arr={1,4,23,6,78,9,0,2};
        selectionSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

例子五

插入排序的细节讲解与复杂度分析 时间复杂度O(N^2),额外空间复杂度O(1)

代码语言:javascript
复制
/**
 * 插入排序
 */
public class InsertSort {
    public static void insertionSort(int [] arr){
        if (arr==null || arr.length<2){
            return;
        }
        for (int i = 1; i < arr.length; i++) {
            for (int j=i-1;j>=0 && arr[j]>arr[j+1];j--){
                swap(arr,j,j+1);
            }
        }
    }
    /**
     * 参与运算的两个值,如果两个相应bit位相同,则结果为0,否则为1。
     *   即:
     *   0^0 = 0,
     *   1^0 = 1,
     *   0^1 = 1,
     *   1^1 = 0
     *例如交换两个整数a=10100001,b=00000110的值,可通过下列语句实现:
     *  a = a^b;   //a=10100111
     *  b = b^a;   //b=10100001
     *  a = a^b;   //a=00000110
     */
    private static void swap(int[] arr, int i, int j) {
        arr[i]=arr[i]^arr[j];
        arr[j]=arr[i]^arr[j];
        arr[i]=arr[i]^arr[j];
    }

    public static void main(String[] args) {
        int [] arr={1,4,23,6,78,9,0,2};
        insertionSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

例子六

剖析递归行为和递归行为时间复杂度的估算 一个递归行为的例子 master公式的使用 T(N) = a*T(N/b) + O(N^d) 1) log(b,a) > d -> 复杂度为O(N^log(b,a)) 2) log(b,a) = d -> 复杂度为O(N^d * logN) 3) log(b,a) < d -> 复杂度为O(N^d) 补充阅读:www.gocalf.com/blog/algorithm-complexity-and-mastertheorem.html

例子七

归并排序的细节讲解与复杂度分析 时间复杂度O(N*logN),额外空间复杂度O(N)

代码语言:javascript
复制
/**
 * 二分递归归并排序
 */
public class MergeSort {
    public static void mergeSort(int[] arr){
        if(arr==null || arr.length<2){
            return;
        }
        mergeSort(arr,0,arr.length-1);
    }

    private static void mergeSort(int[] arr, int l, int r) {
        if (l==r){
            return;
        }
        int mid =l+((r-l)>>1);
        mergeSort(arr,l,mid);
        mergeSort(arr,mid+1,r);
        mergeSort(arr,l,mid,r);
    }

    private static void mergeSort(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++];
        }
        while (p1<=m){
            help[i++]=arr[p1++];
        }
        while (p2<=r){
            help[i++]=arr[p2++];
        }
        for (int j = 0; j < help.length; j++) {
            arr[l+j]=help[j];
        }
    }

    public static void main(String[] args) {
        int[] arr={1,2,5,3,6,8,5,4};
        mergeSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

例子八

小和问题和逆序对问题 小和问题 在一个数组中,每一个数左边比当前数小的数累加起来,叫做这个数组的小和。求一个数组 的小和。 例子: [1,3,4,2,5] 1左边比1小的数,没有; 3左边比3小的数,1; 4左边比4小的数,1、3; 2左边比2小的数,1; 5左边比5小的数,1、3、4、2; 所以小和为1+1+3+1+1+3+4+2=16 逆序对问题 在一个数组中,左边的数如果比右边的数大,则折两个数构成一个逆序对,请打印所有逆序 对。

代码语言:javascript
复制
/**
 * 小和问题
 */
public class SmallSum {
    public static int smallSum(int[] arr) {
        if (arr == null || arr.length < 2) {
            return 0;
        }
        return mergeSort(arr, 0, arr.length - 1);
    }

    public static int mergeSort(int[] arr, int l, int r) {
        if (l == r) {
            return 0;
        }
        int mid = l + ((r - l) >> 1);
        return mergeSort(arr, l, mid) + mergeSort(arr, mid + 1, r) + merge(arr, l, mid, r);
    }

    public static int 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;
        int res = 0;
        while (p1 <= m && p2 <= r) {
            res += arr[p1] < arr[p2] ? (r - p2 + 1) * arr[p1] : 0;
            help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
        }
        while (p1 <= m) {
            help[i++] = arr[p1++];
        }
        while (p2 <= r) {
            help[i++] = arr[p2++];
        }
        for (i = 0; i < help.length; i++) {
            arr[l + i] = help[i];
        }
        return res;
    }

    public static void main(String[] args) {
        int [] arr={1,2,3,4,5,6,7,8};
        smallSum(arr);
        System.out.println(Arrays.toString(arr));
    }
}

本文参考:牛客网

本文参与 腾讯云自媒体同步曝光计划,分享自作者个人站点/博客。
如有侵权请联系 cloudcommunity@tencent.com 删除

本文分享自 作者个人站点/博客 前往查看

如有侵权,请联系 cloudcommunity@tencent.com 删除。

本文参与 腾讯云自媒体同步曝光计划  ,欢迎热爱写作的你一起参与!

评论
登录后参与评论
0 条评论
热度
最新
推荐阅读
目录
  • 例子一:
  • 例子二:
  • 例子三
  • 例子四
  • 例子五
  • 例子六
  • 例子七
  • 例子八
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档