排序

1. 插入排序 （稳定，时复O(n²) ,空复O(1) ）

   把第i个插入到i前面的有序列中
   把a[i]缓存到他，j从i-1开始，当就不小于零且t大于或小于a[j]时,a[j]后移一位，跳出循环后t插入，注意对应位置
   也就是i之前的插入排序，内层插入代码如下，

t = a[i];
j = i-1;
while(j>=0 && t>a[j]){
	a[j+1] = a[j];
	j--;
}
a[j+1] = t;

2. 冒泡排序 （稳定，最坏时复O(n²) ,最好时复O(n)，空复O(1) ）
   内层找最大值或者最小值放在最前面，依次往后找；里面就是从后面不断的不断的把最大值或者最小值放到最前面，如果已经排好了就通过flag告诉外层不用排了内层找最大值或者最小值放在最前面，依次往后找；里面就是从后面不断的不断的把最大值或者最小值放到最前面，如果已经排好了就通过flag告诉外层不用排了

boolen flag = false;
for(j=n-1;j>i;j--){
	if(a[j]>a[j-1]){
		swap(a[j],a[j-1]);
		flag = true;
	}
}
if(flag==false)  //加上flag避免后续是有序的，就不用继续跑了
return;

3. 快速排序 （不稳定，最坏时复O(n²) ,平均时复O(nlogn)，最坏空复O(n) ，平均空复O(logn)）
   子函数是任意在数组中取一个值做中轴，这里说顺序，比中轴小的放在左边对应下标low，大的放右边对应下标high，右边不小于中轴则下标左移一位，否则赋值给当前a[low];左边不大于中轴则下标右移一位，否则赋值给当前a[high];最后跳出后中轴赋给a[low],并返回下标

int Partition(ElemType a[], int low, int high){
	ElemType pivot = a[low];
	while(low<high){
		while(low<high && a[high]>pivot) high--;
		a[low] = a[high];
		while(low<high && a[low]<pivot) low++;
		a[high] =a[low];
	}
	a[low] = pivot;
	return low;
}

4. 堆排序
   给出一个数组，从上到下，从左到右依次根据树的形式写下去，如果根节点始终不大于子节点，则为小根堆（小顶堆），反之则为大根堆（大顶堆）。
   L(i)<=L(2i) && L(i)<=L(2i+1) or L(i)>=L(2i) && L(i)>=L(2i+1)

void AdjustDown(ElemType a[], int k, int len){
	a[0]=a[k]    //A[0]作为缓存
	for(int i=2*k;i<=len;i*=2){
		if(i<len&&a[i]<a[i+1]) i++;  //找最大的
		if(a[0]>=a[i]) break;
		else{          //当比最大的还小，往上赋值
			a[k]=a[i];
			k=i;  //最后这个k就是前面那个i空出来的，无效值，等待覆盖
		}
	}
	a[k]=a[0]; //把最初的k的值放到i的地方
}

void AdjustUp(ElemType a[], int k){
	a[0]=a[k];
	int i=k/2;
	while(i>0 && a(0)>a(i)){
		a[k]=a[i];
		k=i;
		i=k/2;
	}
	a[k]=a[0];
}