稳定性
内部排序，内存，逐步扩大有序记录
外部排序
排序过程的依据不同原理：插入，交换，选择，归并，基数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
,