内部排序算法比较c语言课程设计,内部排序算法的比较和实现

/*冒泡排序  插入排序 二路插入排序 希尔排序   快速排序 选择排序 归并排序  堆排序算法的

C/C++实现。

作者：feosun

日期：2008年10月12日

参考资料：数据结构(C语言版) 清华大学出版社*/#includeusingnamespacestd;//交换两个数的值voidswap(int&a,int&b)

{inttmp;

tmp=a;

a=b;

b=tmp;

}//屏幕输出数组voiddisplay(intarray[],intlen)

{

cout<

{

cout<

}

cout<

}/*冒泡排序

算法思想：将被排序的记录数组R[1..n]垂直排列，每个记录R[i]看作是重量为R[i].key的气泡。

根据轻气泡不能在重气泡之下的原则，从下往上扫描数组 R：凡扫描到违反本原则的

轻气泡，就使其向上"飘浮"。如此反复进行，直到最后任何两个气泡都是轻者在上，

重者在下为止。

时间复杂度 o(n^2)

空间复杂度 o(1)

比较次数 n(n+1)/2*/voidbubble_sort(intarray[],intlen)

{for(inti=len-1;i>=0;i--)

{for(intj=0;jarray[j+1])

swap(array[j],array[j+1]);

}

}/*直接插入排序

算法思想：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元

素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，将它

插入到有序表中的适当位置，使之成为新的有序表，重复n-1次可完成排序过程。

时间复杂度 o(n^2)

空间复杂度 o(1)

比较次数 n(n+1)/2*/voidinsert_sort(intarray[],intlen)

{inttmp,i,j;for(i=1;i

{if(array[i]

{

tmp=array[i];

array[i]=array[i-1];//插入到相应位置for(j=i-2;j>=0;j--)

{//往后移if(array[j]>tmp )

array[j+1]=array[j];else{

array[j+1]=tmp;break;

}

}if(j==-1)

array[j+1]=tmp;

}

}

}/*2-路插入排序

算法思想：增加一个辅助空间d,把r[1]赋值给d[1]，并将d[1]看成是排好序后处于中间

位置的记录。然后从r[2]开始依次插入到d[1]之前或之后的有序序列中。

时间复杂度 o(n^2)

空间复杂度 o(1)

比较次数 n(n+1)/2*/voidbi_insert_sort(intarray[],intlen)

{int*arr_d=(int*)malloc(sizeof(int)*len);

arr_d[0]=array[0];inthead=0,tail=0;for(inti=1;i

{if(array[i]>arr_d[0])

{intj;for( j=tail;j>0;j--)

{if(array[i]

arr_d[j+1]=arr_d[j];elsebreak;

}

arr_d[j+1]=array[i];

tail+=1;

}else{if(head==0)

{

arr_d[len-1]=array[i];

head=len-1;

}else{intj;for(j=head;j<=len-1;j++)

{if(array[i]>arr_d[j])

arr_d[j-1]=arr_d[j];elsebreak;

}

arr_d[j-1]=array[i];

head-=1;

}

}

}for(inti=0;i

{intpos=(i+head );if(pos>=len) pos-=len;

array[i]=arr_d[pos];

}

free(arr_d);

}/*希尔排序

算法思想：先将整个待排序记录分割成若干子序列分别进行直接插入排

序，待整个序列中的记录基本有序时，再对全体记录进行一

次直接插入排序

时间复杂度 o(n^2)

空间复杂度 o(1)

比较次数 ?*/voidshell_insert(intarray[],intd,intlen)

{inttmp,j;for(inti=d;i

{if(array[i]

{

tmp=array[i];

j=i-d;do{

array[j+d]=array[j];

j=j-d;

}while(j>=0&&tmp

array[j+d]=tmp;

}

}

}voidshell_sort(intarray[],intlen)

{intinc=len;do{

inc=inc/2;

shell_insert(array,inc,len);

}while(inc>1);

}/*快速排序

算法思想：将原问题分解为若干个规模更小但结构与原问题相似的子问题。递

归地解这些子问题，然后将这些子问题的解组合成为原问题的解。

时间复杂度 o(nlogn)

空间复杂度 o(logn)

比较次数  ?*/intpartition(intarray[],intlow,inthigh)

{intpivotkey=array[low];while(low

{while(low=pivotkey)--high;

swap(array[low],array[high]);while(low

swap(array[low],array[high]);

}

array[low]=pivotkey;returnlow;

}voidquick_sort(intarray[],intlow,inthigh)

{if(low

{intpivotloc=partition(array,low,high);

quick_sort(array,low,pivotloc-1);

quick_sort(array,pivotloc+1,high);

}

}/*直接选择排序

算法思想：每一趟在n-i+1个记录中选取关键字最小的记录作为有序序列中的第i个记录

时间复杂度 o(n^2)

空间复杂度 o(1) ?

比较次数  n(n+1)/2*/intSelectMinKey(intarray[],intiPos,intlen)

{intret=0;for(inti=iPos; i

{if(array[ret]>array[i])

{

ret=i;

}

}returnret;

}voidselect_sort(intarray[],intlen)

{for(inti=0; i

{intj=SelectMinKey(array,i,len);if(i!=j)

{

swap(array[i],array[j]);

}

}

}/*归并排序

算法思想：设两个有序的子文件(相当于输入堆)放在同一向量中相邻的位置上：R[low..m]，R[m+1..high]，先

将它们合并到一个局部的暂存向量R1(相当于输出堆)中，待合并完成后将R1复制回R[low..high]中。

时间复杂度 o(nlogn)

空间复杂度 o(n)

比较次数  ?*/voidmerge(intarray[],inti,intm,intn)

{intj,k;intiStart=i, iEnd=n;intarrayDest[256];for( j=m+1,k=i; i<=m&&j<=n;++k)

{if(array[i]

arrayDest[k]=array[i++];elsearrayDest[k]=array[j++];

}if(i<=m)for(;k<=n; k++,i++)

arrayDest[k]=array[i];if(j<=n)for(;k<=n; k++,j++)

arrayDest[k]=array[j];for(j=iStart; j<=iEnd; j++)

array[j]=arrayDest[j];

}voidmerge_sort(intarray[],ints,intt)

{intm;if(s

{

m=(s+t )/2;

merge_sort(array,s,m);

merge_sort(array,m+1,t);

merge(array,s,m,t);

}

}/*堆排序

算法思想：堆排序(Heap Sort)是指利用堆(heaps)这种数据结构来构造的一种排序算法。

堆是一个近似完全二叉树结构，并同时满足堆属性：即子节点的键值或索引总是

小于(或者大于)它的父节点。

时间复杂度 o(nlogn)

空间复杂度 o(1)

比较次数  较多*/voidheap_adjust(intarray[],inti,intlen)

{intrc=array[i];for(intj=2*i; j

{if(j=array[j])break;

array[i]=array[j]; i=j;

}

array[i]=rc;

}voidheap_sort(intarray[],intlen)

{inti;for(i=(len-1)/2; i>=0; i--)

heap_adjust(array,i,len);for(  i=(len-1); i>0; i--)

{

swap(array[0],array[i]);//弹出最大值，重新对i-1个元素建堆heap_adjust(array,0,i-1);

}

}intmain() {intarray[]={45,56,76,234,1,34,23,2,3,55,88,100};intlen=sizeof(array)/sizeof(int);//bubble_sort(array,len);//冒泡排序/*insert_sort(array,len);*///插入排序/*bi_insert_sort(array,len);*///二路插入排序/*shell_sort(array,len);*///希尔排序/*quick_sort(array,0,len-1);*///快速排序/*select_sort(array,len);*///选择排序/*merge_sort(array,0,len-1);*///归并排序heap_sort(array,len);//堆排序display(array,len);return0;

}