各种排序算法及其优劣

排序算法优劣的衡量标准
时间代价(最大时间代价，最小时间代价，平均时间代价)：记录的移动和比较次数

空间代价,算法自身的复杂程度

1. 直接插入排序：空间代价O(1)；时间代价O(n^2)；该稳定排序。

int InsertSort(int arr[], int n)
{
	int temp = 0;
	int j = 0;
	for (int i = 1; i < n; i++)
	{
		temp = arr[i];   //待插入元素赋值给temp
		j = i - 1;  //从当前位置往前寻找i的正确位置
		while (j >= 0 && arr[j]>temp)
		{
			arr[j + 1] = arr[j];
			i--;
		}
		arr[i + 1] = temp;
	}
	return 0;
}

2. 折半插入排序：用二分法查找第i个记录的正确位置元素预先有序,时间复杂度O(n^2)，该排序算法稳定。

int biInsertSort(int arr[], int n)
{
	int left = 0, right = 0, mid = 0;
	int p = 0;
int ShellSort(int arr[], int n)
{
	int d = n / 2;   //增量为数组大小的一半
	while (d >= 1)
	{
		for (int k = 0; k < d; k++)
		{
			for (int i = k + d; i < n; i += d)
			{
				int temp = arr[i];
				int j = i - d;
				while (j >= k&&arr[j]>temp)
				{
					arr[j + d] = arr[j];
					j -= d;
				}
				arr[j + d] = temp;
			}
		}
		d = d / 2;
	}
	return 0;
}


for (p = 1; p < n; p++){int temp = arr[p]; //保存待插入数据left = 0;right = p - 1;while (left <= right){mid = (left + right) / 2;if (arr[mid]>temp)right = mid - 1;elseleft = mid + 1;}for (int i = p - 1; i >= left; i--)arr[i + 1] = arr[i];arr[left] = temp;}return 0;}






3. 希尔排序：先将序列转化为若干小序列，在小序列内进行插入排序，然后逐渐扩大小序列的规模

减少序列个数，最终对整个序列进行插入排序完成排序

不稳定，空间代价：O(1);时间代价O(n)到O(n^2)，视增量序列而定
int ShellSort(int arr[], int n)
{
	int d = n / 2;   //增量为数组大小的一半
	while (d >= 1)
	{
		for (int k = 0; k < d; k++)
		{
			for (int i = k + d; i < n; i += d)
			{
				int temp = arr[i];
				int j = i - d;
				while (j >= k&&arr[j]>temp)
				{
					arr[j + d] = arr[j];
					j -= d;
				}
				arr[j + d] = temp;
			}
		}
		d = d / 2;
	}
	return 0;
}


4. 改进的冒泡排序

稳定性：稳定   空间代价分析：O(1)  时间代价分析：O(n^2)

int BubbleSort(int arr[], int n)
{
	int flag = 0;   //标记每一趟排序过程中是否发生了交换
	for (int i = 0; i < n; i++)
	{
		flag = 0;
		for (int j = 0;j < n - i; j++)
		{
			if (arr[j] < arr[j - 1])
			{
				flag = 1;
				int temp = arr[j];
				arr[j] = arr[j - 1];
				arr[j - 1] = temp;
			}
		}
		if (flag == 0)
			return 0;
	}
	return 0;
}




5. 快速排序（分治法）

平均时间空间代价均为：O(log(n))
int Partition(int arr[], int left, int right)
{
	int pivot = arr[left];   //选择最左边的为轴元素
	while (left < right)
	{
		while (left<right&&arr[right]>pivot)
			right--;
		arr[left] = arr[right];
		while (left<right&&arr[left]<=pivot)
			left++;
		arr[right] = arr[left];
	}
	arr[left] = pivot;
	return left;
}
void QuickSort(int arr[], int left, int right)
{
	if (left < right)
	{
		int p = Partition(arr, left, right);
		QuickSort(arr, left, p - 1);
		QuickSort(arr, p + 1, right);
	}
}



6. 选择排序

int SelectionSort(int arr[], int n)

{

for (int i = 1; i < n; i++)

{

int k = i - 1;

for (int j = i; j < n; j++)

{

if (arr[j] < arr[j])

k = j;

}

if (k != i - 1)

{

int t = arr[k];

arr[k] = arr[i - 1];

arr[i - 1] = t;

}

}

return 0;

}