常见排序算法之直接插入排序及三种基础算法对比

最新推荐文章于 2023-05-07 20:28:51 发布

Surplus°

最新推荐文章于 2023-05-07 20:28:51 发布

阅读量533

点赞数

分类专栏：算法数据结构文章标签：算法 c++

本文链接：https://blog.csdn.net/weixin_43373833/article/details/107786110

版权

算法同时被 2 个专栏收录

14 篇文章 0 订阅

订阅专栏

数据结构

9 篇文章 1 订阅

订阅专栏

直接插入排序

直接插入排序和冒泡排序、选择排序是3种基础排序算法。前面已经介绍了冒泡排序以及选择排序，下面介绍一下直接插入排序。3种排序方式的时间复杂度都是O(n²)，但是直接插入排序相比前两种排序方式性能更好，直接插入排序更加适合于已经基本有序和数据量较少的情况。插入排序的基本方法是：每一步将一个待排序的元素，按其排序码的大小，插入到前面已经排好序的一组元素的适当位置上去，直到元素全部插入为止。

算法思想

直接插入排序的基本思想是：当插入第i(i >= 1)个元素时，前面的V[0]，V[1]，……，V[i-1]已经排好序。这时，用V[I]的排序码与V[i-1]，V[i-2]，…的排序码顺序依次进行比较，找到合适的插入位置即将V[i]插入，原来位置上的元素向后顺移。应该注意到直接插入排序只是将元素进行顺移，只需要赋值操作即可，而像冒泡排序、选择排序算法需要将元素进行交换。

时间复杂度

最坏时间复杂度O(n²)

直接插入排序代码

void MySort::InsertSort(std::vector<int>& nums)//直接插入排序
{
	int count1 = 0, count2 = 0;
	int numsSize = nums.size();
	for (int i = 0; i < numsSize; i++) {
		int j = i;
		int tmp = nums[i];//记录当前元素,也称为哨兵
		//如果是第一个元素直接插入，如果不是则看之前已经有序的元素是不是比当前的元素大
		while (j > 0 && tmp < nums[j - 1])
		{
			count1++;
			count2++;
			nums[j] = nums[j - 1];//元素后移
			j--;//再向前移动
		}
		count1++;
		nums[j] = tmp;//当前元素插入位置
	}
	std::cout << "比较次数：" << count1 << " 赋值次数：" << count2 << std::endl;
}

直接插入排序测试

#include <iostream>
#include <vector>
#include <cstdlib>//rand(),srand
#include <ctime>//time()
#include "print_data.h"
#include "mysort.h"

using namespace std;
int main()
{
	srand((int)time(NULL));//随机种子
	vector<int> nums,nums1;
	print_data printTest;
	MySort sortTest;
	for (int i = 0; i < 10; i++)
	{
		nums.push_back(rand() % 100);//生成0-99之间的随机数
	}
	/*nums.push_back(1);
	nums.push_back(0);
	nums.push_back(2);
	nums.push_back(3);
	nums.push_back(4);
	nums.push_back(5);
	nums.push_back(6);
	nums.push_back(7);
	nums.push_back(8);
	nums.push_back(9);*/


	nums1 = nums;

	//经典冒泡排序
	/*printTest.printVector(nums);
	sortTest.BubbleSort(nums);
	printTest.printVector(nums);
	cout << endl;*/
	//改进冒泡排序
	/*printTest.printVector(nums1);
	sortTest.BubbleSort1(nums1);
	printTest.printVector(nums1);*/
	//cout << endl;
	//选择排序
	/*printTest.printVector(nums);
	sortTest.SelectSort(nums);
	printTest.printVector(nums);*/
	//直接插入排序
	printTest.printVector(nums);
	sortTest.InsertSort(nums);
	printTest.printVector(nums);

	system("pause");
	return 0;
}

结果

在这里插入图片描述

直接插入排序与冒泡排序、选择排序对比

冒泡排序以及选择排序可以参考我前面的博客。

测试代码

#include <iostream>
#include <vector>
#include <cstdlib>//rand(),srand
#include <ctime>//time()
#include "print_data.h"
#include "mysort.h"

using namespace std;
int main()
{
	srand((int)time(NULL));//随机种子
	vector<int> nums,nums1,nums2;
	print_data printTest;
	MySort sortTest;
	for (int i = 0; i < 10; i++)
	{
		nums.push_back(rand() % 100);//生成0-99之间的随机数
	}
	/*nums.push_back(1);
	nums.push_back(0);
	nums.push_back(2);
	nums.push_back(3);
	nums.push_back(4);
	nums.push_back(5);
	nums.push_back(6);
	nums.push_back(7);
	nums.push_back(8);
	nums.push_back(9);*/


	nums1 = nums;
	nums2 = nums;

	//经典冒泡排序
	/*printTest.printVector(nums);
	sortTest.BubbleSort(nums);
	printTest.printVector(nums);
	cout << endl;*/
	cout << "改进的冒泡排序："<<endl;
	//改进冒泡排序
	printTest.printVector(nums1);
	sortTest.BubbleSort1(nums1);
	printTest.printVector(nums1);
	cout << "选择排序：" << endl;
	//选择排序
	printTest.printVector(nums);
	sortTest.SelectSort(nums);
	printTest.printVector(nums);
	cout << "直接插入排序：" << endl;
	//直接插入排序
	printTest.printVector(nums2);
	sortTest.InsertSort(nums2);
	printTest.printVector(nums2);

	system("pause");
	return 0;
}

对比结果

在这里插入图片描述
可以从结果图看出，直接插入排序的比较次数明显少于前两种算法。

完整代码

mysort.h

#pragma once
#include <vector>
#include <iostream>
class MySort {
public:
	void BubbleSort(std::vector<int>& nums);//冒泡排序
	void BubbleSort1(std::vector<int>& nums);//改进冒泡排序
	void SelectSort(std::vector<int>& nums);//选择排序
	void InsertSort(std::vector<int>& nums);//直接插入排序
};

mysort.cpp

#include "mysort.h"
void MySort::BubbleSort(std::vector<int>& nums) {
	int count1 = 0, count2 = 0;
	int numsSize = nums.size();
	for (int i = 0; i < numsSize - 1; i++) {
		for (int j = 0; j < numsSize -1 - i; j++) {
			count1++;
			if (nums[j] > nums[j+1]){
				count2++;
				int tmp = nums[j];
				nums[j] = nums[j+1];
				nums[j+1] = tmp;
			}
		}
	}
	std::cout << "比较次数：" << count1 << " 交换次数：" << count2 << std::endl;
}

void MySort::BubbleSort1(std::vector<int>& nums) {
	int count1 = 0, count2 = 0;
	int numsSize = nums.size();
	bool flag = true;
	for (int i = 0; (i < numsSize - 1) && flag; i++) {
		flag = false;
		for (int j = 0; j < numsSize - 1 - i; j++) {
			count1++;
			if (nums[j] > nums[j + 1]) {
				count2++;
				flag = true;
				int tmp = nums[j];
				nums[j] = nums[j + 1];
				nums[j + 1] = tmp;
			}
		}
	}
	std::cout << "比较次数：" << count1 << " 交换次数：" << count2 << std::endl;
}

void MySort::SelectSort(std::vector<int>& nums) 
{
	int count1 = 0, count2 = 0;
	int min = 0;
	int numsSize = nums.size();
	for (int i = 0; i < numsSize ; i++) {
		min = i;
		for (int j = i + 1; j < numsSize; j++) {
			count1++;
			if (nums[min] > nums[j]) {	
				min = j;
			}
		}
		if (min != i)
		{
			count2++;
			int tmp = nums[i];
			nums[i] = nums[min];
			nums[min] = tmp;
		}
		
	}
	std::cout << "比较次数：" << count1 << " 交换次数：" << count2 << std::endl;
}

void MySort::InsertSort(std::vector<int>& nums)//直接插入排序
{
	int count1 = 0, count2 = 0;
	int numsSize = nums.size();
	for (int i = 0; i < numsSize; i++) {
		int j = i;
		int tmp = nums[i];//记录当前元素,也称为哨兵
		//如果是第一个元素直接插入，如果不是则看之前已经有序的元素是不是比当前的元素大
		while (j > 0 && tmp < nums[j - 1])
		{
			count1++;
			count2++;
			nums[j] = nums[j - 1];//元素后移
			j--;//再向前移动
		}
		count1++;
		nums[j] = tmp;//当前元素插入位置
	}
	std::cout << "比较次数：" << count1 << " 赋值次数：" << count2 << std::endl;
}

print_data.h

//#pragma once	两种方式防止重定义
#ifndef PRINT_DATA_H
#define PRINT_DATA_H
#include <iostream>
#include <vector>
class print_data
{
public:
	print_data() = default;
	~print_data() = default;
	void printHello();
	void printNum(int num);
	void printVector(std::vector<int> nums);
private:
};


#endif // !PRINT_DATA_H

print_data.cpp

#include "print_data.h"

void print_data::printHello() {
	std::cout << "print_data function!" << std::endl;
}
void print_data::printNum(int num){
	std::cout << num << std::endl;
}

void print_data::printVector(std::vector<int> nums) {
	int size = nums.size();
	for (int i = 0; i < size; i++)
	{
		std::cout << nums[i] << " ";
	}
	std::cout << std::endl;
}

main.cpp

#include <iostream>
#include <vector>
#include <cstdlib>//rand(),srand
#include <ctime>//time()
#include "print_data.h"
#include "mysort.h"

using namespace std;
int main()
{
	srand((int)time(NULL));//随机种子
	vector<int> nums,nums1,nums2;
	print_data printTest;
	MySort sortTest;
	for (int i = 0; i < 10; i++)
	{
		nums.push_back(rand() % 100);//生成0-99之间的随机数
	}
	/*nums.push_back(1);
	nums.push_back(0);
	nums.push_back(2);
	nums.push_back(3);
	nums.push_back(4);
	nums.push_back(5);
	nums.push_back(6);
	nums.push_back(7);
	nums.push_back(8);
	nums.push_back(9);*/


	nums1 = nums;
	nums2 = nums;

	//经典冒泡排序
	/*printTest.printVector(nums);
	sortTest.BubbleSort(nums);
	printTest.printVector(nums);
	cout << endl;*/
	cout << "改进的冒泡排序："<<endl;
	//改进冒泡排序
	printTest.printVector(nums1);
	sortTest.BubbleSort1(nums1);
	printTest.printVector(nums1);
	cout << "选择排序：" << endl;
	//选择排序
	printTest.printVector(nums);
	sortTest.SelectSort(nums);
	printTest.printVector(nums);
	cout << "直接插入排序：" << endl;
	//直接插入排序
	printTest.printVector(nums2);
	sortTest.InsertSort(nums2);
	printTest.printVector(nums2);

	system("pause");
	return 0;
}

Surplus°

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
常见排序算法之直接插入排序及三种基础算法对比

目录直接插入排序算法思想时间复杂度直接插入排序代码直接插入排序测试结果直接插入排序与冒泡排序、选择排序对比测试代码对比结果完整代码mysort.hmysort.cppprint_data.hprint_data.cppmain.cpp直接插入排序直接插入排序和冒泡排序、选择排序是3种基础排序算法。前面已经介绍了冒泡排序以及选择排序，下面介绍一下直接插入排序。3种排序方式的时间复杂度都是O(n2)，但是直接插入排序相比前两种排序方式性能更好，直接插入排序更加适合于已经基本有序和数据量较少的情况。插入排序的
复制链接

扫一扫