在EXCEL表格里的升序、排序的选择键怎么弄？_百度知道
在EXCEL表格里的升序、排序的选择键怎么弄？
就是这个如图上可以选择升序，排序的键怎么插入？
我有更好的答案
1、选中第一排2、数据--&筛选--&自动筛选3、可以点击三角符号进行排序
采纳率：26%
baidu.com/zhidao/wh%3D600%2C800/sign=8beedb05fbf2b211e47b8d48faba7b0ea9ff2d3572c10dfcfd9.jpg" esrc="http://d.hiphotos点击下拉箭头，下拉框中拉杆往上拉，就可以看到。
数据---筛选--自动筛选
一、数值排序
1、RANK函数
RANK函数是Excel计算序数的主要工具，它的语法为：RANK（number，ref，order），其中number为参与计算的数字或含有数字的单元格，ref是对参与计算的数字单元格区域的绝对引用，order是用来说明排序方式的数字（如果order为零或省略，则以降序方式给出结果，反之按升序方式）。
例如要计算E2、E3、E4单元格存放一季度的总产值，计算各车间产值排名的方法是：在F2单元格内输入公式“=RANK（E2，$E$2:$E$4）”，敲回车即可计算出铸造车间的产值排名是2。再将F2中的公式复制到剪贴板，选中F3、F4单元格按Ctrl+V，就能计算出其余两个车间的产值排名为3和1。美文坊提醒大家如果B1单元格中输入的公式为“=RANK（E2，$E$2:$E$4，1）”，则计算出的序数按升序方式排列，即2、1和3。需要注意的是：相同数值用RANK函数计算得到的序数（名次）相同，但会导致后续数字的序数空缺。假如上例中F2单元格存放的数值与F3相同，则按本法计算出的排名分别是3、3和1（降序时）。
2、COUNTIF函数
COUNTIF函数可以统计某一区域中符合条件的单元格数目，它的语法为COUNTIF（range，criteria）。其中range为参与统计的单元格区域，criteria是以数字、表达式或文本形式定义的条件。其中数字可以直接写入，表达式和文本必须加引号。
仍以上面的为例，F2单元格内输入的公式为“=COUNTIF（$E$2:$E$4，”&“&E2）+1”。计算各车间产值排名的方法同上，结果也完全相同，2、1和3。
此公式的计算过程是这样的：首先根据E2单元格内的数值，在连接符&的作用下产生一个逻辑表达式，即“&176。7”、“&167。3”等。COUNTIF函数计算出引用区域内符合条件的单元格数量，该结果加一即可得到该数值的名次。很显然，利用上述方法得到的是降序排列的名次，对重复数据计算得到的结果与RANK函数相同 3、IF函数
Excel自身带有排序功能，可使数据以降序或升序方式重新排列。如果将它与IF函数结合，可以计算出没有空缺的排名。以上例中E2、E3、E4单元格的产值排序为例，具体做法是：选中E2单元格，根据排序需要，单击Excel工具栏中的“降序排序”或“升序排序”按钮，即可使工作表中的所有数据按要求重新排列。
假如数据是按产值由大到小（降序）排列的，而您又想赋予每个车间从1到n（n为自然数）的排名。可以在G2单元格中输入1，然后在G3单元格中输入公式“=IF（E3=E2，G3，G3+1）”，只要将公式复制到G4等单元格，就可以计算出其他车间的产值排名。
二、文本排序
选举等场合需要按姓氏笔划为文本排序，Excel提供了比较好的解决办法。如果您要将上例数据表按车间名称的笔划排序，可以使用以下方法：选中排序关键字所在列（或行）的首个单元格，单击Excel“数据”菜单下的“排序”命令，再单击其中的“选项”按钮。选中“排序选项”对话框“方法”下的“笔画排序”，再根据数据排列方向选择“按行排序”或“按列排序”，“确定”后回到“排序”对话框。如果您的数据带有标题行，则应选中“有标题行”（反之不选），然后打开“主要关键字”下拉列表，选择其中的“单位”，选中排序方式（“升序”或“降序”）后“确定”，表中的所有数据就会据此重新排列。此法稍加变通即可用于“第一名”、“第二名”等文本排序，请读者自行摸索。三、自定义排序
如果您要求Excel按照“金工车间”、“铸造车间”和“维修车间”的特定顺序重排工作表数据，前面介绍的几种方法就无能为力了。这类问题可以用定义排序规则的方法解决：首先单击Excel“工具”菜单下的“选项”命令，打开“选项”对话框中的“自定义序列”选项卡。选中左边“自定义序列”下的“新序列”，光标就会在右边的“输入序列”框内闪动，您就可以输入“金工车间”、“铸造车间”等自定义序列了，输入的每个序列之间要用英文逗号分隔，或者每输入一个序列就敲回车。如果序列已经存在于工作表中，可以选中序列所在的单元格区域单击“导入”，这些序列就会被自动加入“输入序列”框。无论采用以上哪种方法，单击“添加”按钮即可将序列放入“自定义序列”中备用。
使用排序规则排序的具体方法与笔划排序很相似，只是您要打开“排序选项”对话框中的“自定义排序次序”下拉列表，选中前面定义的排序规则，其他选项保持不动。回到“排序”对话框后根据需要选择“升序”或“降序”，“确定”后即可完成数据的自定义排序。
需要说明的是：显示在“自定义序列”选项卡中的序列（如一、二、三等），均可按以上方法参与排序，请读者注意Excel提供的自定义序列类型。
其他1条回答
为您推荐：
其他类似问题
您可能关注的内容
excel表格的相关知识
换一换
回答问题，赢新手礼包
个人、企业类
违法有害信息,请在下方选择后提交
色情、暴力
我们会通过消息、邮箱等方式尽快将举报结果通知您。排序算法_百度百科
声明：百科词条人人可编辑，词条创建和修改均免费，绝不存在官方及代理商付费代编，请勿上当受骗。
所谓，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。
排序算法分类
(Sorting) 是中的一种重要操作，它的功能是将一个（或记录）的任意序列，重新排列成一个关键字有序的序列。
稳定度（稳定性）
一个排序算法是稳定的，就是当有两个相等记录的关键字R和S，且在原本的列表中R出现在S之前，在排序过的列表中R也将会是在S之前。
当相等的元素是无法分辨的，比如像是整数，稳定度并不是一个问题。然而，假设以下的数对将要以他们的第一个数字来排序。
（4,1）（3,1）（3,7）（5,6）在这个状况下，有可能产生两种不同的结果，一个是依照相等的键值维持相对的次序，而另外一个则没有：
（3,1）（3,7）（4,1）（5,6） （维持次序)
（3,7）（3,1）（4,1）（5,6） （次序被改变)
不稳定算法可能会在相等的键值中改变纪录的相对次序，但是稳定排序算法从来不会如此。不稳定排序算法可以被特别地实现为稳定。作这件事情的一个方式是人工扩充键值的比较，如此在其他方面相同键值的两个对象间之比较，就会被决定使用在原先数据次序中的条目，当作一个同分决赛。然而，要记住这种次序通常牵涉到额外的空间负担。
在计算机科学所使用的排序算法通常被分类为：
(a)计算的（最差、平均、和最好性能），依据列表(list)的大小(n)。
一般而言，好的性能是 O(nlogn)，且坏的性能是 O(n^2)。对于一个理想的性能是 O(n)。
而仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要 O(nlogn)。
(b)使用量（）（以及其他电脑资源的使用）
(c)稳定度：稳定的排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。
(d)一般的方法：插入、交换、选择、合并等等。包含和。包含，包括堆排序等。
排序算法C++算法
C++自带的algorithm库函数中提供了排序算法。
自带排序算法的一般形式为：
sort(arr+m,arr+n);//将数组arr的下标为m的元素到下标为n-1的元素进行从小到大排序
sort(arr+m,arr+n,comp);//与sort(arr+m,arr+n)相比，这个写法可以自己定义排序的规则，其中，comp为自定义的函数
对于sort(arr+m,arr+n)我们举个简单的例子，这个程序实现从键盘读入10个数，然后从小到大输出的功能：
#include&algorithm&
#include&iostream&
inta[10],i;
for(i=0;i&10;i++)
cin&&a[i];
sort(a,a+10);
for(i=0;i&10;i++)
cout&&a[i]&&'';
当然，有时我们需要从大到小的进行排序。那么我们可以用sort(arr+m,arr+n,comp)进行排序。
不过，在调用sort(arr+m,arr+n,comp)之前我们需要自己写个comp函数。
从大到小排序的comp函数可以这样写：
intcomp(inta,intb)
returna&b;//在两元素相同时一定要返回0或者false
下面是10个数从大到小排序的代码：
#include&algorithm&
#include&iostream&
intcomp(inta,intb)
returna&b;//如果a&b则返回1，否则返回0
inta[10],i;
for(i=0;i&10;i++)
cin&&a[i];
sort(a,a+10,comp);
for(i=0;i&10;i++)
cout&&a[i]&&'';
在更多情况下，我们不仅对一个特征进行排序，而是多个特征。例如将学生的成绩进行排序，当然用上面的做法是行不通的。这是，我们就想到了结构体这种数据类型。当我们采用sort()函数的默认规则排序结构体时，sort()默认结构体中的第一个成员为第一关键字，第二个成员为第二关键字，……，第N个元素为第N关键字，然后从小到大排序。
例如我们要将学生的成绩从大到小排序，当成绩相同时，根据姓名字典序小的优先规则进行排序。显然我们无法采用默认规则进行排序。
这时我们可以定义这样的comp：
intcomp(studenta,studentb)
if(a.score&b.score)
if(a.score&b.score)
if(a.name&b.name)
排序算法算法列表
在这个表格中，n是要被的纪录数量以及k是不同键值的数量。
排序算法稳定的
（bubble sort） — O(n^2）
(Cocktail sort，双向的冒泡排序) — O(n^2）
（insertion sort）— O(n^2)
（bucket sort）— O(n); 需要 O(k) 额外空间
(counting sort) — O(n+k); 需要 O(n+k) 额外空间
（merge sort）— O(nlog n); 需要 O(n) 额外空间
原地合并排序— O(n^2)
排序 （Binary tree sort） — O(nlog n)期望时间； O(n^2)最坏时间； 需要 O(n) 额外空间
(Pigeonhole sort) — O(n+k); 需要 O(k) 额外空间
（radix sort）— O(n·k); 需要 O(n) 额外空间
Gnome 排序— O(n^2)
图书馆排序— O(nlog n) with high probability，需要 （1+ε)n额外空间
排序算法不稳定的
（selection sort）— O(n^2)
（shell sort）— O(nlog n) 如果使用最佳的现在版本
组合排序— O(nlog n)
（heapsort）— O(nlog n)
平滑排序— O(nlog n)
（quicksort）— O(nlog n) 期望时间，O(n^2) 最坏情况； 对于大的、乱数列表一般相信是最快的已知排序
Introsort— O(nlog n)
耐心排序— O(nlog n+ k) 最坏情况时间，需要 额外的 O(n+ k) 空间，也需要找到最长的递增子串行（longest increasing subsequence）
排序算法不实用的
Bogo排序— O(n× n!) 期望时间，无穷的最坏情况。
Stupid sort— O(n^3); 递归版本需要 O(n^2) 额外
（Bead sort） — O(n) or O（√n)，但需要特别的硬件
Pancake sorting— O(n)，但需要特别的硬件
stooge sort——O（n^2.7）很漂亮但是很耗时
排序算法排序算法
的算法有很多，对空间的要求及其时间效率也不尽相同。下面列出了一些常见的排序算法。这里面和又被称作，他们对空间的要求不高，但是时间效率却不稳定；而后面三种排序相对于简单排序对空间的要求稍高一点，但时间效率却能稳定在很高的水平。是针对在一个较小范围内的排序算法。
排序算法插入排序
是这样实现的：
1、首先新建一个空列表，用于保存已的有序数列（我们称之为&有序列表&）。
2、从原数列中取出一个数，将其插入&有序列表&中，使其仍旧保持有序状态。
3、重复2号步骤，直至原数列为空。
插入排序的平均为平方级的，效率不高，但是容易实现。它借助了&逐步扩大成果&的思想，使有序列表的长度逐渐增加，直至其长度等于原列表的长度。
插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 都已经排好序，本趟需要找到 i 对应的元素 x 的正确位置 k ，并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位，为元素 x “腾位置”，最后将 k 对应的元素值赋为 x ，一般情况下，插入排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1)。[1]
排序算法冒泡排序
是这样实现的：
1、从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。
2、重复1号步骤，直至再也不能交换。
冒泡排序的平均与相同，也是平方级的，但冒泡排序是原地排序的，也就是说它不需要额外的存储空间。
排序算法选择排序
是这样实现的：
1、设内存放了n个待排数字，数组下标从1开始，到n结束。
2、初始化i=1
3、从数组的第i个元素开始到第n个元素，寻找最小的元素。
4、将上一步找到的最小元素和第i位元素交换。
5、i++,直到i=n－1算法结束，否则回到第3步
选择排序的平均也是O(n^2)的。
比如说这个，我想让它从小到大，怎么做呢？
第一步：从第一位开始找最小的元素，564中4最小，与第一位交换。结果为465
第二步：从第二位开始找最小的元素，465中5最小，与第二位交换。结果为456
第三步：i=2，n=3，此时i=n-1，算法结束
排序算法快速排序
现在开始，我们要接触高效算法了。实践证明，是所有排序算法中最高效的一种。它采用了分治的思想：先保证列表的前半部分都小于后半部分，然后分别对前半部分和后半部分排序，这样整个列表就有序了。这是一种先进的思想，也是它高效的原因。因为在排序算法中，算法的高效与否与列表中数字间的比较次数有直接的关系，而&保证列表的前半部分都小于后半部分&就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了，大大减少了数字间不必要的比较。但查找数据得另当别论了。
排序算法时间复杂度
O(n log n)
O(n log n)
O(n log n)
O(n^1.25）
排序算法复杂度
排序算法简单排序算法
由于程序比较简单，所以没有加什么注释。所有的程序都给出了完整的运行代码，并在我的VC环境
下运行通过。因为没有涉及MFC和WINDOWS的内容，所以在BORLAND C++的平台上应该也不会有什么
问题的。在代码的后面给出了运行过程示意，希望对理解有帮助。
排序算法冒泡法
这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡：
#include&iostream&
voidBubbleSort(int*pData,intCount)
for(inti=0;i&Count-1;i++)
for(intj=Count-1;j&i;j--)
if(pData[j]&pData[j-1])
iTemp=pData[j-1];
pData[j-1]=pData[j];
pData[j]=iT
voidmain()
intdata[7]={10,9,8,7,6,5,4};
BubbleSort(data,7）;
for(inti=0;i&7;i++)
cout&&data[i]&&&&;
system(&PAUSE&);
倒序（最糟情况)
第一轮：10，9，8，7-&10，9，7，8-&10，7，9，8-&7，10，9，8（交换3次)
第二轮：7，10，9，8-&7，10，8，9-&7，8，10，9（交换2次)
第一轮：7，8，10，9-&7，8，9，10（交换1次)
循环次数：6次
交换次数：6次
第一轮：8，10，7，9-&8，10，7，9-&8，7，10，9-&7，8，10，9（交换2次)
第二轮：7，8，10，9-&7，8，9，10-&7，8，10，9（交换1次)
（这是原撰写人的--7，8，10，9-&7，8，10，9-&7，8，10，9（交换0次)，第二轮应该是这样的）
第三轮：7，8，9，10-&7，8，9，10（交换1次)
循环次数：6次
交换次数：3次
上面我们给出了，现在我们分析它：这里，影响我们算法性能的主要部分是循环和交换，
显然，次数越多，性能就越差。从上面的程序我们可以看出循环的次数是固定的，为1+2+...+n-1。
写成公式就是1/2*(n-1）*n。
现在注意，我们给出O方法的定义：
若存在一常量K和起点n0，使当n&=n0时，有f(n)&=K*g(n)，则f(n) = O(g(n))。（呵呵，不要说没学好数学呀，对于编程数学是非常重要的！！！）
现在我们来看1/2*(n-1）*n，当K=1/2，n0=1，g(n)=n*n时，1/2*(n-1）*n&=1/2*n*n=K*g(n)。所以f(n)
=O(g(n))=O(n*n)。所以我们程序循环的为O(n*n)。
再看交换。从程序后面所跟的表可以看到，两种情况的循环相同，交换不同。其实交换本身同数据源的
有序程度有极大的关系，当数据处于倒序的情况时，交换次数同循环一样（每次循环判断都会交换），
复杂度为O(n*n)。当数据为正序，将不会有交换。复杂度为O(0)。乱序时处于中间状态。正是由于这样的
原因，我们通常都是通过循环次数来对比算法。
排序算法交换法
交换法的程序最清晰简单，每次用当前的元素一一的同其后的元素比较并交换。
#include&iostream.h&
voidExchangeSort(int*pData，intCount)
for(inti=0;i&Count-1;i++)
{//共（count-1）轮，每轮得到一个最小值
for(intj=i+1;j&Cj++)
{//每次从剩下的数字中寻找最小值，于当前最小值相比，如果小则交换
if(pData[j]&pData[i])
iTemp=pData[i];
pData[i]=pData[j];
pData[j]=iT
voidmain()
intdata[]={10,9,8,7,6,5,4};
ExchangeSort(data,sizeof(data)/sizeof(int));
for(inti=0;i&sizeof(data)/sizeof(int);i++)
cout&&data[i]&&&&;
system(&PAUSE&);
第一轮：[2]
9，10，8，7-&8，10，9，7-&7，10，9，8（交换3次)
第二轮：7，10，9，8-&7，9，10，8-&7，8，10，9（交换2次)
第一轮：7，8，10，9-&7，8，9，10（交换1次)
循环次数：6次
交换次数：6次
第一轮：8，10，7，9-&8，10，7，9-&7，10，8，9-&7，10，8，9（交换1次)
第二轮：7，10，8，9-&7，8，10，9-&7，8，10，9（交换1次)
第一轮：7，8，10，9-&7，8，9，10（交换1次)
循环次数：6次
交换次数：3次
从运行的表格来看，交换几乎和冒泡一样糟。事实确实如此。循环次数和冒泡一样
也是1/2*(n-1）*n，所以算法的仍然是O(n*n)。由于我们无法给出所有的情况，所以
只能直接告诉大家他们在交换上面也是一样的糟糕（在某些情况下稍好，在某些情况下稍差）。
排序算法选择法
现在我们终于可以看到一点希望：选择法，这种方法提高了一点性能（某些情况下）
这种方法类似我们人为的习惯：从数据中选择最小的同第一个值交换，在从剩下的部分中
选择最小的与第二个交换，这样往复下去。
#include&iostream.h&
voidSelectSort(int*pData，intCount)
for(inti=0;i&Count-1;i++)
iTemp=pData[i];
for(intj=i+1;j&Cj++)
if(pData[j]&iTemp)
iTemp=pData[j];
pData[iPos]=pData[i];
pData[i]=iT
voidmain()
intdata[]={10，9，8，7，6，5，4};
SelectSort(data，7）;
for(inti=0;i&7;i++)
cout&&data[i]&&&&;
cout&&&\n&;
倒序（最糟情况)
第一轮：10，9，8，7-&(iTemp=9）10，9，8，7-&(iTemp=8）10，9，8，7-&(iTemp=7）7，9，8，10（交换1次)
第二轮：7，9，8，10-&7，9，8，10(iTemp=8）-&(iTemp=8）7，8，9，10（交换1次)
第一轮：7，8，9，10-&(iTemp=9）7，8，9，10（交换0次)
循环次数：6次
交换次数：2次
第一轮：8，10，7，9-&(iTemp=8）8，10，7，9-&(iTemp=7）8，10，7，9-&(iTemp=7）7，10，8，9（交换1次)
第二轮：7，10，8，9-&(iTemp=8）7，10，8，9-&(iTemp=8）7，8，10，9（交换1次)
第一轮：7，8，10，9-&(iTemp=9）7，8，9，10（交换1次)
循环次数：6次
交换次数：3次
遗憾的是算法需要的循环次数依然是1/2*(n-1）*n。所以为O(n*n)。
我们来看他的交换。由于每次外层循环只产生一次交换（只有一个最小值）。所以f(n)&=n
所以我们有f(n)=O(n)。所以，在数据较乱的时候，可以减少一定的交换次数。
排序算法插入法
插入法较为复杂，它的基本工作原理是抽出牌，在前面的牌中寻找相应的位置插入，然后继续下一张
#include&iostream.h&
voidInsertSort(int*pData，intCount)
for(inti=1;i&Ci++)
iTemp=pData[i];//保存要插入的数
iPos=i-1;//被插入的数组数字个数
while((iPos&=0)&&(iTemp&pData[iPos]))
{//从最后一个（最大数字）开始对比，大于它的数字往后移位
pData[iPos+1]=pData[iPos];
pData[iPos+1]=iT//插入数字的位置
voidmain(){
intdata[]={10，9，8，7，6，5，4};
InsertSort(data，7);
for(inti=0;i&7;i++)
cout&&data[i]&&&&;
cout&&&\n&;
第一轮：8，10，7，9-&8，10，7，9(交换0次)(循环1次)
第二轮：9，10，8，7-&8，9，10，7（交换1次)（循环2次)
第一轮：8，9，10，7-&7，8，9，10（交换1次)（循环3次)
循环次数：6次
交换次数：3次
第一轮：8，10，7，9-&8，10，7，9（交换0次)（循环1次)
第二轮：8，10，7，9-&7，8，10，9（交换1次)（循环2次)
第一轮：7，8，10，9-&7，8，9，10（交换1次)（循环1次)
循环次数：4次
交换次数：2次
上面结尾的行为分析事实上造成了一种假象，让我们认为这种算法是简单算法中最好的，其实不是，
因为其循环次数虽然并不固定，我们仍可以使用O方法。从上面的结果可以看出，循环的次数f(n)&=
1/2*n*(n-1）&=1/2*n*n。所以其仍为O(n*n)（这里说明一下，其实如果不是为了展示这些简单
的不同，交换次数仍然可以这样推导）。现在看交换，从外观上看，交换次数是O(n)（推导类似
），但我们每次要进行与内层循环相同次数的‘=’操作。正常的一次交换我们需要三次‘=’
而这里显然多了一些，所以我们浪费了时间。
最终，我个人认为，在算法中，选择法是最好的。
排序算法高级排序算法
高级算法中我们将只介绍这一种，同时也是目前我所知道（我看过的资料中）的最快的。
它的工作看起来仍然象一个。首先我们选择一个中间值middle程序中我们使用中间值，然后
把比它小的放在左边，大的放在右边（具体的实现是从两边找，找到一对后交换）。然后对两边分别使
用这个过程（最容易的方法——）。
1.：//这段代码编译可以通过，一运行就出错，内部的细节有些问题，我还没找到解决方法。
#include&iostream.h&
voidrun(int*pData，intleft，intright)
intmiddle，iT
middle=pData[left];
while((pData[i]&middle)&&(i&right))//从左扫描大于中值的数
while((pData[j]&middle)&&(j&left))//从右扫描大于中值的数
if(i&=j)//找到了一对值
iTemp=pData[i];
pData[i]=pData[j];
pData[j]=iT
}while(i&=j);//如果两边扫描的下标交错，就停止（完成一次）
//当左边部分有值（left&j)，递归左半边
if(left&j)
run(pData，left，j);
//当右边部分有值（right&i)，递归右半边
if(right&i)
run(pData，i，right);
voidQuickSort(int*pData，intCount)
run(pData，0，Count-1）;
voidmain()
intdata[]={10，9，8，7，6，5，4};
QuickSort(data，7）;
for(inti=0;i&7;i++)
cout&&data[i]&&&&;//原作者此处代码有误，输出因为date[i],date数组名输出的是地址
cout&&&\n&;
这里我没有给出行为的分析，因为这个很简单，我们直接来分析算法：首先我们考虑最理想的情况
1.的大小是2的幂，这样分下去始终可以被2整除。假设为2的k次方，即k=log2(n)。
2.每次我们选择的值刚好是中间值，这样，数组才可以被等分。
第一层递归，循环n次，第二层循环2*(n/2）......
所以共有n+2(n/2）+4(n/4）+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n
所以为O(log2(n)*n)
其他的情况只会比这种情况差，最差的情况是每次选择到的middle都是最小值或最大值，那么他将变
成交换法（由于使用了，情况更糟）。但是你认为这种情况发生的几率有多大？？呵呵，你完全
不必担心这个问题。实践证明，大多数的情况，总是最好的。
如果你担心这个问题，你可以使用，这是一种不稳定的O(log2(n)*n)算法，但是通常情况下速度要慢
于快速排序（因为要重组堆）。
排序算法其他排序
通常的冒泡是单向的，而这里是双向的，也就是说还要进行反向的工作。
#include&iostream.h&
inlinevoidexchange(int*a,int*b)
voidbubblesort(int*array,intnum)
inti,j,k,flag=0;
for(i=0;i&i++){
printf(&%d&,array[i]);
printf(&\n&);
for(i=0;i&i++){//所有数的个数为num个
for(j=i;j&num-i-1;j++){//每循环一次最底端的数的顺序都会排好，所以初始时j=i;
if(array[j]&array[j+1]){
exchange(&array[j],&array[j+1]);
for(k=num-1-i-1;k&i;k--){//每循环一次最顶端的数据的顺序也会排好，所以初始时k=num-i-2
if(array[k]&array[k-1]){
exchange(&array[k],&array[k-1]);
if(flag==0){//如果flag未发生改变则说明未发生数据交换，则排序完成
voidmain()
intdata[]={10，9，8，7，6，5，4，3，2，1，-10，-1};
bubblesort(data，12）;
for(inti=0;i&12;i++)
cout&&data&&&&;
cout&&&\n&;
排序算法通用排序
这个程序我想就没有分析的必要了，大家看一下就可以了。不明白可以在论坛上问。
MyData.h文件
///////////////////////////////////////////////////////
class CMyData
CMyData(int Index，char* strData);
CMyData();
virtual ~CMyData();
int GetDataSize(){ return m_iDataS };
const char* GetData(){ return m_strD };
//这里重载了操作符：
CMyData& operator =(CMyData &SrcData);
bool operator &(CMyData& data );
bool operator &(CMyData& data );
char* m_strD
int m_iDataS
////////////////////////////////////////////////////////
MyData.cpp文件
////////////////////////////////////////////////////////
CMyData::CMyData():
m_iIndex(0)，
m_iDataSize(0)，
m_strDatamember(NULL)
CMyData::~CMyData()
if(m_strDatamember != NULL)
delete[] m_strD
m_strDatamember = NULL;
CMyData::CMyData(int Index，char* strData):
m_iIndex(Index)，
m_iDataSize(0)，
m_strDatamember(NULL)
m_iDataSize = strlen(strData);
m_strDatamember = new char[m_iDataSize+1];
strcpy(m_strDatamember，strData);
CMyData& CMyData::operator =(CMyData &SrcData)
m_iIndex = SrcData.m_iI
m_iDataSize = SrcData.GetDataSize();
m_strDatamember = new char[m_iDataSize+1];
strcpy(m_strDatamember，SrcData.GetData());
bool CMyData::operator &(CMyData& data )
return m_iIndex&data.m_iI
bool CMyData::operator &(CMyData& data )
return m_iIndex&data.m_iI
///////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////
//主程序部分
#include &iostream.h&
#include &MyData.h&
template &class T&
void run(T* pData，int left，int right)
T middle，iT
//下面的比较都调用我们的操作符函数
middle = pData[(left+right)/2]; //求中间值
while((pData&middle) && (i&right))//从左扫描大于中值的数
while((pData[j]&middle) && (j&left))//从右扫描大于中值的数
if(i&=j)//找到了一对值
iTemp = pD
pData = pData[j];
pData[j] = iT
}while(i&=j);//如果两边扫描的下标交错，就停止（完成一次）
//当左边部分有值（left&j)，递归左半边
if(left&j)
run(pData，left，j);
//当右边部分有值（right&i)，递归右半边
if(right&i)
run(pData，i，right);
template &class T&
void QuickSort(T* pData，int Count)
run(pData，0，Count-1）;
void main()
CMyData data[] = {
CMyData（8，&xulion&)，
CMyData（7，&sanzoo&)，
CMyData（6，&wangjun&)，
CMyData（5，&VCKBASE&)，
CMyData（4，&jacky2000&)，
CMyData（3，&cwally&)，
CMyData（2，&VCUSER&)，
CMyData（1，&isdong&)
QuickSort(data，8）;
for (int i=0;i&8;i++)
cout&&data.m_iIndex&&& &&&data.GetData()&&&\n&;
cout&&&\n&;
．DevStore．[引用日期]
．百度百科[引用日期]}