几种常用排序(冒泡插入希尔快排归并)

几种常用排序(冒泡插入希尔快排归并)

冒泡法（沉底法）

• 简介：简单排序中第一个学习的算法，入门必学算法。
• 效率：非常低。当数据达到一定数量级时，排序时间非常长。
• 原理：每一个元素和其他元素比较，符合条件就交换位置，不符合条件则不操作。
• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(1)$
• 稳定性：稳定
• 代码实现：

bubble_Sort(int *a,int len)
{
	int i, j;
	int tmp;
	for ( i = 0; i < len; ++i)
	{
		for ( j = 0; j < len - i; ++j)
		{
			if (a[j] < a[j + 1])
			{
				tmp = a[j];
				a[j] = a[j + 1];
				a[j + 1] = tmp;
			}
		}
	}
}

插入法

• 简介：简单排序的一种。
• 效率：非常低，排序效率和冒泡法差不多。
• 原理：从第二个元素开始，记录该元素值，循环和前面的元素比较，符合条件则插入，不符合则继续与更前面的一个元素比，若循环结束都没找到符合条件的，则直接插入最前面。
• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(1)$
• 稳定性：稳定
• 代码实现：

void insert_Sort(int *a, int len)
{
	
	int tmp;
	int j;
	for (int i = 1; i < len; ++i)
	{
		tmp = a[i];
		j = i - 1;
		while (j >= 0 && a[j] > tmp)
		{
			a[j+1] = a[j];
			j--;
		}
		a[j + 1] = tmp;
	}
}

希尔排序

• 简介：高级排序的一种，插入法优化版，将数组按增量分组后再按插入法排序。
• 效率：较高
• 代码实现：

//希尔排序
void shell_sort(int *a, int len)
{
	int inc = len;
	while (inc > 1)
	{
		inc = inc / 3 + 1;
		//把数组根据增量分组,然后遍历每一组
		int i;
		for (i = 0; i < inc; ++i)
		{//对每组执行插入排序
			int j;
			for (j = i + inc; j < len; j += inc)
			{
				int tmp = a[j];
				int k = j - inc;
				while (k >= 0 && tmp < a[k])
				{
					a[k + inc] = a[k];
					k -= inc;
				}
				a[k + inc] = tmp;
			}
		}
	}
}

快速排序

• 简介：所有排序中速度最快的，但不稳定，递归实现。
• 效率：很高。
• 原理：取出左边第一个元素为tmp，1、右边倒序与tmp比较（小于tmp放左边取出元素的位置（进入循环2）），不符合则继续循环1；2、随即从左边按顺序与tmp比较，大于tmp的放右边取出元素的位置。1、2轮换进行循环。然后递归排序tmp左边和右边部分。左边和右边下标值相等或左边大于右边，则return。
• 时间复杂度：$O(n log_2 n)$
• 空间复杂度：$O(n log_2 n)$
• 稳定性：不稳定
• 代码实现：

//快速排序
void QuickSort(int *arr, int start, int end)
{
	if (start >= end)
		return;
	int i = start;
	int j = end;
	int tmp = arr[i];
	while (i < j)
	{
		while (i < j&&arr[j] >= tmp)
		{
			--j;
		}
		if (i<j&&tmp>arr[j])
		{
			arr[i] = arr[j];
			i++;
		}
		while (i < j&&i < j&&arr[i] <= tmp)
		{
			++i;
		}
		if (i < j&&arr[i] > tmp)
		{
			arr[j] = arr[i];
			j--;
		}
	}
	arr[i] = tmp;
	QuickSort(arr, start, i - 1);
	QuickSort(arr, i + 1, end);
}

归并排序

• 简介：稳定的排序中效率最高的，递归实现。
• 效率：很高。
• 原理：归并操作的工作原理如下：
  • 第一步：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
  • 第二步：设定两个指针，最初位置分别为两个已经排序序列的起始位置
  • 第三步：比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
  • 重复步骤3直到某一指针超出序列尾
  • 将另一序列剩下的所有元素直接复制到合并序列尾
• 时间复杂度：$O(n log_2 n)$
• 空间复杂度：$O(n)$
• 稳定性：稳定
• 代码实现：

//归并排序辅助函数
void Merge(int *a, int start, int mid, int end, int *tmp)
{
	int i = start;
	int j = mid + 1;
	int k = 0;
	while (i <= mid&&j <= end)
	{
		if (a[i] < a[j])
		{
			tmp[k++] = a[i++];
		}
		else
		{
			tmp[k++] = a[j++];
		}
	}
	while (i <= mid)
	{
		tmp[k++] = a[i++];
	}
	while (j <= end)
	{
		tmp[k++] = a[j++];
	}
	for (int i = 0; i < k; ++i)
	{
		a[start + i] = tmp[i];
	}
}
//归并排序接口
void MergeSort(int *arr, int start, int end, int *tmp)
{
	if (start == end)
	{
		return;
	}
	int mid = (start + end) / 2;
	MergeSort(arr, start, mid, tmp);
	MergeSort(arr, mid + 1, end, tmp);
	Merge(arr, start, mid, end, tmp);
}