排序算法合集(简单选择排序，插入排序，希尔排序，堆排序，冒泡排序，快速排序

已于 2022-06-09 15:52:25 修改
阅读量387 收藏 3
点赞数
分类专栏： 数据结构与算法 文章标签： c语言 算法 数据结构 c++
于 2022-06-09 15:27:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hanghang924/article/details/125204272
版权

1.插入排序

插入排序是每次将一个数插入到前面已经排好序的部分中

实现代码:

void InsertSort(vector<int> &nums) {
	cout << "插入排序" << endl;
	int i, j, temp;
	for (i = 1; i < nums.size(); i++) {
		if (nums[i] < nums[i - 1]) {
			temp = nums[i];
			for (j = i - 1; j >= 0 && nums[j] > temp; j--) {
				nums[j + 1] = nums[j];
			}
			nums[j+1] = temp;
		}
		PrintNums(nums);
	}
}

 时间复杂度:

最好情况(原本全部有序） O(n)

最坏情况(逆序)  o(n2)

平均时间复杂度o(n2)

稳定性:稳定

优化思路:

可以将插入位置的搜索改为二分查找

2.希尔排序

将原来序列分成多个子表，不断对子表进行插入排序。缩小子表中元素的间距直到d=1时停止

实现代码

void ShellSort(vector<int>& nums) {
	cout << "希尔排序" << endl;
	vector<int> dNums = { 5,3,1 };
	int i,j,temp;
	for (int d : dNums) {
		for (i = d; i < nums.size(); i++) {
			if (nums[i] < nums[i - d]) {
				temp = nums[i];
				for (j = i - d; j >= 0 && temp < nums[j]; j -= d) {
					nums[j + d] = nums[j];
				}
				nums[j + d] = temp;
			}
			PrintNums(nums);
		}
	}

 时间复杂度：与增量序列d有关，最坏为o(n2)

稳定性：不稳定

3.快速排序

在待排序表中取数枢轴元素，通过一趟排序将原表划分成为左边小于枢轴右边大于枢轴的两部分。然后分别递归地对两个子表重复上述过程。

代码:

int Partition(vector<int>& nums, int low, int high) {
	int pivot = nums[low];
	while (low < high) {
		while (low < high && nums[high] >= pivot) --high;
		nums[low] = nums[high];
		while (low < high && nums[low] <= pivot) ++low;
		nums[high] = nums[low];
	}
	nums[low] = pivot;
	return low;
}
void QuickSort(vector<int>& nums,int low,int high) {
	PrintNums(nums);
	if (low < high) {
		int pivot = Partition(nums, low, high);
		QuickSort(nums, low, pivot - 1);
		QuickSort(nums, pivot + 1, high);
	}
}

 时间复杂度:

最好O(nlog2n)

最坏O(n2)

空间复杂度

最好o(log2n)

最坏o(n)

稳定性

不稳定

4.简单选择排序

在每一轮的排序元素中选择最小的加入有序子序列

代码

void EasySort(vector<int>& nums) {
	cout << "简单选择排序" << endl;
	int temp;
	for (int i = 0; i < nums.size()-1; i++) {
		int min = i;
		for (int j = i+1; j < nums.size(); j++) {
			if (nums[j] < nums[min]) {
				min = j;
			}
		}
		swap(nums[i], nums[min]);
		PrintNums(nums);
	}
}

时间复杂度o(n2)

稳定性：不稳定

优化:每一轮排序中同时选择最小的和最大的元素

void EasySort2(vector<int>& nums) {
	cout << "简单选择排序2" << endl;
	int i, j, min, max;
	for(i = 0 ; i < nums.size()-1-i;i++){
		min = max = i;
		for (j = i + 1; j < nums.size() - i; j++) {
			if (nums[j] < nums[min]) min = j;
			else if (nums[j] > nums[max]) max = j;
		}
		if (min != i) {
			Swap(nums[min], nums[i]);
		}
		if (max != nums.size() - i - 1) {
			if (max==i) Swap(nums[min],nums[nums.size()-i-1]);
			else Swap(nums[max], nums[nums.size() - i - 1]);
		}
	}
	PrintNums(nums);
}

5.堆排序

建立大根堆，每一趟选出堆顶元素加入序列

void HeapAdjust(vector<int>& nums, int k,int len) {
	int temp = nums[k];
	for (int i = 2 * k; i < len; i *= 2) {
		if (i < len - 1 && nums[i] < nums[i + 1]) i++;
		if (temp >= nums[i]) break;
		else {
			nums[k] = nums[i];
			k = i;
		}
	}
	nums[k] = temp;
}
void BuildMaxHeap(vector<int>& nums) {
	for (int i = nums.size()/ 2; i >= 0; i--)
		HeapAdjust(nums, i,nums.size());
}
void HeapSort(vector<int>& nums) {
	cout << "堆排序" << endl;
	BuildMaxHeap(nums);
	for (int i = nums.size() - 1; i > 0; i--) {
		swap(nums[i], nums[0]);
		HeapAdjust(nums, 0,i);
		PrintNums(nums);
	}
}

时间复杂度 o(nlog2n),不稳定

6.冒泡排序

这个不单独写了看下面的总代码吧

总代码:

#include<iostream>
#include<vector>
using namespace std;
void PrintNums(vector<int> nums) {
	for (int i = 0; i < nums.size(); i++) {
		cout << nums[i] << " ";
	}
	cout << endl;
}
void Swap(int& a, int& b) {
	int temp;
	temp = a;
	a = b;
	b = temp;
}
void InsertSort(vector<int> &nums) {
	cout << "插入排序" << endl;
	int i, j, temp;
	for (i = 1; i < nums.size(); i++) {
		if (nums[i] < nums[i - 1]) {
			temp = nums[i];
			for (j = i - 1; j >= 0 && nums[j] > temp; j--) {
				nums[j + 1] = nums[j];
			}
			nums[j+1] = temp;
		}
		PrintNums(nums);
	}
}
void ShellSort(vector<int>& nums) {
	cout << "希尔排序" << endl;
	vector<int> dNums = { 5,3,1 };
	int i,j,temp;
	for (int d : dNums) {
		for (i = d; i < nums.size(); i++) {
			if (nums[i] < nums[i - d]) {
				temp = nums[i];
				for (j = i - d; j >= 0 && temp < nums[j]; j -= d) {
					nums[j + d] = nums[j];
				}
				nums[j + d] = temp;
			}
			PrintNums(nums);
		}
	}
}
int Partition(vector<int>& nums, int low, int high) {
	int pivot = nums[low];
	while (low < high) {
		while (low < high && nums[high] >= pivot) --high;
		nums[low] = nums[high];
		while (low < high && nums[low] <= pivot) ++low;
		nums[high] = nums[low];
	}
	nums[low] = pivot;
	return low;
}
void QuickSort(vector<int>& nums,int low,int high) {
	PrintNums(nums);
	if (low < high) {
		int pivot = Partition(nums, low, high);
		QuickSort(nums, low, pivot - 1);
		QuickSort(nums, pivot + 1, high);
	}
}
void EasySort(vector<int>& nums) {
	cout << "简单选择排序" << endl;
	int temp;
	for (int i = 0; i < nums.size()-1; i++) {
		int min = i;
		for (int j = i+1; j < nums.size(); j++) {
			if (nums[j] < nums[min]) {
				min = j;
			}
		}
		swap(nums[i], nums[min]);
		PrintNums(nums);
	}
}
void EasySort2(vector<int>& nums) {
	cout << "简单选择排序2" << endl;
	int i, j, min, max;
	for(i = 0 ; i < nums.size()-1-i;i++){
		min = max = i;
		for (j = i + 1; j < nums.size() - i; j++) {
			if (nums[j] < nums[min]) min = j;
			else if (nums[j] > nums[max]) max = j;
		}
		if (min != i) {
			Swap(nums[min], nums[i]);
		}
		if (max != nums.size() - i - 1) {
			if (max==i) Swap(nums[min],nums[nums.size()-i-1]);
			else Swap(nums[max], nums[nums.size() - i - 1]);
		}
	}
	PrintNums(nums);
}
void HeapAdjust(vector<int>& nums, int k,int len) {
	int temp = nums[k];
	for (int i = 2 * k; i < len; i *= 2) {
		if (i < len - 1 && nums[i] < nums[i + 1]) i++;
		if (temp >= nums[i]) break;
		else {
			nums[k] = nums[i];
			k = i;
		}
	}
	nums[k] = temp;
}
void BuildMaxHeap(vector<int>& nums) {
	for (int i = nums.size()/ 2; i >= 0; i--)
		HeapAdjust(nums, i,nums.size());
}
void HeapSort(vector<int>& nums) {
	cout << "堆排序" << endl;
	BuildMaxHeap(nums);
	for (int i = nums.size() - 1; i > 0; i--) {
		swap(nums[i], nums[0]);
		HeapAdjust(nums, 0,i);
		PrintNums(nums);
	}
}
void BubbleSort(vector<int>& nums){
	cout << "冒泡排序" << endl;
	for (int i = 0; i < nums.size()-1; i++) {
		for (int j = 0; j < nums.size() - i -1; j++) {
			if (nums[j] > nums[j + 1]) {
				swap(nums[j], nums[j + 1]);
			}
		}
		PrintNums(nums);
	}
}
void HeapDelete(vector<int>& nums) {
	BuildMaxHeap(nums);
	PrintNums(nums);
	cout << "输入要删除的元素位置(0<i<"<<nums.size()-1<<")" << endl;
	int i;
	cin >> i;
	nums[i] = nums[nums.size() - 1];
	nums.pop_back();
	HeapAdjust(nums, i, nums.size() - 1);
	PrintNums(nums);
}
int main() {
	while (1) {
		vector<int> nums = { 265,301,751,129,937,863,742,694,76,438 };
		int type;
		cout << "(1)简单选择排序(2)堆排序(3)直接插入排序(4)希尔排序（增量分别为5、3、1）(5)冒泡排序(6)快速排序(7)删除堆元素" << endl;
		cin >> type;
		switch (type)
		{
		case 1:
			EasySort2(nums);
			break;
		case 2:
			HeapSort(nums);
			break;
		case 3:
			InsertSort(nums);
			break;
		case 4:
			ShellSort(nums);
			break;
		case 5:
			BubbleSort(nums);
			break;
		case 6:
			QuickSort(nums, 0, nums.size() - 1);
			break;
		case 7:
			cout << "堆删除元素" << endl;
			HeapDelete(nums);
			break;
		default:
			break;
		}
	}
}

Hanghang924
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构排序算法
The_star_is_at的博客
06-23 1090
#include using namespace std; /* 输入一组关键字序列分别实现下列排序: 1.实现简单选择排序、直接插入排序和冒泡排序。 2.实现希尔排序算法。 3.实现快速排序算法。 4.实现堆排序算法。 */ #define Maxsize 100 using namespace std; typedef int KeyType; type
六种内部排序算法比较：直接插入排序、希尔排序、冒泡排序、快速排序、选择排序、堆排序。
12-04
本话题主要探讨六种内部排序算法：直接插入排序、希尔排序、冒泡排序、快速排序、选择排序以及堆排序。这六种排序算法各有优劣，适用于不同的场景，接下来我们将逐一进行详细阐述。 1. **直接插入排序**： 直接...
排序算法（一）冒泡排序，简单选择排序，直接插入排序，希尔排序
gongdileidechouzhu的博客
04-13 930
冒泡排序
2020-09-11
Tiny_code刘的博客
09-14 272
C++实现常用排序算法
【C语言】实现插入排序、选择排序、冒泡排序、希尔排序、归并排序、堆排序、快速排序
m0_62714628的博客
12-23 1695
【C语言】实现插入排序、选择排序、冒泡排序、希尔排序、归并排序、堆排序、快速排序
内排序：冒泡排序、简单选择排序、直接插入排序、希尔排序、堆排序、快速排序介绍及C语言实现
weixin_37515325的博客
05-04 829
排序 (参考大话数据结构第9章，归并排序没有看，快速排序的优化部分没有看) 相关概念： 1.内排序与外排序：根据在排序过程中待排序的记录是否全部被放置在内存中分为内排序和外排序。本文讨论的7种排序算法都是内排序。 2.稳定性：能保证排序前两个相等的数据其在序列中的先后位置顺序与排序后它们两个先后位置顺序相同。即：如，如果Ai==Aj，Ai原来在Aj位置前，排序后Ai仍然是在Aj位置前 冒泡排序： bubbleSort0:最基础版冒泡排序：j从前往后循环，j每循环一次只是将剩下数据中的.
希尔排序，冒泡排序，堆排序等各种排序算法
12-07
本主题将详细探讨希尔排序、冒泡排序、堆排序等经典的排序算法，这些都是数据结构与算法学习中的核心内容，尤其对于北邮数据结构课程来说，理解并掌握这些排序方法至关重要。 1. **插入排序**： 插入排序是一种...
C++实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
在本文中，我们将深入探讨C++实现的八种常见的排序算法，它们分别是插入排序、冒泡排序、选择排序、希尔排序、快速排序、归并排序、堆排序和LST基数排序。这些排序算法在计算机科学中有着广泛的应用，是理解和掌握...
Java实现八个常用的排序算法：插入排序、冒泡排序、选择排序、希尔排序等
09-03
快速排序是一种高效的排序算法，由C.A.R. Hoare在1960年提出。基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分记录继续进行排序，以达到...
c语言实现冒泡排序、希尔排序等多种算法示例
12-31
实现以下排序插入排序O(n^2) 冒泡排序 O(n^2) 选择排序 O(n^2) 快速排序 O(n log n) 堆排序 O(n log n) 归并排序 O(n log n) 希尔排序 O(n^1.25) 1.插入排序 O(n^2) 一般来说，插入排序都采用in-place在数组上实现。...
直接插入排序、希尔排序、起泡排序、快速排序、简单选择排序、堆排序、二路归并排序
11-16
直接插入排序、希尔排序、起泡排序、快速排序、简单选择排序、堆排序、二路归并排序的C++语言实现，亲测可行，二路归并排序未得到预期结果，望指正。
冒泡排序 选择排序 插入排序 快速排序 堆排序 希尔排序的C语言实现
weixin_44033321的博客
09-06 232
平台：VS2019 参考：《大话数据结构》 #include<stdio.h> #define MAXSIZE 10 typedef struct{ int r[MAXSIZE + 1]; /*r[0]用作哨兵或临时变量*/ int length; }SqList; /*交换*/ void swap(SqList* L,int i,int j) { int temp; temp = L->r[i]; L->r[i] = L->r[j]; L
排序算法 | 快排、冒泡、堆排、归并、基数、递归、希尔、计数
qq_44250700的博客
09-26 9872
本文为笔者学习排序算法时整理的学习笔记，包括刷过的练习题目。文中部分题解与图片摘自“牛客网”。因为知识点众多，后续会持续整理更新~
万字总结——常见的八大排序算法（插入排序、希尔排序、选择排序、堆排序、冒泡排序、快速排序、归并排序、计数排序）
最新发布
m0_73900674的博客
09-26 2077
二万字排序总结超详解（图示 + 动图）
图解排序算法(一)之3种简单排序(选择，冒泡，直接插入)
weixin_30920091的博客
10-12 201
排序是数据处理中十分常见且核心的操作，虽说实际项目开发中很小几率会需要我们手动实现，毕竟每种语言的类库中都有n多种关于排序算法的实现。但是了解这些精妙的思想对我们还是大有裨益的。本文简单温习下最基础的三类算法：选择，冒泡，插入。 　　先定义个交换数组元素的函数，供排序时调用 /** * 交换数组元素 * @param arr * @param ...
内部排序：直接插入排序、选择排序、冒泡排序、希尔排序、快速排序、堆排序、归并排序代码实现（C语言）
知且行的博客
02-13 1251
#include<stdio.h> #include<stdlib.h> #include<math.h> //直接插入排序 //排序思想：从第二个元素开始，寻找合适的位置存放该元素，一趟排完 void DinsertSort(int array[],int n){ for(int i=1;i<n;i++){//从1开始 int temp=a...
排序算法-冒泡、选择、堆、插入、归并、快速、希尔
伟庭的博客
08-15 700
排序算法-冒泡、选择、堆、插入、归并、快速、希尔
排序算法(直接插入、折半插入、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数类排序)
热门推荐
xjtuse123的博客
08-16 1万+
目录 一、概述 二、算法复杂度 三、插入类排序 1.直接插入排序 2.折半插入排序 3.希尔排序 四、交换类排序 1.冒泡排序 2.快速排序 五、选择类排序 1.简单选择排序 2.堆排序 六、归并排序 1.二路归并排序 七、基数排序 1.基数...
【排序算法】直接插入排序、希尔排序、冒泡排序、快速排序、归并排序
学无止境
05-16 1420
直接插入排序 、快速排序随机选择pivot 、插入排序基本思想实现算法分析希尔排序基本思想程序算法分析 注：本文实现升序排序 直接插入排序 基本思想 基本思想：保持左端的数字是有序的，将未进行操作过的右端的数字 value 与左端的进行比较，如果 左端 > value，则进行交换，重复进行比较，直到左端 < value 或者 value 到达最左端，重复相同的操作，直到所有的数字完成排序
经典排序算法详解：冒泡、插入、选择到堆排序
本文档是MoreWindows在研一期间整理的关于七大常用排序算法的白话讲解，主要包括冒泡排序、直接插入排序、直接选择排序、希尔排序、归并排序、快速排序和堆排序。这些算法是计算机科学中的基础知识，对于理解数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值