算法中的计算

㈠ 一文讲透算法中的时间复杂度和空间复杂度计算方式

作为一名“程序猿”，大家应该都听过这么一句话：程序=数据结构+算法。

这句话是由瑞士计算机科学家尼古拉斯·沃斯（Niklaus Wirth）在 1984 年获得图灵奖时说的一句话，这位大佬还以这句话为名出了一本书《Algorithms + Data Structures=Programs》，从此这句话就成为了大家耳熟能详的一句名言。

随着时间的推移，不管这句话是不是非常准确，但至少能说明数据结构与算法对程序来说是非常核心的基础，如果我们想要写出更多优秀优雅的代码，那么数据结构与算法是必须要掌握好的。

很多人可能觉得，我不会算法，代码一样写得很"溜"，算法这东西似乎用处不大。现在互联网的发达，我们想要什么几乎都可以在网上找到现成的，各种框架功能十分强大，似乎看起来确实不用算法也可以写出“好代码”。然而假如我们不懂算法，比如项目中用到了排序，我们如何评估代码的执行效率？再比如最常用的 ArrayList 和 LinkedList ，我们该如何选择，又比如说我们需要去集合中找某一个数，又该如何写出性能优秀的代码呢？

同样的代码，如何判断谁的代码是优秀的代码？可读性，可扩展性，健壮性可能都可以用来判定，然而这些东西我觉得并不能直接体现出你代码的优秀，因为对用户而言，访问你的代码响应速度快那就是优秀的代码，相反，动辄响应几秒甚至更长时间的接口，恐怕就算你可读性再好，再健壮也称不上是好代码。

所以说一段代码是否优秀，最直接的判断标准就是性能，而如果要写出高性能的代码，那么就必须要了解算法，而且抛开这个因素，但凡不想一辈子都写 CRUD 代码的，也需要去了解算法，我们使用的很多框架和中间件底层都有数据结构和算法的身影，学好算法对我们源码阅读时理解其设计思想也是大有裨益的。

要说功利性的目的，那就是面试，目前很多大厂的面试，算法基本必面，所以想进大厂的话，咱们也得好好学学算法。

提到算法，很多人的第一反应就是太难学了，学不会，或者说经常是看完就忘了，但是其实对于我们一个普通的开发者而言，因为并不需要我们去发明算法，我们需要的仅仅只是去灵活的运用算法，所以并不需要非常扎实的数据基础，当然基本的数学常识还是要有的。

如果说需要去发明设计一款算法，那就要去推导去证明算法的可行性，这种是需要具有非常扎实的数学基础的，一般人确实无法做到，然而我们普通程序员口中提到算法无非是二分查找法，哈希算法等，高级一点的就还有回溯，贪心，动态规划等等，这些所谓的算法都是已经有现成的公式了，我们要做的无非就是理解它，然后灵活的运用它。这就和我们以前学习数学公式一样，给你一个公式，然后你去做题，做题的过程其实就是去灵活地运用这个公式。

算法也是同理，都是有特定方法和特定思路的，我们也并不需要去推导证明这种方式为什么可行，所以学习算法没有其他诀窍，就是先理解思路，然后多练，等熟练了，自然就可以灵活运用了，也不会说学了立刻就忘了。学完就忘无非两个原因，一是没理解，二是没有练习巩固。

数据结构与算法经常是放在一起讲，这两者是没办法独立的，因为算法是为了达到某种目的的一种实现方式，而数据结构是一种载体，也就是说算法必须依赖数据结构这种载体，否则就是空谈。换句话说：数据结构是为算法服务的，而算法又需要作用在特定的数据结构之上。

一个算法到底好不好，我们如何去评价？前面我们提到了，你的代码好不好，最直观的就是看响应速度，算法也一样，同样实现一个目的（比如说排序），谁的算法速度快，我们就可以认为谁的算法更优，如果说两种算法实现的速度差不多，那么我们还可以去评价算法所占用的空间，谁占用的空间少，那么就可以认为谁的算法更优，这就是算法的基础：时间复杂度和空间复杂度。

学习算法之前，我们必须要学会如何分析时间复杂度和空间复杂度（也就是“快”和“省”），否则自己写出来的算法自己都不知道算法的效率。

接触过算法的都知道，算法的时间复杂度是用大写的“O”来表示的，比如： O(1) ， O(n) ， O(logn) ， O(nlogn) ， O(n²) 等等。

变量指的是变量，也就是一段代码的执行时间是随着变量的变化而变化的，而不变指的是常量，也就是不论我的变量如何改变，执行时间都不会改变。

接下来我们就实际的来分析下常用时间复杂度的例子来练习一下。

0(1) 复杂度算法也称之为常数阶算法。这里的 1 是用来代指常量，也就是说这个算法的效率是固定的，无论你的数据量如何变化，效率都一样，这种复杂度也是最优的一种算法。

上面的示例中不论有多少行代码，时间复杂度都是属于常数阶段。换言之：只要代码不存在 循环 ， 递归 等循环类调用，不论代码有多少行，其复杂度都是常数阶。

O(n) 复杂度算法也称之为线性阶段。比如下面这个示例我们应该怎么分析复杂度呢？

前面常量阶没分析是因为常量阶比较容易理解，接下来我们就以线性阶这个为例子来分析下具体是怎么得到的。

我们假设每一行代码的执行时间是 T ，那么上面这段代码的执行复杂度是多少呢？

答案很明显，那就是 T+n*T ，也就是 (n+1)T ，而在算法中有一个原则，那就是常量可以被忽略，所以就得到了 nT ，换成大 O 表示法就是 O(n) 。

这只是一个简略的计算过程，大家也不用较真说每行代码执行时间可能不一样之类的，也不要较真说 for 循环占用了一行，下面的大括号也占用了一行，如果要较真这个，那我建议可以去想一下 1=1 为什么等于 2 。

算法中的复杂度反应的只是一个趋势，这里 O(n) 反应的就是一个趋势，也就是说随着 n 的变化，算法的执行时间是会降低的。

知道了上面的线性阶，那么平方阶就很好理解了，双层循环就是平方阶，同理，三次循环就是立方阶， k 次循环就是 k 次方阶。

O(logn) 也称之为对数阶，对数阶也很常见，像二分查找，二叉树之类的问题中会见到比较多的对数阶复杂度，但是对数阶也是比较难理解的一种算法复杂度。

下面我们还是来看一个例子：

这段代码又该如何分析复杂度呢？这段代码最关键的就是要分析出 while 循环中到底循环了多少次，我们观察这个循环，发现 i 并不是逐一递增，而是不断地翻倍： 1->2->4->8->16->32->64 一直到等于 n 为什么才会结束，所以我们得到了这样的一个公式： 2^x=n 。

也就是说我们只要计算出 x 的值，就得到了循环次数，而根据高中的数学知识我们可以得到 x=log2n （ 2 在下面，是底数，试了几种方法都打不出来，放弃了），所以根据上面线性阶的分析方法，我们省略常量，就得到了示例中的算法复杂度为 O(log2n) 。

同样的分析方式，下面的例子，我们可以很快地分析出复杂度就为 O(log3n) ：

上面得到的 log3n 我们可以再做进一步的转换： log3n=log32 * log2n ，而 log32 （注意这几个地方的情况 3 是底数，在下面） 是一个常量，常量可以省略，所以也就得到了： O(log3n)=O(log2n) 。同样的道理，不论底数是多少，其实最终都可以转化成和 O(log2n) 相等，正因为如此，为了方便，我们算法中通常就会省略底数，直接写作 O(logn) 。

上面的数学公式大家如果忘了或者看不懂也没关系，只要记住不论对数的底数是多少，我们都算作 O(logn) ，而对于一个算法的复杂度是否是对数阶，还有一个简易的判断方法： 当循环中下标以指定倍数形式衰减，那么这就是一个对数阶 。

如果理解了上面的对数阶，那么这种线性对数阶就非常好理解了，只需要在对数阶的算法中再嵌一层循环就是线性对数阶：

分析了前面这些最常用的时间复杂度，其实我们可以得到以下规律：

除了上面常用的复杂度之外，另外还有指数阶，阶层阶，根号阶等，这些接触的相对会较少，我们就不特意做分析了，如果大家感兴趣的话，可以自己去了解下。

前面我们分析的都是只有一段代码比较复杂的情况下得到的复杂度结果，那么假如我一个算法中，有多段代码都比较复杂呢？这时候复杂度该如何分析？

我们先看下面这个例子：

这个例子中有三个循环，首先第一个，是一个常量，那么根据前面的结论，不论这个常量是多大，都属于常量级，所以第一个循环中的复杂度为 O(1) ，第二个和第三个循环我们前面也分析过，复杂度分别为 O(n) 和 O(n²) 。

也就是这一段代码中有三段代码产生了三种不同复杂度，而且这三个复杂度可以很明显得到的大小关系为： O(1)<o(n)<o(n²) span=""> </o(n)<o(n²)> ，像这种在同一个算法中有明确大小关系的，我们就可以直接取最大值作为这个算法的复杂度，所以这个例子中算法的复杂度就是 O(n²) 。

接下来我们再来看一个例子：

这个例子我们同样对三段循环分别分析可以分别得到如下复杂度： O(1) ， O(m) ， O(n) 。这时候我们只能知道 O(1) 最小可以忽略，但是后面两个无法却无法确定大小，所以这时候我们需要取两段循环复杂度之和来作为算法的复杂度，所以可以得到这个例子的算法复杂度为： O(m+n) 。

上面分析的时间复杂度都是比较简单的，实际算法中可能会比示例中复杂的多，而且我们示例中只要是循环都是无脑循环，也就是一定从头循环到尾，然而实际中我们有时候并不需要从头循环到尾，可能中途就会结束循环，所以我们根据实际情况，又可以将时间复杂度从以下四个方面来进一步分析：

这四种类型的时间复杂度在这里只会介绍前面三种，因为第四种比较复杂，而且使用场景也非常有限，而且对于这四种复杂度的分析，大家也作为了解就可以，不敢兴趣的朋友们可以跳过这一小部分，因为在绝大部分情况我们只需要分析最坏复杂度就行，也就是假设循环全部执行完毕场景下的时间复杂度。

我们通过一个例子来理解下最好时间复杂度：

这个方法就是在一个指定数组中找到指定元素的下标，找不到就返回 -1 ，这个方法比较简单，应该比较好理解。

注意这个方法中的循环体，如果找到元素，那么就直接返回，这就会有一个现象，那就是我这个循环体到底会循环多少次是不确定的，可能是 1 次，也可能是 n （假设数组的长度） 次，所以假如我们要找的元素就在数组中的第一个位置，那么我循环一次就找到了，这个算法的复杂度就是 O(1) ，这就是最好情况时间复杂度。

理解了最好时间复杂度，那么最坏时间复杂度也很好理解了，那就是数组中不存在我要找到元素，或者说最后一个值才是我要找的元素，那么这样我就必须循环完整个数组，那么时间复杂度就是 O(n) ，这也就是最坏时间复杂度。

最好时间复杂度和最坏时间复杂度毕竟只有特殊情况才会发生，概率还是相对较小，所以我们很容易就想到我们也需要有一个平均时间复杂度。

我们简单的来分析一下，为了便于分析，我们假设一个元素在数组和不在数组中的概率都为 1/2 ，然后假如在数组在，那么又假设元素出现在每个位置的概率也是一样的，也就是每个位置出现元素的概率为： 1/n 。

所以最终得到的平均时间复杂度应该等于元素在数组中和元素不在数组中两种情况相加。

因为元素在数组中的概率为 1/2 ，然后在每个位置出现的概率也为 1/n 。假如元素出现在第一个位置，复杂度为 1*(1/2n) ；假如元素出现在第二个位置，复杂度为 2 * (1/2n) ，最终得到当前场景下时间复杂度为： 1*(1/2n) + 2 * (1/2n) + ... + n*(1/2n) =(n+1)/4。

前面已经假定了元素不在数组中的概率为 1/2 ，所以当前场景下的时间复杂度为： n * (1/2) ，因为元素不在数组中，那么这个算法必然会将整个循环执行完毕，也就循环是 n 次。

最后我们把两种情况的复杂度之和相加就得到了平均时间复杂度： (n+1)/4 + n/2 = (3n+1)/4 ，最终我们将常数类的系数忽略掉，就得到了平均时间复杂度为 O(n) 。

均摊时间复杂度的算法需要使用摊还分析法，计算方式相对有点复杂，而且使用场景很有限，本文就不做过多介绍了。

空间复杂度全称就是渐进空间复杂度，用来表示算法的存储空间与数据规模之间的增长关系。和时间复杂度一样，空间复杂度也是用大 O 进行表示。

其实学会了分析时间复杂度，那么空间复杂度的分析就简单了，主要就看我们在一个算法当中到底有没有使用到了额外的空间来进行存储数据，然后判断这个额外空间的大小会不会随着 n 的变化而变化，从而得到空间复杂度。

我们来看一个给数组赋值例子，假设这就是一个算法，我们可以来分析下这个算法的空间复杂度：

一开始定义了一个变量，这里需要空间，但是这是一个常量级的（不随 n 的变化而变化），然后再定义了一个数组，数组的长度为 n ，这里数组也需要占用空间，而且数组的空间是随着 n 的变化而变化的，其余代码没有占用额外空间，所以我们就可以认为上面示例中的空间复杂度为 O(n) 。

对于算法的空间复杂度也可以简单的进行总结一下：

本文主要讲述了为什么要学习算法，也简单减少了数据结构与算法之间的关系，随后主要介绍了算法中的入门知识：时间复杂度和空间复杂度。想要学好算法，必须要掌握如何分析一个算法的时间复杂度和空间复杂度，只有自己会分析这两个个衡量算法主要性能的标准，才能更好的写出性能优秀的算法，同时我们也讲到了最好时间复杂度，最坏时间复杂度，平均时间复杂度和均摊时间复杂度，不过这四种复杂度的计算方式大家作为了解即可，等实际确实需要使用到再来回顾也不迟。

㈡ 在算法设计中，怎么计算出算法是指数计算时间还是多项式计算时间呢

举个例子: for(i=1:i<n:i++)

{
index ++;
for(j=1:j<n;j++)
{
sum ++;
}
}

对于一个确定的n，要算n^2 +n次，其中有两项，随着n增加，增长速度最快的是n^2这一项（导数最大），所以，这就是一个多项式级复杂度的算法（n^2级）

for(k=1:k<2^n;k++)
{
abc ++;
}

for(i=1:i<n:i++)

{
index ++;
for(j=1:j<n;j++)
{
sum ++;
}
}

这个里面，对于一个确定的n，要计算2^n+n^2+n次，很显然，现在随着n的增长，增加速度最快的是2^n这一项，所以他是一个指数级复杂度的算法（2^n级）

现在懂了吧？一个算法的复杂度很可能是某几项的加总，其中有一项增长最快，它是多项式型，就是多项式级，是指数型，就是指数级。是阶乘型，就是阶乘级。另外，如果最高项是2*n^2这样的，那么复杂度仍然是n^2，系数不要。

㈢ 算法空间复杂度具体怎么算

数据结构中算法空间复杂度计算方法：

一个算法的空间复杂度只考虑在运行过程中为局部变量分配的存储空间的大小，它包括为参数表中形参变量分配的存储空间和为在函数体中定义的局部变量分配的存储空间两个部分。

若一个算法为递归算法，其空间复杂度为递归所使用的堆栈空间的大小，它等于一次调用所分配的临时存储空间的大小乘以被调用的次数(即为递归调用的次数加1，这个1表示开始进行的一次非递归调用)。

空间复杂度(Space Complexity)是对一个算法在运行过程中临时占用存储空间大小的量度，记做S(n)=O(f(n))。

而一般的递归算法就要有O(n)的空间复杂度了，因为每次递归都要存储返回信息。一个算法的优劣主要从算法的执行时间和所需要占用的存储空间两个方面衡量。

㈣ 什么是算法算法有哪些分类

分类算法是在数学和计算机科学之中，算法为一个计算的具体步骤，常用于计算、数据处理和自动推理。

精确而言，算法是一个表示为有限长列表的有效方法。算法应包含清晰定义的指令用于计算函数，算法分类可以根据算法设计原理、算法的具体应用和其他一些特性进行分类。

具体意义：

如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

算法中的指令描述的是一个计算，当其运行时能从一个初始状态和（可能为空的）初始输入开始，经过一系列有限而清晰定义的状态，最终产生输出并停止于一个终态。一个状态到另一个状态的转移不一定是确定的。随机化算法在内的一些算法，包含了一些随机输入。

㈤ BBR算法中轮数计算方法

        轮数在拥塞算法中是一个重要的概念，基于丢包的拥塞算法中，比如reno算法在拥塞避免阶段，每轮进行一次拥塞窗口加1，bic算法也是每轮进行一次拥塞窗口增加，只是增加的幅度不同，而基于时延的拥塞算法，如vegas算法，检测出一轮内的最小rtt_us值，与rtt_min对比推断得到当前网络的数据包排队的情况。这些例子中可以看出，对于算法的实现都需要考虑轮数的统计。

        那算法是如何计算轮数的呢？主要分为三种，一种形如reno，bic这类算法中，轮数的计算建立在 某一轮能发送snd_cwnd个数据包，当累计了snd_cwnd个数据包确认，就为一轮结束。算法中有个snd_cwnd_cnt变量用来累计当前轮已经收到了多少的数据包确认，当该值大于等于拥塞窗口snd_cwnd，就认为一轮结束了。

以reno为例，w为控制增窗的频率快慢，reno中等于snd_cwnd

   void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w)

   {

        if (tp->snd_cwnd_cnt >= w) { //累计了snd_cwnd个ack数据包

            if (tp->snd_cwnd < tp->snd_cwnd_clamp)//未超过申明的最大窗口值

                tp->snd_cwnd++;

             tp->snd_cwnd_cnt = 0; //累计ack个数清零

         } else {//累计ack个数

            tp->snd_cwnd_cnt++;

        }

}

        第二类，如vegas这种基于时延的拥塞算法中，用序列号进行区分，记录某一轮的起始点对应的snd_nxt，当snd_nxt所对应的数据包没有发生重传，被接收端ack确认的时间即为一个rtt，也就是一轮，如下图所示，数据包a被ack确认时，只有线段SEQ1以上的数据包是之后发送的，当这区间某个数据包被ack确认，说明已经经过了一轮rtt，新一轮中，只有线段SEQ2以上的数据包是之后发送的。

以vegas算法为例，

if (after(ack, vegas->beg_snd_nxt)) {

    /* Do the Vegas once-per-RTT cwnd adjustment. */

    /* Save the extent of the current window so we can use this

    * at the end of the next RTT.

    */

    vegas->beg_snd_nxt  = tp->snd_nxt;

    ...

}

        第三种就是bbr算法中所使用的轮数计算方法，用时间来区分，每个数据包发送都记录当前交付到对端的数据包个数delivered，某一时刻T为一轮的起始点，对应的交付到对端个数为D，时间小于T的记录的delivered都小于D，之后发送的数据包记录的delivered都大于等于D，当接收端收到ack(sack)数据包对应发送的delivered大于等于D，说明T时刻之后发送的数据包至少有个一到达了接收端，即经过了一轮RTT。

        如上图所示，时刻T1所对应的tp->delivered 为D，那时刻T1右侧发送的数据包都是之后发送的，记录prior_delivered都大于等于D，当两个重传数据包被ack确认时，其对应的prior_delivered都为D，说明T1时刻之后发送的两个数据包经过一个RTT传输已经被接收，已经经过了一轮，开始了新一轮，而此时tp->delivered为D+2，之后发送的数据包记录的prior_delivered都大于等于D+2，当收到ack确认的数据包记录的prior_delivered大于等于D+2，说明时间已经又过了一轮，新一轮已经开始。

/* See if we've reached the next RTT */

if (!before(rs->prior_delivered, bbr->next_rtt_delivered)) {

    bbr->next_rtt_delivered = tp->delivered;

    bbr->rtt_cnt++;

    bbr->round_start = 1;

    ...

}

rs->prior_delivered就为每个ack(sack)确认的包发送时记录的tp->delivered值，当其大于等于某一轮起始的delivered值，就为新一轮开始。

        这三种不同的方法，bic算法中这样处理是由于比如窗口每轮增加5个包，并不是一轮结束后窗口加5，而是每经过1/5的窗口值就进行拥塞窗口加1的操作。vegas算法中，需要统计一轮内最小rtt_us，需要知道某一轮的起始和结束点，定期的重置当前轮内追踪到的最小rtt_us以及调整窗口值。然而，BBR算法不仅负责拥塞避免阶段的发包，而且还接管了拥塞丢包状态下发包行为，而vegas算法中的轮数计算只能用于不丢包的open/disorder状态，假设某个时刻发生大面积丢包，拥塞窗口骤降，需要经过两三轮的重传才能重传完毕，才能推进snd_una，进而更新轮数。这对BBR来说是非常不合适了，因为已经拥塞丢包了，网络状况很有可能已经变差了，而这时却因为计算出来的轮数偏小，不能及时的更新最大带宽值，进而延迟了网络处于拥塞的状态时间。

㈥ 计算教学中如何正确处理算理和算法的关系

计算的算理是指计算的理论依据，通俗地讲就是计算的道理。算理一般由数学概念、定律、性质等构成，用来说明计算过程的合理性和科学性。计算的算法是计算的基本程序或方法，是算理指导下的一些人为规定，用来说明计算过程中的规则和逻辑顺序。

算理和算法既有联系，又有区别。算理是客观存在的规律，主要回答“为什么这样算”的问题；算法是人为规定的操作方法，主要解决“怎样计算”的问题。算理是计算的依据，是算法的基础，而算法则是依据算理提炼出来的计算方法和规则，它是算理的具体体现。算理为计算提供了正确的思维方式，保证了计算的合理性和可行性；算法为计算提供了便捷的操作程序和方法，保证了计算的正确性和快速性。算理和算法是计算教学中相辅相成、缺一不可的两个方面。

处理好算理与算法的关系对于突出计算教学核心，抓住计算教学关键具有重要的作用。当前，计算教学中“走极端”的现象实质上是没有正确处理好算理与算法之间关系的结果。一些教师受传统教学思想、教学方法的支配，计算教学只注重计算结果和计算速度，一味强化算法演练，忽视算理的推导，教学方式“以练代想”，学生“知其然，不知其所以然”，导致教学偏向“重算法、轻算理”的极端。与此相反，一些教师片面理解了新课程理念和新教材，他们把过多的时间用在形式化的情境创设、动手操作、自主探索、合作交流上，在理解算理上大做文章，过分强调为什么这样算，还可以怎样算，却缺少对算法的提炼与巩固，造成学生理解算理过繁，掌握算法过软，形成技能过难，教学走向“重算理、轻算法”的另一极端。

如何正确处理算理与算法的关系，防止“走极端”的现象，广大数学教师在教学实践中进行了有益的探索，取得了许多成功经验。比如，“计算教学要寻求算理与算法的平衡，使计算教学‘既重算理，又重算法”“把算理与算法有机融合，避免算理与算法的‘硬性对接’”“引导学生在理解算理的基础上自主地生成算法，在算法形成与巩固的过程中进一步明晰算理”“计算教学要让学生探究并领悟算理，及时抽象并掌握算法，力求形成技能并学会运用”等等，这些观点对于计算教学少走弯路、提高计算教学质量具有重要作用。

对此，笔者认为，处理计算教学中算理与算法的关系还应注意以下五点：一是算理与算法是计算教学中有机统一的整体，形式上可分，实质上不可分，重算法必须重算理，重算理也要重算法；二是计算教学的问题情境既为引出新知服务，体现“学以致用”，也为理解算理、提炼算法服务，教学要注意在“学用结合”的基础上，以理解算理，掌握算法，形成技能为主；三是算理教学需借助直观，引导学生经历自主探索、充分感悟的过程，但要把握好算法提炼的时机和教学的“度”，为算法形成与巩固提供必要的练习保证；四是算法形成不能依赖形式上的模仿，而要依靠算理的透彻理解，只有在真正理解算理的基础上掌握算法、形成计算技能，才能算是找到了算理与算法的平衡点；五是要防止算理与算法之间出现断痕或硬性对接，要充分利用例题或“试一试”中的“可以怎样算？”“在小组里说一说，计算时要注意什么？”等问题，指导学生提炼算法，为算理与算法的有效衔接服务。

㈦ 什么叫算法算法有哪几种表示方法

算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。计算机科学家往往将“算法”一词的含义限定为此类“符号算法”。“算法”概念的初步定义：一个算法是解决一个问题的进程。而并不需要每次都发明一个解决方案。

已知的算法有很多，例如“分治法”、“枚举测试法”、“贪心算法”、“随机算法”等。

(7)算法中的计算扩展阅读

算法中的“分治法”

“分治法”是把一个复杂的问题拆分成两个较为简单的子问题，进而两个子问题又可以分别拆分成另外两个更简单的子问题，以此类推。问题不断被层层拆解。然后，子问题的解被逐层整合，构成了原问题的解。

高德纳曾用过一个邮局分发信件的例子对“分治法”进行了解释：信件根据不同城市区域被分进不同的袋子里；每个邮递员负责投递一个区域的信件，对应每栋楼，将自己负责的信件分装进更小的袋子；每个大楼管理员再将小袋子里的信件分发给对应的公寓。

㈧ c语言中什么是算法有哪些描述算法的例子

1、有穷性（有限性）。任何一种提出的解题方法都是在有限的操作步骤内可以完成的。
如果在有限的操作步骤内完不成，得不到结果，这样的算法将无限的执行下去，永远不会停止。除非手动停止。例如操作系统就不具有有穷性，它可以一直运行。
2、一个算法应该具有以下七个重要的特征：
1）有穷性（finiteness）
算法的有穷性是指算法必须能在执行有限个步骤之后终止
2）确切性(definiteness)
算法的每一步骤必须有确切的定义；
3）输入项(input)
一个算法有0个或多个输入,以刻画运算对象的初始情况,所谓0个输入是指算法本身定出了初始条件；
4）输出项(output)
一个算法有一个或多个输出,以反映对输入数据加工后的结果.没有输出的算法是毫无意义的；
5）可行性(effectiveness)
算法中执行的任何计算步都是可以被分解为基本的可执行的操作步,即每个计算步都可以在有限时间内完成；
6）
高效性（high
efficiency）
执行速度快,占用资源少；
7）
健壮性（robustness）
健壮性又称鲁棒性，是指软件对于规范要求以外的输入情况的处理能力。所谓健壮的系统是指对于规范要求以外的输入能够判断出这个输入不符合规范要求，并能有合理的处理方式。

㈨ rsa算法中的mod运算

15^27(mod 33)=15*15^26( mod 33)=15*(15^2)^13(mod 33)=15*27^13(mod 33)=15*27*27^12(mod 33)=9*(27^4)^3(mod 33)=9*9^3(mod 33)=9^4(mod 33)=27(mod 33)
不知道楼主看懂没,简言之就是把乘方分开处理,

㈩ 数学的各种算法

算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。
算法中的指令描述的是一个计算，当其运行时能从一个初始状态和（可能为空的）初始输入开始，经过一系列有限而清晰定义的状态，最终产生输出并停止于一个终态。一个状态到另一个状态的转移不一定是确定的。随机化算法在内的一些算法，包含了一些随机输入。
形式化算法的概念部分源自尝试解决希尔伯特提出的判定问题，并在其后尝试定义有效计算性或者有效方法中成形。这些尝试包括库尔特·哥德尔、Jacques Herbrand和斯蒂芬·科尔·克莱尼分别于1930年、1934年和1935年提出的递归函数，阿隆佐·邱奇于1936年提出的λ演算，1936年Emil Leon Post的Formulation 1和艾伦·图灵1937年提出的图灵机。即使在当前，依然常有直觉想法难以定义为形式化算法的情况。
一个算法应该具有以下五个重要的特征：
有穷性
（Finiteness）
算法的有穷性是指算法必须能在执行有限个步骤之后终止；
确切性
(Definiteness)
算法的每一步骤必须有确切的定义；
输入项
(Input)
一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件；
输出项
(Output)
一个算法有一个或多个输出，以反映对输入数据加工后的结果。没有输出的算法是毫无意义的；
可行性
(Effectiveness)
算法中执行的任何计算步骤都是可以被分解为基本的可执行的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）。
一、数据对象的运算和操作：计算机可以执行的基本操作是以指令的形式描述的。一个计算机系统能执行的所有指令的集合，成为该计算机系统的指令系统。一个计算机的基本运算和操作有如下四类：[1]
1.算术运算：加减乘除等运算
2.逻辑运算：或、且、非等运算
3.关系运算：大于、小于、等于、不等于等运算
4.数据传输：输入、输出、赋值等运算[1]
二、算法的控制结构：一个算法的功能结构不仅取决于所选用的操作，而且还与各操作之间的执行顺序有关。
算法可大致分为基本算法、数据结构的算法、数论与代数算法、计算几何的算法、图论的算法、动态规划以及数值分析、加密算法、排序算法、检索算法、随机化算法、并行算法，厄米变形模型，随机森林算法。
算法可以宏泛地分为三类：
一、有限的，确定性算法 这类算法在有限的一段时间内终止。他们可能要花很长时间来执行指定的任务，但仍将在一定的时间内终止。这类算法得出的结果常取决于输入值。
二、有限的，非确定算法 这类算法在有限的时间内终止。然而，对于一个（或一些）给定的数值，算法的结果并不是唯一的或确定的。
三、无限的算法 是那些由于没有定义终止定义条件，或定义的条件无法由输入的数据满足而不终止运行的算法。通常，无限算法的产生是由于未能确定的定义终止条件。
希望我能帮助你解疑释惑。