简述希尔排序、堆排序

希尔排序（Shell Sort）

思路:
希尔排序是把无序数列按下标定量分组，对每组使用直接插入算法排序；随着增量gap逐渐减小，每组包含的有序量越来越多，当增量减至1时，整个无序数列变为有序数列。

算法实现：

#include<stdio.h>
//通过数据后移完成插入排序
void ShellSortMove(int a[],int n){
    int i,j,gap,temp,count=0;
    for(gap = n/2;gap>0;gap/=2){
    	printf("gap=%d分组:\n",gap);        //通过gap分组进行直接插入排序
        for(i=gap;i<n;i+=gap){              //gap即分组偏移量，以此代码为例第一轮gap=5
            temp = a[i];                    //第一轮比较a[0], a[1], a[2], a[3], a[4],   
            for(j = i-gap;j>=0;j-=gap){     //分别对应与a[5], a[6], a[7], a[8], a[9]比较 
            	if(a[j]>temp)               //第二轮gap=2，如下对应比较
                	a[j+gap] = a[j];        //a[0], a[1], a[2], a[3], a[4],a[5],a[6],a[7]
             	else                        //a[2], a[3], a[4], a[5], a[6],a[7],a[8],a[9]
             		break;                  //第三轮同理直至有序
            }        
            a[j+gap] = temp;
            printRes(a,10,count);
			count++; 
        }
    }
}
//通过数据交换完成插入排序
void ShellSortSwap(int a[], int n)
{
    int i, j, gap,count=0,temp;
    for(gap=n/2; gap>0; gap/=2){
    	printf("gap=%d分组:\n",gap);
    	for(i=gap; i<n; i++)
            for(j=i-gap; j>=0; j-=gap){
            	if(a[j]>a[j+gap]){
            		temp=a[j+gap];
            		a[j+gap]=a[j];
            		a[j] = temp;
            		printRes(a,10,count);
            		count++;
				}
				else 
					break;
			}
	}
}
void print(int a[],int n){
	for(int i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}
void printRes(int a[],int n,int i){
	printf("第%2d次循环完毕：",i+1);
	for(int i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}
int main(){
	int a[10]={84,83,88,87,61,50,70,60,80,99};
	printf("        排序前: "); 
	print(a,10);
	ShellSortSwap(a,10);
}

动态模拟：（数据交换）

代码测试：

1、数据后移

2、数据交换

堆排序（Heap Sort）

思路：

将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

Ri <= R2i + 1 且 Ri <= R2i + 2 （小根堆）Ri >= R2i + 1 且 Ri >= R2i + 2 （大根堆）

索引为i的左子节点的数组存储下标是 ( 2 ∗ i + 1 ) ，右子节点的数组存储下标是 ( 2 ∗ i + 2 )​
算法实现：

#include<stdio.h>
void print(int a[],int n){
	for(int i=0;i<n;i++)
		printf("%3d",a[i]);
	printf("\n");
}
void printRes(int a[],int n,int i){
	printf("第%2d次循环完毕：",i+1);
	for(int j=0;j<n;j++)
		printf("%3d",a[j]);
	printf("\n");
}
void Swap(int array[], int i, int j) {
    int key  = array[i];
    array[i] = array[j];
    array[j] = key;
}
//比较该节点的子节点及其子节点包含的子树，满足条件的交换节点值 
void DownCompare(int a[], int i, int n) { 		
    int parent = i;                            // 父节点下标
    int leftchild  = 2 * i + 1;                // 左子节点下标
    int rightchild  = 2 * i + 2;               // 右子节点下标
    while (leftchild < n) {
        if (rightchild < n && a[leftchild] < a[rightchild]) {
            leftchild++;
        }
        if (a[parent] < a[leftchild]) {        // 判断父节点是否小于左子节点
            Swap(a, parent, leftchild);        // 交换父节点和子节点
            parent = leftchild;                // 子节点下标 赋给 父节点下标
        }
        rightchild = leftchild * 2 + 2;
        leftchild  = leftchild * 2 + 1;        // 换行，比较下面的父节点和子节点
    }
}
//初始化创建大根堆 
void BuildHeap(int a[], int n) {
    for (int i = n / 2 - 1; i >= 0; i--) {
        DownCompare(a, i, n);             
    }
}
void HeapSort(int a[], int n) {
    BuildHeap(a, n); 
    for (int i = n - 1; i > 0; i--) {
        Swap(a, 0, i); 				
        DownCompare(a, 0, i); 			//交换完毕后重新建立合法大根堆 
        printRes(a,15,15-i-1);
    }
}
int main() {
    int a[15] = {91, 60, 96, 13, 35, 65, 46, 65, 10,30,40,31,77,81,22};
    printf("        排序前: "); 
    print(a,15);
    HeapSort(a, 15);
    return 0;
}

动态模拟：

代码测试：

 （动图源于网络）