22.1.7 master公式及O(NLogN)的排序

1 master 公式

(1) 写公式
  • T(N) = a * T(N/b) + O(N^d);

  • master公式用来求递归行为的时间复杂度,式中T(N/b)表示母问题被分解为子问题的规模,a表示子问题被调用的次数,O(N^d)表示算法中其他过程的时间复杂度。

    例如:

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

    public static int process(int[] arr,int L,int R)
    {
       if(L==R)
           return arr[L];
       int mid = L+((R-L)>>1);//mid = L+((R-L)/2),/2可以表示为右移一位。
       int leftMax = process(arr,L,mid);
       int rightMax = process(arr,mid,R);
       return Math.max(leftMax,rightMax);
    }
  • 其中,T(N) = 2 * T(N/2) + O(1);a = 2,b = 2,d = 0;

(2)求时间复杂度:
  • log以b为底a的对数 < d , 时间复杂度为O(N^d);

  • log以b为底a的对数 > d , 时间复杂度为O(N^log以b为底a的对数);

  • log以b为底a的对数 = d , 时间复杂度为O((N^d) * logN);

2 O(NLogN)的排序:

(1) 归并排序:

public static void main(String[] args)
{
int[] arr = {2,4,6,4,6,7,1,8,3,9,8};
process(arr,0,arr.length-1);
for(int cur:arr)
{
System.out.print(cur+" ");
}
}

public static void process(int[] arr,int L,int R)
{
if(L==R)
return;
int mid = L+((R-L)>>1);
process(arr,L,mid);
process(arr,mid+1,R);
mergeSoft(arr,L,mid,R);
}

public static void mergeSoft(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(i=0;i<help.length;i++)
arr[L+i] = help[i];
}

example:小和问题,求逆序对

  • 小和问题描述:对于一个数组例如,2,1,5,8,9,6,3,4。其中2和5,8,9,6,3,4都会产生小和2,同理1与5,8,9,6,3,4也都会产生小和1,依次累加所有的小和然后返回。

//小和问题
public static void main(String[] args)
{
int[] arr = { 2,1,5,8,9,6,3,4};
int res = smallSum(arr);
System.out.println(res+" ");
}

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

public static int process(int[] arr,int L,int R)
{
if(L==R)
return 0;
int mid = L+((R-L)>>1);
return process(arr,L,mid)+process(arr,mid+1,R)+mergeSoft(arr,L,mid,R);
}

public static int mergeSoft(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;
}

(2) 快速排序

public static void main(String[] args)
{
int[] arr = { 2,1,5,8,9,6,3,4};
quickSort(arr,0,(arr.length-1));
}

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

public static void quickSort(int[] arr,int l,int r)
{
if(l<r)
{
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);
}
}

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])
{
swap(arr,++less,l++);
}
else if(arr[l]>arr[r])
{
swap(arr,--more,l);
}
else
l++;
}
    swap(arr,more,r);
    return new int[]{less+1,more};
}

22.1.7 master公式及O(NLogN)的排序的更多相关文章

  1. Master公式计算递归时间复杂度

    我们在算递归算法的时间复杂度时,Master定理为我们提供了很强大的便利! Master公式在我们的面试编程算法中除了BFPRT算法的复杂度计算不了之外,其他都可以准确计算! 这里用求数组最大值的递归 ...

  2. 算法初级面试题01——认识时间复杂度、对数器、 master公式计算时间复杂度、小和问题和逆序对问题

    虽然以前学过,再次回顾还是有别样的收获~ 认识时间复杂度 常数时间的操作:一个操作如果和数据量没有关系,每次都是固定时间内完成的操作,叫做常数操作. 时间复杂度为一个算法流程中,常数操作数量的指标.常 ...

  3. 数据结构与算法学习(二)——Master公式及其应用

    本篇文章涉及公式,由于博客园没有很好的支持,建议移步我的CSDN博客和简书进行阅读. 1. Master公式是什么? 我们在解决算法问题时,经常会用到递归.递归在较难理解的同时,其算法的复杂度也不是很 ...

  4. 左神算法第一节课:复杂度、排序(冒泡、选择、插入、归并)、小和问题和逆序对问题、对数器和递归(Master公式)

    第一节课 复杂度 排序(冒泡.选择.插入.归并) 小和问题和逆序对问题 对数器 递归 1.  复杂度 认识时间复杂度常数时间的操作:一个操作如果和数据量没有关系,每次都是固定时间内完成的操作,叫做常数 ...

  5. 转:master公式(主方法)

    master公式(也称主方法)是利用分治策略来解决问题经常使用的时间复杂度的分析方法,(补充:分治策略的递归解法还有两个常用的方法叫做代入法和递归树法),众所众知,分治策略中使用递归来求解问题分为三步 ...

  6. 备战秋招之十大排序——O(nlogn)级排序算法

    时间复杂度O(nlogn)级排序算法 五.希尔排序 首批将时间复杂度降到 O(n^2) 以下的算法之一.虽然原始的希尔排序最坏时间复杂度仍然是O(n^2),但经过优化的希尔排序可以达到 O(n^{1. ...

  7. 数据结构与算法——认识O(NlogN)的排序(1)

    归并排序 1) 整体就是一个简单递归,左边排好序.右边排好序.让其整体有序 2) 让其整体有序的过程里用了外排序方法 3) 利用master公式来求解时间复杂度 4) 归并排序的实质 时间复杂度0(N ...

  8. 时间复杂度为O(nlogn)的排序算法

    时间复杂度为O(nlogn)的排序算法(归并排序.快速排序),比时间复杂度O(n²)的排序算法更适合大规模数据排序. 归并排序 归并排序的核心思想 采用"分治思想",将要排序的数组 ...

  9. master公式 ------ 求递归情况下的时间复杂度

    剖析递归行为和递归行为时间复杂度的估算一个递归行为的例子T(N) = a*T(N/b) + O(N^d)1) log(b,a) > d -> 复杂度为O(N^log(b,a))2) log ...

随机推荐

  1. Solution -「JSOI2008」「洛谷 P4208」最小生成树计数

    \(\mathcal{Description}\)   link.   给定带权简单无向图,求其最小生成树个数.   顶点数 \(n\le10^2\),边数 \(m\le10^3\),相同边权的边数不 ...

  2. Solution -「多校联训」染色

    \(\mathcal{Description}\)   Link.   给定 \(n\) 和 \(q\) 次询问,每次询问给出 \(x,k\),求第 \(x\) 位为 0 且任意两个 1 的下标之差不 ...

  3. Ubuntu20重装nvidia驱动

    终端:nvidia-smi 查看驱动信息 错误:NVIDIA-SMI has failed because it couldn't communicate with the NVIDIA driver ...

  4. jenkins发布代码选择不同分支

    jenkins上传代码分支以前都是用变量的方式,手动实现.过程就像这样 构建时候的界面就像下面这样,需要手动输入分支版本. 或者有固定的上线分支,用参数化构建 选项参数 来选择.总之这些方法比较传统, ...

  5. Prometheus之Dockerfile编写、镜像构建、容器启动

    目录 从官方镜像启动:prom/prometheus 官方Dockerfile分析 编写自己的Dockerfile 构建镜像: 启动容器: 从官方镜像启动:prom/prometheus 拉取镜像 $ ...

  6. [自动化]基于kolla-ceph的自动化部署ceph集群

    kolla-ceph来源: 项目中的部分代码来自于kolla和kolla-ansible kolla-ceph的介绍: 1.镜像的构建很方便, 基于容器的方式部署,创建.删除方便 2.kolla-ce ...

  7. S32Kxxx bootloader之CAN bootloader

    了解更多关于bootloader 的C语言实现,请加我Q扣: 1273623966 (验证信息请填 bootloader),欢迎咨询或定制bootloader(在线升级程序). 最近完成了S32Kxx ...

  8. 重点收藏!BI数据分析工具哪家强?

    信息爆炸时代,大数据晋升为一个时髦词汇.不论是在哪个行业领域,大数据分析成为各企业备受推崇的决策工具.对于海量数据的挖掘,有助于统计事情发生的概率,帮助人们计算做某些事情成功的几率.企业正在数据的海洋 ...

  9. prometheus k8s服务发现

    Prometheus的服务发现在解决什么问题? 被监控的目标(target)是整个监控体系中重要组成部分,传统监控系统zabbix通过 网络发现的机制自动创建主机到zabbix-server,进而快速 ...

  10. 使用教程:宝塔服务器管理助手Linux面版

    网页提示:宝塔Linux面板初始化成功,点击登陆页面:直接使用初始化配置时填写的帐号及密码登陆面板功能:网站管理.FTP管理.数据库管理.系统安全.文件管理.计划任务.环境设置. 方法/步骤1: 使用 ...