排序之简单排序的整理

最新推荐文章于 2020-04-16 17:12:33 发布

原创最新推荐文章于 2020-04-16 17:12:33 发布 · 232 阅读

CC 4.0 BY-SA版权

文章标签：

1.排序的概念
排序：所谓排序就是使一串记录，按照其中的某个或者某些关键字的大小，递增或者递减起来的操作。
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程中的要求不能在内外存之间移动数据的排序。
稳定性：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
常见的排序算法：

2.常见的排序算法
2.1插入排序
2.1.1直接插入排序
基本思想：直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。
排序展示：
初始： 5 2 4 6 1 3
第一趟：2 5 4 6 1 3
第二趟：2 4 5 6 1 3
第三趟：2 4 5 6 1 3
第四趟：1 2 4 5 6 3
第五趟：1 2 3 4 5 6
代码实现：

//直接插入排序
//有序区间：[0,i)
//无序区间：[i,size)
void insertSort(int array[], int size)
{
	for (int i = 0; i < size; i++)
	{
		int j = 0 ;
		int k = array[i];
		for (j = i - 1; k < array[j] && j >= 0; j--)
		{
			array[j + 1] = array[j];
		}
		array[j + 1] = k;
	}
}

直接插入排序的特性总结：

元素集合越接近有序，直接插入排序算法的时间效率越高
时间复杂度：最坏情况下：O(N^2) 最好情况下：O(N)
空间复杂度：O(1)，它是一种稳定的排序算法
稳定性：稳定
2.1.2希尔排序
基本思想：先选定一个整数，把待排序文件中所有记录分成个组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
排序展示：

代码实现：

//希尔排序
void shellSort(int array[], int size)
{
	int gap = size;
	while (1)
	{
		gap = gap / 3 + 1;
		for (int i = 0; i < size; i++)
		{
			int j ;
			int k = array[i];
			for (j = i - gap; j >= 0 && k < array[j]; j-=gap)
			{
				array[j + gap] = array[j];
			}
			array[j + gap] = k;
		}
		if (gap == 1)
		{
			break;
		}
	}
}

希尔排序的特性总结：
1.希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。
3. 希尔排序的时间复杂度：最坏情况下：O(N^2)
平均时间复杂度： O(N^1.3—N2）
4. 稳定性：不稳定
2.2 选择排序
2.2.1 直接选择排序
基本思想：每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
排序展示：
在这里插入图片描述
代码实现：

//直接选择排序
//有序区间[size-i,size-1)
//无序区间[0,size-i)
void selectSort(int array[],int size)
{
	for (int i = 0; i < size; i++)
	{
		int max = 0;
		for (int j = 0; j < size - i; j++)
		{
			if (array[j]>array[max])
			{
				max = j;
			}
		}
		int t = array[max];
		array[max] = array[size - 1 - i];
		array[size - 1 - i] = t;

	}
}

直接选择排序的特性总结：1. 时间复杂度：O(N^2)
2. 空间复杂度：O(1)
3. 稳定性：不稳定
2.2.2 堆排序
基本思想：堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。排升序要建大堆，排降序建小堆。
排序展示：
在这里插入图片描述
代码实现：

//堆排序
//1.建大堆
void swap(int *a, int *b) {
	int t = *a;
	*a = *b;
	*b = t;
}

void heapify(int array[], int size, int index)
{
	int left = 2 * index + 1;
	int right = 2 * index + 2;
	if (left >= size)
	{
		return;
	}
	int max = left;
	if (right < size &&array[right] > array[left])
	{
		max = right;
	}
	if (array[index] >= array[max])
	{
		return;
	}
	int t = array[max];
	array[max] = array[index];
	array[index] = t;

	index = max;
	heapify(array, size, max);
}
void createHeap(int array[], int size)
{
	for (int i = (size - 2) / 2; i >= 0; i--)
	{
		heapify(array, size, i);
	}
}
void heapSort(int array[], int size)
{
	createHeap(array, size);
	for (int i = 0; i < size; i++)
	{
		int t = array[0];
		array[0] = array[size - i-1];
		array[size - 1 - i] = t;
		heapify(array, size - i - 1, 0);
	}
}

堆排序的特性总结：

时间复杂度：O(N*logN)
空间复杂度：O(1)
稳定性：不稳定

2.3 交换排序
基本思想：所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。
2.3.1 冒泡排序
基本思想：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。
排序展示：
初始： 5 2 4 6 1 3
第一趟：2 4 5 1 3 6
第二趟：2 4 1 3 5 6
第三趟：2 1 3 4 5 6
第四趟：1 2 3 4 5 6
代码实现：

void bubbleSort(int a[], int size) {
	// 把最大的数冒泡到最后去
	for (int i = 0; i < size; i++) {
		int sorted = 1;//优化
		for (int j = 0; j < size - i - 1; j++) 
		{
			if (a[j] > a[j + 1])
			{
				int t = a[j];
				a[j] = a[j + 1];
				a[j + 1] = t;
				sorted = 0;
			}
		}
		if (sorted == 1) {
			break;
		}
	}
}

冒泡排序的特性总结： 1. 时间复杂度：最坏情况下：O(N^2) 最好情况下：O(N)
2. 空间复杂度：O(1)
3. 稳定性：稳定
2.3.2 快速排序
基本思想：任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。
排序展示：
在这里插入图片描述
代码实现：

//快速排序
//前后指针法
int partition(int array[], int left, int right) {
	 //[left, div) 比基准小
	 //[div, i) 比基准值大于等于
	int div = left;
	int i = left;
	for (; i < right; i++) 
	{
		if (array[i] < array[right]) 
		{
			int t = array[i];
            array[i] = array[div];
            array[div] = t;
            div++;
		}
	}

	int temp = array[div];
    array[div] = array[right];
    array[right] = temp;
	return div;
}
void quickSort(int array[], int left,int right)
{
	if (left >= right)
	{
		return;
	}
	int index = partition(array, left, right);
	//分治左右两个小区间
	quickSort(array, left, index - 1);
	quickSort(array, index + 1, right);
}

快速排序的特性总结：
2. 时间复杂度：最好情况下：O(N*logN) 最坏情况下：O(N^2)
3. 空间复杂度：O(logN)
4.稳定性：不稳定
2.4 归并排序
基本思想：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
排序展示：
在这里插入图片描述
代码实现：

//归并排序
void merge(int array[], int temp[], int left, int m, int right)//合并两个有序序列
{
	int leftend = m - 1;
	int p = left, i;
	int num = right - left + 1;
	while (left <= leftend&&m <= right)
	if (array[left] <= array[m])
		temp[p++] = array[left++];
	else
		temp[p++] = array[m++];
	while (left <= leftend)
		temp[p++] = array[left++];
	while (m <= right)
		temp[p++] = array[m++];
	for (i = 0; i<num; i++, right--)
		array[right] = temp[right];
}
void m_Sort(int array[], int temp[], int left, int right)
{
	int mid;
	if (left<right)
	{
		mid = (left + right) / 2;
		m_Sort(array, temp, left, mid);
		m_Sort(array, temp, mid + 1, right);
		merge(array, temp, left, mid + 1, right);
	}
}
void mergeSort(int array[], int size)
{
	int *temp = (int *)malloc(size*sizeof(int));
	if (!temp)
	{
		return;
	}
	m_Sort(array, temp, 0, size - 1);
	free(temp);
}

归并排序的特性总结：
4. 归并排序更多的是解决在磁盘中的外排序问题。
5. 时间复杂度：O(N*logN)
6. 空间复杂度：O(N)
7. 稳定性：稳定
2.3 非比较排序
2.3.1计数排序
基本思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。
操作步骤： 1. 统计相同元素出现次数 2. 根据统计的结果将序列回收到原来的序列中
计数排序的特性总结： 1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度：O(MAX(N,范围))
3. 空间复杂度：O(范围)
4. 稳定性：稳定
2.3.2基数排序—多关键码排序（桶排序）
操作步骤：1.以当前位桶的编号，将数据放在对应的桶中
2.按照编号从小到大对每个桶中的元素进行回收。
基数排序的特性总结： 1. 基数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度：O(MAX(N,范围))
3. 空间复杂度：O(范围)
4. 稳定性：稳定