all sort

void insertSort(int a[], int n)
{
	if(n == 0 || n == 1)
		return;
	int i, j, temp;
	i = j = temp = 0;
	for(i = 1; i != n; ++ i)
	{
		temp = a[i];
		for(j = i; j > 0 && a[j-1] > temp; -- j)
			a[j] = a[j-1];
		a[j] = temp;
	}

}

两边比较高效，因为一边排序在有序的情况下，O(N*N)最差，或者都是相等元素时候最差，两边排序，相等也停下来交换，就可以都获得平均O(NlogN)的复杂度

void quickSort(int a[], int left, int right)
{
//	if(right - left < 10)//cutoff = 10
//		insertSort2(a, left, right);
	//always forget*************
	if(left >= right)//还是忘记了判断
		return;
	//1 rand
//	swap(a[right], a[rand()%(right - left) + left]);
	//2 median
	int p = (right + left) >> 1;  //mid
    if(a[left]<a[right])
    {
        if(a[right]>a[p])       //right is the max
        {
            if(a[left]>a[p])    p=left;
        }
        else    //left<right<p
            p=right;
    }
    else
    {
        if(a[left]>a[p])
        {
            if(a[right]>a[p])   p=right;
        }
        else p=left;
    }
    swap(a[p],a[right]);

	int temp = a[right];
	int i = left-1;//因为首先++ i
	int j = right;//因为首先--j，并且pivot在right

	while(true)
	{
		do ++ i; while(i < right && a[i] < temp);
		do -- j; while(a[j] > temp);

		if(i > j)
			break;
		swap(a[i], a[j]);
	}
	swap(a[i], a[right]);
	quickSort(a, left, i-1);//注意要是left，right递归，0，什么不是递归表示形式
	quickSort(a, i+1, right);
}

mergesort的细节就是注释出来的部分

void mergeTwo(int a[], int left, int mid, int right, int temp[])
{
	int i = left, j = mid+1;
	int m = mid, n = right;
	int k = 0;
	while(i <= m && j <= n)
	{
		if(a[i] <= a[j])
			temp[k++] = a[i++];
		else
			temp[k++] = a[j++];
	}

	while(i <= m)
		temp[k++] = a[i++];

	while(j <= n)
		temp[k++] = a[j++];

	for(i = 0; i < k;++ i)//i<=k数组溢出
	{
		a[left + i] = temp[i];//应该是赋值给left后面的元素
	}
}


void mergeSort(int a[], int left, int right, int temp[])
{
	if(left < right)
	{
		int mid = (right + left)>>1;
		mergeSort(a, left, mid, temp);
		mergeSort(a, mid+1, right,temp);
		mergeTwo(a, left, mid, right, temp);
	}

}


bool MergeSort(int a[], int n)
{
	int* p = new int[n];
	if(p == NULL)
		return false;

	mergeSort(a, 0, n-1, p);
	delete[] p;
	return true;
}

void MinHeapFixup(int a[], int child)
{	
	int temp = a[child];
	while(parent >= 1 && child != 1)
	{
		cout<<a[parent]<<endl;
		if(a[parent] <= temp)
			break;

		a[child] = a[parent];
		child = parent;
		parent = child>>1;
	}
	a[child] = temp;
}


void MinHeapAddNumber(int a[], int n, int nNum)
{
	a[n+1] = nNum;
	MinHeapFixup(a, n+1);
}


void MinHeapFixdown(int a[], int parent, int n)
{
	int child = 2 * parent;
	int temp = a[parent];
	while(child <= n)
	{
		if(child + 1 <= n && a[child+1] < a[child])
			++ child;

		if(a[child] >= temp)
			break;

		a[parent] = a[child];
		parent = child;
		child = 2 * parent;
	}
	a[parent] = temp;
}

void MinHeapDeleteNumber(int a[], int n)
{
	swap(a[0], a[n-1]);
	MinHeapFixdown(a, 0, n-1);
}


void MakeMinHeap(int a[], int n )
{
	for(int i = n>>1; i >= 1; -- i)
		MinHeapFixdown(a, i, n);
}