程序复杂度-O(logN)计算过程

最新推荐文章于 2024-04-11 09:53:31 发布
最新推荐文章于 2024-04-11 09:53:31 发布
阅读量4k 收藏 4
点赞数 4
分类专栏： 数据结构和算法 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wukkk111/article/details/107481783
版权
本文详细解析了二分查找算法的时间复杂度为何为O(logN)，通过数学推导说明了每次查找如何将搜索范围减半，最终得出查找次数为以2为底的对数，从而解释了二分查找效率高的原因。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

O(logN) 一般是用于二分查找的时候 时间复杂度也可以看做 程序循环的次数 例如
一共有n个元素 二分查找原理是每次查找的会取中间的以为作为一个对比一依据 所以
每次查找剩余的元素个数为
n n/2 n/2/2 n/2/2/2 … n/2^k
k为找到那个元素的次数 n/2^k表示还剩下多少元素
那么k 等于以2为底的 log2N 2为常数可以省略 所以二分查找的时间复杂度为logN

算法之路（二）呈现O(logN)型的三个算法
weixin_30505225的博客
07-11 2390
典型时间复杂度 我们知道算法的执行效率，可以从它的时间复杂度来推算出一二。而典型的时间复杂度有哪些类型呢？ 由上图，可以看出，除了常数时间复杂度外，logN型的算法效率是最高的。今天就介绍三种非常easy的logN型算法。 对分查找 给定一个整数X和整数A0，A1，…，An-1,后者已经预先排序并在内存中，求是的Ai= X的下表i,如果X不在数据中，则返回i =...
算法复杂度O(logn)详解
热门推荐
qq_34358193的博客
06-01 3万+
@阅读目录 一.O(logn)代码小证明 二.典型时间复杂度 三.常见的????????????????算法 1.对分查找 2. 欧几里得算法 3.幂运算 一.O(logn)代码小证明 我们先来看下面一段代码: int cnt = 1; while (cnt < n) { cnt *= 2; //时间复杂度为O(1)的程序步骤序列 } 由于cnt每次在乘以2之后都会更加逼近n，也就是说，在有x次后，cnt将会大于n从而跳出循环，所以2???? = ???? ,也就是????=????
算法中的时间复杂度logN
qq_32444437的博客
04-11 2897
软件开发中通过合理的算法能减小计算的空间复杂度和时间复杂度，有的复杂度为logN，什么是logN？通过毕业后的努力工作基本都忘了。
详解O(log n)时间复杂度的由来
每天八杯水的博客
04-30 5557
算法复杂度共分为两类：时间复杂度、空间复杂度 时间复杂度是指执行这个算法所需要的计算工作量时间； 空间复杂度是指执行这个算法所需要的内存空间。 一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度，也代表了时间复杂度O()。 一、O(log n)简单算法演示讲解 int a=1； while(a<n){ a=a*2; } 时间复杂度就是看某个语句的最大执行次数： int a=1 //执行了.
每日一道算法（搜索插入位置——二分查找，时间复杂度为O(logn) ）
weixin_44912627的博客
01-14 1083
时间复杂度o(1), o(n), o(logn), o(nlogn)。算法时间复杂度的时候有说o(1), o(n), o(logn), o(nlogn)，这是算法的时空复杂度的表示。不仅仅用于表示时间复杂度，也用于表示空间复杂度。O后面的括号中有一个函数，指明某个算法的耗时/耗空间与数据增长量之间的关系。其中的n代表输入数据的量。 时间复杂度是什么意思？那么时间复杂度为 O(log n ) 是什么意思？ 那么先理解一下 O(1) ，O(n) 是什么意思： O(1) 表示一次操作即可直接取得目标元素（比如字典
时间复杂度为O（logN）的常用算法，算法数据结构
04-07
在实际编程中，掌握这些O(logN)时间复杂度的算法对于优化程序性能至关重要，特别是在处理大数据量时。例如，折半查找常用于数据库索引、二分图的判断等问题；欧几里得算法在数论和加密算法中广泛应用；而快速幂运算...
数据结构【时间复杂度、空间复杂度--1】
我心如火
04-20 2846
本期知识：什么是数据结构？.算法的复杂度，时间复杂度概念及其例题讲解，空间复杂度概念及其例题讲解，常见时间复杂度以及复杂度oj练习
分析算法时间复杂度---渐进表示法
优快云wg的博客
04-22 3611
渐进表示法，算法时间复杂度分析
算法的时间复杂度与空间复杂度---举例分析
houminZhang的博客
03-25 2074
一、 算法 算法的定义是这样的：解题方案的准确而完善的描述，是一系列解决问题的清晰指令。巴拉巴拉的，虽然是一小句但还是不想看（题外话：有时候吧专业名词记下来面试的时候还是挺有用的），其实就是解决一个问题的完整性描述。只不过这个描述就可能是用不同的方式或者说是“语言”了。 - 算法的效率 既然算法是解决问题的描述，那么就像一千个人眼中有一千个阿姆雷特他大姨夫一样，解决同一个问题的办法也是多种...
二分查找算法的时间复杂度
startwithdp的专栏
04-15 3356
学过数据结构，当然当年也学过算法的时间复杂度的，不知道当年是不是会推倒时间复杂度，大概也就是根据基本语句的执行次数来获得最高的数量级吧 例如 i=0；  while（i i=0; j=0； while（i    ｛  while（j         {              j++;//这条语句执行了n^2次         }i++;j=0; ｝ 总共执行次数应该是n
logn时间复杂度
m0_57442684的博客
09-18 366
例如二分查找，每次减少一半搜索，经过x次，最终结束查找。时间复杂度O(logn)
时间复杂度的计算
qq_62095410的博客
04-30 1万+
时间复杂度一般指时间复杂性。 常见的时间复杂度有：常数阶T(n) = O(1)，对数阶O(logn)，线性阶O(n)，线性对数阶O(nlogn)，平方阶O(n^2),三次方阶O(n^3)。 一、常数阶T(n)=O(1) int a=1; cout<<a<<endl; 即只执行了一次，所以T(n)=O(1) 二、对数阶O(logn) int n; cin>>n; for(int i=1;i<=n;i=i*2) { cout<...
O(logn) 时间复杂度
Through Da Storm
08-13 1万+
预先知道算法的复杂度是一回事，了解其后的原理是另一件事情。 不管你是计算机科班出身还是想有效解决最优化问题，如果想要用自己的知识解决实际问题，你都必须理解时间复杂度。 先从简单直观的 O(1) 和 O(n) 复杂度说起。O(1) 表示一次操作即可直接取得目标元素（比如字典或哈希表），O(n) 意味着先要检查 n 个元素来搜索目标，但是 O(log n) 是什么意思呢？ 你第一次听说 O(log n) 时间复杂度可能是在学二分搜索算法的时候。二分搜索一定有某种行为使其时间复杂度为 log n。我们来看看
时间复杂度计算方法
weixin_49093912的博客
03-02 8869
时间复杂度的计算 for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { cout << "csdn" << endl; } } for (i = 0; i < n; i++) { for (j = i; j < n; j++)
二分法logn时间复杂度解释
smart boy
06-21 1万+
二分法的关键思想是 假设该数组的长度是N那么二分后是N/2，再二分后是N/4……直到二分到1结束（当然这是属于最坏的情况了，即每次找到的那个中点数都不是我们要找的），那么二分的次数就是基本语句执行的次数，于是我们可以设次数为x，N*（1/2）^x=1；则x=logn,底数是2，...
整数的幂计算（三种方法）最快O(logn)
gc.collect()
10-02 4434
整数的幂计算 算法1： 一般来说的常见的计算xnx^nxn的方式，就是逐步乘上x，这样一共需要O(n)次O(n)次O(n)次的乘法 算法2： 但如果x4x^4x4的话，其实我们只需要计算一次x2x^2x2，再用两个x2x^2x2相乘就好了。这样的话，算法复杂度就被降低到了O(logn)O(log n)O(logn) 。如果不是偶数的话，也可以通过提取出一个偶数来得到对应的结果。用递归的方式很容易就...
几个时间复杂度O(logN)的算法
weixin_30483013的博客
02-26 663
1 二分查找算法 int BinarySearch(const ElementType A[], ElementType X, int N) { int mid, right, left; right = 0; left = N - 1; while(right <= left){ // 不断更新左右边界的索引（实质是每...
时间复杂度o(1), o(n), o(logn), o(nlogn)
luzhensmart的专栏
02-22 8183
1、时间复杂度o(1), o(n), o(logn), o(nlogn)。算法时间复杂度的时候有说o(1), o(n), o(logn), o(nlogn)，这是算法的时空复杂度的表示。不仅仅用于表示时间复杂度，也用于表示空间复杂度。O后面的括号中有一个函数，指明某个算法的耗时/耗空间与数据增长量之间的关系。其中的n代表输入数据的量。 2、时间复杂度为O(1)。 　　是最低的时空...
【时间复杂度】详解O(logn)
weixin_52709852的博客
03-05 3689
时间复杂度： (代码每行运行的次数总和，大O符号表示法：描述代码执行时间的增长变化趋势) 常见时间复杂度（按效率排序） O(1) < O(logn) < O(n) < O(nlogn) < O(n²) < O(n²logn) < O(n³) 对数阶O(logn): 当算法中循环出现折半的时候，就会出现对数阶 例1: 例2: I = 1 while(I<n): I = I * 2 线性对数阶O(n...
详细讲一讲为什么时间复杂度是O（logn），程序是怎么执行的
最新发布
04-06
<think>好的，我现在需要详细解释为什么这个快速幂算法的时间复杂度是O(log n)，以及程序的具体执行过程。首先，我得回忆一下递归和分治策略的基本原理。这个函数每次将指数n折半，所以直观上感觉时间复杂度应该和递归的深度有关，而每次递归处理的问题规模减半，所以应该是log n级别的。 接下来，我需要具体分析递归调用的过程。例如，假设n是8，那么第一次调用会计算n/2=4，然后继续递归到2，再到1，最后返回。这样递归深度确实是log2(8)=3层。每次递归后的合并操作（即乘法）只需要常数时间，所以总时间应该是O(log n)。 不过，我得确认当n不是2的幂时，情况是否仍然成立。比如n=5，第一次拆分为2，然后递归到2，再拆分为1，这样递归深度仍然是log2(5)≈2.32，向上取整为3层。这时候奇数的情况会多一次乘法，但总体递归次数还是和log n成正比。 然后，我需要解释程序的具体执行步骤。例如，当调用function4(x,5)时，首先计算n/2=2，然后递归调用function4(x,2)，再拆分为1，返回x=2，然后计算t=2，返回到上一层，得到t*t=4，再因为原来的n=2是偶数，返回4。回到n=5的情况，此时t=4，然后因为n是奇数，所以返回4*4*x，即4*4*2=32。这个过程展示了递归分解和合并的步骤。 可能还需要考虑递归树的结构，每个节点代表一次递归调用，子节点是更小的问题。由于每次n都被分成n/2，递归树的高度是log n，每层的操作是常数时间，所以总时间是O(log n)。 此外，我需要对比普通递归的时间复杂度O(n)，说明为什么快速幂更高效。例如，普通递归每次减少n-1，需要n次递归调用，而快速幂每次减半，所以次数减少到log n次。 最后，需要确认是否所有情况下都成立，比如n为0或1的情况，这些基本情况确实直接返回，不会影响时间复杂度。同时，确认每次递归中的操作（判断奇偶、乘法）都是常数时间，不会增加复杂度。可能还要提到整数除法的处理，n/2实际上是向下取整，但这对递归次数的影响是否在log n范围内，应该没问题。 总结起来，我需要分步骤解释递归的分解过程，每次问题规模减半，导致递归深度为log n，每层操作是常数时间，从而总体时间复杂度是O(log n)。同时，通过具体例子说明程序的执行流程，帮助理解递归调用的顺序和合并结果的方式。</think>--- ### **一、时间复杂度为$O(\log n)$的核心原因** #### **1. 递归分解策略** 快速幂算法的核心是**分治思想**。每次递归调用将指数$n$ **折半**，即通过`n / 2`将问题分解为更小的子问题。例如： - 当$n=8$时，分解为$x^4 \times x^4$ - 当$n=7$时，分解为$x^3 \times x^3 \times x$ **关键点**：每次递归后，问题规模（即指数$n$）减半，递归深度为$\log_2 n$。 --- #### **2. 递归树与操作次数** 以$n=8$为例，递归过程如下： ``` 层1：计算 x^8 → 分解为 (x^4)² 层2：计算 x^4 → 分解为 (x^2)² 层3：计算 x^2 → 分解为 (x^1)² 层4：计算 x^1 → 直接返回 x ``` - **递归深度**：$\log_2 8 = 3$层（实际递归到$x^1$后逐层返回） - **每层操作**：每层只需1次乘法（如$t \times t$或$t \times t \times x$），总操作次数为$O(\log n)$。 --- ### **二、程序执行过程详解** #### **1. 递归调用流程** 以计算$x=2$的$n=5$次方为例（即$2^5=32$）： ```c 调用 function4(2,5): n=5 是奇数 → 计算 t = function4(2,2) └─ 调用 function4(2,2): n=2 是偶数 → 计算 t = function4(2,1) └─ 调用 function4(2,1): 返回 2 → t=2 → 返回 2*2 = 4 → t=4 → 返回 4*4*2 = 32 ``` #### **2. 递归树可视化** ``` function4(2,5) ├─ function4(2,2) │ ├─ function4(2,1) → 返回 2 │ └─ 返回 2*2 = 4 └─ 返回 4*4*2 = 32 ``` - **递归深度**：$\lceil \log_2 5 \rceil = 3$层 - **总乘法次数**：3次（每层1次） --- ### **三、与普通递归的对比** #### **1. 普通递归实现** 普通递归的代码为： ```c int pow(x, n) { if (n == 0) return 1; return x * pow(x, n-1); // 每次减少1，时间复杂度O(n) } ``` - **时间复杂度**：$O(n)$（需要$n$次递归调用） - **问题**：当$n=10^9$时，递归深度过大，导致栈溢出或超时。 #### **2. 快速幂的优势** 快速幂通过**折半分解**将时间复杂度优化到$O(\log n)$。 - **当$n=10^6$时**：普通递归需$10^6$次操作，快速幂仅需$\log_2 10^6 \approx 20$次操作。 --- ### **四、数学归纳法证明时间复杂度** #### **1. 递归关系式** 设$T(n)$为计算$x^n$的时间复杂度，则递归关系为： $$ T(n) = T\left(\frac{n}{2}\right) + O(1) $$ - **解释**：每次递归分解为$n/2$的问题，加上常数时间的乘法和判断。 #### **2. 求解递归式** 根据主定理（Master Theorem）： $$ T(n) = T(n/2) + O(1) → T(n) = O(\log n) $$ --- ### **五、边界条件与特殊情况** #### **1. 当$n=0$或$n=1$时** - 直接返回结果，时间复杂度为$O(1)$。 #### **2. 当$n$为负数时** - 当前代码未处理负数情况，需额外逻辑（如取倒数）。 #### **3. 整数溢出问题** - 例如$x=2, n=30$时，结果可能超过`INT_MAX`（假设为32位整型）。 --- ### **六、总结** - **时间复杂度**：$O(\log n)$，因为每次递归将问题规模减半。 - **执行过程**：通过分治策略递归分解指数，复用中间结果减少重复计算。 - **优势**：适合大指数计算，避免普通递归的指数级时间开销。 --- #### **附录：时间复杂度对比表** | 算法类型 | 时间复杂度 | 计算$2^{30}$所需操作次数 | |------------|------------|--------------------------| | 普通递归 | $O(n)$ | 30次乘法 | | 快速幂 | $O(\log n)$| 5次乘法（$\log_2 30 \approx 5$） |
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值