基础算法

时间复杂度  O(N)

  for(i=1;i<=n;i++)   //循环了n*n次，当然是O(n^2)

           for(j=1;j<=n;j++)

                 s++;

 

快速排序

解释：快速排序是找出一个元素（理论上可以随便找一个）作为基准(pivot),然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正确位置，排序完成。所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。

 

举例说明一下吧，这个可能不是太好理解。假设要排序的序列为

 

2 2 4 9 36 7 1 5 首先用2当作基准，使用i j两个指针分别从两边进行扫描，把比2小的元素和比2大的元素分开。首先比较2和5，5比2大，j左移

 

2 2 4 9 36 7 1 5 比较2和1，1小于2，所以把1放在2的位置

 

2 1 4 9 36 7 1 5 比较2和4，4大于2，因此将4移动到后面

 

2 1 4 9 36 7 4 5 比较2和7，2和6，2和3，2和9，全部大于2，满足条件，因此不变

 

经过第一轮的快速排序，元素变为下面的样子

[1] 2 [49 3 6 7 5]

 

之后，在把2左边的元素进行快排，由于只有一个元素，因此快排结束。右边进行快排，递归进行，最终生成最后的结果。

 

 

它的平均时间复杂度为O(nlgn)。

 

 

堆排序算法

 

例如有数据[3,5,7,11,55,42,466,4]

此时有

3

5               7

         11    55        42            466

4

 

 

3

5               7

         4    55          42            466

11

 

3

4               7

         5    55          42            466

11

 

 

 

 

 

每次进行排序，若不满足条件一直排序，排序需要满足的规则是

         N1

N2     N3

N1 要小于N2 N3才是满足条件的

 

 

 

 

 

 

二分查找算法

　　二分查找算法是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜素过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。如果在某一步骤数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。折半搜索每次把搜索区域减少一半，时间复杂度为Ο(logn)。

 

 

 

 

 

BFPRT(线性查找算法)

 

介绍：

 

BFPRT算法解决的问题十分经典，即从某n个元素的序列中选出第k大（第k小）的元素，通过巧妙的分析，BFPRT可以保证在最坏情况下仍为线性时间复杂度。该算法的思想与快速排序思想相似，当然，为使得算法在最坏情况下，依然能达到o(n)的时间复杂度，五位算法作者做了精妙的处理。

BFPRT算法：1973年， Blum、 Floyd 、 Pratt 、 Rivest、 Tarjan

时间复杂度

O(N)

 

算法步骤：

 

 

1. 将n个元素每5个一组，分成n/5(上界)组。

 

2. 取出每一组的中位数，任意排序方法，比如插入排序。

 

3. 递归的调用selection算法查找上一步中所有中位数的中位数，设为x，偶数个中位数的情况下设定为选取中间小的一个。

 

4. 用x来分割数组，设小于等于x的个数为k，大于x的个数即为n-k。

 

5. 若i==k，返回x；若ik，在大于x的元素中递归查找第i-k小的元素。

 

终止条件：n=1时，返回的即是i小元素。

 

例如有一组数据   n=10

11，14，44，21，24，99，54，22，90，57

先把他分成2组，n/5个为一组

A组   11，14，44，21，24

B组   99，54，22，90，57

 

在他们中选出中位数，随便选一种算法

中位数是  21 57

再在21 57选一个中位数，这里只有2个那么就选21

 

那么现在x = 21

小于等于21的有3个  那么k=3

那么大于21的有n-k    10-3 =7

 

如果要寻找第K小的数字，那么正好是X返回X

若ik，在大于x的元素中递归查找第i-k小的元素。

 

深度优先搜索(DFS)

 

深度优先搜索（缩写DFS）有点类似广度优先搜索，也是对一个连通图进行遍历的算法。它的思想是从一个顶点V0开始，沿着一条路一直走到底，如果发现不能到达目标解，那就返回到上一个节点，然后从另一条路开始走到底，这种尽量往深处走的概念即是深度优先的概念。

　深度优先搜索算法（Depth-First-Search），是搜索算法的一种。它沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。DFS属于盲目搜索。

　　深度优先搜索是图论中的经典算法，利用深度优先搜索算法可以产生目标图的相应拓扑排序表，利用拓扑排序表可以方便的解决很多相关的图论问题，如最大路径问题等等。一般用堆数据结构来辅助实现DFS算法。

　　深度优先遍历图算法步骤：

　　1.访问顶点v；

　　2.依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问；

　　3.若此时图中尚有顶点未被访问，则从一个未被访问的顶点出发，重新进行深度优先遍历，直到图中所有顶点均被访问过为止。

　　上述描述可能比较抽象，举个实例：

　　DFS在访问图中某一起始顶点v后，由v出发，访问它的任一邻接顶点w1；再从w1出发，访问与w1邻接但还没有访问过的顶点w2；然后再从w2出发，进行类似的访问，…如此进行下去，直至到达所有的邻接顶点都被访问过的顶点u为止。

　　接着，退回一步，退到前一次刚访问过的顶点，看是否还有其它没有被访问的邻接顶点。如果有，则访问此顶点，之后再从此顶点出发，进行与前述类似的访问；如果没有，就再退回一步进行搜索。重复上述过程，直到连通图中所有顶点都被访问过为止。

 

例子

图2-1 寻找V0到V6的一条路（无需最短路径）

假设按照以下的顺序来搜索：

1.V0->V1->V4，此时到底尽头，仍然到不了V6，于是原路返回到V1去搜索其他路径；

2.返回到V1后既搜索V2，于是搜索路径是V0->V1->V2->V6,，找到目标节点，返回有解。

这样搜索只是2步就到达了，但是如果用BFS的话就需要多几步。

 

广度优先搜索算法（Breadth-First-Search）

 

刚刚说的广度优先搜索是连通图的一种遍历策略，那就有必要将图先简单解释一下。

 

图2-1连通图示例图

 

如图2-1所示，这就是我们所说的连通图，这里展示的是一个无向图，连通即每2个点都有至少一条路径相连，例如V0到V4的路径就是V0->V1->V4。

一般我们把顶点用V缩写，把边用E缩写。

 

3.1.算法的基本思路

常常我们有这样一个问题，从一个起点开始要到一个终点，我们要找寻一条最短的路径，从图2-1举例，如果我们要求V0到V6的一条最短路（假设走一个节点按一步来算）【注意：此处你可以选择不看这段文字直接看图3-1】，我们明显看出这条路径就是V0->V2->V6，而不是V0->V3->V5->V6。先想想你自己刚刚是怎么找到这条路径的：首先看跟V0直接连接的节点V1、V2、V3，发现没有V6，进而再看刚刚V1、V2、V3的直接连接节点分别是：{V0、V4}、{V0、V1、V6}、{V0、V1、V5}（这里画删除线的意思是那些顶点在我们刚刚的搜索过程中已经找过了，我们不需要重新回头再看他们了）。这时候我们从V2的连通节点集中找到了V6，那说明我们找到了这条V0到V6的最短路径：V0->V2->V6，虽然你再进一步搜索V5的连接节点集合后会找到另一条路径V0->V3->V5->V6，但显然他不是最短路径。

 

例如

3. 倒酒问题

 

一个8L杯子装满了酒，有一个一个3L空杯子和一个5L空杯子，问怎样才能用最少的次数倒出4L的酒。（不能倒掉）

这是一个面试中常见的逻辑题，做到这样的题，如果不了解其背后的套路，只是像个没头苍蝇一样不断的去尝试，倒来倒去可能会花很多时间，而且不一定是最少的，甚至，还有可能把自己绕晕。

 

一个解法是把每次倒完后3个杯子中酒的数量视为一个状态，而”倒“的过程则是一个状态迁移的过程，初始状态为800，状态迁移则是把杯子A的酒倒入杯子B，结果要求要么A为空，要么B为满。我们可以有如下推理过程：

 

 

 

对于这个推理过程，要注意两点：

 

一是我采用了“宽度优先” 的状态迁移过程，也就是说我的思路过程是从左到右，然后在每一列上从上到下，这可以保证我找到的是最少的步数

二是对于已经出现过的状态，我不再处理，不然问题规模不会逐渐缩小（如从800到530后，很自然在扩展530的时候，我还可以倒回去成为800，但因为800出现过，不再处理）

这里，800-305-332-602-620-125-134这条路线以一步的优势胜出！

 

 

例如 连连看问题

 

这其实是《编程之美》第一章”1.14 连连看游戏设计“中介绍的一个算法，连连看可以由一个二维数组表示，数组元素的值表示不同的图形，我们可以用0表示该位置没有图形。连连看中两个结点能够相连从而消去的标准是：相连不超过两个弯的相同图形：

这个问题的结构与迷宫问题有点类似，可是为了应用BFS，我们的大脑也得转个弯，玩家依次点了两个结点后，我们需要判断是否可以消去：

 

图形是否相等非常简单，只要判断该处元素的值即可

相连是否不超过两个弯，我们需要从中取一个结点为起始点，先拿到无须转弯就能到达的结点集合A，看目标结点是否在里面；如果不在，则需要对结点集合A中所有结点，拿到其无须转弯就能到达的结点（未在之前访问过），判断目标结点是否在内；如果不在，则继续扩展，这次如果再不在，说明两结点连接超过两个弯了，不满足

此处, vertex是所有没有图形的结点，而edge则是任意两个在同一直线上的，未被有图形的结点截断的结点之间的联系。BFS的应用在于结点距离不超过2次，此处距离是指转弯次数。

 

 

 

 

 

动态规划算法

 

一、基本概念

    动态规划过程是：每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。

二、基本思想与策略

    基本思想与分治法类似，也是将待求解的问题分解为若干个子问题（阶段），按顺序求解子阶段，前一子问题的解，为后一子问题的求解提供了有用的信息。在求解任一子问题时，列出各种可能的局部解，通过决策保留那些有可能达到最优的局部解，丢弃其他局部解。依次解决各子问题，最后一个子问题就是初始问题的解。

    由于动态规划解决的问题多数有重叠子问题这个特点，为减少重复计算，对每一个子问题只解一次，将其不同阶段的不同状态保存在一个二维数组中。

    与分治法最大的差别是：适合于用动态规划法求解的问题，经分解后得到的子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上，进行进一步的求解）。

 

三、适用的情况

能采用动态规划求解的问题的一般要具有3个性质：

    (1) 最优化原理：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优化原理。

    (2) 无后效性：即某阶段状态一旦确定，就不受这个状态以后决策的影响。也就是说，某状态以后的过程不会影响以前的状态，只与当前状态有关。

   （3）有重叠子问题：即子问题之间是不独立的，一个子问题在下一阶段决策中可能被多次使用到。（该性质并不是动态规划适用的必要条件，但是如果没有这条性质，动态规划算法同其他算法相比就不具备优势）

 

四、求解的基本步骤

     动态规划所处理的问题是一个多阶段决策问题，一般由初始状态开始，通过对中间阶段决策的选择，达到结束状态。这些决策形成了一个决策序列，同时确定了完成整个过程的一条活动路线(通常是求最优的活动路线)。如图所示。动态规划的设计都有着一定的模式，一般要经历以下几个步骤。

    初始状态→│决策１│→│决策２│→…→│决策ｎ│→结束状态

                      图1 动态规划决策过程示意图

    (1)划分阶段：按照问题的时间或空间特征，把问题分为若干个阶段。在划分阶段时，注意划分后的阶段一定要是有序的或者是可排序的，否则问题就无法求解。

    (2)确定状态和状态变量：将问题发展到各个阶段时所处于的各种客观情况用不同的状态表示出来。当然，状态的选择要满足无后效性。

    (3)确定决策并写出状态转移方程：因为决策和状态转移有着天然的联系，状态转移就是根据上一阶段的状态和决策来导出本阶段的状态。所以如果确定了决策，状态转移方程也就可写出。但事实上常常是反过来做，根据相邻两个阶段的状态之间的关系来确定决策方法和状态转移方程。

    (4)寻找边界条件：给出的状态转移方程是一个递推式，需要一个递推的终止条件或边界条件。

    一般，只要解决问题的阶段、状态和状态转移决策确定了，就可以写出状态转移方程（包括边界条件）。

实际应用中可以按以下几个简化的步骤进行设计：

    （1）分析最优解的性质，并刻画其结构特征。

    （2）递归的定义最优解。

    （3）以自底向上或自顶向下的记忆化方式（备忘录法）计算出最优值

    （4）根据计算最优值时得到的信息，构造问题的最优解

 

五、算法实现的说明

    动态规划的主要难点在于理论上的设计，也就是上面4个步骤的确定，一旦设计完成，实现部分就会非常简单。

     使用动态规划求解问题，最重要的就是确定动态规划三要素：

    （1）问题的阶段 （2）每个阶段的状态

    （3）从前一个阶段转化到后一个阶段之间的递推关系。

     递推关系必须是从次小的问题开始到较大的问题之间的转化，从这个角度来说，动态规划往往可以用递归程序来实现，不过因为递推可以充分利用前面保存的子问题的解来减少重复计算，所以对于大规模问题来说，有递归不可比拟的优势，这也是动态规划算法的核心之处。

    确定了动态规划的这三要素，整个求解过程就可以用一个最优决策表来描述，最优决策表是一个二维表，其中行表示决策的阶段，列表示问题状态，表格需要填写的数据一般对应此问题的在某个阶段某个状态下的最优值（如最短路径，最长公共子序列，最大价值等），填表的过程就是根据递推关系，从1行1列开始，以行或者列优先的顺序，依次填写表格，最后根据整个表格的数据通过简单的取舍或者运算求得问题的最优解。

          f(n,m)=max{f(n-1,m),f(n-1,m-w[n])+P(n,m)}

 

 

 

 

 

朴素贝叶斯分类算法

 

思想：根据特征属性，对某个样本进行分类；包括待分类项，分类器和类别三个要素。分类器的质量与分类器的构造方法，样本特性以及样本数量有关。计算某个输入分类项属于某个类别的概率，选择其中最大的作为其类别。

     适用范围：要求特征属性之间是独立的。

1.1、摘要

贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。本文作为分类算法的第一篇，将首先介绍分类问题，对分类问题进行一个正式的定义。然后，介绍贝叶斯分类算法的基础——贝叶斯定理。最后，通过实例讨论贝叶斯分类中最简单的一种：朴素贝叶斯分类。

1.2、分类问题综述

对于分类问题，其实谁都不会陌生，说我们每个人每天都在执行分类操作一点都不夸张，只是我们没有意识到罢了。例如，当你看到一个陌生人，你的脑子下意识判断TA是男是女；你可能经常会走在路上对身旁的朋友说“这个人一看就很有钱、那边有个非主流”之类的话，其实这就是一种分类操作。

从数学角度来说，分类问题可做如下定义：

已知集合：和，确定映射规则，使得任意有且仅有一个使得成立。（不考虑模糊数学里的模糊集情况）

其中C叫做类别集合，其中每一个元素是一个类别，而I叫做项集合，其中每一个元素是一个待分类项，f叫做分类器。分类算法的任务就是构造分类器f。

这里要着重强调，分类问题往往采用经验性方法构造映射规则，即一般情况下的分类问题缺少足够的信息来构造100%正确的映射规则，而是通过对经验数据的学习从而实现一定概率意义上正确的分类，因此所训练出的分类器并不是一定能将每个待分类项准确映射到其分类，分类器的质量与分类器构造方法、待分类数据的特性以及训练样本数量等诸多因素有关。

例如，医生对病人进行诊断就是一个典型的分类过程，任何一个医生都无法直接看到病人的病情，只能观察病人表现出的症状和各种化验检测数据来推断病情，这时医生就好比一个分类器，而这个医生诊断的准确率，与他当初受到的教育方式（构造方法）、病人的症状是否突出（待分类数据的特性）以及医生的经验多少（训练样本数量）都有密切关系。

1.3、贝叶斯分类的基础——贝叶斯定理

每次提到贝叶斯定理，我心中的崇敬之情都油然而生，倒不是因为这个定理多高深，而是因为它特别有用。这个定理解决了现实生活里经常遇到的问题：已知某条件概率，如何得到两个事件交换后的概率，也就是在已知P(A|B)的情况下如何求得P(B|A)。这里先解释什么是条件概率：

表示事件B已经发生的前提下，事件A发生的概率，叫做事件B发生下事件A的条件概率。其基本求解公式为：。

贝叶斯定理之所以有用，是因为我们在生活中经常遇到这种情况：我们可以很容易直接得出P(A|B)，P(B|A)则很难直接得出，但我们更关心P(B|A)，贝叶斯定理就为我们打通从P(A|B)获得P(B|A)的道路。

下面不加证明地直接给出贝叶斯定理：

 

1.4、朴素贝叶斯分类

1.4.1、朴素贝叶斯分类的原理与流程

朴素贝叶斯分类是一种十分简单的分类算法，叫它朴素贝叶斯分类是因为这种方法的思想真的很朴素，朴素贝叶斯的思想基础是这样的：对于给出的待分类项，求解在此项出现的条件下各个类别出现的概率，哪个最大，就认为此待分类项属于哪个类别。通俗来说，就好比这么个道理，你在街上看到一个黑人，我问你你猜这哥们哪里来的，你十有八九猜非洲。为什么呢？因为黑人中非洲人的比率最高，当然人家也可能是美洲人或亚洲人，但在没有其它可用信息下，我们会选择条件概率最大的类别，这就是朴素贝叶斯的思想基础。

朴素贝叶斯分类的正式定义如下：

1、设为一个待分类项，而每个a为x的一个特征属性。

2、有类别集合。

3、计算。

4、如果，则。

那么现在的关键就是如何计算第3步中的各个条件概率。我们可以这么做：

1、找到一个已知分类的待分类项集合，这个集合叫做训练样本集。

2、统计得到在各类别下各个特征属性的条件概率估计。即。

3、如果各个特征属性是条件独立的，则根据贝叶斯定理有如下推导：

 

因为分母对于所有类别为常数，因为我们只要将分子最大化皆可。又因为各特征属性是条件独立的，所以有：

 

根据上述分析，朴素贝叶斯分类的流程可以由下图表示（暂时不考虑验证）：

 

 

可以看到，整个朴素贝叶斯分类分为三个阶段：

第一阶段——准备工作阶段，这个阶段的任务是为朴素贝叶斯分类做必要的准备，主要工作是根据具体情况确定特征属性，并对每个特征属性进行适当划分，然后由人工对一部分待分类项进行分类，形成训练样本集合。这一阶段的输入是所有待分类数据，输出是特征属性和训练样本。这一阶段是整个朴素贝叶斯分类中唯一需要人工完成的阶段，其质量对整个过程将有重要影响，分类器的质量很大程度上由特征属性、特征属性划分及训练样本质量决定。

第二阶段——分类器训练阶段，这个阶段的任务就是生成分类器，主要工作是计算每个类别在训练样本中的出现频率及每个特征属性划分对每个类别的条件概率估计，并将结果记录。其输入是特征属性和训练样本，输出是分类器。这一阶段是机械性阶段，根据前面讨论的公式可以由程序自动计算完成。

第三阶段——应用阶段。这个阶段的任务是使用分类器对待分类项进行分类，其输入是分类器和待分类项，输出是待分类项与类别的映射关系。这一阶段也是机械性阶段，由程序完成。

 

 

我们来举个简单的例子，让读者对上述思路有个形象的认识

 

考虑一个医疗诊断问题，有两种可能的假设：（1）病人有癌症。（2）病人无癌症。样本数据来自某化验测试，它也有两种可能的结果：阳性和阴性。假设我们已经有先验知识：在所有人口中只有0.008的人患病。此外，化验测试对有病的患者有98%的可能返回阳性结果，对无病患者有97%的可能返回阴性结果。

 

上面的数据可以用以下概率式子表示：

 

P(cancer)=0.008,P(无cancer)=0.992

 

P(阳性|cancer)=0.98,P(阴性|cancer)=0.02

 

P(阳性|无cancer)=0.03，P(阴性|无cancer)=0.97

 

假设现在有一个新病人，化验测试返回阳性，是否将病人断定为有癌症呢？

 

在这里，Y={cancer，无cancer}，共两个类别，这个新病人是一个样本，他有一个属性阳性，可以令x=(阳性)。

 

我们可以来计算各个类别的后验概率：

 

P(cancer | 阳性) = P(阳性 |cancer)p(cancer)=0.98*0.008 = 0.0078

 

P(无cancer | 阳性) =P(阳性 | 无cancer)*p(无cancer)=0.03*0.992= 0.0298

因为我们可以知道结果是阳性，那么

P(cancer | 阳性) + P(无cancer | 阳性) = 1

那么cancer的概率为

0.0078/(0.0078 +0.0298) = 0.207

 

那么无cancer的概率为

0.0298/(0.0078 +0.0298) = 0.79

 

因此，应该判断为无癌症。

 

 

 

 

 

迪杰斯特拉算法介绍

 

迪杰斯特拉算法图解

 

以上图G4为例，来对迪杰斯特拉进行算法演示(以第4个顶点D为起点)。

 

 

初始状态：S是已计算出最短路径的顶点集合，U是未计算除最短路径的顶点的集合！

第1步：将顶点D加入到S中。

    此时，S={D(0)}, U={A(∞),B(∞),C(3),E(4),F(∞),G(∞)}。     注:C(3)表示C到起点D的距离是3。

 

第2步：将顶点C加入到S中。

    上一步操作之后，U中顶点C到起点D的距离最短；因此，将C加入到S中，同时更新U中顶点的距离。以顶点F为例，之前F到D的距离为∞；但是将C加入到S之后，F到D的距离为9=(F,C)+(C,D)。

    此时，S={D(0),C(3)},U={A(∞),B(23),E(4),F(9),G(∞)}。

 

第3步：将顶点E加入到S中。

    上一步操作之后，U中顶点E到起点D的距离最短；因此，将E加入到S中，同时更新U中顶点的距离。还是以顶点F为例，之前F到D的距离为9；但是将E加入到S之后，F到D的距离为6=(F,E)+(E,D)。

    此时，S={D(0),C(3),E(4)},U={A(∞),B(23),F(6),G(12)}。

 

第4步：将顶点F加入到S中。

    此时，S={D(0),C(3),E(4),F(6)},U={A(22),B(13),G(12)}。

 

第5步：将顶点G加入到S中。

    此时，S={D(0),C(3),E(4),F(6),G(12)},U={A(22),B(13)}。

 

第6步：将顶点B加入到S中。

    此时，S={D(0),C(3),E(4),F(6),G(12),B(13)},U={A(22)}。

 

第7步：将顶点A加入到S中。

    此时，S={D(0),C(3),E(4),F(6),G(12),B(13),A(22)}。

 

此时，起点D到各个顶点的最短距离就计算出来了：A(22) B(13) C(3) D(0) E(4) F(6) G(12)。

 

 

 

 

 

 

 

冒泡排序

经典排序算法 - 冒泡排序Bubble sort

 

原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,

 

这样一趟过去后,最大或最小的数字被交换到了最后一位,

 

然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子

 

例子为从小到大排序,

 

原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

 

 

 

第一趟排序(外循环)

 

第一次两两比较6 > 2交换(内循环)

 

交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

 

交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

 

 

 

第二次两两比较,6 > 4交换

 

交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

 

交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

 

 

 

第三次两两比较,6 > 1交换

 

交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

 

交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

 

 

 

第四次两两比较,6 > 5交换

 

交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

 

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

 

 

第五次两两比较,6 < 9不交换

 

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

 

 

第二趟排序(外循环)

 

第一次两两比较2 < 4不交换

 

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

 

 

 

第二次两两比较,4 > 1交换

 

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

 

 

第三次两两比较,4 < 5不交换

 

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

 

 

第四次两两比较,5 < 6不交换

 

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

 

 

第三趟排序(外循环)

 

第一次两两比较2 > 1交换

 

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

 

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 

 

 

第二次两两比较,2 < 4不交换

 

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 

 

 

第三次两两比较,4 < 5不交换

 

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

 

第四趟排序(外循环)无交换

 

第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

 

选择排序

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。以此类推，直到所有元素均排序完毕。