C各种排序Word文档格式.docx
- 文档编号:19291895
- 上传时间:2023-01-05
- 格式:DOCX
- 页数:7
- 大小:18.81KB
C各种排序Word文档格式.docx
《C各种排序Word文档格式.docx》由会员分享,可在线阅读,更多相关《C各种排序Word文档格式.docx(7页珍藏版)》请在冰豆网上搜索。
//否则指针p指向查找路径上访问的最后一个结点并返回FALSE;
//指针f指向T的双亲,其初始调用值为NULL。
if(!
T){p=f;
returnFALSE;
}//查找不成功
elseif(key=T->
data.key){//查找成功
p=T;
returnTRUE;
}//elseif结束
T->
data.key)//在左子树中继续查找
SearchBST(T->
lchild,key,T,p);
elseSearchBST(T->
rchild,key,T,p);
//在右子树中继续查找
}//SearchBST
4.二叉排序树的插入算法
StatusInsertBST(BiTree&
T,TElemTypee){
//当二叉排序树T中不存在关键字等于e.key的数据元素时,
//插入e并返回TRUE,否则返回FALSE
SearchBST(T,e,NULL,p)){//查找不成功
s=(BiTree)malloc(sizeof(BiTNode));
s->
data=e;
s->
lchild=NULL;
rchild=NULL;
p)T=s;
//被插结点*s为新的根结点
elseif(e.key<
p->
data.key)
p->
lchild=s;
//被插结点*s为左孩子
elsep->
rchild=s;
//被插结点*s为右孩子
returnTURE
}//if结束
elsereturnFALSE;
//树中已有关键字相同结点不再插入
}//InsertBST
5.二叉排序树的删除算法
StatusDeleteBST(BiTree&
T,KeyTypekey){
//若二叉排序树T中存在关键字等于key的数据元素时,则删除该数据元素结点
//并返回TRUE;
否则返回FALSE
T)returnFALSE;
//不存在关键字等于key的数据元素
else{
if(key=T->
data.key)Delete(T);
//找到关键字等于key的数据元素
data.key)DeleteBST(T->
lchild,key);
elseDeleteBST(T->
rchild,key)
returnTRUE;
}//else结束
}//DeleteBST
//从二叉排序树中删除结点p,并重接它的左子树或右子树
rchild){//右子树空,则只需重接它的左子树
q=p;
p=p->
lchild;
free(q);
elseif(!
lchild){//左子树空,则只需重接它的右子树
rchild;
else{//左子树和右子树均不空
s=p->
while(s->
rchild){//转左,然后向右到尽头
q=s;
s=s->
rchild
}
data=s->
data;
//s指向被删除结点的前驱
if(q!
=p)q->
rchild=s->
//重接q指针所指的右子树
elseq->
lchild=s->
//重接q指针所指的左子树
6.二叉平衡树的旋转算法
(1)右旋平衡处理。
voidR_Rotate(BSTree&
//对以*p为根的二叉排序树作右旋处理,处理之后p指向新的树根结点,
//即旋转处理之前的左子树的根结点。
lc=p->
//lc指向p的左子树根结点
lchild=lc->
bf=0//p左子树指向lc右子树,且平衡因子为0
lc->
rchild=p;
lc->
bf=0//lc右子树指向p,且平衡因子为0
p=lc;
//p指向新的根结点,
}//R_Rotate
(2)左旋平衡处理。
voidL_Rotate(BSTree&
//对以*p为根的二叉排序树作左旋处理,处理之后p指向新的树根结点,
//即旋转处理之前的右子树的根结点。
rc=p->
//rc指向p的右子树根结点
rchild=rc->
bf=0//p右子树指向rc左子树,且平衡因子为0
rc->
lchild=p;
rc->
bf=0//rc的左子树指向p,且平衡因子为0
p=rc;
}//L_Rotate
1.直接插入排序算法
voidInsertSort(SqList&
L){
//对顺序表L作直接插入排序
for(i=2;
i<
=L,length;
++i)
if(L.r.key<
L.r[i-1].key){//若“<
”,则将L.r插入有序子表
L.r[0]=L.r;
//复制为哨兵
for(j=i-1;
L.r[0].key<
L.r[j].key);
--j)
L.r[j+1]=L.r[j];
//记录后移
L.r[j+1]=L.r[0];
//插入到正确位置
}//InsertSort
2.希尔排序算法
voidShellinsert(SqList&
L,intdk){
//对顺序表L作一趟希尔插入排序。
此算法和一趟直接插入排序相比,作了以下修改:
//
(1)前后记录为止的增量是dk,而不是1;
//
(2)r[0]只是暂存单元,而不是哨兵。
当j<
=0时,插入位置已经找到。
for(i=dk+1;
=L.length;
L.r[i-dk].key){//需要将L.r插入有序增量子表
//暂存在L.r[0]
for(j=i-dk;
j>
0&
&
(L.r[0].key<
j-=dk)
L.r[j+dk]=L.r[j];
//记录后移,查找插入位置
L.r[j+dk]=L.r[0];
}//ShellInsert
3.冒泡排序算法
voidBubbleSort(SqList&
//对顺序表L作冒泡排序。
//前后记录为止的增量是dk,而不是1;
//r[0]只是暂存单元,而不是哨兵。
for(i=0;
for(j=n-2;
i;
if(L.r[j+1].key<
L.r[j].key){//交换
temp=L.r[j+1];
L.r[j]=temp;
}//BubbleSort
4.快速排序算法
intPartition(SqList&
L,intlow,inthigh){
//交换顺序表L中子表r[low..high]的记录,“枢轴”记录到位并返回其所在位置
//此时,在它之前(后)的记录均不大(小)于它。
L.r[0]=L.r[low];
//用子表第一个记录作“枢轴”记录
pivotkey=L.r[low].key;
//pivotkey是“枢轴”记录关键字
high){//从表的两端交替地向中间扫描
high&
L.r[low].key>
=pivotkey)
--high;
L.r[low]=L.r[high];
//比“枢轴”记录小的记录移到低端
L.r[high].key<
++low;
L.r[high]=L.r[low];
//比“枢轴”记录大的记录移到高端
L.r[low]=L.r[0];
//“枢轴”记录到位
returnlow;
//返回“枢轴”位置
}//Partition
voidQsort(SqList&
//对顺序表L中的子序列L.r[low..high]作快速排序。
算法中出现的pivotloc是“枢轴”位置。
if(low<
high){//长度大于1
pivotloc=Partition(L,low,high);
//将L.r[low..high]一分为二
Qsort(L,low,pivotloc-1);
//对低子表递归排序
Qsort(L,pivotloc-1,high);
//对高子表递归排序
}//QSort
voidQuickSort(SqList&
//对顺序表L作快速排序
Qsort(L,1,L.length);
}//QuickSort
5.直接选择排序算法
voidSelectSort(SqList&
//对顺序表L作直接选择排序
for(i=1;
L.length;
++i){//选择第i个小的记录,并交换到位
k=i;
for(j=i+1;
j<
++j)//在L.r[i..length]中选择key最小的记录
if(L.r[j].key<
L.r[k].key)k=j;
if(i!
=k){//与第i个记录交换
temp=L.r;
L.r=L.r[k];
L.r[k]=temp;
}//for结束
}//SelectSort
6.堆排序算法
typedefSqListHeapType;
voidHeapAdjust(HeapType&
H,ints,intm){
//已知H.r[s..m]中记录的关键字除H.r[s].key之外均满足堆的以,
//此函数调整H.r[s]的关键字,使H.r[s..m]成为一个堆。
temp=H.r[s];
for(j=2*s;
=m;
j*=2){//沿着key较大的孩子结点向下筛选
if(j<
m&
(H.r[j].key<
H.r[j+1].key))
++j;
//j为key较大的记录的下标
(temp.key<
H.r[j].key))
break;
//temp应该插入在位置s上
H.r[s]=H.r[j];
s=j;
H.r[s]=temp;
//插入
}//HeapAdjust
voidHeapSort(HeapType&
H){
//对顺序表H进行堆排序
for(i=H.length/2;
i>
0;
--i)
HeapAdjust(H,i,H.length);
//把H.r[1..H.length]构造成堆
for(i=H.length;
1;
--i){
temp=H.r[1];
H.r[1]=H.r;
H.r=temp;
//将堆顶记录和当前未经排序的子序列H.r[1..i]中的最后一个记录相互交换
HeapAdjust(H,1,i-1);
//将H.r[1..i-1]重新调整为堆
}HeapSort
7.归并排序算法
typedefSqListRcdType;
voidMerge(RcdTypeSR[],RcdType&
T[],inti,intm,intn){
//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR[i..n]
for(j=m+1,k=i;
=m&
=n;
++k){
//将SR中记录由小到大地并入TR
if(SR.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
=n)TR[k..n]=SR[j..n];
//将剩余的SR[j..n]复制到TR
}//Merge
voidMSort(RcdTypeSR[],RcdType&
TR1[],ints,intt){
//将SR[s..t]归并排序为TR1[s..t]。
if(s==t)TR1[s]=SR[s];
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
8.基数排序算法
voidDistribute(SLCell&
r,inti,ArrType&
f,ArrType&
e){
//静态链表L的r域中记录已经按(keys[0],keys[1],…,keys[i-1])有序。
此算法
//按第i个关键字keys建立RD个子表,使同一个子表中记录的keys相同。
//f[0..RD-1]和e[0..RD-1]分别指向各子表中的第一个记录和最后一个记录。
for(j=0;
RD;
++i)f[j]=0;
//各子表初始化为空表
for(p=r[0].next;
p;
p=r[p].next){
j=Ord(r[p].keys);
//函数Ord将记录中第i个关键字映射到[0..RD]中去
f[j])f[j]=p;
elser[e[j]].next=p;
e[j]=p;
//将p所指的结点插入到第j个子表中
}//Distribute
voidCollect(SLCell&
r,inti,ArrTypef,ArrTypee){
//此算法按keys自小至大地将f[0..RD-1]所指各子表依次链接成一个链表。
//e[0..rd-1]为各子表的尾指针。
f[j];
j=Succ(j));
//找第一个非空子表,Succ为求后继函数
r[0].next=f[j];
t=e[j];
//r[0].next指向第一个非空字表中第一个结点
while(j<
RD-1){
for(j=Succ(j);
RD-1&
//寻找下一个非空子表
if(f[j]){r[t].next=f[j];
}//链接两个非空字表
}while结束
r[t].next=0;
//t指向最后一个非空子表中的最后一个结点
}//Collect
voidRadixSort(SLList&
//顺序表L采用静态链表表示。
对L作基数排序,
//使得L成为按关键字自小到大的有序静态链表,L.r[0]为头结点。
L.recnum;
++i)L.r.next=i+1;
L.r[L.recnum].next=0;
//将L改造为静态链表
L.keynum;
++i){
//按最低位优先,即LSD方法依次对各关键字进行分配和收集
Distribute(L.r,i,f,e)//第i趟分配
Collect(L.r,i,f,e)//第i趟收集
}//RadixSort
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- 各种 排序
![提示](https://static.bdocx.com/images/bang_tan.gif)