排序

冒泡排序       具有稳定性     O(n2)

   for(i=0;i<=length-1;i++)
    {
        for(j=0;j<=length-i-1;j++)
        {
            if(arr[j] > arr[j+1])
            {
                temp= arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
        }
    } 

插入排序       具有稳定性     O(n2)

for(i=1;i<length;i++)
	{
		for(j=i-1;j>=0 && a[j]>a[j+1]; j--)
		{
			temp=a[j];
			a[j]=a[j+1];
			a[j+1]=temp;
		}
	}
	

选择排序     不具有稳定性   O(n2)

	for(i=0;i<length-1;i++)
	{
		min=i;
		for(j=i+1;j<length;j++)
		{			
			if(arr[j]<arr[min])
			{
				min=j;				
			}		
		}
		temp=arr[i];		
		arr[i]=arr[min];
		arr[min]=temp	;	
	}

归并排序      具有稳定性     O(n log n)

	void merge(int arr[],int l,int m,int r){
		
		int help[r-l+1];  
		int i = 0;
		int p1 = l;
		int p2 = m + 1;
		while (p1 <= m && p2 <= r) {
			help[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
		}
		while (p1 <= m) {
			help[i++] = arr[p1++];
		}
		while (p2 <= r) {
			help[i++] = arr[p2++];
		}
		for (i = 0; i < (r-l+1); i++) {
			arr[l + i] = help[i];
		}
	}

void mergesort(int arr[],int l,int r){
		if(l==r){
			return;
		}
		
		int mid=l+(r-l)/2;
		mergesort(arr,l,mid);
		mergesort(arr,mid+1,r);
		merge(arr, l, mid, r);
	}

快速排序      不具有稳定性        O(n log n)

void quick_sort(int a[],int l,int r)
{
	if(l<r)
  {			
	int i=l;
	int j=r;
	int k=a[l];
	
	while(i<j)
	{
		while(i<j && a[j]>=k)
		{
			j--;
		}
		if(i<j)
		{
			a[i++]=a[j];
		}
		while(i<j && a[i]<k)
		{
			i++;
		}
		if(i<j)
		{
			a[j--]=a[i];
		}
	}
	
	a[i]=k;
	quick_sort(a,l,i-1);
	quick_sort(a,i+1,r);
 }
		
}

堆排序     具有稳定性      O(nlogn)

void heapint(int a[],int index)
{
	int temp;
	while(a[index]>a[(index-1)/2])
	{
		temp=a[index];
		a[index]=a[(index-1)/2];
		a[(index-1)/2]=temp;
		
		index=(index-1)/2;		
	}
} 

void heapify(int a[],int index,int size)
{
	int l = index*2+1;
	int temp;
	while(l<size)
  {
			
	int largest = a[l]<a[l+1]&&l+1<size ? l+1 : l;
	largest = a[largest] >a[index] ? largest :index;
	if(largest==index)
	{
		break;
	}
	
	temp = a[index];
	a[index] = a[largest];
	a[largest] = temp;

	index=largest;
	l=index*2+1;
  }
	
}

int main()
{
	int a[]={1,3,4,2,6};
	int size=5;
	int i,temp;

	for(i=0;i<size;i++)
	{
		heapint(a,i);
	}
	//int size=length;
	
	swap(a,0,--size);

	while(size>0)
	{
		heapify(a,0,size);
		swap(a,0,--size);
	}
	
	for(i=0;i<5;i++)
	{
		printf("%d",a[i]);
	}
}