7.内部排序

排序，将无序序列有序化;

排序分内部排序和外部排序，区别于排序是否在内存中；

排序的稳定性：取决于是否会改变原有顺序的相同元素的前后关系；注：稳定性与算法的优劣无关；

内部排序总结：

内部排序

1.插入排序（时间O(n^2))

1）直接插入排序

//L[1-n]上排序；
void InsertSort(Elem A[],int n){
   	for(int i=2;i<=n;i++){//n-1次插入，第二个元素开始，索引0为哨兵；
        if(A[i]<A[i-1]){//若当前待插入的结点小于前一个结点；
            A[0]=A[i];//哨兵 
            for(j=i-1;A[0]<A[j];j--){//寻找插入位置；
                A[j+1]=A[j];//元素后移
            }//j+1为当前插入位置；
            A[j+1]=A[0];//插入；
        }
   	}
}

复杂度：

空间复杂度：O(1)

时间复杂度：O(n^2),注：若序列基本有序则时间复杂度为O(n);

稳定性：稳定；注：稳定性取决于算法的if插入逻辑，把小的才插入大的前；这样就不会改变其相等元素的相对位置；

实用性：顺序表和链表都适用；注：大部分算法只适用顺序表；

注：直接插入排序的最多比较次数即该序列逆序；至多n(n-1)/2;

2）折半插入排序

将插入的过程结合折半查找(要插入的序列为已排序的前段），故会减少比较次数；

void Half_InsertSort(Elem A[],int n){
   	for(int i=2;i<=n;i++){//n-1次插入，第二个元素开始，索引0为哨兵；
        if(A[i]<A[i-1]){
            A[0]=A[i];//哨兵,用作关键字存储和比较；
            low=1;high=i-1;
            while(low<=high){
                mid=(low+hign)/2;
                if(A[mid]>A[0]) hign=mid-1;
                else low=mid+1;
            }
            for(j=i-1;j>=high+1;j--){
                A[j+1]=A[j];//元素后移
            }
            A[high+1]=A[0];//插入；
        }
   	}
}

注：折半插入排序相比直接插入排序，在寻找插入的位置时比较次数更少；若有n个元素则比较时间复杂度为O(nlog_2{n})

折半插入排序和直接插入排序的移动次数一样，所以折半插入排序的时间复杂度为O(n^2)

折半插入排序和直接插入排序都是稳定的排序算法；

注：稳定性取决于算法的插入逻辑，把小的才插入大的前；这样就不会改变其相等元素的相对位置；

3）希尔排序；

以指定增量将序列分组，并对每组序列使用插入排序，当整个表“基本有序”时，对全体元素进行一次的直接插入排序；一次比较，0或1次移动；

void ShellSort(Elem A[],int n){
    for(dk=n/2;dk>=1;dk=dk/2)//步长变化；
        for(i=dk+1;i<=n;i++)//对指定步长的序列插入排序
        	if(A[i]<A[i-dk]){
                A[0]=A[i];//暂存A[0]
                for(int j=i-dk; j>0&&A[0]<A[j] ;j-=dk) A[j+dk]=A[j];//移动大的元素；
                A[j+dk]=A[0];//最后的j+dk为插入的位置；
        	}
}

稳定性：不稳定；注：若有序列{3 2 2 …}以增量2为分组，第二个2与3交换，则改变了相同元素原有的相对顺序；

适用性：希尔排序仅适用于顺序表；

2.交换排序

1）冒泡排序；稳；（一趟排序确定一个位置）

平均时间复杂度O(n^{2),最坏时间复杂度也为O(n}2)

冒泡排序稳定，因为swap交换逻辑是元素更小才交换；

void bubblesort(Elem A[],int n){
    for(int i=0; i<n-1; i++){//n-1趟排序
        flag=false;
        for(int j=n-1;j>i;j--){//n-1-i次比较；第一趟若6个元素i=0;比较5次；
            if(A[j-1]<A[j]) {
            	swap(A[j-1],A[j]);//逆序冒泡，得到小到大序列；大的往后放
        		flag=true;
        	}
        }
        if(flag==true) break;//一趟排序未交换任何元素则排序完；
    }
}

2）快速排序；不稳；

基于分治思想的排序算法；

算法：

void QuickSort(Elem A[],int low,int hign){
    if(low < hign){
        int p = Paration(A,low,hign);//return pivot_index;一趟排序完后的枢轴位置；
        QuickSort(A,low,p-1);//递归左半部分；
        QuickSort(A,p+1,hign);//递归右半部分；
    }
}
//
int Partition(Elem A[],int low,int hign){
    Elem pivot=A[low];//设置枢轴
    while(low < hign){
        while(low < hign && A[hign]>=pivot) high--;//向左移动到小于枢轴处
        A[low]=A[high];//将该元素赋值i处；
        while(low<hign && A[low]<=pivot) low++;//将i右移；
        A[high]=A[low];
    }
    A[low]=pivot;
    return low;//返回该趟排序后的枢轴位置；
}

空间复杂度：

递归树的深度log(n)，即空间复杂度；

时间复杂度：

最好情况下时间复杂度O（nlog_2{n}),序列越无序算法效率越高；

最坏时间复杂度O(n^2);序列越有序，效率越低；

排序不稳定

如：5 2 2，以5为枢轴

3.选择排序（都不稳定）

注：选择排序过程中的比较次数与序列初始状态无关；比较次数n(n-1)/2

1）简单选择排序；

SelectSort(Elem A[],int len){
    for(int i=0; i<n-1; i++)//遍历n-1次，选n-1次
    	int min=i;
    	for(int j=i+1;j<n;j++){
            if(A[j]<A[min]) m=j;
    	}
    	if(min!=i) Swap(A[i],A[min]);
}
//空间复杂度O(1),时间复杂度为O(n^2)
//2 2 1 3;选择排序，1 2换 两个则交换的顺序，不稳定算法；

2）堆排序；（重点）

树型选择排序；特点是排序的过程中

堆位一颗完全二叉树；且排序的过程将二叉树视为顺序存储结构；

父结点为i,左子结点则为2i,右子结点为2i+1;

且父结点都大于左右子结点的堆称为大根堆；

父结点都小于左右子结点的堆称为小根堆；

//排序
Void HeapSort(Elem A[],int len){
	buildMaxHeap(A,len);//从最后一个叶子结点的父结点开始向后遍历调整（筛选）[n/2下]；
    for(i=len;i>1;i--){//遍历n-1次；
        Swap(A[i],A[1]);//若为第一轮则第一个为堆顶元素，与尾元素交换；
        AdjustDown(A,1,i-1);//向下整理；
    }
}
//若向堆A[]中添加元素，则向上调整策略AdiustDown；

复杂度：

空间复杂度,为O(1);

时间复杂度，初始化建堆的时间复杂度为O(n),调整堆的时间复杂度为O(nlog_2{n})

整体时间复杂度为O(nlog_2{n}).

稳定性：不稳定；

手算一个无序排序的序列进行堆排序的过程：

1）将序列按层次遍历的结果，构造一颗完全二叉树；，

2）将完全二叉树转换为堆，建堆（从右往左，下层至上层）；逆层次调整(筛选）父结点，从最后一个叶子结点的父结点开始向后遍历调整（筛选）[n/2向下取整]；；注：增加才一直自下而上父结点；

3）调整策略的选择；

若为大顶堆则选择最大的子结点交换；

若为小顶堆则选则最小的子结点交换；

3）堆排序；

将堆顶元素与最后即对堆的最后一个叶子结点交换后，即第一个元素与最后一个元素swap；

之后堆的性质改变后，重新调整堆；

4.归并排序

二路归并排序；“归并”，两两有序表组成一个新得有序表；

递归形式的二路归并是基于分治算法的；

算法复杂度：

空间复杂度，O(n)；

时间复杂度，O(nlog_2{n})；

算法稳定；

注：

Merge（）需要开辟n的数组，空间复杂度度为n;

一次Merge()的时间复杂度为O(n),一共 [log_2{n}向上]归并；

算法：

void MergeSort(Elem A[],int low,int high){
    if(low<high){
        mid=(low+high)/2;//向下取整
        MergeSort(A,low,mid);
        MergeSort(A,mid,high);
        Merge(A,low,mid,mid);//归并两子序列，即将两序列排序为一个序列；
        //实现Merge需开辟n的内存空间；最终归并两个n/2个序列；
        //且一次二路归并，n/2个2个序列归并，时间为n/2*2;
    }
}

5.基数排序

基于关键字大小进行排序；借助“分配”和“收集”对关键字排序；LSD为最低为优先排序，MSD为最高位优先排序；

注：分配即按指定位得关键字对号进入各自队列，收集，则是依次收集所有队列出队元素；

时间空间复杂度

n即排序的关键字数量，d即关键字的位数，如789，d(789)=3;

r为关键字的基的个数，即关键字的位单位的种类；数字r=10;字母r=26;…

对应r个队列,空间复杂度O®

一次分配收集的时间为n+r,时间复杂度O(d*(n+r))

基数排序是稳定的；

借助队列的性质，先进先出，相同元素依然先后顺序分配，故稳定；时刻稳定；

（默认考察）LSD低位优先排序案例：