c

void shellsort(int *a, int n)
{
	if(NULL == a || n <= 0)
		throw exception("error: wrong input.");
	if(1 == n)
		return;
	
	for(int increment = n/2; increment > 0; increment /= 2)
	{
		for(int i = increment; i < n; ++i)
		{
			int tmp = a[i];
			int j = i;
			for(; j >= increment && a[j-increment] > tmp; j -= increment)
				a[j] = a[j-increment];
			a[j] = tmp;
		}
	}
}

void bubbleSort(int *a, int n)
{
	for(int i = 0; i < n; ++i)
		for(int j = 1; j < n - i; ++i)
			if(a[j-1] > a[j])
				swap(a[j-1], a[j]);
}

void insertSort(int *a, int n)
{
	if(NULL == a || n <= 0)
		throw exception("error: wrong input.");
	if(1 == n)
		return;

	for(int i = 1; i < n; ++i)
	{
		int tmp = a[i];
		int j = i - 1;
		for(; j >= 0 && a[j] > tmp; --j)
				a[j+1] = a[j];
		a[j+1] = tmp;
	}
}

void quicksort(int *vec, int beg, int end)
{
	if(beg < end)
	{
		//每次都取最后一位数当比较数;
		int num = vec[end];
		int mid = beg;

		for(int i = beg; i < end; ++i)
		{
			if(vec[i] < num)
			{
				swap(vec, i, mid++);
			}
		}
		swap(vec, mid, end);
		quicksort(vec, beg, mid - 1);
		quicksort(vec, mid+1, end);
	}
}

void merge(int *vec, int *temp, int Lpos, int Rpos, int Rend)
{
	int Lend = Rpos - 1;
	int Tpos = Lpos;
	int Apos = Lpos;
	while(Lpos <= Lend && Rpos <= Rend)
	{
		if(vec[Lpos] < vec[Rpos])
			temp[Tpos++] = vec[Lpos++];
		else
			temp[Tpos++] = vec[Rpos++];
	}

	while(Lpos <= Lend)
		temp[Tpos++] = vec[Lpos++];
	while(Rpos <= Rend)
		temp[Tpos++] = vec[Rpos++];

	for(int i = Apos; i <= Rend; ++i)
		vec[i] = temp[i];
}
void msort(int *vec, int *temp, int beg, int end)
{
	if(beg < end)
	{
		int q = (beg+end)/2;
		msort(vec, temp, beg, q);
		msort(vec, temp, q+1, end);
		merge(vec, temp, beg, q+1, end);
	}
}
void mergeSort(int *vec, int n)
{
	if( NULL == vec || n < 1)
		return;
	int *temp = new int[n];
	msort(vec, temp, 0, n-1);
}

void maxHeap(int vec[],int n, int index)
{
	if(index * 2 + 2 <= n)
	{
		int p = vec[index];
		int l = vec[index*2 + 1];
		int r = vec[index*2 + 2];
		int maxIndex = p >= l ? index : index*2 + 1;
		maxIndex = vec[maxIndex] >= r ? maxIndex : index*2 + 2;

		if(maxIndex != index)
		{
			swap(vec, index, maxIndex);
			maxHeap(vec, n, maxIndex);
		}
	}
	else if(index * 2 + 1 == n)
	{
		int p = vec[index];
		int l = vec[index*2 + 1];
		if(l > p)
		{
			swap(vec, index, index*2);
		}
	}	
}
void buildHeap(int vec[], int n)
{
	int beg = (n+1)/2 - 1;
	for(int i = beg; i >= 0; --i)
	{
		maxHeap(vec, n, i);
	}
}
void heapsort(int vec[], int n)
{
	buildHeap(vec, n);
	for(int i = n; i > 0; --i)
	{
		swap(vec, 0, i);
		maxHeap(vec, i-1, 0);
	}
}

int findMiddle(int *v, int beg, int end)
{
	int mid = (beg + end) / 2;
	if(v[beg] > v[mid])
		swap(v[beg], v[mid]);
	if(v[mid] > v[end-1])
		swap(v[mid], v[end-1]);
	if(v[beg] > v[mid])
		swap(v[beg], v[mid]);

	swap(v[mid], v[end-1]);
	return v[end-1];
}
void quickSort(int *v, int beg, int end)
{
	if(NULL == v)
		throw exception("error");

	if(beg < end)
	{
		int tmp = findMiddle(v, beg, end);
		int j = beg;
		for(int i = beg; i < end -1; ++i)
		{
			if(v[i] < tmp)
				swap(v[i],v[j++]);
		}
		swap(v[j], v[end-1]);
		quicksort(v, beg, j - 1);
		quicksort(v, j+1, end);
	}
}