基础练习 数列排序

目录

问题描述　

一、sort排序：

二、冒泡排序

三、选择排序

四、插入排序

五、希尔排序（缩小增量排序）

六、归并排序

七、快速排序

八、堆排序

九、二叉树排序

十、计数排序

十一、桶排序

十二、基数排序

以上排序算法的比较和分析

---

问题描述　

　给定一个长度为n的数列，将这个数列按从小到大的顺序排列。1<=n<=200

输入格式

　　第一行为一个整数n。
　　第二行包含n个整数，为待排序的数，每个整数的绝对值小于10000。

输出格式

　　输出一行，按从小到大的顺序输出排序后的数列。

样例输入

5
8 3 6 4 9

样例输出

3 4 6 8 9

 

一、sort排序：

更多信息可借鉴（介绍的很全面）：https://blog.csdn.net/weixin_42617472/article/details/83748991

#include <iostream>
#include <vector>
#include <functional>
#include <algorithm> 
using namespace std; 
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char** argv) {
	int n;
	cin>>n;
	
	vector<int> arr;
	int num;
	for(int i = 0; i < n; i++)
	{
		cin>>num;
		arr.push_back(num);
	}
	sort(arr.begin(), arr.end());//up
	for(int i = 0; i < n; i++)
	{
		cout<<arr[i]<<" ";
	}
	
	return 0;
}

二、冒泡排序

1. 比较相邻的元素，如果前一个比后一个大，就把它们两个调换位置。
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

    分类 -------------- 内部比较排序
    数据结构 ---------- 数组
    最差时间复杂度 ---- O(n^2)
    最优时间复杂度 ---- 如果能在内部循环第一次运行时,使用一个旗标来表示有无需要交换的可能,可以把最优时间复杂度降低到O(n)
    平均时间复杂度 ---- O(n^2)
    所需辅助空间 ------ O(1)
    稳定性 ------------ 稳定

#include <iostream>
using namespace std;
 
void BubbleSort(int arr[], int n)
{
	int temp;

        // 外层循环控制循环次数，n个数，n-1对 ，最多n-1次
	for(int i = 0; i < n-1; i++)
	{
		// 内层循环控制比较范围
		for(int j = 0; j < n - 1 - i; j++)
		{
                        //依次比较相邻的两个元素,使较大的那个向后移
			if(arr[j] > arr[j+1])
			{
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
	}
 } 
 
int main(int argc, char** argv) {
	int n;
	cin>>n;
	
	int arr[n];
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
	}
	//冒泡排序 
	BubbleSort(arr,n);
	for(int i = 0; i < n; i++)
	{
		cout<<arr[i]<<" ";
	}
	return 0;
}

 

三、选择排序

算法过程：初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

 分类 -------------- 内部比较排序
 数据结构 ---------- 数组
 最差时间复杂度 ---- O(n^2)
 最优时间复杂度 ---- O(n^2)
 平均时间复杂度 ---- O(n^2)
 所需辅助空间 ------ O(1)
 稳定性 ------------ 不稳定

#include <iostream>
using namespace std;

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

void selectSort(int arr[], int n)
{
	int temp,min;
	for(int i = 0; i < n-1; i++)
	{//i为已排序序列的末尾 
		min = i;
		for(int j = i+1; j < n; j++)//未排序序列 
		{
			if(arr[j] < arr[min])//寻找未排序序列的最小值
			{
				min = j; 
			} 
		}
		if(min != i)
		{//将第i小值放在末尾，该操作也说明选择排序算法不稳定 
			temp = arr[i];
			arr[i] = arr[min];
			arr[min] = temp;
		}
	}
 } 

int main(int argc, char** argv) {
	int n;
	cin>>n;
	
	int arr[n];
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
	}
	//选择排序 
	selectSort(arr,n);
	for(int i = 0; i < n; i++)
	{
		cout<<arr[i]<<" ";
	}
	return 0;
}

四、插入排序

算法：

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

 分类 ------------- 内部比较排序
 数据结构 ---------- 数组
 最差时间复杂度 ---- 最坏情况为输入序列是降序排列的,此时时间复杂度O(n^2)
 最优时间复杂度 ---- 最好情况为输入序列是升序排列的,此时时间复杂度O(n)
 平均时间复杂度 ---- O(n^2)
 所需辅助空间 ------ O(1)
 稳定性 ------------ 稳定

#include <iostream>
using namespace std;

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

void insertSort(int arr[], int n)
{
	int current;
	for(int i = 1; i < n; i++)
	{
		current = arr[i];
		int j = i - 1;
		while(j >= 0 && arr[j] > current)
		{
			arr[j+1] = arr[j];
			j--;
		}
		arr[j+1] = current;
	}
 } 

int main(int argc, char** argv) {
	int n;
	cin>>n;
	
	int arr[n];
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
	}
	//插入排序 
	insertSort(arr,n);
	for(int i = 0; i < n; i++)
	{
		cout<<arr[i]<<" ";
	}
	return 0;
}

五、希尔排序（缩小增量排序）

 思想：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序。

1. 增量h与n的关系：3*h+1 <= n ，并按此规律递减

2. 对于某个增量h,存在一组数据组成的子序列，进行插入排序

3. 当h = 1时，就成为直接插入排序，此时数据已经基本有序。

当n较小时，直接插入排序速度较快，当n较大时，希尔排序更具有优势。

希尔排序是不稳定的排序算法。

 代码：

#include <iostream>
using namespace std;

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

void shellSort(int arr[], int n)
{
	int h = 1;
	while(h <= n)//生成初始增量 
	{
		h = 3*h + 1;
	}
	while(h >= 1)
	{
		for(int i = h; i < n; i++)
		{
			int j = i - h;
			int get = arr[i];
			while(j >= 0 && arr[j]