代码对比算法
‘壹’ 用代码实现几种排序算法的时间复杂度比较
一、简单排序算法
由于程序比较简单，所以没有加什么注释。所有的程序都给出了完整的运行代码，并在我的VC环境
下运行通过。因为没有涉及MFC和WINDOWS的内容，所以在BORLAND C++的平台上应该也不会有什么
问题的。在代码的后面给出了运行过程示意，希望对理解有帮助。
1.冒泡法：
这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡：
#include <iostream>
using namespace std;
void BubbleSort(int * pData, int Count)
{
int iTemp;
for (int i=0; i<Count; i++)
{
for (int j=Count-1; j>i; j--)
{
if (pData[j]<pData[j-1])
{
iTemp = pData[j-1];
pData[j-1] = pData[j];
pData[j] = iTemp;
}
}
}
}
void main()
{
int data[7] = {10,9,8,7,6,5,4};
BubbleSort(data,7);
for (int i=0; i<7; i++)
{
cout<<data[i]<<" ";
}
cout<<endl;
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，10，9->7，8，10，9(交换0次)
第一轮：7，8，10，9->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)。乱序时处于中间状态。正是由于这样的
原因，我们通常都是通过循环次数来对比算法。
2.交换法：
交换法的程序最清晰简单，每次用当前的元素一一的同其后的元素比较并交换。
#include <iostream.h>
void ExchangeSort(int* pData，int Count)
{
int iTemp;
for(int i=0;i<Count-1;i++)
{ //共（count-1)轮，每轮得到一个最小值
for(int j=i+1;j<Count;j++)
{ //每次从剩下的数字中寻找最小值，于当前最小值相比，如果小则交换
if(pData[j]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)。由于我们无法给出所有的情况，所以
只能直接告诉大家他们在交换上面也是一样的糟糕（在某些情况下稍好，在某些情况下稍差）。
3.选择法：
现在我们终于可以看到一点希望：选择法，这种方法提高了一点性能（某些情况下）
这种方法类似我们人为的排序习惯：从数据中选择最小的同第一个值交换，在从省下的部分中
选择最小的与第二个交换，这样往复下去。
#include <iostream.h>
void SelectSort(int* pData，int Count)
{
int iTemp;
int iPos;
for(int i=0;i<Count-1;i++)
{
iTemp = pData;
iPos = i;
for(int j=i+1;j<Count;j++)
{
if(pData[j]<iTemp)
{
iTemp = pData[j];
iPos = j;
}
}
pData[iPos] = pData;
pData = iTemp;
}
}
void main()
{
int data[] = {10，9，8，7，6，5，4};
SelectSort(data，7);
for (int i=0;i<7;i++)
cout<<data<<" ";
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)。所以，在数据较乱的时候，可以减少一定的交换次数。
4.插入法：
插入法较为复杂，它的基本工作原理是抽出牌，在前面的牌中寻找相应的位置插入，然后继续下一张
#include <iostream.h>
void InsertSort(int* pData，int Count)
{
int iTemp;
int iPos;
for(int i=1;i<Count;i++)
{
iTemp = pData[i]; //保存要插入的数
iPos = i-1; //被插入的数组数字个数
while((iPos>=0) && (iTemp9，10，8，7(交换1次)(循环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>
void run(int* pData，int left，int right)
{
int i，j;
int middle，iTemp;
i = left;
j = right;
middle = pData[left];
do{
while((pData[i]<middle) && (i<right))//从左扫描大于中值的数
i++;
while((pData[j]>middle) && (j>left))//从右扫描大于中值的数
j--;
if(i<=j)//找到了一对值
{
//交换
iTemp = pData[i];
pData[i] = pData[j];
pData[j] = iTemp;
i++;
j--;
}
}while(i<=j);//如果两边扫描的下标交错，就停止（完成一次）
//当左边部分有值(left<j)，递归左半边
if(left<j)
run(pData，left，j);
//当右边部分有值(right>i)，递归右半边
if(right>i)
run(pData，i，right);
}
void QuickSort(int* pData，int Count)
{
run(pData，0，Count-1);
}
void main()
{
int data[] = {10，9，8，7，6，5，4};
QuickSort(data，7);
for (int i=0;i<7;i++)
cout<<data<<" ";
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)算法，但是通常情况下速度要慢
‘贰’ 请教一个 c语言 字符串数组之间比较的算法，谢谢
这种时候当然是使用标准容器拉
std::map可以满足你的需要
10个ip 地址 复制给10个std::string. 然后构造一个 std::map<std::string, int> 再逐个使用insert方法插入， 如果插入成功（通过检查insert的返回值, 具体请搜索msdn,这里篇幅有限。）
如果插入成功， 继续； 不成功，就表示有重复，将返回的那个已经存在的ip对应的优先级++， 再继续。
map的特点就是不重复，你省去了自己去写比较，去优化的繁琐，而且一般stl实现的效率都是很高的绝对不是你这种40多次的O(N)的，应该至少都是o(ln N)
‘叁’ 比较两个代码的算法复杂度
算法复杂度是指算法在编写成可执行程序后，运行时所需要的资源，资源包括时间资源和内存资源。应用于数学和计算机导论。
‘肆’ 求一个比较大小的JAVA算法
1.是的
2.a-可以直接求和，b-利用近似公式
3.近似公式为e=(1+1/n)^n,n->无穷大
4.这两个公式都需要运算n到足够大来减少误差
假如你运算到n=k满足精度需要了
那么你首先要保证当n=k-1时算出的值与n=k的值差别小于0.0001
假如需要考虑截断误差，那么你就要考虑到任何一个1/n或者1/n!的形式的截断误差，以及运算中每一步的累计误差，都是可以计算的
从累积误差的角度来说，第一个方法较优
因为每一个求和项目都是整数的倒数，只发生一次截断
之后的误差计算直接将最大误差可能求和就可以了
而且每一次迭代可以应用上一次的结果，效率较高
但是缺点是当n比较大的时候，n!也会是一个比较大的数，n的类型定义得不好会溢出
第二个方法就需要计算一次截断误差，并且计算n次方的误差累积
‘伍’ C语言编写代码实现几种内部排序算法的性能比较，有偿求代码和简要的实验报告。
http://wenku..com/view/6ff074740912a216147929db.html
可以参考这个
部分代码，使用了模板，其他算法自己弄把，输出的数据弄几个表格就是结果了
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
voidtestSort(intlen);
intmain(intargc,char*argv[])
{
testSort(10000);
testSort(20000);
testSort(40000);
testSort(80000);
testSort(160000);
testSort(320000);
testSort(640000);
testSort(1280000);
testSort(2560000);
testSort(5120000);
testSort(10240000);
return0;
}
#defineCOUNT_SETVAL//测试消耗时间注释掉这两句
#defineCOUNT_COMPARE
#ifdefCOUNT_SETVAL
__int64gSetValTimes;
#endif
#ifdefCOUNT_COMPARE
__int64gCompareTimes;
#endif
//交换
template<classT>
inlinevoidswap(T&_X,T&_Y)
{
T_T=_X;
_X=_Y;
_Y=_T;
#ifdefCOUNT_SWAP
gSwapTimes++;
#endif
#ifdefCOUNT_SETVAL
gSetValTimes+=3;
#endif
}
//复制
template<classT>
inlinevoidsetVal(T&_X,T&_Y)
{
_X=_Y;
#ifdefCOUNT_SETVAL
gSetValTimes++;
#endif
}
//比较
template<classT>
inlineintcompare(T&_X,T&_Y)
{
#ifdefCOUNT_COMPARE
gCompareTimes++;
#endif
return_X<_Y;
}
//堆排序
template<classT,classS>
voidheap_sort(T*_A,S_N)
{
Stop,bot,nxt,cur;
top=bot=nxt=_N;
while(cur=nxt,bot>0)
{
if(cur*2+1<bot&&compare(_A[nxt],_A[cur*2+1]))nxt=cur*2+1;
if(cur*2+2<bot&&compare(_A[nxt],_A[cur*2+2]))nxt=cur*2+2;
if(cur<nxt)swap(_A[cur],_A[nxt]);
elsenxt=top?--top:(swap(_A[0],_A[--bot]),0);
}
}
//原地合并排序
template<classT,classS>
voidncmerge_sort(T*_A,S_N)
{
Sstep,ins,l,m,r,pos0,pos1;
T*_T=newT[_N];
for(step=2;step<_N*2;step*=2)
{
for(l=0;l+step/2<_N;l+=step)
{
m=l+step/2;
r=m+step/2<_N?m+step/2:_N;
pos0=l;pos1=m;ins=0;
while(pos0<m&&pos1<r)
{
if(compare(_A[pos1],_A[pos0]))setVal(_T[ins++],_A[pos1++]);
elsesetVal(_T[ins++],_A[pos0++]);
}
while(pos0<m)setVal(_T[ins++],_A[pos0++]);
while(pos1<r)setVal(_T[ins++],_A[pos1++]);
while(ins>0)setVal(_A[--r],_T[--ins]);
}
}
delete[]_T;
}
//冒泡排序
template<classT,classS>
voidbubble_sort(T*_A,S_N)
{
Si,j,pos;
for(i=0;i<_N;i++)
{
pos=i;
for(j=i+1;j<_N;j++)if(compare(_A[j],_A[pos]))pos=j;
if(pos!=i)swap(_A[i],_A[pos]);
}
}
//快速排序
template<classT,classS>
voidquick_sort(T*_A,S_N)
{
Tpivot;
Sl=0;
Sm=_N/2;
Sr=_N-1;
if(_N>1)
{
if(compare(_A[r],_A[l]))swap(_A[l],_A[r]);
if(compare(_A[m],_A[l]))swap(_A[l],_A[m]);
if(compare(_A[r],_A[m]))swap(_A[m],_A[r]);
setVal(pivot,_A[m]);
while(l<=r)
{
while(compare(_A[l],pivot))l++;
while(compare(pivot,_A[r]))r--;
if(l<=r)swap(_A[l++],_A[r--]);
}
quick_sort(_A,r+1);
quick_sort(_A+l,_N-l);
}
return;
}
template<classT,classS>
voidheap2_sort(T*_A,S_N)
{
Ttempitem;
Scurrent,next;
Stop=_N/2;
while(_N>0)
{
if(top>0)top-=1;elseswap(_A[--_N],_A[0]);
setVal(tempitem,_A[top]);
current=top;
while(1)
{
next=current*2+1;
if(next+1<_N&&compare(_A[next],_A[next+1]))
{
next+=1;
}
if(next<_N)
{
setVal(_A[current],_A[next]);
current=next;
}
elsebreak;
}
while(next>0)
{
next=(current-1)/2;
if(next>=top&&compare(_A[next],tempitem))
{
setVal(_A[current],_A[next]);
current=next;
}
elsebreak;
}
setVal(_A[current],tempitem);
}
}
template<classT,classS>
voidcomb_sort(T*_A,S_N)
{
Snoswap=1;
Sdelta=_N;
Si;
while(!noswap||delta>1)
{
if(delta>1)
{
delta=(S)(delta/1.25);
}
for(noswap=1,i=0;i+delta<_N;i++)
{
if(compare(_A[i+delta],_A[i]))
{
noswap=0;
swap(_A[i+delta],_A[i]);
}
}
}
return;
}
voidtestSort(intlen)
{
srand(time(NULL));
int*Array=newint[len];
for(inti=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
clock_ttb=clock();
quick_sort(Array,len);
printf("quick:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb); for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
heap_sort(Array,len);
printf("heap:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb); for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
ncmerge_sort(Array,len);
printf("ncmerge:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb); for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
heap2_sort(Array,len);
printf("heap2:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb);
for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
comb_sort(Array,len);
printf("comb:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb);
if(len<50000)
{
for(i=0;i<len;i++)Array[i]=rand();
#ifdefCOUNT_SETVAL
gSetValTimes=0;
#endif
#ifdefCOUNT_COMPARE
gCompareTimes=0;
#endif
tb=clock();
bubble_sort(Array,len);
printf("bubble:N=%d ",len);
#ifdefCOUNT_SETVAL
printf("复制:%I64d ",gSetValTimes);
#endif
#ifdefCOUNT_COMPARE
printf("比较:%I64d ",gCompareTimes);
#endif
printf("time:%ums ",clock()-tb);
}
printf(" ");
}
‘陆’ 几种经典排序算法优劣比较的C++程序实现
一、低级排序算法
1.选择排序
（1）排序过程
给定一个数值集合，循环遍历集合，每次遍历从集合中选择出最小或最大的放入集合的开头或结尾的位置，下次循环从剩余的元素集合中遍历找出最小的并如上操作，最后直至所有原集合元素都遍历完毕，排序结束。
（2）实现代码
//选择排序法
template
void Sort：：SelectSort（T* array， int size）
{
int minIndex；
for（int i = 0； i < size； i++）
{
minIndex = i；
for（int j = i + 1； j < size； j++）
{
if（array[minIndex] > array[j]）
{
minIndex = j；
}
}
if（minIndex ！= i）
{
Swap（array， i， minIndex）；
}
}
}
（3）分析总结
选择排序时间复杂度比较高，达到了O（n^2），每次选择都要遍历一遍无序区间。选择排序对一类重要的元素序列具有较好的效率，就是元素规模很大，而排序码却比较小的序列。另外要说明的是选择排序是一种不稳定的排序方法。
2.冒泡排序
（1）排序过程
冒泡排序的过程形如其名，就是依次比较相邻两个元素，优先级高（或大或小）的元素向后移动，直至到达序列末尾，无序区间就会相应地缩小。下一次再从无序区间进行冒泡操作，依此循环直至无序区间为1，排序结束。
（2）实现代码
//冒泡排序法
template
void Sort：：BubbleSort（T* array， int size）
{
for（int i = 0； i < size； i++）
{
for（int j = 1； j < size - i； j++）
{
if（array[j] < array[j - 1]）
{
Swap（array， j， j - 1）；
}
}
}
}
（3）分析总结
冒泡排序的时间复杂度也比较高，达到O（n^2），每次遍历无序区间都将优先级高的元素移动到无序区间的末尾。冒泡排序是一种稳定的排序方式。
二、高级排序算法
（1）排序过程
归并排序的原理比较简单，也是基于分治思想的。它将待排序的元素序列分成两个长度相等的子序列，然后为每一个子序列排序，然后再将它们合并成一个序列。
（2）实现代码
//归并排序
template
void Sort：：MergeSort（T* array， int left， int right）
{
if（left < right）
{
int mid = （left + right） / 2；
MergeSort（array， left， mid）；
MergeSort（array， mid + 1， right）；
Merge（array， left， mid， right）；
}
}
//合并两个已排好序的子链
template
void Sort：：Merge（T* array， int left， int mid， int right）
{
T* temp = new T[right - left + 1]；
int i = left， j = mid + 1， m = 0；
while（i <= mid && j <= right）
{
if（array[i] < array[j]）
{
temp[m++] = array[i++]；
}
else
{
temp[m++] = array[j++]；
}
}
while（i <= mid）
{
temp[m++] = array[i++]；
}
while（j <= right）
{
temp[m++] = array[j++]；
}
for（int n = left， m = 0； n <= right； n++， m++）
{
array[n] = temp[m]；
}
delete temp；
}
（3）分析总结
归并排序最好、最差和平均时间复杂度都是O（nlogn），是一种稳定的排序算法。
‘柒’ 算法设计：比较两个文件的差别
两个文件可以比较是否相同，不同在哪里？
最简单办法：comp file1 file2 d/a/l/n=n/c/off n
但是如何进行更改的，就涉及到操作的追溯。这个过程是不可逆的。所以无解。
除非有操作记录表！可以追溯。
‘捌’ 排序算法性能比较（数据结构）C语言程序
这题你只要把每个算法的程序代码看一下，在计算下就行
冒泡排序：两个循环，从1加到N，(1+N)N/2 = 500500,最坏交换情况是每次判断都要交换，既500500*3次
选择排序：也是两个循环，比较次数跟冒泡排序一样500500，但是这个只要底层循环交换，既只需1000*3 = 3000次赋值。
插入排序：循环次数一样500500，但是这个最坏情况是每比较一次就赋值一次，既需500500次赋值
希尔排序：时间复杂度是N^1.3倍，比较次数和赋值应该是1000^1.3次方。
归并排序和快速排序，你去查查它的时间复杂度是怎么算，O(lgN*N),好像有系数，算法导论那本书上有，现在不记得是多少了。
希望能帮到你，
‘玖’ vc6.0 比较代码的优异
人家只是为了衡量算法的效率，不用又是时间复杂度又是空间复杂度的，你只需要用GetTickCount()函数获取两个算法运行的时间就可以了。
DWORD dwBegin = GetTickCount();
算法1
DWORD dwEnd = GetTickCount();
DWORD dwSpan = dwEnd - dwBegin；// 获得算法1的耗时(单位毫秒)
dwBegin = GetTickCount();
算法2
dwEnd = GetTickCount();
DWORD dwSpan1 = dwEnd - dwBegin；// 获得算法2的耗时(单位毫秒)
比较dwSpan 和dwSpan1 就知道孰优孰劣了。
‘拾’ c语言代码的比较
C代码质量现在主要考虑时间效率。好的结构和算法能极大的优化时间效率。比较的话，很白痴级的，你把同样功能的，分别运行比较下时间和占用内存就能看出来了。