考研408 王道 数据结构 算法题整理（五）排序

1. 插入排序

1.1 直接插入排序

**核心：**有序表+待排元素+无序表 —— 待排元素往前找插入位置，大于待排元素的依次后移（边比较边移动）

void InsertSort(Sqlist &L){
	for(int i=2;i<L.length;i++){       //i=0为哨兵，i=1是初始有序序列，从i=2开始比较 
		if(L.data[i]<L.data[i-1]){     //L.data[i]比有序表的最后一个小，需前移 
			L.data[0]=L.data[i];       //先把待排元素复制给哨兵
			//从有序序列最后一个（即待排的前一个）开始从后往前扫描，大于哨兵的均后移
			for(int j=i-1;L.data[j]>L.data[0];j--) 
				L.data[j+1]=L.data[j]; //后移 
			L.data[j+1]=L.data[0];     //哨兵归还待排元素 
		}
	}
}

1.2 折半插入排序

**核心：**有序表+待排元素+无序表 —— 对有序表先用折半查找找到插入位置（优化比较次数），再一次性后移 （先比较后移动）
**性质：**比较次数与表的初始状态无关，取决于n
移动次数与表的初始状态有关

1.3 希尔排序

**核心：**相同间隔的元素有序 —— 取降序序列作为增量（如[5,3,1]）,每次按顺序取一个增量作为间隔，对相同间隔的元素使用直接插入排序进行排序

2. 交换排序

2.1 冒泡排序

核心：无序区+已确定最终位置序列 —— 从一端开始，依次取无序区的元素与无序区的其他元素按顺序两两比较，若逆序则交换，直到碰到有序区

void BubbleSort(ElemType A[],int n){ //（小元素向表头冒）
	for(int i=0;i<n-1,i++){ //i=0为有序区的起始位置（将每趟最小的元素冒到这边来）每一趟（i++）都会确定一个有序数
		bool flag=false;
		for(int j=n-1;j>i;j--){ //从后端往前端两两比较，将小的往前冒，直到碰到有序边界i
			if(A[j]<A[j-1]){ //后一个居然比前一个小，换一下 
				swap(A[j],A[j-1]);
				flag=true;
			}
		}
		if(flag==false) return; //这一趟都没有交换，已经有序了
	}
} 

2.2 快速排序

void Qsort(int A[], L, R){       //a数组保存数据，L和R是边界
   if (L>=R) return;             //当前区间元素个数<=1则退出
   int key, i=L, j=R;            //i和j是左右两个数组下标移动
   把a数组中随机一个元素和A[L]交换  //快排优化，使得基准值的选取随机
   key=A[L];                     //key作为枢值参与比较
   while (i<j){
      while (i<j && A[j]>key)
          j--;
      while (i<j && A[i]<=key)
          i++;
      if (i<j)
          swap(A[i], A[j]);      //交换A[i]和A[j]
   }
   swap(A[L], A[i]);
   Qsort(A, L, i-1);            //递归处理左区间
   Qsort(A, i+1, R);            //递归处理右区间
}

3. 选择排序

3.1 简单选择排序

**核心：**有序序列+无序序列，每次在无序序列中选择最小的元素放到有序序列的最后面（并入有序序列）

void SelectSort(ElemType A[], int n){
	for(int i=0;i<n;i++){
		min=i;
		for(int j=i+1;j<n;j++){
			if(A[j]<A[j]) min=j;
		}
		if(min!=i) swap(A[i],A[min]);
	}
}

3.2 堆排序

核心：
1）堆排序：将待排序列调整为大根堆，根节点与末尾结点交换，则此时末尾结点为最大关键字（确定最终位置），同时重新调整为大根堆，以此循环，最终得到一个非递减序列
**2）初建堆：**从最后一个非叶节点（i=n/2向下取整）开始，依次往上调整为大根堆
**3）调整堆：**确保每个节点的根节点的关键字都大于其孩子节点（大根堆）
注意区分【初建堆】和【从空堆插入结点建立堆】：
【初建堆】已有堆，通过从最后一个非叶结点开始往上不断调整形成大/小根堆），
【从空堆插入结点建立堆】需每次将新节点插入在堆的末尾，并调整为大/小根堆。

//建立大根堆
void BuildMaxHeap(ElemType A[],int len){
	for(int i=len/2;i>0;i--) HeadAdjust(A,i,len);
} 
//将以k为根的子树调整为大根堆 
void HeadAdjust(ElemType A[],int k,int len){
	A[0]=A[k]; //A[0]暂存子树的根节点 
	for(i=2*k;i<=len;i*=2){ //沿key较大的子节点向下筛选 
		if(i<len&&A[i]<A[i+1]) i++; //取key较大的子节点的下标 
		if(A[0]>=A[i]) break;  //筛选结束 
		else{
			A[k]=A[i]; //将A[i]调整到双亲结点上 
			k=i;  //修改k值，以便继续向下筛选 
		}
	}
	A[k]=A[0]; //被筛选结点的值放入最终位置 
}
//堆排序
void HeapSort(ElemType A[],int len){
	BuildMaxHeap(A,len);
	for(i=ken;i>1;i--){
		Swap(A[i],A[1]);
		HeadAdjust(A,1,i-1);
	}
}

4. 归并排序（2路归并排序）

**核心：**从头依次对比两个有序表的元素，将较小元素放入辅助数组（新的有序表）向后移，直到其中一个有序表已对比完，将另一个表的后续元素直接并入新有序表即可。

//顺序表存储
void Merge(ElemType R[],ElemType T[],int low,int mid,int high)
{ 
   //将有序表R[low..mid]和R[mid+1..high]归并为有序表T[low..high] 
	int i,j,k;
	i=low; j=mid+1;k=low; 
    while(i<=mid&&j<=high)
	{
		//将R中记录由小到大地并入T中 
		if(R[i].key<=R[j].key) T[k++]=R[i++]; 
        else T[k++]=R[j++]; 
	} 
	while(i<=mid)               //将剩余的R[low..mid]复制到T中 
		T[k++]=R[i++];
	while(j<=high)              //将剩余的R[j.high]复制到T中 
		T[k++]=R[j++];
}

//链表存储
LinkList MergeLinkList(LinkList A,LinkList B){ 
    LinkList C=(LinkList)malloc(sizeof(LNode));
    C->next=NULL;
    LNode *pc=C, *r=C;
    LNode *pa=A->next;
    LNode *pb=B->next;
    while(pa!=NULL&&pb!=NULL){
    	if(pa->data<=pb->data){
    		r->next=pa;
    		r=pa;
			pa=pa->next;
		}
		else{
			r->next=pb;
			r=pb;
    		pb=pb->next;
		}
	}
	while(pa!=NULL){
		r->next=pa;
		r=pa;
		pa=pa->next;
	}
	while(pb!=NULL){
		r->next=pb;
		r=pb;
		pb=pb->next;
	}
	return C;
}

5. 基数排序

核心：【最低位优先（LSD）+ 对于三位数而言，此时需要有10个链队列（10个数字0~9）】
先从个位数开始，按序列的每个数的个位数将其挂到相应的链队下，全部挂完后依次出队
对新的队列按十位数将其挂到相应的链队下，全部挂完后依次出队
对新的队列按百位数将其挂到相应的链队下，全部挂完后依次出队
出队序列即为一条递增队列