堆排序和归并排序

各种排序放大的时间复杂度，空间复杂度，以及稳定性

三中排序的移动次数比较

堆排序的时间复杂度为O(nlogn),无论好还他的时间复杂度是一样的 

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAXSIZE 10
typedef struct
{
	int r[MAXSIZE+1];
	int length;
}SqList;
void swap(SqList *L,int i,int j)
{
	int temp=L->r[i];
	L->r[i]=L->r[j];
	L->r[j]=temp;
}
void HeapAdjust(SqList* L,int s,int m)
{
	int temp,j;
	temp = L->r[s];
	for(j=2*s;j<=m;j*=2)/*沿关键字较大的孩子节点向下查找*/
	{
		if(j<m&&L->r[j]<L->r[j+1])/*如果左孩子小于右孩子*/
		{
			++j;/*J指向较大的节点*/
		}
		if(temp>=L->r[j])/*将小的放在最下面如果他比她大说明不是最小的，*/
		{
			break;
		}
		L->r[s]=L->r[j];
		s=j;
	}
	L->r[s]=temp;
}
void HeapSort(SqList* L)
{
	int i;
	for(i=L->length/2;i>0;i--)//构建大顶堆，最大的元素永远在堆顶所以排序的时候只要吧对定的元素挡在最后面就可以了
	{
		HeapAdjust(L,i,L->length);
	}
	for(i=L->length;i>1;i--)/*将堆顶元素移走从新构建大顶堆*/
	{
		swap(L,1,i);/*将第一个元素和最后一个元素交换*/
		HeapAdjust(L,1,i-1);/*将第一个元素到倒数第二个元素从新构建大顶堆*/
	}
}
int main()
{
	SqList *L =(SqList*)malloc(sizeof(SqList));
	printf("排序前\n");
	int i;
	srand(time(NULL));
	for(i=1;i<11;i++)
	{
		L->r[i]=rand()%15+1;
		L->length++;
		printf("%d ",L->r[i]);
	}
	printf("\n");
	HeapSort(L);
	printf("排序后：\n");
	for(i=1;i<MAXSIZE+1;i++)
	{
		printf("%d ",L->r[i]);
	}
	printf("\n");
	
	return 0;
}

归并排序：讲一个无序的序列无限的二分，分到每一个序列只有一个元素，则他一定是有序的，再将这些有序的数列通过归并成一个新的有序的数列，一直到所有蒜素都进去

归并时间复杂度为O(nlogn)最好最坏平均的复杂度都是他，空间复杂度是O(n+logn)

不用递归的归并排序

void Merge(int SR[],int TR[],int i,int m,int n)
{
	int j,k,l;
	for(j=m+1/*第二个数列的开始*/,k=i;i<=m&&j<=n;k++)
	{
		if(SR[i]<SR[j])/*如果第一个数列的当前元素小于第二个数列，进入TR*/
		{/*按照顺序进入当前的TR中*/
			TR[k]=SR[i++];
		}
		else
		{
			TR[k]=SR[j++];
		}
	}
	if(i<=m)/*如果前面拍完还剩的将后面的数列全都按顺序放入TR中*/
	{/*前一个数列剩*/
		for(l=0;l<=m-i;l++)
		{
			TR[k+l]=SR[i+l];
		}
	}
	if(j<=n)
	{/*后一个数列剩*/
		for(l=0;l<=n-j;l++)
		{
			TR[k+l]=SR[j+l];
		}
	}
	/*执行到底当前的数列一定是有序的*/
	
}