算法——排序2

快速排序：

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
堆排序：
首先把数组当作完全二叉树，然后保证根节点最大，然后把根节点与最后一个元素交换，然后再调整二叉树（逐渐减小数组），让根依然保持最大，然后重复上一次操作。
归并排序：
不交换数据，但需要借助额外的空间，用作临时存储空间。
算法的时间复杂度：
注意：时间复杂度不是算法运行所需要的时间，而是算法执行的次数

	平均状况
快速排序	O(nlog2n)
堆排序	O(nlog2n)
归并排序	O(nlog2n)

排序算法的稳定性：
当序列中有相等的数据时，算法不会改变这两个数据的前后位置，

	稳定性
快速排序	不稳定
堆排序	不稳定
归并排序	稳定

#include<stdio.h>
void _quick_sort(int* arr,size_t left,size_t right)
{
	if(left>=right) return;
	int pi=(left+right)/2;//计算标杆的下标
	int pv=arr[pi];//备份标杆的值
	int l=left,r=right;//备份左右下标
   while(l<r)//左右下标相遇时结束
   {
	   while(l<pi&&arr[l]<=pv)  l++; //在标杆的左边寻找比它大的数
          if(l>pi)
		  {  
			  //与标杆交换位置，并记录新的标杆的位置
             arr[pi]=arr[l];
			 pi=l;
		  }
		while(r>pi&&arr[r]>=pv) r--; //在标杆的右边寻找比它小的数 
		if(r<pi)
		{
			 arr[pi]=arr[r];
			 pi=r;
		}
   }
   //还原标杆的值
   arr[pi]=pv;
   if(pi-left>1)  _quick_sort(arr,left,pi-1);
   if(right-pi>1) _quick_sort(arr,pi+1,right); 
}
void quick_sort(int* arr,size_t len)//快速排序
{
  _quick_sort(arr,0,len-1);
}

#include<stdio.h>
#define   swap(a,b)    {typeof(a) t=a;a=b; b=t;}
void creat_heap(int* arr,size_t root,size_t len)
{
	if(root>=len)  return;
    int left=root*2+1;
	int right=root*2+2;
	creat_heap(arr,left,len);
	creat_heap(arr,right,len);
	int max=root;
	if(left<len)
	{
		if(arr[left]>arr[max])
			max=left;
	}
	if(right<len)
	{
       if(arr[right]>arr[max])
		   max=right;
	}
	if(max!=root)  
       swap(arr[max],arr[root]);
	
}
void heap_sort(int* arr,size_t len)//堆排序
{
  for(int i=0;i<len;i++)
   {	  
       creat_heap(arr,0,len-i);
	   swap(arr[0],arr[len-i-1]);
   }   
}

#include<stdio.h>
void merge(int* arr,size_t left,size_t pi,size_t right,int* temp)
{
	int i=left,j=pi+1,k=left;
	while(i<=pi&&j<=right)
	{
		if(arr[i]<arr[j])
		{
			temp[k++]=arr[i++];
		}
		else
			temp[k++]=arr[j++];
	}
	while(i<=pi)
		temp[k++]=arr[i++];
	while(j<=right)
		temp[k++]=arr[j++];
		for(int i=left;i<=right;i++) //拷贝到数组
		{
			arr[i]=temp[i];
		}
}
void _merge_sort(int* arr,size_t left,size_t right,int* temp)
{
	if(left>=right) return;       //拆分
	int pi=(left+right)/2;
	_merge_sort(arr,left,pi,temp);
	_merge_sort(arr,pi+1,right,temp);
     merge(arr,left,pi,right,temp);
}
void merge_sort(int* arr,size_t len)//归并排序
{
	int temp[len];
	_merge_sort(arr,0,len-1,temp);
}