数据结构排序小结Word下载.docx
《数据结构排序小结Word下载.docx》由会员分享，可在线阅读，更多相关《数据结构排序小结Word下载.docx（17页珍藏版）》请在冰豆网上搜索。
L.r[j+1]=L.r[0];
//插入到正确位置
}
}//InsertSort
2）折半插入排序返回目录
平均情况—O（n2）稳定性：
13
14
15
voidBInsertSort（SqList&
//对顺序表L作折半插入排序。
inti,j,high,low,m;
++i）{
//将L.r[i]暂存到L.r[0]
low=1;
high=i-1;
while（low<
=high）{//在r[low..high]中折半查找有序插入的位置
m=（low+high）/2;
//折半
if（LT（L.r[0].key,L.r[m].key））high=m-1;
//插入点在低半区
elselow=m+1;
//插入点在高半区
j>
=high+1;
--j）L.r[j+1]=L.r[j];
L.r[high+1]=L.r[0];
//插入
}//BInsertSort
3）希尔排序算法演示返回目录
理想情况—O（nlog2n）最坏情况—O（n2）稳定性：
不稳定
16
17
18
19
voidShellInsert（SqList&
L,intdk）{
//对顺序表L作一趟希尔插入排序。
本算法对算法10.1作了以下修改：
//1.前后记录位置的增量是dk，而不是1；
//2.r[0]只是暂存单元，不是哨兵。
当j<
=0时，插入位置已找到。
for（i=dk+1;
if（LT（L.r[i].key,L.r[i-dk].key））{//需将L.r[i]插入有序增量子表
//暂存在L.r[0]
for（j=i-dk;
0&
&
j-=dk）
L.r[j+dk]=L.r[j];
//记录后移，查找插入位置
L.r[j+dk]=L.r[0];
}//ShellInsert
voidShellSort（SqList&
L,intdlta[],intt）{
//按增量序列dlta[0..t-1]对顺序表L作希尔排序。
for（intk=0;
k<
t;
k++）
ShellInsert（L,dlta[k]）;
//一趟增量为dlta[k]的插入排序
}//ShellSort
二、交换排序
1）冒泡排序算法演示返回目录
voidBubbleSort（SeqListR）{
inti，j;
Booleanexchange;
//交换标志
for（i=1;
i<
n;
i++）{exchange="
FALSE;
j="
n-1;
j"
>
=i;
j--）//对当前无序区R[i..n]自下向上扫描
if（R[j+1].key<
R[j].key）{//交换记录
R[0]=R[j+1];
//R[0]不是哨兵，仅做暂存单元
R[j+1]=R[j];
R[j]=R[0];
exchange=TRUE;
//发生了交换，故将交换标志置为真
}
if（!
exchange）//本趟排序未发生交换，提前终止算法
return;
}//endfor（外循环）
}//BubbleSort<
/n;
i++）{>
2）快速排序算法演示返回目录
平均情况—O（nlog2n）最坏情况—O（n2）辅助空间：
O（log2n）稳定性：
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
intPartition（SqList&
L,intlow,inthigh）{
//交换顺序表L中子序列L.r[low..high]的记录，使枢轴记录到位，
//并返回其所在位置，此时，在它之前（后）的记录均不大（小）于它
KeyTypepivotkey;
RedTypetemp;
pivotkey=L.r[low].key;
//用子表的第一个记录作枢轴记录
while（low<
high）{//从表的两端交替地向中间扫描
high&
L.r[high].key>
=pivotkey）--high;
temp=L.r[low];
L.r[low]=L.r[high];
L.r[high]=temp;
//将比枢轴记录小的记录交换到低端
L.r[low].key<
=pivotkey）++low;
//将比枢轴记录大的记录交换到高端
returnlow;
//返回枢轴所在位置
}//Partition
L.r[0]=L.r[low];
//枢轴记录关键字
L.r[low]=L.r[high];
//将比枢轴记录小的记录移到低端
L.r[high]=L.r[low];
//将比枢轴记录大的记录移到高端
L.r[low]=L.r[0];
//枢轴记录到位
//返回枢轴位置
voidQSort（SqList&
//对顺序表L中的子序列L.r[low..high]进行快速排序
intpivotloc;
if（low<
high）{//长度大于1
pivotloc=Partition（L,low,high）;
//将L.r[low..high]一分为二
QSort（L,low,pivotloc-1）;
//对低子表递归排序，pivotloc是枢轴位置
QSort（L,pivotloc+1,high）;
//对高子表递归排序
}//QSort
voidQuickSort（SqList&
L）{//算法10.8
//对顺序表L进行快速排序
QSort（L,1,L.length）;
}//QuickSort
三、选择排序
1）简单选择排序算法演示返回目录
时间复杂度：
voidSelectSort（SqList&
//对顺序表L作简单选择排序。
for（i=1;
i<
L.length;
++i）{//选择第i小的记录，并交换到位
j=SelectMinKey（L,i）;
//在L.r[i..L.length]中选择key最小的记录
if（i!
=j）{//L.r[i]←→L.r[j];
与第i个记录交换
temp=L.r[i];
L.r[i]=L.r[j];
L.r[j]=temp;
}//SelectSort
2）堆排序算法演示返回目录
平均情况—O（nlog2n）最坏情况—O（nlog2n）辅助空间：
voidHeapAdjust（HeapType&
H,ints,intm）{
//已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的定义，
//本函数调整H.r[s]的关键字，使H.r[s..m]成为一个大顶堆
//（对其中记录的关键字而言）
intj;
RedTyperc;
rc=H.r[s];
for（j=2*s;
j<
=m;
j*=2）{//沿key较大的孩子结点向下筛选
if（j<
m&
H.r[j].key<
H.r[j+1].key）++j;
//j为key较大的记录的下标
if（rc.key>
=H.r[j].key）break;
//rc应插入在位置s上
H.r[s]=H.r[j];
s=j;
H.r[s]=rc;
}//HeapAdjust
voidHeapSort（HeapType&
H）{
//对顺序表H进行堆排序。
inti;
for（i=H.length/2;
i>
0;
--i）//把H.r[1..H.length]建成大顶堆
HeapAdjust（H,i,H.length）;
for（i=H.length;
1;
--i）{
temp=H.r[i];
H.r[i]=H.r[1];
H.r[1]=temp;
//将堆顶记录和当前未经排序子序列Hr[1..i]中
//最后一个记录相互交换
HeapAdjust（H,1,i-1）;
//将H.r[1..i-1]重新调整为大顶堆
}//HeapSort
四、归并排序算法演示返回目录
O（n）稳定性：
voidMerge（RedTypeSR[],RedTypeTR[],inti,intm,intn）{
//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
intj,k;
for（j=m+1,k=i;
=m&
=n;
++k）{
//将SR中记录由小到大地并入TR
ifLQ（SR[i].key,SR[j].key）TR[k]=SR[i++];
elseTR[k]=SR[j++];
if（i<
=m）//TR[k..n]=SR[i..m];
将剩余的SR[i..m]复制到TR
while（k<
=n&
=m）TR[k++]=SR[i++];
=n）//将剩余的SR[j..n]复制到TR
j<
=n）TR[k++]=SR[j++];
}//Merge
voidMSort（RedTypeSR[],RedTypeTR1[],ints,intt）{
//将SR[s..t]归并排序为TR1[s..t]。
intm;
RedTypeTR2[20];
if（s==t）TR1[t]=SR[s];
else{
m=（s+t）/2;
//将SR[s..t]平分为SR[s..m]和SR[m+1..t]
MSort（SR,TR2,s,m）;
//递归地将SR[s..m]归并为有序的TR2[s..m]
MSort（SR,TR2,m+1,t）;
//将SR[m+1..t]归并为有序的TR2[m+1..t]
Merge（TR2,TR1,s,m,t）;
//将TR2[s..m]和TR2[m+1..t]归并到TR1[s..t]
}//MSort
voidMergeSort（SqList&
//对顺序表L作归并排序。
MSort（L.r,L.r,1,L.length）;
}//MergeSort
五、基数排序算法演示返回目录
平均情况—O（d（n+rd））最坏情况—O（d（n+rd））辅助空间：
O（rd）稳定性：
voidDistribute（SLList&
L,inti,ArrType&
f,ArrType&
e）{
//静态链表L的r域中记录已按（keys[0],...,keys[i-1]）有序，
//本算法按第i个关键字keys[i]建立RADIX个子表，
//使同一子表中记录的keys[i]相同。
f[0..RADIX-1]和e[0..RADIX-1]
//分别指向各子表中第一个和最后一个记录。
intj,p;
for（j=0;
RADIX;
++j）f[j]=0;
//各子表初始化为空表
for（p=L.r[0].next;
p;
p=L.r[p].next）{
j=L.r[p].keys[i]-'
0'
;
//将记录中第i个关键字映射到[0..RADIX-1]，
if（!
f[j]）f[j]=p;
elseL.r[e[j]].next=p;
e[j]=p;
//将p所指的结点插入第j个子表中
}//Distribute
voidCollect（SLList&
L,inti,ArrTypef,ArrTypee）{
//本算法按keys[i]自小至大地将f[0..RADIX-1]所指各子表依次链接成
//一个链表，e[0..RADIX-1]为各子表的尾指针
intj,t;
!
f[j];
j++）;
//找第一个非空子表，succ为求后继函数:
++
L.r[0].next=f[j];
//L.r[0].next指向第一个非空子表中第一个结点
t=e[j];
while（j<
RADIX）{
for（j=j+1;
RADIX&
//找下一个非空子表
RADIX）//链接两个非空子表
{L.r[t].next=f[j];
t=e[j];
}
L.r[t].next=0;
//t指向最后一个非空子表中的最后一个结点
}//Collect
voidRadixSort（SLList&
//L是采用静态链表表示的顺序表。
//对L作基数排序，使得L成为按关键字自小到大的有序静态链表，
//L.r[0]为头结点。
ArrTypef,e;
L.recnum;
++i）L.r[i-1].next=i;
L.r[L.recnum].next=0;
//将L改造为静态链表
for（i=0;
L.keynum;
//按最低位优先依次对各关键字进行分配和收集
Distribute（L,i,f,e）;
//第i趟分配
Collect（L,i,f,e）;
//第i趟收集
print_SLList2（L,i）;
}//RadixSort
Shaker排序法-改良的气泡排序
作者：
来源：
zz发表时间：
2007-11-30浏览次数：
2411字号：
大中小
中国源码网内相关主题链接
Shaker排序法-改良的气泡排序
請看看之前介紹過的氣泡排序法：
for（i=0;
MAX-1&
flag==1;
i++）{
flag=0;
for（j=0;
MAX-i-1;
j++）{
if（number[j+1]<
number[j]）{
SWAP（number[j+1],number[j]）;
flag=1;
}
事實上這個氣泡排序法已經不是單純的氣泡排序了，它使用了旗標與右端左移兩個方法來改進排序的效能，而Shaker排序法使用到後面這個觀念進一步改良氣泡排序法。
在上面的氣泡排序法中，交換的動作並不會一直進行至陣列的最後一個，而是會進行至MAX-i-1，所以排序的過程中，陣列右方排序好的元素會一直增加，使得左邊排序的次數逐漸減少，如我們的例子所示：
排序前：
952790498058691850
1.2790498058691850[95]95浮出
2.27498058691850[9095]90浮出
3.274958691850[809095]80浮出
4.2749691850[58809095]......
5.27691849[5058809095]......
6.691827[495058809095]......
7.6918[27495058809095]
方括號括住的部份表示已排序完畢，Shaker排序使用了這個概念，如果讓左邊的元素也具有這樣的性質，讓左右兩邊的元素都能先排序完成，如此未排序的元素會集中在中間，由於左右兩邊同時排序，中間未排序的部份將會很快的減少。
方法就在於氣泡排序的雙向進行，先讓氣泡排序由左向右進行，再來讓氣泡排序由右往左進行，如此完成一次排序的動作，而您必須使用left與right兩個旗標來記錄左右兩端已排序的元素位置。
一個排序的例子如下所示：
45197781132818197711
往右排序：
194577132818197711[81]
向左排序：
[11]1945771328181977[81]
[11]194513281819[777781]
[1113]1945182819[777781]
[1113]19182819[45777781]
[111318]191928[45777781]
[111318]1919[2845777781]
[1113181919][2845777781]
如上所示，括號中表示左右兩邊已排序完成的部份，當left>
right時，則排序完成。
publicclassShakerSort
...{
publicstaticvoidsort（int[]number）
inti,left=0,right=number.length-1,shift=0;
while（left<
right）
...{//向右进行气泡排序
for（i=left;
right;
i++）
if（number[i]>
number[i+1]）
swap（number,i,i+1）;
shift=i;
right=shift;
//向左进行气泡排序
for（i=right;
i>
left;
i--）
if（number[i]<
number[i-1]）
升级会员 