常见的几种排序算法

（1）冒泡排序法：

时间复杂度：O(n^2) 空间复杂度： O(1) 稳定性：稳定

void BubbbleSort(int *arr, int n)
{
	int i, j;

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

（2）改进冒泡排序法：

时间复杂度：O(n^2) 空间复杂度： O(1) 稳定性：稳定

void BubbbleSort(int *arr, int n)
{
	int i, j;

	for (i = 0; i < n - 1; i++) 
	{
		bool swapFlag = false;

		for (j = 0; j < n - 1 - i; j++) 
		{
			if (arr[j] > arr[j+1])
			{
				int temp;
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
				swapFlag = true;
			}
		}
		if (!swapFlag)
		{
			break;
		}
	}	
}

（3）选择排序法：

时间复杂度：O(n^2) 空间复杂度： O(1) 稳定性：不稳定

void SelectSort(int *arr, int n)
{
	int i, j, k;

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

（4）插入排序法：

时间复杂度：O(n^2) 空间复杂度： O(1) 稳定性：稳定

void InsertSort(int *arr, int n)
{
	int i, j, key;

	for (i = 1; i < n; i++)
	{
		j = i - 1;
		key = arr[i];
		while (j >= 0 && arr[j] > key)
		{
			arr[j+1] = arr[j];
			j--;
		}
		arr[j+1] = key;
	}
}

（5）希尔排序法：

时间复杂度：O(nlgn)~O(n^2) 空间复杂度： O(1) 稳定性：不稳定

void ShellSort(int *arr, int n)
{
	int i, j, step, key;

	for (step = n / 2; step > 0; step /= 2) 
	{
		for (i = step; i < n; i += step)
		{
			j = i - step;
			key = arr[i];
			while (j >= 0 && arr[j] > key)
			{
				arr[j+step] = arr[j];
				j -= step;
			}
			arr[j+step] = key;
		}
	}
}

（6）快速排序法：

时间复杂度：最好：O(nlgn) 最差：O(n^2) 平均：O(nlgn) 空间复杂度： O(lgn) 稳定性：不稳定

void QuickSort(int *arr, int n)
{
	int i, j;
	int val;

	i = 0;
	j = n - 1;
	val = arr[0];

	if (n > 1)
	{
		while (i < j)
		{
			for ( ; j > i; j--)
			{
				if (arr[j] < val)
				{
					arr[i++] = arr[j];
					break;
				}
			}

			for ( ; i < j; i++) 
			{
				if (arr[i] > val) 
				{
					arr[j--] = arr[i];
					break;
				}
			}
		}
		arr[i] = val;
		QuickSort(arr, i);
		QuickSort(arr + i + 1, n - i - 1);
	}
}

（7）归并排序法：

时间复杂度：O(nlgn) 空间复杂度： O(n) 稳定性：稳定

void MergeSortCore(int *arr, int first, int last, int *p);
void MergeSortArray(int *arr, int first, int mid, int last, int *p);

void MergeSort(int *arr, int n)
{
	int *p = new int[n];

	MergeSortCore(arr, 0, n - 1, p);

	delete[] p;
}

void MergeSortCore(int *arr, int first, int last, int *p)
{
	int mid;

	if(first < last)
	{
		mid = (first + last) / 2;
		MergeSortCore(arr, first, mid, p);
		MergeSortCore(arr, mid + 1, last, p);
		MergeSortArray(arr, first, mid, last, p);
	}
}

void MergeSortArray(int *arr, int first, int mid, int last, int *p)
{
	int i, j, m, n, k;

	i = first;
	j = mid + 1;
	m = mid;
	n = last;
	k = 0;

	while(i <= m && j <= n)
	{
		if(arr[i] <= arr[j]) 
		{
			p[k++] = arr[i++];
		}
		else 
		{
			p[k++] = arr[j++];
		}
	}

	while (i <= m) 
	{
		p[k++] = arr[i++];
	}

	while (j <= n) 
	{
		p[k++] = arr[j++];
	}

	for(i = 0; i < k; i++) 
	{
		arr[first+i] = p[i];
	}
}

（8）堆（最大堆）排序法：

时间复杂度：O(nlgn) 空间复杂度： O(1) 稳定性：不稳定

void HeapAdjust(int *arr, int i, int n);

void HeapSort(int *arr, int n)
{
	int i;

	for (i = n / 2 - 1; i >= 0; i--)
		HeapAdjust(arr, i, n);

	for(i = n - 1; i > 0; i--)
	{
		int temp;
		temp = arr[0];
		arr[0] = arr[i];
		arr[i] = temp;

		HeapAdjust(arr, 0, i);
	}
}

void HeapAdjust(int *arr, int i, int n)
{
	int nChild;

	for ( ; 2 * i + 1 < n; i = nChild)
	{
		nChild = 2 * i + 1;
		if(nChild < n - 1 && arr[nChild] < arr[nChild+1]) 
		{
			++nChild;
		}

		if (arr[i] < arr[nChild])
		{
			int temp;
			temp = arr[i];
			arr[i] = arr[nChild];
			arr[nChild] = temp;
		}
		else 
		{
			break;
		}
	}
}