排序算法

分给的挺高的，今天太晚了有点困了，明天有时间再给你看看吧

排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：点击以下图片查看大图：关于时间复杂度平方阶(O(n2))排序各类简单排序：直接插入、直接选择和冒泡排序。线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序；O(n1+§))排序，§是介于0和1之间的常数。希尔排序线性阶(O(n))排序基数排序，此外还有桶、箱排序。关于稳定性稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。名词解释：n：数据规模k："桶"的个数In-place：占用常数内存，不占用额外内存Out-place：占用额外内存稳定性：排序后2个相等键值的顺序和排序之前它们的顺序相同包含以下内容：1、冒泡排序2、选择排序3、插入排序4、希尔排序5、归并排序6、快速排序7、堆排序8、计数排序9、桶排序10、基数排序 排序算法包含的相关内容具体如下：冒泡排序算法冒泡排序（BubbleSort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。选择排序算法选择排序是一种简单直观的排序算法，无论什么数据进去都是O(n?)的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间。插入排序算法插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。希尔排序算法希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。归并排序算法归并排序（Mergesort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（DivideandConquer）的一个非常典型的应用。快速排序算法快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个项目要Ο(nlogn)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(nlogn)算法更快，因为它的内部循环（innerloop）可以在大部分的架构上很有效率地被实现出来。堆排序算法堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。计数排序算法计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。桶排序算法桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。基数排序算法基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

O(n^2)

一、冒泡排序，代码和运行结果如图所示。重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。二、选择排序，代码和运行结果如图所示。思想：选择排序，让数组中的每一个数，依次与后面的数进行比较，如果前面的数大于后面的数，就进行位置的交换。换个说法，选择排序：第一个数依次与后面的数比较，第一次比较完之后最小的数在最前面 。扩展资料：冒泡排序算法的原理如下：1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。2、对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。3、针对所有的元素重复以上的步骤，除了最后一个。4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。参考资料：百度百科——冒泡排序

从小到大的排序classProgram{publicstaticvoidSort(int[]myArray){//取长度最长的词组--冒泡法for(intj=1;j<myArray.Length;j++){for(inti=0;i<myArray.Length-1;i++){//如果myArray[i]>myArray[i+1]，则myArray[i]上浮一位if(myArray[i]>myArray[i+1]){inttemp=myArray[i];myArray[i]=myArray[i+1];myArray[i+1]=temp;}}}}staticvoidMain(string[]args){int[]myArray=newint[]{10,8,3,5,6,7,4,6,9};Sort(myArray);for(intm=0;m<myArray.Length;m++){Console.WriteLine(myArray[m]);}}从大到小的排序classProgram{publicstaticvoidSort(int[]myArray){//取长度最长的词组--冒泡法for(intj=1;j<myArray.Length;j++){for(inti=0;i<myArray.Length-1;i++){//如果myArray[i]<myArray[i+1]，则myArray[i]下沉一位if(myArray[i]<myArray[i+1]){inttemp=myArray[i];myArray[i]=myArray[i+1];myArray[i+1]=temp;}}}}staticvoidMain(string[]args){int[]myArray=newint[]{10,8,3,5,6,7,4,6,9};Sort(myArray);for(intm=0;m<myArray.Length;m++){Console.WriteLine(myArray[m]);}}

　　排序算法是什么?有多少种?排序算法总结又是怎样?以下是为您整理的排序算法总结，供您参考! 　　【排序算法总结】 　　排序算法：一种能将一串数据依照特定的排序方式进行排列的一种算法。 　　排序算法性能：取决于时间和空间复杂度，其次还得考虑稳定性，及其适应的场景。 　　稳定性：让原本有相等键值的记录维持相对次序。也就是若一个排序算法是稳定的，当有俩个相等键值的记录R和S，且原本的序列中R在S前，那么排序后的列表中R应该也在S之前。 　　以下来总结常用的排序算法，加深对排序的理解。 　　 冒泡排序 　　原理 　　俩俩比较相邻记录的排序码，若发生逆序，则交换;有俩种方式进行冒泡，一种是先把小的冒泡到前边去，另一种是把大的元素冒泡到后边。 　　性能 　　时间复杂度为O(N^2)，空间复杂度为O(1)。排序是稳定的，排序比较次数与初始序列无关，但交换次数与初始序列有关。 　　优化 　　若初始序列就是排序好的，对于冒泡排序仍然还要比较O(N^2)次，但无交换次数。可根据这个进行优化，设置一个flag，当在一趟序列中没有发生交换，则该序列已排序好，但优化后排序的时间复杂度没有发生量级的改变。 　　代码 　 　插入排序 　　原理 　　依次选择一个待排序的数据，插入到前边已排好序的序列中。 　　性能 　　时间复杂度为O(N^2)，空间复杂度为O(1)。算法是稳定的，比较次数和交换次数都与初始序列有关。 　　优化 　　直接插入排序每次往前插入时，是按顺序依次往前找，可在这里进行优化，往前找合适的插入位置时采用二分查找的方式，即折半插入。 　　折半插入排序相对直接插入排序而言：平均性能更快，时间复杂度降至O(NlogN)，排序是稳定的，但排序的比较次数与初始序列无关，总是需要foor(log(i))+1次排序比较。 　　使用场景 　　当数据基本有序时，采用插入排序可以明显减少数据交换和数据移动次数，进而提升排序效率。 　　代码 　　 希尔排序 　　原理 　　插入排序的改进版，是基于插入排序的以下俩点性质而提出的改进方法： 　　插入排序对几乎已排好序的数据操作时，效率很高，可以达到线性排序的效率。 　　但插入排序在每次往前插入时只能将数据移动一位，效率比较低。 　　所以希尔排序的思想是： 　　先是取一个合适的gap 　　缩小间隔gap，例如去gap=ceil(gap/2)，重复上述子序列划分和排序 　　直到，最后gap=1时，将所有元素放在同一个序列中进行插入排序为止。 　　性能 　　开始时，gap取值较大，子序列中的元素较少，排序速度快，克服了直接插入排序的缺点;其次，gap值逐渐变小后，虽然子序列的元素逐渐变多，但大多元素已基本有序，所以继承了直接插入排序的优点，能以近线性的速度排好序。 　　代码 　　 选择排序 　　原理 　　每次从未排序的序列中找到最小值，记录并最后存放到已排序序列的末尾 　　性能 　　时间复杂度为O(N^2)，空间复杂度为O(1)，排序是不稳定的(把最小值交换到已排序的末尾导致的)，每次都能确定一个元素所在的最终位置，比较次数与初始序列无关。 　　代码 　　 快速排序 　　原理 　　分而治之思想： 　　Divide：找到基准元素pivot，将数组A[p..r]划分为A[p..pivotpos-1]和A[pivotpos+1u2026q]，左边的元素都比基准小，右边的元素都比基准大; 　　Conquer：对俩个划分的数组进行递归排序; 　　Combine：因为基准的作用，使得俩个子数组就地有序，无需合并操作。 　　性能 　　快排的平均时间复杂度为O(NlogN)，空间复杂度为O(logN)，但最坏情况下，时间复杂度为O(N^2)，空间复杂度为O(N);且排序是不稳定的，但每次都能确定一个元素所在序列中的最终位置，复杂度与初始序列有关。 　　优化 　　当初始序列是非递减序列时，快排性能下降到最坏情况，主要因为基准每次都是从最左边取得，这时每次只能排好一个元素。 　　所以快排的优化思路如下： 　　优化基准，不每次都从左边取，可以进行三路划分，分别取最左边，中间和最右边的中间值，再交换到最左边进行排序;或者进行随机取得待排序数组中的某一个元素，再交换到最左边，进行排序。 　　在规模较小情况下，采用直接插入排序 　　代码 　　 归并排序 　　原理 　　分而治之思想： 　　Divide：将n个元素平均划分为各含n/2个元素的子序列; 　　Conquer：递归的解决俩个规模为n/2的子问题; 　　Combine：合并俩个已排序的子序列。 　　性能 　　时间复杂度总是为O(NlogN)，空间复杂度也总为为O(N)，算法与初始序列无关，排序是稳定的。 　　优化 　　优化思路： 　　在规模较小时，合并排序可采用直接插入; 　　在写法上，可以在生成辅助数组时，俩头小，中间大，这时不需要再在后边加俩个while循环进行判断，只需一次比完。 　　代码 　　 堆排序 　　原理 　　堆的性质： 　　是一棵完全二叉树 　　每个节点的值都大于或等于其子节点的值，为最大堆;反之为最小堆。 　　堆排序思想： 　　将待排序的序列构造成一个最大堆，此时序列的最大值为根节点 　　依次将根节点与待排序序列的最后一个元素交换 　　再维护从根节点到该元素的前一个节点为最大堆，如此往复，最终得到一个递增序列 　　性能 　　时间复杂度为O(NlogN)，空间复杂度为O(1)，因为利用的排序空间仍然是初始的序列，并未开辟新空间。算法是不稳定的，与初始序列无关。 　　使用场景 　　想知道最大值或最小值时，比如优先级队列，作业调度等场景。 　　代码 　　 计数排序 　　原理 　　先把每个元素的出现次数算出来，然后算出该元素所在最终排好序列中的绝对位置(最终位置)，再依次把初始序列中的元素，根据该元素所在最终的绝对位置移到排序数组中。 　　性能 　　时间复杂度为O(N+K)，空间复杂度为O(N+K)，算法是稳定的，与初始序列无关，不需要进行比较就能排好序的算法。 　　使用场景 　　算法只能使用在已知序列中的元素在0-k之间，且要求排序的复杂度在线性效率上。 　　代码 　　 桶排序 　　原理 　　根据待排序列元素的大小范围，均匀独立的划分M个桶 　　将N个输入元素分布到各个桶中去 　　再对各个桶中的元素进行排序 　　此时再按次序把各桶中的元素列出来即是已排序好的。 　　性能 　　时间复杂度为O(N+C)，O(C)=O(M(N/M)log(N/M))=O(NlogN-NlogM)，空间复杂度为O(N+M)，算法是稳定的，且与初始序列无关。 　　使用场景 　　算法思想和散列中的开散列法差不多，当冲突时放入同一个桶中;可应用于数据量分布比较均匀，或比较侧重于区间数量时。 　　 基数排序 　　原理 　　对于有d个关键字时，可以分别按关键字进行排序。有俩种方法： 　　MSD：先从高位开始进行排序，在每个关键字上，可采用计数排序 　　LSD：先从低位开始进行排序，在每个关键字上，可采用桶排序 　　性能 　　时间复杂度为O(d*(N+K))，空间复杂度为O(N+K)。 　 　总结 　　以上排序算法的时间、空间与稳定性的总结如下：

思维方法：求和取平均值，然后从中间开始向两边比较排序。算法思想简单描述：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。算法：/*功能：冒泡排序输入：数组名称（也就是数组首地址）、数组中元素个数*/void bubble_sort(int *x, int n){int j, k, h, t;for (h=n-1; h>0; h=k) /*循环到没有比较范围*/{for (j=0, k=0; j<h; j++) /*每次预置k=0，循环扫描后更新k*/{if (*(x+j) > *(x+j+1)) /*大的放在后面，小的放到前面*/{t = *(x+j);*(x+j) = *(x+j+1);*(x+j+1) = t; /*完成交换*/k = j; /*保存最后下沉的位置。这样k后面的都是排序排好了的。*/}}}}

看你是升序还是降序,升序的话,第一趟跑完之后,3在前面。注意控制数组的下标，判断符合条件的时候，调换这两个值在数组中的位置，然后执行下一个循环。

冒泡排序算法的分析与改进 孙伟 （安徽中医学院 医药信息工程学院 09医软一班，安徽合肥，230009） 摘 要： 冒泡排序算法有两个优点：1“编程复杂度”很低，很容易写出代码；2. 具有稳定性，这里的稳定性是指原序列中相同元素的相对顺序仍然保持到排序后的序列，但当需要排序的数据较多且无序时，冒泡排序算法的时间复杂度较大，比较次数较多，本文提出了一种冒泡排序算法的改进方法，可以大大减少比较的次数，降低算法的时间复杂度。 关键词：交换排序 扫描 稳定 算法 中图分类号：TU 411.01 文献标识码：A Bubble sort algorithm analysis and improvement SUN Wei (Anhui University of Traditional Chinese Medicine Medical Information Engineering, Hefei 230009, China ；) Abstract: Bubble sort algorithm has two advantages:1 “Programming complexity”is very low，and it is easy to write code;2.It has the stability, the stability refers to the original sequence in the same element relative sequence remains to sort sequence, but when the need to sort the data and more disordered, bubble sort algorithm time complexity compared to larger, more often, this paper presents a bubble sort algorithm method, can greatly reduce the number of comparisons, reduce the time complexity of algorithm. Key words：Exchange sort ; Scanning ; stability ; Algorithm 1. 概述 1.1 冒泡排序简介 冒泡排序法是一种交换排序法，这种方法的基本思想是，将待排序 的元素看作是竖着排列的“ 气泡”，较小的元素比较轻，从而要往上浮。在冒泡排序算法中我们要对这个“ 气泡”序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即“ 轻”的元素在下面，就交换它们的位置。显然，处理一遍之后，“ 最轻”的元素就浮到了最高位置；处理二遍之后，“ 次轻”的元素就浮到了次高位置。在作第二遍处理时，由于 最高位置上的元素已是“ 最轻”元素，所以不必检查。一般地，第i 遍处理时，不必检查第i 高位置以上的元素，因为经过前面i- 1遍的处理，它们已正确地排好序。 1.2 冒泡排序方法 冒泡排序法是一种最简单的排序算法, 它和气泡从水中往上冒的情况有些类似。其基本算法如下：对1 至n 个记录，先将第n 个和第n- 1 个记录的键值进行比较，如r [n].key ——————————————————————————————————————————————————————— 收稿日期：2012-4-14； 作者简介：孙伟 1992-10-04 女 09713033 09医软一班 实现的功能：将键值最小的记录传到了第1 位。然后，再对2 至n 个记录进行同样操作，则具有次小键值的记录被安置在第2 位上。重复以上过程， 每次的移动都向最终排序的目标前进，直至没有记录需要交换为止。具体实现时，可以用一支旗子flag 表示第i 趟是否出现交换。如果第i 趟没有交换，则表示此时已完成排序，因而可以终止。 1.3 冒泡排序过程示例 设待排序的键值为： 25 17 65 13 94 47 41 94 执行冒泡排序的过程如下图所示。其中，第一列为初始键值序列, 第二列至第八列依次为各趟排序的结果， 图中用方括号括起来的是当前待排序的无序区。 每一次排序都使有序区扩充了一个气泡，在经过i 次排序之后，有序区中就有i 个气泡， 而无序区中气泡的重量总是大于等于有序区中气泡的重量，整个冒泡排序过程至多需要进行n- 1 次排序。但是, 若在某一次排序中未发现气泡位置的交换， 则说明待排序的无序区中所有气泡均满足轻者在上，重者在下的原则因此冒泡排序过程可在此次排序后终止。在上图的示例中，在第四次(图中第五列) 排序过程中就没有气泡交换位置, 此时整个文件已达到有序状态。为此，实际给出的算法中， 我们可以引入一个布尔量flag ， 在每一次排序之前， 先将它置为true ，若在一次排序中交换了记录, 则将它置为false 。当一次排序结束时，我们再检查flag ，若未曾交换过记录便终止算法。 该算法的时间复杂性为0(n2), 算法为稳定的排序方法。 2. 对于冒泡算法的改进 2.1 第一种改进方法 如果在某一趟循环中没有任何数据交换发生， 则表明数据已经排序完毕。那么剩余的循环就不需要再执行假设需要排序的数据已经按照从小到大排列，那么第一趟比较就不会有任何数据交换发生。这种改进算法如下： 设置一个标志位，当没有交换的时候这个标志位不会变化，那么说明数据已经排序好了，就不需要再进行剩余的循环。只有在标志位被重新设置的情况下才会进行剩余的循环。 public static void ImproveBubble1(int [ ]myArray) { bool isSorted = false; for(int i = 0; i // 只有在没有排序的情况下才继续循环 { isSorted = true; // 设定排序标志 for(int j = 0; j myArray[j+1] ) { isSorted = false; // 如果是没有排序，就重新设定标志 Swap(refmyArray, refmyArray[i+1]); } } } } 从这种算法可以看出，若记录的初始状态是正序（ 从小到大） 的，则一趟扫描即可完成排序。所需的较和记录移动的次数分别达到最小值n- 1 和0。即算法最好的时间复杂度为0(n)；若初始记录是反序（ 从大到小） 的，则需要进行n- 1 趟排序，每趟排序要进行n- i 次关键字的比较，且每次比较都必须移记录三次来达到交换记录位置。在这情况下比较和移动次数达到最大值：比较次数：Cmax= n(n- 1)/2 移动次数： Mmax=3n(n- 1)/2因此这种改进方法的最坏时间复杂度也为0(n^2)。在平均情况下，算法可能在中间的某一趟排序完后就终止，但总的比较次数仍为0(n^2)，所以算法的 平均时间复杂度为0(n^2)。因此，这种算法最好的时间复杂度为0(n)。平均，最坏时刻复杂度为0(n^2)。 2.2 第二种改进方法 在冒泡排序的每趟扫描中， 记住最后一次交换发生的位置lastexchange 也能有所帮助。因为该位置之前的相邻记录已经有序，故下一趟排序开始的时候，0 到lastexchange 已经是有序的了，lastexchange 到n- 1是无序区。所以一趟排序可能使当前有序区扩充多个记录。即较大缩小无序区范围，而非递减1，以此减少排序趟数。这种算法如下： 在冒泡排序中，每趟排序实现了将最大(升序) 或最小(降序) 的记录安置到未排序部分的最后位置，即最终位置。通过进一步观察研究，由于每趟排序过程中，通过和邻记录关键字两两比较，大(升序) 或小(降序) 的记录在不断地往下沉或往后靠，小(升序) 或大(降序) 的记录在不断往上冒或往前靠。每经过一趟排序，在最后次交换位置后面的记录都已经排好序。根据上面的思路，对n 个记录进行第k 趟排序，首先需在第k- 1 趟排序时记下最后交换的位置。然后在第k 趟排序时，将第一个记录的关键字与第二个记录的关键字进行比较，符合交换条件时，进行交换。再比较第二个记录和第三个记录的关键字，依次类推，直至第m- 1 个记录和第m 个记录的关键字进行比较，而不需要比较至n- k- 1 个记录。在大部分排序中，m 都小于n- k- 1从而减少了比较趟数和每趟的比较次数。由于在第一趟排序 时，没有上一趟排序的m 值。因此，还要设置m 的初始值为n- 1。 public static void ImproveBubble2(int[ ]myArray) { int m= myArray.Length -1; int k, j; while(m> 0 ) { for( k=j=0; j myArray[j+1]) { Swap(refmyArray[j], refmyArray[j+1]); k = j; // 记录每次交换的位置 }} m= k; // 记录最后一个交换的位置 }} 从这种算法可以看出，若记录的初始状态是正序（ 从小到大） 的。则一趟扫描即可完成排序， 所的关键比较和记录移动的次数分别达到最小值n- 1 和0。即算法最好的时间复杂度为0(n);若初始记录是反序（ 从大到小） 的，则需要进行n- 1 趟排序，每趟排序要进行n- i 次关键字的比较，且每次比较都须移动记录三次来达到交换记录位置。在这情况下比较和移动次数达到最大值：比较次数：Cmax= n(n- 1)/2 移动次数Mmax=3n(n- 1)/2因此，这种办法的最坏时间复杂度也为0(n^2)。在平均情况下，算法较大地改变了无序区的范围，从而减少了比较的次数，但总的比较次数仍为0(n^2)。所以算法的平均时间复杂度为0(n^2)。因此，算法2 最好的时间复杂度为0(n)。平均，最坏时刻复杂度为0(n^2)。 2.3 双向扫描冒泡法 若记录的初始状态为:只有最轻的气泡位于d[n]的位置(或者最重的气泡位于d[0]位置) ，其余的气泡均已排好序。在上述三种算法中都要做n- 1 趟扫描。实际上只需一趟扫描就可以完成排序。所以对于这种不 对称的情况。可对冒泡排序又作一次改进。在排序过程中交替改变扫描方向。即先从下扫到上，再从上扫到下，来回地进行扫描，这样就得到双向冒泡排序算法。 对n 个记录进行排序时，设up 记录了从前面向后面依次进行扫描时最后的交换位置，low 记录了从后面向前面依次进行扫描时最前的交换位置。由上个改进的冒泡排序的原理可知，up 后面的记录和low 前面的记录都已有序。每趟排序都由两次不同方向的比较、交换组成。第一次是从未排好序的第一个记录开始，即从low 记录开始，向后依次两两比较，如果不符合条件，则交换之， 直至比较到未排好序的最后一个记录，即up 记录为止。同时记下最后一次交换的位置，并存于up 。第二次是从未排好序的最后一个记录开始, 即从up 记录开始，向前依次两两比较，如果不符合条件，则交换之，直至比较到未排好序的第一个记 录，即low 记录为止。同时记下最后次交换的位置，并存于low 。这样，就完成了一趟排序。每趟排序都实现了将未排好序部分的关键字大的记录往后移 (升序) ， 关键字小的记录往前移（ 升序) ，从而使 两端已排好序（ 如果是降序，记录移动的方向则相反) 。未排好序部分的记录的首尾位置分别由low 和up 指明。不断按上面的方法进行排序，使两端已排好序的记录不断增多，未排好序部分的记录逐渐减少。即low 和up 的值不断接近，当low>=up 时，表明已没有未排好序的记录，排序就完成了。由于在第一趟排序时，没有上趟排序的low 和up 值。因此，还要设置low 和up 的初始值分别为0 和n- 1。 public static void ImproveBubble3(int [ ]myArray) { int low, up, index, i; low= 0; up = myArray.Length - 1; index = low; while( up > low) { for( i=low; imyArray[i+1]) { Swap(refmyArray, refmyArray[i+1]); index = i; }} up= index; // 记录最后一个交换的位置 for(i=up; i>low; i- - ) // 从最后一个交换 位置处从下向上扫描 { if(myArray Swap(refmyArray, refmyArray[i- 1]); index = i; }} low= index; // 记录最后一个交换的位 置 }} 从这种算法可以看出，若记录的初始状态是正 序（ 从小到大） 的，则一趟扫描即可完成排序。所需的关键比较和记录移动的次数分别达到最小值n- 1 和0。即算法最好的时间复杂度为0(n);若初始记录是反序（ 从大到小） 的，则需要进行[n/2]趟排序。如果只有最重的气泡在最上面（ 或者最轻的气泡在最下面） ，其余的有序，这时候就只需要比较1 趟。但是在最坏的情况下，算法的复杂度也为0(n^2)。因此，算法最好的时间复杂度为0(n)，最坏时刻复杂度为0(n^2)。 3. 性能分析 为了分析数据两种冒泡排序法的性能， 我们用自编的测试程序对大量数据进行了测试，得出下表，从表中可以直观地看出两种冒泡排序方法的性能差异（ 时间单位为毫秒）。 图1 算法运行时间比较表 4. 结束语 从上面的表格可以看出，在数据量比较小的时候，这几种算法基本没有任何区别。当数据量比较大的时候，双向扫描冒泡排序会有更好的效率。但是效率并没有根本的提升。因此冒泡排序确实不是我们排序的首选。在数据量比较大的时候，快速排序等会有非常明显的优势。但是在数据量很小的时候，各种排序算法的效率差别并不是很大。那么冒泡排序也会有自己的用武之地。因此，在实际考虑算法的时候，最重要的是熟悉各种算法的性能表现并且根据数据的数量以及当前运行的环境，开发的进度选择最合适的算法。 [参 考 文 献] ［1］（ 美） 莱维丁著. 潘彦译，《算法设计与分析基础》. 清华大学出版社 ［2］ 胡金初，《计算机算法》. 清华大学出版社 ［3］ 阿苏外耶（M．H．Alsuwaiyel），朱洪（译），《算法设计技巧与分析》．电子工业出版社 ［4］（美）Robert sedgewick，《算法分析导论》．机械工业出版社 ［5］（ 美）Michael T．Goodrich Roberto Tamassia，《算法分析与设计》人民邮电出版社 ［6］王晓东，《计算机算法设计与分析》电子工业出版社 ［7］Shaffer，Clifford，张铭，《数据结构与算法分析》电子工业出版社 ［8］刘任任 ，《算法设计与分析》武汉理工大学出版社，2003

冒泡排序算法的原理如下：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。所以时间复杂度为n*（n-1）

具体如下。冒泡排序原理：比较相邻两元素，将值大的交换到右边（从小到大排序，也可从大到小排序）；步骤：第一趟第一次比较：首先比较第一和第二个数，将小数放在前面，将大数放在后面。比较第2和第3个数，将小数放在前面，大数放在后面。重复步骤(2)，直到比较到最后的两个数，将小数放在前面，大数放在后面，第一趟排序完成。冒泡排序（BubbleSort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括：点击以下图片查看大图：关于时间复杂度平方阶(O(n2))排序各类简单排序：直接插入、直接选择和冒泡排序。线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序；O(n1+§))排序，§是介于0和1之间的常数。希尔排序线性阶(O(n))排序基数排序，此外还有桶、箱排序。关于稳定性稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。名词解释：n：数据规模k："桶"的个数In-place：占用常数内存，不占用额外内存Out-place：占用额外内存稳定性：排序后2个相等键值的顺序和排序之前它们的顺序相同包含以下内容：1、冒泡排序2、选择排序3、插入排序4、希尔排序5、归并排序6、快速排序7、堆排序8、计数排序9、桶排序10、基数排序 排序算法包含的相关内容具体如下：冒泡排序算法冒泡排序（BubbleSort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。选择排序算法选择排序是一种简单直观的排序算法，无论什么数据进去都是O(n?)的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间。插入排序算法插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。希尔排序算法希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。归并排序算法归并排序（Mergesort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（DivideandConquer）的一个非常典型的应用。快速排序算法快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个项目要Ο(nlogn)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。事实上，快速排序通常明显比其他Ο(nlogn)算法更快，因为它的内部循环（innerloop）可以在大部分的架构上很有效率地被实现出来。堆排序算法堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。计数排序算法计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。桶排序算法桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。基数排序算法基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

for(i=1;i<n;i++){ for(j=0;j<n-i;j++){ if(a[j]>a[j+1]){ temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } }

有两种。冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到最大数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最大数。如此下去，直至最终完成排序。

PDL语言全称是过程设计语言（Process Design Language），它是在伪代码的基础上，扩充了模块的定义与调用、数据定义和输入输出而形成的。它的控制结构与伪代码相同。PDL是一种用于描述模块算法设计和细节处理的语言

前段时间为准备百度面试恶补的东西，虽然最后还是被刷了，还是把那几天的“战利品”放点上来，算法一直是自己比较薄弱的地方，以后还要更加努力啊。下面用Python实现了几个常用的排序，如快速排序，选择排序，以及二路并归排序等等。 代码如下:#encoding=utf-8import randomfrom copy import copydef directInsertSort(seq): """ 直接插入排序 """ size = len(seq) for i in range(1,size): tmp, j = seq[i], i while j > 0 and tmp < seq[j-1]: seq[j], j = seq[j-1], j-1 seq[j] = tmp return seqdef directSelectSort(seq): """ 直接选择排序 """ size = len(seq) for i in range(0,size - 1): k = i;j = i+1 while j < size: if seq[j] < seq[k]: k = j j += 1 seq[i],seq[k] = seq[k],seq[i] return seqdef bubbleSort(seq): """冒泡排序""" size = len(seq) for i in range(1,size): for j in range(0,size-i): if seq[j+1] < seq[j]: seq[j+1],seq[j] = seq[j],seq[j+1] return seqdef _divide(seq, low, high): """快速排序划分函数""" tmp = seq[low] while low != high: while low < high and seq[high] >= tmp: high -= 1 if low < high: seq[low] = seq[high] low += 1 while low < high and seq[low] = high: return mid = _divide(seq, low, high) _quickSort(seq, low, mid - 1) _quickSort(seq, mid + 1, high)def quickSort(seq): """快速排序包裹函数""" size = len(seq) _quickSort(seq, 0, size - 1) return seqdef merge(seq, left, mid, right): tmp = [] i, j = left, mid while i < mid and j 运行结果如下： 代码如下:E:python_projectpractice>sorting.py[10, 47, 56, 76, 64, 84, 26, 8, 47, 51, 88, 81, 32, 95, 91, 29, 28, 69, 61, 45][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95][8, 10, 26, 28, 29, 32, 45, 47, 47, 51, 56, 61, 64, 69, 76, 81, 84, 88, 91, 95]

冒择入希快归堆：冒泡、选择、插入、希尔、快速、归并、堆排序

#include<stdio.h>#include<stdlib.h>#include<time.h>int b[ 10 ];void Merge( int c[], int d[], int l, int m, int r ){ int i = l, j = m + 1, k = l; while( ( i <= m ) && ( j <= r ) ) if( c[ i ] <= c[ j ] ) d[ k++ ] = c[ i++ ]; else d[ k++ ] = c[ j++ ]; if( i > m ) for( int q = j; q <= r; q++ ) d[ k++ ] = c[ q ]; else for( int q = i; q <= m; q++ ) d[ k++ ] = c[ q ];}void Copy( int c[], int d[], int n1, int n2 ){ for( int i = n1; i <= n2; i++ ) c[ i ] = d[ i ];}void MergeSort( int a[], int left, int right ){ if( left < right ) { int i = ( left + right ) / 2; //取中点，分成两路 MergeSort( a, left, i ); MergeSort( a, i + 1, right ); Merge( a, b, left, i, right ); //合并到数组b Copy( a, b, left, right ); //复制到数组a }}int main(){ int a[ 10 ], i; srand( time( 0 ) ); for( i = 0; i < 10; i++ ) a[ i ] = rand() % 100; //随机生成 for( i = 0; i < 10; i++ ) //输出随机生成的数据 printf( "%d ", a[ i ] ); printf( " " ); MergeSort( a, 0, 9 ); for( i = 0; i < 10; i++ ) //输出排序后的结果 printf( "%d ", a[ i ] ); printf( " " ); return 0;} //在vc++6.0上调试运行成功。若有不明白的地方，call me!!!