浅谈各种排序与查找比较

浅谈各种排序与查找比较

容迎辉

【内容摘要】排序与查找在软件基础中应是学习的重点，对于我们而言排序与查找也是重要的，应该说在生活中也会有用到这些。因排序与查找较多，在此对各种排序与查找进行讲解，并通过对它们的效率分析来比较各种排序与查找的优劣。

【关键词】排序查找比较举例

一、排序

所谓排序，就是要整理文件中的记录，使之按关键字递增（或递减）次序排列起来。

（一）内部排序的主要算法分类及描述

1、插入排序

（1）直接插入排序

算法思想：每次将一个带排序的记录，按其关键字大小插入到前面已经排好序的子文件中的适当位置，直到全部记录插入完成为止。

算法描述：

Void Insertsort(SeqList R)

{int i,j;

for(i=2;i<=n;i++)

if(r[i].key

{r[0]=r[i];j=i-1;

Do{r[j+1]=r[j];

j--;

}while(r[0].key

R[j+1]=r[0];

}

}

（2）希尔排序

含义：希尔排序又称为“缩小增量排序”。

算法描述：

rectype r[n+d];

int d[t];

shellsort(rectype r[],int d[])

{ int I,j,k,h;

rectype temp;

int maxint=32767;

for(i=0;i

r[i].key = -maxint;

k=0;

do{

h=d[k];

for(i=h+d[0]-1;i

{ temp=r[i];

J=i-h;

While(temp.key

{ r[j+h]=r[j];

J=j-h;

}

R[j+h]=temp;

}

K++;

} while(h!=1);

}

2、交换排序

（1）冒泡排序

算法思想：将被排序的记录数组r[1…n]垂直排列，每个记录r[i]看做是重量为r[i].key的气泡。根据轻气泡不能在重气泡之下的原则，从下往上扫描数组r:凡扫描到违反本原则的轻气泡，就使其向上“漂浮”。如此反复进行，直到最后任何两个气泡都是轻者在上，重者在下为止。

算法描述：

Void bubblesort(seqlist r)

{ int I,j;

Boolean exchange;

For(i=1;i

Exchange=false;

For(j=n-1;j>=I;j--)

If(r[j+1].key

R[0]=r[j+1];

R[j+1]=r[j];

R[j]=r[0];

Exchange=true;

}

If(! Exchange)

Return;

}

}

(2)快速排序

快速排序通常被称为分治法（将原问题分解为若干个规模更小但结构与原问题相似的子问题。递归地解这些问题，然后将这些子问题的解组合为与原问题的解）。

算法思想：分解、求解、组合

算法描述：

（快速排序）void quicksort(seqlist r,int low,int high)

{ int pivotpos;

if(low

pivotpos=partition(r,low,high);

quicksort(r,low,pivotpos-1);

quicksort(r,pivotpos+1,high);

}

}

(划分算法) int partition(seqlist r,int I,int j)

{ recetype pivot=r[i];

While(i

While(i=pivot.key)

j--;

if(i

r[i++]=r[j];

while(i

i++;

if(i

r[j--]=r[i];

}

R[i]=pivot;

Return I;

}

3、选择排序

（1）直接选择排序

算法思想：每一趟在待排序的记录中选出关键字最小的记录，依次放在已排序的记录序列的最后，直至全部记录拍完为止。

算法描述：selectsort（rectype r[]）

{ int I,j,k;

Rectype temp;

For(i=0;i

{ k=I;

For(j=i+1;j

If(r[j].key

If(k!=i)

{ temp=r[i];

R[i]=r[k];

R[k]=temp;

}

}

}

(2)归并排序

算法思想：假设初始表含有n个记录，则可看成是n个有序的子表，每个子表的长度为1，然后两两归并，得到n/2个长度为2或1的有序子表，再两两归并，如此重复，直至得到一个长度为n的有序子表为止，这种方法称为“二路归并排序”。

算法描述：merge(rectype r[],rectype r1[],int low,int mid,int high) { int I,j,k;

I=low;j=mid+1;k=low;

While((i<=mid)&&(j<=high)){

If(r[i].key<=r[j].key)

R1[k++]=r[i++];

Else

R1[k++]=r[j++];}

While(i<=mid) r1[k++]=r[i++];

While(j<=high) r1[k++]=r[j++];

}

(3)堆排序

堆实质上是满足如下性质的完全二叉树：树种任一非叶子结点的关键字均不大于（或不小于）其左右孩子（若存在）结点的关键字（即如果按照线性存储该树，可得到一个不下降序列或不上升序列）。

算法描述：void HeapSort(Record r[],int n)

{

for(i=n/2;i>=1;i--)//初始建堆，从最后一个非终端结点至根结点

进行筛选

Sift(r,i,n);

for(i=1;i

{r[1]--r[n-i+1];

Sift(r,i,n-i);

procedure shift(r,n:longint); //调整堆

varv,k:longint;

begin