划分过程的算法

Ⅰ 快速排序算法的示例代码

usingSystem;usingSystem.Collections.Generic;usingSystem.Linq;usingSystem.Text;namespacetest{classQuickSort{staticvoidMain(string[]args){int[]array={49,38,65,97,76,13,27};sort(array,0,array.Length-1);Console.ReadLine();}/**一次排序单元，完成此方法，key左边都比key小，key右边都比key大。**@paramarray排序数组**@paramlow排序起始位置**@paramhigh排序结束位置**@return单元排序后的数组*/privatestaticintsortUnit(int[]array,intlow,inthigh){intkey=array[low];while(low<high){/*从后向前搜索比key小的值*/while(array[high]>=key&&high>low)--high;/*比key小的放左边*/array[low]=array[high];/*从前向后搜索比key大的值，比key大的放右边*/while(array[low]<=key&&high>low)++low;/*比key大的放右边*/array[high]=array[low];}/*左边都比key小，右边都比key大。//将key放在游标当前位置。//此时low等于high*/array[low]=key;foreach(intiinarray){Console.Write({0} ,i);}Console.WriteLine();returnhigh;}/**快速排序*@paramarry*@return*/publicstaticvoidsort(int[]array,intlow,inthigh){if(low>=high)return;/*完成一次单元排序*/intindex=sortUnit(array,low,high);/*对左边单元进行排序*/sort(array,low,index-1);/*对右边单元进行排序*/sort(array,index+1,high);}}}运行结果：27 38 13 49 76 97 65
13 27 38 49 76 97 6513 27 38 49 65 76 97
快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：
初始状态 {49 38 65 97 76 13 27} 进行一次快速排序之后划分为 {27 38 13} 49 {76 97 65} 分别对前后两部分进行快速排序{27 38 13} 经第三步和第四步交换后变成 {13 27 38} 完成排序。{76 97 65} 经第三步和第四步交换后变成 {65 76 97} 完成排序。图示 快速排序的最坏情况基于每次划分对主元的选择。基本的快速排序选取第一个元素作为主元。这样在数组已经有序的情况下，每次划分将得到最坏的结果。一种比较常见的优化方法是随机化算法，即随机选取一个元素作为主元。这种情况下虽然最坏情况仍然是O(n^2)，但最坏情况不再依赖于输入数据，而是由于随机函数取值不佳。实际上，随机化快速排序得到理论最坏情况的可能性仅为1/(2^n)。所以随机化快速排序可以对于绝大多数输入数据达到O(nlogn)的期望时间复杂度。一位前辈做出了一个精辟的总结：“随机化快速排序可以满足一个人一辈子的人品需求。”
随机化快速排序的唯一缺点在于，一旦输入数据中有很多的相同数据，随机化的效果将直接减弱。对于极限情况，即对于n个相同的数排序，随机化快速排序的时间复杂度将毫无疑问的降低到O(n^2)。解决方法是用一种方法进行扫描，使没有交换的情况下主元保留在原位置。 QUICKSORT(A，p，r)
1if p<r
2then q ←PARTITION(A，p，r)
3QUICKSORT(A，p，q-1)
4QUICKSORT(A，q+1，r)
为排序一个完整的数组A，最初的调用是QUICKSORT(A，1，length[A]）。
快速排序算法的关键是PARTITION过程，它对子数组A[p..r]进行就地重排：
PARTITION(A，p，r)
1x←A[r]
2i←p-1
3for j←p to r-1
4do if A[j]≤x
5then i←i+1
6exchange A[i]←→A[j]
7exchange A[i+1]←→A[r]
8return i+1 对PARTITION和QUICKSORT所作的改动比较小。在新的划分过程中，我们在真正进行划分之前实现交换：
（其中PARTITION过程同快速排序伪代码（非随机））
RANDOMIZED-PARTITION(A，p，r)
1i← RANDOM(p，r)
2exchange A[r]←→A[i]
3return PARTITION(A，p，r)
新的快速排序过程不再调用PARTITION，而是调用RANDOMIZED-PARTITION。
RANDOMIZED-QUICKSORT(A，p，r)
1if p<r
2then q← RANDOMIZED-PARTITION(A，p，r)
3RANDOMIZED-QUICKSORT(A，p，q-1)
4RANDOMIZED-QUICKSORT(A，q+1，r) 这里为方便起见，我们假设算法Quick_Sort的范围阈值为1（即一直将线性表分解到只剩一个元素），这对该算法复杂性的分析没有本质的影响。
我们先分析函数partition的性能，该函数对于确定的输入复杂性是确定的。观察该函数，我们发现，对于有n个元素的确定输入L[p..r]，该函数运行时间显然为θ（n）。
最坏情况
无论适用哪一种方法来选择pivot，由于我们不知道各个元素间的相对大小关系（若知道就已经排好序了），所以我们无法确定pivot的选择对划分造成的影响。因此对各种pivot选择法而言，最坏情况和最好情况都是相同的。
我们从直觉上可以判断出最坏情况发生在每次划分过程产生的两个区间分别包含n-1个元素和1个元素的时候（设输入的表有n个元素）。下面我们暂时认为该猜测正确，在后文我们再详细证明该猜测。
对于有n个元素的表L[p..r]，由于函数Partition的计算时间为θ（n），所以快速排序在序坏情况下的复杂性有递归式如下：
T(1)=θ(1),T(n)=T(n-1)+T(1)+θ(n) (1)
用迭代法可以解出上式的解为T(n)=θ（n2）。
这个最坏情况运行时间与插入排序是一样的。
下面我们来证明这种每次划分过程产生的两个区间分别包含n-1个元素和1个元素的情况就是最坏情况。
设T(n）是过程Quick_Sort作用于规模为n的输入上的最坏情况的时间，则
T(n)=max(T(q)+T(n-q))+θ（n)，其中1≤q≤n-1 (2)
我们假设对于任何k<n，总有T(k）≤ck，其中c为常数；显然当k=1时是成立的。
将归纳假设代入（2），得到：
T(n）≤max(cq2+c(n-q)2)+θ（n)=c*max(q2+(n-q)2)+θ（n)
因为在[1,n-1]上q2+(n-q)2关于q递减，所以当q=1时q2+(n-q)2有最大值n2-2(n-1）。于是有：
T(n）≤cn2-2c(n-1)+θ（n）≤cn2
只要c足够大，上面的第二个小于等于号就可以成立。于是对于所有的n都有T(n）≤cn。
这样，排序算法的最坏情况运行时间为θ（n2），且最坏情况发生在每次划分过程产生的两个区间分别包含n-1个元素和1个元素的时候。
时间复杂度为o（n2）。
最好情况
如果每次划分过程产生的区间大小都为n/2，则快速排序法运行就快得多了。这时有：
T(n)=2T(n/2)+θ（n),T(1)=θ（1) (3)
解得：T(n)=θ（nlogn)
快速排序法最佳情况下执行过程的递归树如下图所示，图中lgn表示以10为底的对数，而本文中用logn表示以2为底的对数.
由于快速排序法也是基于比较的排序法，其运行时间为Ω（nlogn)，所以如果每次划分过程产生的区间大小都为n/2，则运行时间θ（nlogn）就是最好情况运行时间。
但是，是否一定要每次平均划分才能达到最好情况呢？要理解这一点就必须理解对称性是如何在描述运行时间的递归式中反映的。我们假设每次划分过程都产生9:1的划分，乍一看该划分很不对称。我们可以得到递归式：
T(n)=T(n/10)+T(9n/10)+θ（n),T(1)=θ（1) (4)
请注意树的每一层都有代价n，直到在深度log10n=θ（logn）处达到边界条件，以后各层代价至多为n。递归于深度log10/9n=θ（logn）处结束。这样，快速排序的总时间代价为T(n)=θ（nlogn），从渐进意义上看就和划分是在中间进行的一样。事实上，即使是99:1的划分时间代价也为θ（nlogn）。其原因在于，任何一种按常数比例进行划分所产生的递归树的深度都为θ（nlogn），其中每一层的代价为O(n），因而不管常数比例是什么，总的运行时间都为θ（nlogn），只不过其中隐含的常数因子有所不同。（关于算法复杂性的渐进阶，请参阅算法的复杂性)
平均情况
快速排序的平均运行时间为θ(nlogn)。
我们对平均情况下的性能作直觉上的分析。
要想对快速排序的平均情况有个较为清楚的概念，我们就要对遇到的各种输入作个假设。通常都假设输入数据的所有排列都是等可能的。后文中我们要讨论这个假设。
当我们对一个随机的输入数组应用快速排序时，要想在每一层上都有同样的划分是不太可能的。我们所能期望的是某些划分较对称，另一些则很不对称。事实上，我们可以证明，如果选择L[p..r]的第一个元素作为支点元素，Partition所产生的划分80%以上都比9:1更对称，而另20%则比9:1差，这里证明从略。
平均情况下，Partition产生的划分中既有“好的”，又有“差的”。这时，与Partition执行过程对应的递归树中，好、差划分是随机地分布在树的各层上的。为与我们的直觉相一致，假设好、差划分交替出现在树的各层上，且好的划分是最佳情况划分，而差的划分是最坏情况下的划分。在根节点处，划分的代价为n，划分出来的两个子表的大小为n-1和1，即最坏情况。在根的下一层，大小为n-1的子表按最佳情况划分成大小各为（n-1)/2的两个子表。这儿我们假设含1个元素的子表的边界条件代价为1。
在一个差的划分后接一个好的划分后，产生出三个子表，大小各为1，（n-1)/2和（n-1)/2，代价共为2n-1=θ（n）。一层划分就产生出大小为（n-1)/2+1和（n-1)/2的两个子表，代价为n=θ（n）。这种划分差不多是完全对称的，比9:1的划分要好。从直觉上看，差的划分的代价θ（n）可被吸收到好的划分的代价θ（n）中去，结果是一个好的划分。这样，当好、差划分交替分布划分都是好的一样：仍是θ（nlogn），但θ记号中隐含的常数因子要略大一些。关于平均情况的严格分析将在后文给出。
在前文从直觉上探讨快速排序的平均性态过程中，我们已假定输入数据的所有排列都是等可能的。如果输入的分布满足这个假设时，快速排序是对足够大的输入的理想选择。但在实际应用中，这个假设就不会总是成立。
解决的方法是，利用随机化策略，能够克服分布的等可能性假设所带来的问题。
一种随机化策略是：与对输入的分布作“假设”不同的是对输入的分布作“规定”。具体地说，在排序输入的线性表前，对其元素加以随机排列，以强制的方法使每种排列满足等可能性。事实上，我们可以找到一个能在O(n）时间内对含n个元素的数组加以随机排列的算法。这种修改不改变算法的最坏情况运行时间，但它却使得运行时间能够独立于输入数据已排序的情况。
另一种随机化策略是：利用前文介绍的选择支点元素pivot的第四种方法，即随机地在L[p..r]中选择一个元素作为支点元素pivot。实际应用中通常采用这种方法。
快速排序的随机化版本有一个和其他随机化算法一样的有趣性质：没有一个特别的输入会导致最坏情况性态。这种算法的最坏情况性态是由随机数产生器决定的。你即使有意给出一个坏的输入也没用，因为随机化排列会使得输入数据的次序对算法不产生影响。只有在随机数产生器给出了一个很不巧的排列时，随机化算法的最坏情况性态才会出现。事实上可以证明几乎所有的排列都可使快速排序接近平均情况性态，只有非常少的几个排列才会导致算法的近最坏情况性态。
一般来说，当一个算法可按多条路子做下去，但又很难决定哪一条保证是好的选择时，随机化策略是很有用的。如果大部分选择都是好的，则随机地选一个就行了。通常，一个算法在其执行过程中要做很多选择。如果一个好的选择的获益大于坏的选择的代价，那么随机地做一个选择就能得到一个很有效的算法。我们在前文已经了解到，对快速排序来说，一组好坏相杂的划分仍能产生很好的运行时间 。因此我们可以认为该算法的随机化版本也能具有较好的性态。

Ⅱ 快速排序的一次划分过程

快速排序（Quicksort）是对冒泡排序的一种改进，由东尼·霍尔在1960年提出。 快速排序是指通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序。整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

步骤为：

从数列中挑出一个元素，称为“基准”（pivot），

重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。

递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
上面简单版本的缺点是，它需要的额外存储空间，也就跟归并排序一样不好。额外需要的存储器空间配置，在实际上的实现，也会极度影响速度和缓存的性能。有一个比较复杂使用原地（in-place）分区算法的版本，且在好的基准选择上，平均可以达到空间的使用复杂度。

Ⅲ 地球收缩运动的参数算法与阶段划分

从地球膨胀说，到地球收缩说、地球脉动说，再到地球周期性胀缩论，人类认识地球运动的本质过程经历了从归纳推理到演绎推理到综合认识的演变，这种认识的转变完成了从最初的依据现象假说本质上升到理论联系实际的哲学过程。

在上一节里，讨论了地球膨胀过程的问题，我们说地球膨胀包含两方面内容：一是指地球的整个胀缩运动过程呈膨胀的趋势；二是指地球周期性胀缩过程中的膨胀过程，因此，在讨论地球膨胀阶段划分时，特意将地球收缩阶段单列出。本节的主要论点则集中在地球收缩运动方面。

地球的收缩运动是人们最早认识的地壳构造运动之一。本节将在总结地球收缩运动证据的基础上，提出地球陆块中央的推覆运动模式。对因地球收缩所产生的周长改变量（△L）、半径改变量（△R）、体积改变量（△V）等，分别建立理论计算公式，并对公式中有关参数的取值办法做出相应说明。将地球在收缩力作用下发生收缩运动的过程分为四个阶段，即：体积缩小的初始阶段；周长、表面积减小阶段；收缩力持续增大作用阶段；收缩力持续减小作用阶段。

对地球收缩过程中发生的板块汇聚与冲撞进行理论划分，认为板块之间的压缩效应可分为6种，即：上举式、下沉式、入覆式、包嵌式、推叠式、铆钩式等。

1.收缩参数的求取

1.1地球收缩所产生的周长改变量（△L）

设地球膨胀后收缩前的周长为L_A，地球收缩运动结束后切膨胀前的周长为L_B，则地球收缩运动所产生的周长改变量

地球动力与运动

式中各参数的单位可以是m、km，但计算中要注意前后单位的统一。

实际工作中，地球周长的改变量可按下式求取：

地球动力与运动

设：i=1,L₁为洋壳缩短量（km）;

i=2,L₂为山体缩短量（km）;

i=3,L₃为海沟缩短量（km）;

i=4,L₄为板缘推覆缩短量（km）;

i=5,L₅为板内推覆缩短量（km）;

i=6,L₆为逆断裂超覆缩短量（km）;

i=7,L₇为地层褶皱缩短量（km）;

k为遗漏项缩短量（km）。

这样，式（4-14）简化为：

地球动力与运动

在运用式（4-15）时，有两点一定要注意：一是，计算时应该是同一高度，特别是全球性的数据问题，如果没有统一的高度，你用海拔0线，他用海拔10m线，或者此地用一个高度值，彼地用另一个高度值，那么，所得结果存在误差，应该根据全球海平面加以校正；二是，计算应该在同一个过地球球心的切面圆周上进行，否则，所统计的结果极容易扩大。

实际计算中，式（4-15）的每一项都是一个累计求和公式：

地球动力与运动

i的变化表示统计项的不同，j的变化表示统计地区的不同。这样，式（4-15）可改写成如下完整形式：

地球动力与运动

计算办法大多是现成的，如平衡剖面法，古地磁分析法等。

平衡剖面法用来计算L₂、L₄、L₅、L₆、L₇已有广泛的报道，如曾融生等在计算了喜马拉雅—祁连山的大陆碰撞过程后，得出自50Ma印度次大陆和羌塘块体向特提斯喜马拉雅和拉萨块体地壳挤入的长度分别为508km和429km，等。

古地磁分析法用来计算L₁，是一种较能被人接受的办法，尽管误差可能较大，但目前却较为现实。用古地磁数据计算板块间的洋壳消失量的步骤：第一，选定边界条件。找出即将工作的线路应该属于统计地球圆周的线路，选准海拔面所对应的目的层系，找到板块间的缝合处。第二，分析古地磁数据。在缝合带两侧不同的板块上取得各种不同年龄岩石的磁化数据，确定古地磁纬度，做出每一块岩石形成磁化时古磁纬度图。第三，计算洋壳消失量。比较两板块之间的相对位置，划定计算的地史时间段，计算洋壳消失的长度。

由于海沟一直以来被认为是洋壳的消亡处，并没被认为是地球收缩时的产物之一，所以，关于海沟使地壳长度缩短的问题几乎无人计算。计算海沟的缩减量也可以按照上述方法进行。如果想避开海沟，找一条不过海沟的切面也是可以的。

计算地壳周长的缩短量，应该视所选切面的圆周上是否包含式（4-17）中的各项因素，并不是所有的路径都含有洋壳的缩短问题、海沟问题等，计算前可以先进行归类。

图4-16是关于塔里木盆地西北缘柯坪造山带的构造改变量的恢复情况，可见，近东西向的I线推覆量为80km，Ⅱ线推覆量为68km，近南北向的BB′线（图4-16乙）在没有消除东西向推覆影响的前提下，所算出的缩短量达到50%，而CC′线（图4-16丙）的缩短量有28%，这样在喜马拉雅造山期，仅柯坪地区就至少完成了地壳表面积1564km²的收缩量（蔡东升，等，1996）。

1.2地球收缩所产生的半径改变量（△R）

在获得周长改变量之后求半径改变量，可按下式计算：

地球动力与运动

图4-16塔里木盆地西北缘柯坪造山带构造恢复情况（据蔡东升等，1996）

甲—东西向平面断裂恢复；乙—BB′平衡剖面；丙—CC′平衡剖面

1.3地球收缩所产生的体积改变量（△V）

地球的体积改变量由下式计算：

地球动力与运动

式（4-19）中的R_A或R_B可以通过现代地球物理方法测定，而另一个可求。

可以确定，由于地球的胀缩力在作用时间和作用力绝对值方面存在着差异，地球的膨胀力虽然作用时间较短，但绝对作用力大，所以，所得地球膨胀的体积改变量、半径改变量、表面积改变量、周长改变量的绝对值都将比地球收缩的对应量的绝对值大。就是说地球每绕银核一周，体积将越来越大。

2.地球的收缩模式

收缩力作用于地球的整个阶段无疑都使地球表现为体积的收缩，为了分析问题的方便，现将地球在收缩力作用下发生收缩运动的过程分为四个阶段，即：体积缩小的初始阶段，周长、表面积减小阶段，收缩力持续增大作用阶段，收缩力持续减小作用阶段。

2.1体积缩小的初始阶段

地球体积缩小的初始阶段是指地球从受收缩力作用开始到地壳进行缩短之前的阶段，是一种理想的阶段，实际上无法判断。

即使不考虑温度、物态对物体压缩效应的影响，由于地壳的绝对厚度远小于地球其他层圈的厚度，所以，在同一收缩力作用场的作用下，相等的时间内，地壳的缩短量远小于其他层圈的缩短量累加值。那么，在地球缩小的初始阶段（假定没有地壳的断裂或者形变），就会在岩石圈和软流圈之间形成一个空腔层（见图4-17），如果将空腔的内球和外球壳形成内接，则在内接点的对应侧，出现大体积的空缺，使外层岩石圈形成悬空状态，从而了地壳发生收缩运动的环境。

图4-17地球收缩的初始阶段示意图

（a）地球收缩时各层圈都将产生缩小量，岩石圈的缩小量是其他层圈缩小量的千分之几；（b）将这些缩小量在一侧富集，形成了大量的空腔（实线代表收缩前，虚线代表收缩后）

2.2周长、表面积缩小阶段

周长、表面积缩小阶段是指地壳开始大范围的出现压应断裂到地壳停止大范围出现压性断裂的阶段。这一阶段实质上包含了后面即将谈到的两个阶段。

任何的破碎都是在地壳的最脆弱处进行，地壳板块的结合处无疑是最易破碎处（图4-18），当地球收缩，在岩石圈下产生体积空腔后，地壳在其自身重力作用下，将压力向球壳的四周传递，当压力遇到受力易碎处时，就会形成水平方向的压缩力（图中放大虚框内）。板块1与板块2之间的压缩效应可分为6种（见图4-19）。

图4-18地壳板块的结合处为地壳收缩的优先点，重力可以转变成水平压力

图4-19地球收缩时板块间所体现的压缩方式示意图

（a）上举式（高耸山脉）；（b）下沉式（海沟）；（c）入覆式；（d）包嵌式；（e）推叠式；（f）铆钩式；A—原板块结合处

图4-19中所列各种并没有包含地壳缩短方式的全部，仅仅是罗列了发生在板块之间的几种大型的使地壳缩短的方式，如图4-20所列方式以及发生在板块内部的小型逆断裂等均未加以考虑。

图4-20印度—欧亚大陆之间的碰撞过程示意图

（1）上举式：这是一种大陆和大陆之间的碰撞方式。一般地，由于大陆和大陆在结合处具有相等或相近的厚度，使得水平压力的受力面积相等，在结合面上形成“僵持”。另外，地球的球体外形使结合面两侧的陆块保持上凸状态，因此，在压力的持续作用下，陆块与陆块最先跟从的方向为向球外突出，即上举。上举变形描述的只是大陆与大陆因地球收缩导致形变的初步，紧随其后的是岩石破碎、断裂、岩层沿断裂面的滑动等，极易造成上举的结束。

（2）下沉式：也是一种大陆和大陆之间的碰撞方式。如果下沉式发生在收缩力持续增加阶段，则下沉式为上举式的继续，如果下沉式在收缩力持续减小阶段产生，则下沉式的结果可能是海沟的一种。

当下沉式作为上举式的继续时，其形成机制是这样的：当A两侧岩层上举，岩层所受作用力超过岩石的最大载荷发生断裂，造成地壳的第一次缩短，缩短量为断裂段的长度。在收缩力的持续作用下，主体段将继续相向靠拢，理论上将发生第二次上举，但是，因为第一上举的最后结果形成了断裂后的岩石堆积，其产生的重力压力改变了A处的初始边界条件，造成了A两侧板块结合带呈下凹态势，从而导致了陆块与陆块的下沉式出现。

引入注目的印度—欧亚板块的碰撞过程，其实包含了上举和下沉的发展过程，尽管之前可能有其他形式的板块间的碰撞，但那已不是陆块和陆块之间的碰撞（见图4-20）。

（3）入覆式：这是一种厚的板块1和薄的板块2发生碰撞体现最多的一种方式。在结合面上，薄壳的承压面小于厚壳的承压面，因而，薄壳的压应力大于厚壳的压应力（图4-21），在持续的压力作用下，薄壳就像一把尖刀，轻松地插入或切削厚壳，最后形成薄壳潜入、厚壳上覆的“入覆式”地壳缩短模式。一般地，洋壳较陆壳薄，所以在板块的碰撞过程中，洋壳总是在陆壳之下出现。

图4-21薄壳板块和厚壳板块碰撞时的承压分析

（a）厚壳，具有大的承压面，因而，单位面积承压量较小；（b）薄壳，具有小的承压面，因而，单位面积承压量较大

（4）包嵌式：也是一种厚的板块1和薄的板块2发生碰撞的方式，与入覆式不同之处在于薄壳没有切削厚壳，也不是潜入到厚壳底下，而是嵌入到厚壳之中，将厚的板块分成上下两部分，形成厚壳包着薄壳，薄壳嵌入厚壳的包嵌式地壳缩短模式。其承压分析同入覆式。

（5）推叠式：当A两侧板块物性相差较大时，板块碰撞就会产生一侧较另一侧更易破裂的形变，从而形成推叠式的地壳缩短模式。这是自然界较发育的一种模式。

（6）铆钩式：这是一种收缩力持续减小阶段产生的板块碰撞模式，它是推叠式发育不全的产物。当收缩力使地壳碰撞发生了形变后，持续的收缩力越来越小，以后所产生的压力形成慢慢释放的状态，以至不能再改变岩石，形成了铆钩式。

2.3地球周长改变量持续增大阶段

地球周长改变量持续增大阶段是指地壳开始大范围的出现压应断裂到老地层不断出现在新地层之上、陆块运移速度迅速并持续增加的阶段。由于收缩力的持续作用，地壳内部物质的收缩量越来越大，“空腔”在单位时间内形成的体积越来越大，导致地球固体表层的承压力越来越大，地壳的形变强度也就越来越大，板块间在完成最初的几种模式接触碰撞后，为适应越来越大的地壳缩短量，即产生强烈的、急促的变形，地壳主体的不断跟进，使原本破碎的断块不断地向外逃逸，形成老地层的接连暴露、飞来峰等。此阶段为地壳缩短的黄金时段，在此时段，那些完成了入覆式碰撞的板块相对运动，则体现出洋壳的急速减退，陆块运移速度迅速加大，如果是封闭的或具有狭窄出口的海洋，此时会形成海进的假象，这种假象的持续时间有半个地球收缩期到整个地球收缩期长，这种假象只有等下一次的地球膨胀运动才消失，但又将造成新的假象。

2.4地球周长改变量持续减小阶段

地球周长改变量持续减小阶段是指老地层不再覆盖新地层、板块运移速度不再迅速提升到地壳停止大范围出现压性断裂的阶段。

在这一阶段里，地壳的弯曲变形幅度由强变弱，慢慢消失。体现在山区地貌上的特征是，由推覆断裂或大型逆掩断裂边缘到盆地边缘是幅度逐渐变小的背斜带，最后生成的背斜两翼甚至没有断裂。如准噶尔盆地的南缘山前褶皱带、昆仑山北缘山前褶皱带等，即是本阶段产物。

综上所述，如果选定一个切面，确定了在这个切面上需要计算的时代地层，在满足了计算前提条件下，分析出这个切面的地壳收缩包含了上举式、下沉式、推叠式、铆钩式和板内褶皱与逆断裂几种地壳的缩短方式。通过计算，分别获得了各种方式的地壳缩短量为△L₁、△L₂、△L₃、△L₄、△L₅（见图4-22），则地壳在这次收缩运动中周长总收缩量及地壳收缩前的长度可求。

图4-22地球周长的收缩方式示意图

L—地球收缩前的周长；L′—地球收缩后的周长；△L—地球周长收缩量

3.关于地球收缩过程中的地方性裂谷形成

如果以2.5×10⁸a作为地球绕银核的周期，以地球目前处于收缩力持续减小作用阶段为置信水平，那么，地球发生收缩运动的时间长度为约为1.269×10⁸a，这是一个漫长的时间段，在这个时间段内，地球还将绕太阳旋转1.269亿多周，地球受银核与太阳的潮汐力作用形成地球—太阳—银核一线的机会为2.54亿次，如果形成潮汐干涉的几率为亿分之一，则在地球的收缩期内出现地幔潮汐因干涉加强振幅的次数为2～3次，因地幔物质的局部富集而出现局部膨胀，从而将出现在地球收缩过程中的地方性裂谷。

图4-23一个挤压式地堑的例子（据Wise,1963：转引自王燮培等，1992）

地球收缩期形成裂谷和地堑的现象常见报道，如图4-23的例子。

那些在挤压作用之后出现的伸展作用所造成的山中地堑的构造格局的现象也常被人们研究，如：西欧地堑、秘鲁的安第斯山西部地堑（如图4-24）等。

图4-24安第斯山（秘鲁）概略剖面图（据M马托埃，1982）

剖面西部发生伸展，东部发生挤压

图4-23这类与挤压相伴随的张性构造，是属于应力转换的结果，主要作用力与次生作用力的力源相同，都是挤压力，挤压与引张形成的构造在同一地点。图2-24这类在挤压期形成的张性构造，背景为挤压的，局部为张性的，力源不同，挤压力为地球收缩期的大背景力，张性力为地球的潮汐力形成局部峰值所造成，两者作用为先后关系，形成的构造可以不在同一地点。

4.关于地球收缩过程中的地方性海侵

当地球收缩时，收缩力持续增加，地壳周长将会迅速减小，导致板块相对位置改变的速度急速变化，如果这时在两个相对位置迅速的陆块之间为封闭的海洋或开口较小的海洋，那么，在此两陆块间将出现海侵（或海平面上升）。

5.小结

地球的膨胀运动和收缩运动是地球运动产生地质改变的两个大的单元，是不可抗拒的运动，地球上的板块运动属于球面质点运动的一部分，被包含于其中，在各种计算因素中可清楚地看出这点。在矿产普查与勘探中，总是要涉及到各种断裂和褶皱，我们深信，关于地球膨胀阶段和地球收缩阶段的划分及其各种模式的建立，对油气勘探领域、构造单元等的划分将产生帮助。

Ⅳ 谱聚类算法的划分准则

谱聚类算法将聚类问题转化为图的划分问题之后，基于图论的划分准则的优劣直接影响到聚类结果的好坏。常见的划分准则有Mini cut，Average cut，Normalized cut，Min-max cut，Ratio cut，MNcut等。 Mini cut准则容易出现分割出只包含几个顶点的较小子图的歪斜分割现象，Ratio cut和Normalized cut等在一定程度上可以避免这种现象，但是当类间重叠严重时歪斜分割现象仍旧会发生。Chris Ding等人提出的基于Min-max cut的图划分方法充分体现了“子图内部相似度最大，子图之间的相似度最小”原则，能够产生比较平衡划分。
上述五种划分都是不断地将图划分为2个子图的反复迭代运算过程，当划分函数的最小值满足一定的条件时迭代过程便会终止，相应的函数可以称为2-way划分函数。 Meilă和Xu[64]认为可以同时把图划分为k个子图并于2004年提出了一种k-way规范割目标函数，而且对于参数k的选取问题也作了分析说明。
我们可以发现当k=2时，MNcut与Ncut两者是等价的。

Ⅳ 排序算法的比较，选择5种排序算法完成排序比较结果，包括运算时间等

排序算法
<script>
Array.prototype.swap = function(i, j)
{
var temp = this[i];
this[i] = this[j];
this[j] = temp;
}

Array.prototype.bubbleSort = function()
{
for (var i = this.length - 1; i > 0; --i)
{
for (var j = 0; j < i; ++j)
{
if (this[j] > this[j + 1]) this.swap(j, j + 1);
}
}
}

Array.prototype.selectionSort = function()
{
for (var i = 0; i < this.length; ++i)
{
var index = i;
for (var j = i + 1; j < this.length; ++j)
{
if (this[j] < this[index]) index = j;
}
this.swap(i, index);
}
}

Array.prototype.insertionSort = function()
{
for (var i = 1; i < this.length; ++i)
{
var j = i, value = this[i];
while (j > 0 && this[j - 1] > value)
{
this[j] = this[j - 1];
--j;
}
this[j] = value;
}
}

Array.prototype.shellSort = function()
{
for (var step = this.length >> 1; step > 0; step >>= 1)
{
for (var i = 0; i < step; ++i)
{
for (var j = i + step; j < this.length; j += step)
{
var k = j, value = this[j];
while (k >= step && this[k - step] > value)
{
this[k] = this[k - step];
k -= step;
}
this[k] = value;
}
}
}
}

Array.prototype.quickSort = function(s, e)
{
if (s == null) s = 0;
if (e == null) e = this.length - 1;
if (s >= e) return;
this.swap((s + e) >> 1, e);
var index = s - 1;
for (var i = s; i <= e; ++i)
{
if (this[i] <= this[e]) this.swap(i, ++index);
}
this.quickSort(s, index - 1);
this.quickSort(index + 1, e);
}

Array.prototype.stackQuickSort = function()
{
var stack = [0, this.length - 1];
while (stack.length > 0)
{
var e = stack.pop(), s = stack.pop();
if (s >= e) continue;
this.swap((s + e) >> 1, e);
var index = s - 1;
for (var i = s; i <= e; ++i)
{
if (this[i] <= this[e]) this.swap(i, ++index);
}
stack.push(s, index - 1, index + 1, e);
}
}

Array.prototype.mergeSort = function(s, e, b)
{
if (s == null) s = 0;
if (e == null) e = this.length - 1;
if (b == null) b = new Array(this.length);
if (s >= e) return;
var m = (s + e) >> 1;
this.mergeSort(s, m, b);
this.mergeSort(m + 1, e, b);
for (var i = s, j = s, k = m + 1; i <= e; ++i)
{
b[i] = this[(k > e || j <= m && this[j] < this[k]) ? j++ : k++];
}
for (var i = s; i <= e; ++i) this[i] = b[i];
}

Array.prototype.heapSort = function()
{
for (var i = 1; i < this.length; ++i)
{
for (var j = i, k = (j - 1) >> 1; k >= 0; j = k, k = (k - 1) >> 1)
{
if (this[k] >= this[j]) break;
this.swap(j, k);
}
}
for (var i = this.length - 1; i > 0; --i)
{
this.swap(0, i);
for (var j = 0, k = (j + 1) << 1; k <= i; j = k, k = (k + 1) << 1)
{
if (k == i || this[k] < this[k - 1]) --k;
if (this[k] <= this[j]) break;
this.swap(j, k);
}
}
}

function generate()
{
var max = parseInt(txtMax.value), count = parseInt(txtCount.value);
if (isNaN(max) || isNaN(count))
{
alert("个数和最大值必须是一个整数");
return;
}
var array = [];
for (var i = 0; i < count; ++i) array.push(Math.round(Math.random() * max));
txtInput.value = array.join("\n");
txtOutput.value = "";
}

function demo(type)
{
var array = txtInput.value == "" ? [] : txtInput.value.replace().split("\n");
for (var i = 0; i < array.length; ++i) array[i] = parseInt(array[i]);
var t1 = new Date();
eval("array." + type + "Sort()");
var t2 = new Date();
lblTime.innerText = t2.valueOf() - t1.valueOf();
txtOutput.value = array.join("\n");
}
</script>

<body onload=generate()>
<table style="width:100%;height:100%;font-size:12px;font-family:宋体">
<tr>
<td align=right>
<textarea id=txtInput readonly style="width:100px;height:100%"></textarea>
</td>
<td width=150 align=center>
随机数个数<input id=txtCount value=500 style="width:50px"><br><br>
最大随机数<input id=txtMax value=1000 style="width:50px"><br><br>
<button onclick=generate()>重新生成</button><br><br><br><br>
耗时(毫秒)：<label id=lblTime></label><br><br><br><br>
<button onclick=demo("bubble")>冒泡排序</button><br><br>
<button onclick=demo("selection")>选择排序</button><br><br>
<button onclick=demo("insertion")>插入排序</button><br><br>
<button onclick=demo("shell")>谢尔排序</button><br><br>
<button onclick=demo("quick")>快速排序(递归)</button><br><br>
<button onclick=demo("stackQuick")>快速排序(堆栈)</button><br><br>
<button onclick=demo("merge")>归并排序</button><br><br>
<button onclick=demo("heap")>堆排序</button><br><br>
</td>
<td align=left>
<textarea id=txtOutput readonly style="width:100px;height:100%"></textarea>
</td>
</tr>
</table>
</body>

Ⅵ 快速排序算法原理与实现

快速排序的基本思想就是从一个数组中任意挑选一个元素（通常来说会选择最左边的元素）作为中轴元素，将剩下的元素以中轴元素作为比较的标准，将小于等于中轴元素的放到中轴元素的左边，将大于中轴元素的放到中轴元素的右边。

然后以当前中轴元素的位置为界，将左半部分子数组和右半部分子数组看成两个新的数组，重复上述操作，直到子数组的元素个数小于等于1（因为一个元素的数组必定是有序的）。

以下的代码中会常常使用交换数组中两个元素值的Swap方法，其代码如下

publicstaticvoidSwap(int[] A, inti, intj){

inttmp;

tmp = A[i];

A[i] = A[j];

A[j] = tmp;

(6)划分过程的算法扩展阅读：

快速排序算法 的基本思想是：将所要进行排序的数分为左右两个部分，其中一部分的所有数据都比另外一 部分的数据小，然后将所分得的两部分数据进行同样的划分，重复执行以上的划分操作，直 到所有要进行排序的数据变为有序为止。

定义两个变量low和high，将low、high分别设置为要进行排序的序列的起始元素和最后一个元素的下标。第一次，low和high的取值分别为0和n-1，接下来的每次取值由划分得到的序列起始元素和最后一个元素的下标来决定。

定义一个变量key，接下来以key的取值为基准将数组A划分为左右两个部分，通 常，key值为要进行排序序列的第一个元素值。第一次的取值为A[0]，以后毎次取值由要划 分序列的起始元素决定。

从high所指向的数组元素开始向左扫描，扫描的同时将下标为high的数组元素依次与划分基准值key进行比较操作，直到high不大于low或找到第一个小于基准值key的数组元素，然后将该值赋值给low所指向的数组元素，同时将low右移一个位置。

如果low依然小于high，那么由low所指向的数组元素开始向右扫描，扫描的同时将下标为low的数组元素值依次与划分的基准值key进行比较操作，直到low不小于high或找到第一个大于基准值key的数组元素，然后将该值赋给high所指向的数组元素，同时将high左移一个位置。

重复步骤(3) (4)，直到low的植不小于high为止，这时成功划分后得到的左右两部分分别为A[low……pos-1]和A[pos+1……high]，其中，pos下标所对应的数组元素的值就是进行划分的基准值key，所以在划分结束时还要将下标为pos的数组元素赋值 为 key。

Ⅶ 如何进行IP子网划分

子网掩码概念及子网划分规则
一、子网掩码概述

1.子网掩码的概念
子网掩码是一个32位地址，用于屏蔽IP地址的一部分以区别网络标识和主机标识，并说明该IP地址是在局域网上，还是在远程网上。

2.确定子网掩码数
用于子网掩码的位数决定于可能的子网数目和每个子网的主机数目。在定义子网掩码前，必须弄清楚本来使用的子网数和主机数目。

定义子网掩码的步骤为：

A、确定哪些组地址归我们使用。比如我们申请到的网络号为 “210.73.a.b”，该网络地址为c类IP地址，网络标识为“210.73”，主机标识为“a.b”。

B、根据我们现在所需的子网数以及将来可能扩充到的子网数，用宿主机的一些位来定义子网掩码。比如我们现在需要12个子网，将来可能需要16个。用第三个字节的前四位确定子网掩码。前四位都置为“1”，即第三个字节为“11110000”，这个数我们暂且称作新的二进制子网掩码。

C、把对应初始网络的各个位都置为“1”，即前两个字节都置为“1”，第四个字节都置为“0”，则子网掩码的间断二进制形式为：“11111111.11111111.11110000.00000000”

D、把这个数转化为间断十进制形式为：“255.255.240.0”

这个数为该网络的子网掩码。

3.IP掩码的标注
A、无子网的标注法

对无子网的IP地址，可写成主机号为0的掩码。如IP地址210.73.140.5，掩码为255.255.255.0，也可以缺省掩码，只写IP地址。

B、有子网的标注法

有子网时，一定要二者配对出现。以C类地址为例。

1.IP地址中的前3个字节表示网络号，后一个字节既表明子网号，又说明主机号，还说明两个IP地址是否属于一个网段。如果属于同一网络区间，这两个地址间的信息交换就不通过路由器。如果不属同一网络区间，也就是子网号不同，两个地址的信息交换就要通过路由器进行。例如：对于IP地址为210.73.140.5的主机来说，其主机标识为00000101，对于IP地址为210.73.140.16的主机来说它的主机标识为00010000，以上两个主机标识的前面三位全是000，说明这两个IP地址在同一个网络区域中，这两台主机在交换信息时不需要通过路由器进行10.73.60.1的主机标识为00000001，210.73.60.252的主机标识为11111100，这两个主机标识的前面三位000与011不同，说明二者在不同的网络区域，要交换信息需要通过路由器。其子网上主机号各为1和252。

2.掩码的功用是说明有子网和有几个子网，但子网数只能表示为一个范围，不能确切讲具体几个子网，掩码不说明具体子网号，有子网的掩码格式(对C类地址)。

二、子网掩码的用处之一

便于网络设备尽快地区分本网段地址和非本网段的地址。

主机A与主机B交互信息。

主机A: IP地址：202.183.58.11

子网掩码：255.255.255.0

路由地址：202.183.58.1

主机B: IP地址：202.183.56.5

子网掩码：255.255.255.0

路由地址：202.183.56.1

路由器从端口202.183.58.1接收到主机A发往主机B的IP数据报文后，

（1）首先用端口地址202.183.58.1与子网掩码地址255.255.255.0进行“逻辑与”，得到端口网段地址：202.183.58.0，

（2）然后将目的地址202.183.56.5与子网掩码地址255.255.255.0进行“逻辑与”，得202.183.56.0,

（3）将结果202.183.56.0与端口网段地址202.183.58.0比较，如果相同，则认为是本网段的，不予转发。如果不相同，则将该IP报文转发到端口202.183.56.1所对应的网段。

三、子网掩码的用处之二

将子网进一步划分，缩小子网地址空间。将一个网段划分多个子网段，便于网络管理。

学校校园网信息中心可以将202.183.56.0（C类地址）分配给两个系，每个系约有120

台计算机，则可以将子网掩码地址定义为：255.255.255.128

这样将原来的一个网段分成两个独立的子网段，便于网络管理。

系1的地址范围：202.183.56.1—202.183.56.126

子网地址：1100101010110111 00111000 0xxxxxxx

系2的地址范围：202.183.56.129—202.183.56.254

子网地址：1100101010110111 00111000 1xxxxxxx

四、子网掩码的算法

（一）、利用子网数来计算
在求子网掩码之前必须先搞清楚要划分的子网数目，以及每个子网内的所需主机数目。
1)将子网数目转化为二进制来表示
2)取得该二进制的位数，为 N
3)取得该IP地址的类子网掩码，将其主机地址部分的的前N位置 1 即得出该IP地址划分子网的子网掩码。
如欲将B类IP地址168.195.0.0划分成27个子网：
1)27=11011
2)该二进制为五位数，N = 5
3)将B类地址的子网掩码255.255.0.0的主机地址前5位置 1，得到 255.255.248.0
即为划分成 27个子网的B类IP地址 168.195.0.0的子网掩码。
（二）、利用主机数来计算
1)将主机数目转化为二进制来表示
2)如果主机数小于或等于254（注意去掉保留的两个IP地址），则取得该主机的二进制位数，为 N，这里肯定 N<8。如果大于254，则 N>8，这就是说主机地址将占据不止8位。
3)使用255.255.255.255来将该类IP地址的主机地址位数全部置1，然后从后向前的将N位全部置为 0，即为子网掩码值。
如欲将B(c)类IP地址168.195.0.0划分成若干子网，每个子网内有主机700台(17)：
1) 700=1010111100
2)该二进制为十位数，N = 10(1001)
3)将该B类地址的子网掩码255.255.0.0的主机地址全部置 1，得到255.255.255.255
然后再从后向前将后 10位置0,即为： 11111111.11111111.11111100.00000000
即255.255.252.0。这就是该欲划分成主机为700台的B类IP地址 168.195.0.0的子网掩码。

五、子网的计算

在思科网络技术学院CCNA教学和考试当中，不少同学在进行IP地址规划时总是很头疼子网和掩码的计算。现在给大家一个小窍门，可以顺利解决这个问题。

首先，我们看一个CCNA考试中常见的题型：一个主机的IP地址是202.112.14.137，掩码是255.255.255.224，要求计算这个主机所在网络的网络地址和广播地址。

常规办法是把这个主机地址和子网掩码都换算成二进制数，两者进行逻辑与运算后即可得到网络地址。其实大家只要仔细想想，可以得到另一个方法：255.255.255.224的掩码所容纳的IP地址有256－224＝32个（包括网络地址和广播地址），那么具有这种掩码的网络地址一定是32的倍数。而网络地址是子网IP地址的开始，广播地址是结束，可使用的主机地址在这个范围内，因此略小于137而又是32的倍数的只有128，所以得出网络地址是202.112.14.128。而广播地址就是下一个网络的网络地址减1。而下一个32的倍数是160，因此可以得到广播地址为202.112.14.159。

CCNA考试中，还有一种题型，要你根据每个网络的主机数量进行子网地址的规划和计算子网掩码。这也可按上述原则进行计算。比如一个子网有10台主机，那么对于这个子网需要的IP地址是：

10＋1＋1＋1＝13

注意：加的第一个1是指这个网络连接时所需的网关地址，接着的两个1分别是指网络地址和广播地址。因为13小于16（16等于2的4次方），所以主机位为4位。而

256－16＝240

所以该子网掩码为255.255.255.240。

如果一个子网有14台主机，不少同学常犯的错误是：依然分配具有16个地址空间的子网，而忘记了给网关分配地址。这样就错误了，因为：

14＋1＋1＋1＝17

17大于16，所以我们只能分配具有32个地址（32等于2的5次方）空间的子网。这时子网掩码为：255.255.255.224。

六、子网掩码及其应用 （综合）

在TCP/IP协议中，SUBNET MASKS（子网掩码）的作用是用来区分网络上的主机是否在同一网络取段内。在大型网络中，CLASS A的SUBNET MASKS为255.0.0.0， CLASS B的SUBNET MASKS为255.255.0.0，CLASS C的SUBNET MASKS为255.255.255.0。

假如某台主机的SUBNET MASKS为IP地址为202.119.115.78，它的SUBNET MASKS为255.255.255.0。将这两个数据作AND运算后，所得出的值中的非0的BYTE部分即为NETWORK ID 。运算步骤如下：

202.119.115.78的二进制值为：
11001010.01110111.01110011.01001110
255.255.255.0的二进制值为:
11111111.11111111.11111111.00000000
AND后的结果为：
11001010.01110111.01110011.00000000
转为二进制后即为：
202.119.115.0

它就是NETWORK ID，在IP地址中剩下的即为HOST ID，即为78，这样当有另一台主机 的IP 地址为202.119.115.83，它的SUBNET MASKS也是255.255.255.0，则其NETWORK ID 为202.119.115，HOST ID为83，因为这两台主机的NETWORK ID都是202.119.115，因此，这两台主机在同一网段内。

但是，在实际应用中，可能会有多个分布与各地的网络，而且，每个网络的主机数量并不很多，如果申请多个NETWORK ID，会造成IP资源的浪费，而且很不经济，如果我们在SUBNET MASKS上动一下手脚，可以在只申请一个NETWORK ID的基础上解决这个问题。

比如，我们有三个不同的子网，每个网络的HOST数量各为20、25和50，下面依次称为甲、乙和丙网，但只申请了一个NETWORK ID 就是202.119.115。首先我们把甲和乙网的SUBNET MASKS改为255.255.255.224，224的二进制为11100000，即它的SUBNET MASKS为：

11111111.11111111.11111111.11100000

这样，我们把HOST ID的高三位用来分割子网，这三位共有000、001、010、011、100、 101、110、111八种组合，除去000（代表本身）和111（代表广播），还有六个组合，也就是可提供六个子网，它们的IP地址分别为：（前三个字节还是202.119.115）


00100001~00111110 即33~62为第一个子网
01000001~01011110 即65~94为第二个子网
01100001~01111110 即97~126为第三个子网
10000001~10011110 即129~158为第四个子网
10100001~10111110 即161~190为第五个子网
11000001~11011110 即193~222为第六个子网
选用161~190段给甲网，193~222段给乙网，因为各个子网都支持30台主机，足以应付甲网和乙网20台和25台的需求。

再来看丙网，由于丙网有50台主机，按上述分割方法无法满足它的IP需求，我们 可以将它的SUBNET MASKS设为255.255.255.192， 由于192的二进制值为11000000，按上述方法，它可以划分为两个子网，IP地址为：

01000001~01111110 即65~126为第一个子网
10000001~10111110 即129~190为第二个子网

这样每个子网有62个IP可用，将65~126分配丙网，多个子网用一个NETWORK ID 即告实现。


如果将子网掩码设置过大，也就是说子网范围扩大。那么根据子网寻径规则，很可能发往和本地机不在同一子网内的目的机的数据，会因为错误的相与结果而认为是在同一子网内，那么，数据包将在本子网内循环，直到超时并抛弃。数据不能正确到达目的机，导致网络传输错误。如果将子网掩码设置得过小，那么就会将本来属于同一子网内的机器之间的通信当做是跨子网传输，数据包都交给缺省网关处理，这样势必增加缺省网关的负担，造成网络效率下降。因此，任意设置子网掩码是不对的，应该根据网络管理部门的规定进行设置。

随着IP地址资源的日趋枯竭，可供分配的IP地址越来越少，往往一个拥 有几百台计算机规模的网络只能得到区区几个IP地址，于是，许多人开始采用其他技术来扩展IP空间。

Ⅷ dp的算法是什么

DP算法是解决多阶段决策过程最优化问题的一种常用方法。

多阶段决策过程是指这样一类特殊的活动过程，过程可以按时间顺序分解成若干个相互联系的阶段，在每一个阶段都需要做出决策，全部过程的决策是一个决策序列。

动态规划算法是解决多阶段决策过程最优化问题的一种常用方法，难度比较大，技巧性也很强。利用动态规划算法，可以优雅而高效地解决很多贪婪算法或分治算法不能解决的问题。

原理

动态规划问世以来，在经济管理、生产调度、工程技术和最优控制等方面得到了广泛的应用。例如最短路线、库存管理、资源分配、设备更新、排序、装载等问题，用动态规划方法比用其它方法求解更为方便。

虽然动态规划主要用于求解以时间划分阶段的动态过程的优化问题，但是一些与时间无关的静态规划(如线性规划、非线性规划)，只要人为地引进时间因素，把它视为多阶段决策过程，也可以用动态规划方法方便地求解。

Ⅸ 快速排序算法

第一趟排序后数组中的元素排列为37、35、38、36、47、53、65、73；
第二趟排序后数组中的元素排列为36、35、37、38、47、53、65、73；
第三趟排序后数组中的元素排列为35、36、37、38、47、53、65、73；
第四趟排序后数组中的元素排列为35、36、37、38、47、53、65、73；
第五趟排序后数组中的元素排列为35、36、37、38、47、53、65、73；
第六趟排序后数组中的元素排列为35、36、37、38、47、53、65、73；
第七趟排序后数组中的元素排列为35、36、37、38、47、53、65、73；
第八趟排序后数组中的元素排列为35、36、37、38、47、53、65、73。

Ⅹ 有关图划分算法

首先，最多划分为两部分，因为如果大于等于3部分，那么将其中任意两个部分合并可以优化答案。
这样问题就是求无向图的边连通度的问题了，可以用网络流来解决。具体算法可以参考《图论算法与信息学竞赛》这本书。