排序

稳定性

内部排序，内存，逐步扩大有序记录

外部排序

排序过程的依据不同原理：插入，交换，选择，归并，基数o（d.n）

插入类，交换类，选择类，归并

插入类：在R[1...I-1].KEY<=R【i】。key<R[j+1.........i-1].key;

将R【j+1。。。。。i-1】中的所有记录·后移一个位置；

将R【】插入（复制）到R

 

排序算法评价时间开销和空间开销

 

时间还与最好，最坏

直接插入排序：最好的情况是比较次数n-1，移动次数为0次

最坏情况：·递减有序比较次数（n+2）（n-1）/2

移动次数（n+4）（n-1）/2

顺序插入排序

折半插入排序

for（i=2;i<=length;i++）{

for(i=2;i<=L.length;++i){

Lr[0]=L.r[i];//将L。r[i]暂存在L。r[0]

在L。r[1.....i-1]中折半查找插入位置（high+1）；

for（j=i-1；j<high+1;--j）

L.r[j+1]=L..r[j]

L.R【high+1】=L。r【0】；

low=1;high=i-1;

while(low<=high)

{

m=(low<=high){

m=(low+high)/2

if(L.R[0].KEY<L.R[M].KEY)

HIGH=m-1；

else low=m+1；

}

}

 

 

}

 

 

}

希尔排序

void shellInset(Sqlist&L,int dk)

for（i=dk+1;i<=n;++i）

if(L.r[i].key<L.r[i-dk].key){

L.r[0]=L.r[i];

for(j=i-dk;j>0&&(L.r[0].key<L.r[j].key);j-=dk)

L.r[j+dk]=L.r[j];

L.r[j+dk]=L.r[0];

}

 

 

 

shellinsert

for（k=0；k<t;++k）

  shellinsert（L,dlta[k]）

 

对待排序先宏观后微观

将个记录分成d个子序列

 

表插入排序

交换排序包含冒泡排序和快排

void bubblesort（Elem R[],int n）

{

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

  for(j=1;j<=n-j:j++)

if(R[j].key>R[j+1].key)

     {Swap(R[j],R[j+1]}

}

 

}

改进版本

void bubblesort(Elem R[],int n){

i=n;flag=1;

while((i>1)&&flag){

flag=0;

for(j=1;j<i:)

}

 

}

 

优化

 

记住本趟最后一个以后都是有序的

冒泡排序的最好比较次数n-1，移动

最坏次数是移动3n

快排：

枢轴52,49,80,36,14,58,61,97,23,75

23,49,14,36,52,58,61,97,80,75

 1 int Partition(RedType &R[],int low,int high)
 2 pivotkey =R[low].key;
 3 while(low<high){
 4   while(low<high&&R[high].key>=pivotkey)
 5   --high;
 6  R[low]<-->R[high];
 7  while(low<high&&R[low].key<=pivotkey)
 8 ++low;
 9 }
10 return low;//返回枢轴所在位置
11 }
12 
13 
14 
15 
16 }

时间复杂度o(nlogn)

如果初始状态是按关键字有序为o（n^2）

 

选择排序

 

 

 

简单选择排序

无序序列中找到最小的放到ai

 1 void SelectSort(Elem R[],int n)
 2 
 3 {
 4 //对记录序列R【1.。。n】做简单选择排序
 5 for（i=1；i<n；++i）{
 6 //选择第i小的记录，并交换到位
 7 j=SelectMinKey(R,i);
 8 //在R【i。。。n】中选择关键字最小的记录
 9 if(i!=j)R[i]<-->R[j];
10 /与第i个记录交换
11 }
12 
13 
14 }

对n个记录进行比较次数n（n-1）/2

移动最少0，最多3（n-1）

 

 

树形选择排序

从根到顶，将最小的改成正无穷

时间复杂度nlogn

空间复杂度增加

 

 

堆排序

堆的定义：
小顶堆大顶堆

左右子孩子都小于根是大顶堆。

堆顶元素是最大值（大顶堆）

堆排序无论最坏最好时间复杂度都为nlogn

 

归并排序

将两个或两个以上的有序子序列归并为一个有序

1 void Merge(RcdType SR[],RcdType&TR[],int i,int m,int n)
2 for(j=m+1,k=i;i<=m&&j<=n;++k)
3 {
4 if(SR[i]。key《=SR[j]。key) TR[K]=SR[i++];
5 else TR[K]=SR[j++];
6 }
7 ...
8 }

将剩余的SR[I...M]复制到TR

将剩余的SR【j...n】复制到TR

if(i<=m)TR[K...N]=SR[i....m];
if(j<=n)TR[K....N]=SR[j..n];

2路归并

第一趟、

时间复杂度o(NLogn)空间O（N）

 

基数排序

链式基数排序（分配收集）分别按各位，十位百位排序，是稳定的

比较的多个关键字MSD或者LSD

 

数字0-9

 

 

,

 

转载于:https://www.cnblogs.com/fengtangjiang/p/11464940.html