七大排序算法

最新推荐文章于 2024-04-28 13:55:08 发布
最新推荐文章于 2024-04-28 13:55:08 发布
阅读量119 收藏
点赞数
分类专栏： 笔记 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45976950/article/details/108791346
版权

插入排序

#include<iostream>


/*插入排序*/


void InsertSort(int arr[], int len)
{
	int preIndex = 0, current = 0;

	for (int i = 1; i < len; i++)
	{
		preIndex = i - 1;
		current = arr[i];

		while (preIndex >= 0 && arr[preIndex] > current)
		{
			arr[preIndex + 1] = arr[preIndex];
			preIndex--;
		}
		arr[preIndex + 1] = current;
	}
	
}


int main()
{
	int beauties[] = { 163,161,158,165,171,170,163,159,162 };

	int len = sizeof(beauties) / sizeof(beauties[0]);

	InsertSort(beauties, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", beauties[i]);
	}


	system("pause");
	return 0;
}

归并排序

#include<iostream>

//采用分治思想
//每次循环把n个元素分解成n/2个子序列
//用合并排序法堆两个子序列递归排序
//合并两个已排序的子序列

// 6,5,3,1,8,7,2,4 
// 分解
// 6,5,3,1   8,7,2,4 
// 6,5  3,1  8,7  2,4 
// 6  5  3  1  8  7  2  4 
// 合并排序
// 5,6  1,3 7,8  2,4
// 1,3,5,6  2,4,7,8
// 1,2,3,4,5,6,7,8


void mergeAdd_demo(int arr[], int left, int mid, int right)
{
	int temp[64] = { 0 };
	int i = left;	//指向左边数组最小的元素位置
	int j = mid;	//指向右边数组最小的元素位置
	int k = 0;		//临时数组下标

	while (i<mid && j<=right)
	{
		if (arr[i] < arr[j])
		{
			temp[k++] = arr[i++];
		}
		else
		{
			temp[k++] = arr[j++];
		}
	}

	while (i < mid)
	{
		temp[k++] = arr[i++];
	}

	while (j <= right)
	{
		temp[k++] = arr[j++];
	}

	//把temp中得到内容拷贝到arr数组中
	memcpy(arr + left, temp, sizeof(int)*(right - left + 1));
}

void mergeAdd(int arr[], int left, int mid, int right,int *temp)
{
	int i = left;	//指向左边数组最小的元素位置
	int j = mid;	//指向右边数组最小的元素位置
	int k = 0;		//临时数组下标

	while (i < mid && j <= right)
	{
		if (arr[i] < arr[j])
		{
			temp[k++] = arr[i++];
		}
		else
		{
			temp[k++] = arr[j++];
		}
	}

	while (i < mid)
	{
		temp[k++] = arr[i++];
	}

	while (j <= right)
	{
		temp[k++] = arr[j++];
	}

	//把temp中得到内容拷贝到arr数组中
	memcpy(arr + left, temp, sizeof(int)*(right - left + 1));
}

//细分成单个数据，两两进行归并
void mergeSort(int arr[], int left, int right, int *temp)
{
	int mid = 0;
	if (left < right)
	{
		mid = left + (right - left) / 2;
		mergeSort(arr, left, mid, temp);
		mergeSort(arr, mid + 1, right, temp);
		mergeAdd(arr, left, mid + 1, right, temp);
	}
}


int main()
{
	int beauties[] = { 6,5,3,1,8,7,2,4 };
	int len = sizeof(beauties) / sizeof(beauties[0]);
	int *temp = new int[len];

	mergeSort(beauties, 0, len - 1, temp);

	for (int i = 0; i < len; i++)
	{
		printf("%d ", beauties[i]);
	}

	system("pause");
	return 0;
}

快速排序

#include<iostream>

//选择第一个数为基准数，已基准为中心将小于它的排在前面，大于等于它的排在后面


int partition(int arr[], int low, int high)
{
	int i = low;
	int j = high;
	int base = arr[low];

	if (low < high)
	{
		while (i < j)
		{
			while (i < j&&arr[j] >= base)
			{
				j--;
			}
			if (i < j)//右边已经找到小于基数的数
			{
				arr[i++] = arr[j];
			}
			while (i < j && arr[i] < base)
			{
				i++;
			}
			if (i < j)//左边边已经找到大于基数的数
			{
				arr[j--] = arr[i];
			}
			arr[i] = base;
		}
		return i;
	}

}

void QuickSort(int *arr, int low, int high)
{
	if (low < high)
	{
		int index = partition(arr, low, high);

		QuickSort(arr, low, index - 1);
		QuickSort(arr, index + 1, high);
	}

}



int main()
{
	int beauties[] = { 163,161,158,165,171,170,163,159,162 };

	int len = sizeof(beauties) / sizeof(beauties[0]);

	QuickSort(beauties,0 , len-1);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", beauties[i]);
	}

	system("pause");
	return 0;
}

冒泡排序

#include<iostream>

//交换
void swap(int &num1, int &num2)
{
	int temp = num1;
	num1 = num2;
	num2 = temp;
}

void BubbleSort(int arr[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		bool sorted = true;
		for (int j = 0; j < len - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				swap(arr[j], arr[j + 1]);
				sorted = false;
			}
		}
		if (sorted)break;
	}
}

int main()
{
	int beauties[] = { 163,161,158,165,171,170,163,159,162 };

	int len = sizeof(beauties) / sizeof(beauties[0]);

	BubbleSort(beauties, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", beauties[i]);
	}

	system("pause");
	return 0;
}

希尔排序

#include<iostream>


/*希尔排序*/
//无需大幅移动数据即可完成整个数组的排序
//相当于插入排序的优化


void ShellSort(int arr[], int len)
{
	int gap = len / 2;
	for (; gap > 0; gap = gap / 2)
	{
		for (int i = gap; i < len; i++)
		{
			int current = arr[i];
			int j = 0;
			for (j = i - gap; j >= 0 && arr[j] > current; j -= gap)
			{
				arr[j + gap] = arr[j];
			}
			arr[j + gap] = current;
		}
	}

}



int main()
{
	int beauties[] = { 163,161,158,165,171,170,163,1,2 };

	int len = sizeof(beauties) / sizeof(beauties[0]);

	ShellSort(beauties, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", beauties[i]);
	}


	system("pause");
	return 0;
}

选择排序

#include<iostream>


using namespace std;


//交换两个变量的值
void swap(int *num1, int *num2)
{
	int temp = *num1;
	*num1 = *num2;
	*num2 = temp;
}

void SelectSort1(int arr[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		int max = 0;
		for (int j = 1; j < len - i; j++)
		{
			if (arr[j] > arr[max])
			{
				max = j;
			}
		}
		if (max != (len - i - 1))
		{
			swap(&arr[max], &arr[len - i - 1]);//和最后一个交换
		}
	}
	
}

void SelectSort2(int arr[], int len)
{
	int i, j;
	for (i = 0; i < len - 1; i++)
	{
		int min = i;
		for (j = i + 1; j < len; j++)
		{
			if (arr[j] < arr[min])
			{
				min = j;
			}
		}
		swap(&arr[min], &arr[i]);//和第一个交换
	}


}


int main()
{
	int beauties[] = { 163,161,158,165,171,170,163,159,162 };

	int len = sizeof(beauties) / sizeof(beauties[0]);

	SelectSort1(beauties, len);
	for (int i = 0; i < len; i++)
	{
		printf("%d ", beauties[i]);
	}


	system("pause");
	return 0;
}
nI丶唯一
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见的七大排序算法Java实现.zip
07-30
本压缩包"常见的七大排序算法Java实现.zip"包含了七种经典的排序算法在Java语言中的实现。尽管文件列表中并未明确列出每种排序算法的名称，但根据常规，这七大排序算法可能包括冒泡排序、插入排序、选择排序、快速...
C语言进阶——指针
热爱可抵岁月漫长
03-01 243
指针 1. 什么是指针 作用 2. 指针的类型 3. 指针的值 4. 指针指向的值（区域） 5. 指针的运算 6. 指针和数组 7. 指针和函数
图解七大排序算法
Mike's Tech Blog
07-06 3697
“排序是计算机的核心内容。事实上，从很多方面看，如果没有排序，计算机就不会变成现实。” 《算法之美：指导工作与生活的算法》 排序算法，或许是我们日常最常见也是使用频率最多的算法。比如你在电商网站买东西，推荐商品往往基于相似度或者基于销售量等维度排序。我们每日接收的邮件是程序中按照时间进行排序好的，我们点外卖时候推送的列表是按照评分和地理位置进行排序的。搜索引擎检索内容也是按照一定的相似度算法进行排序好才呈现给你的，所以搜索引擎实际上就是一个排序引擎。 本篇文章通过图例的方式逐一讲...
【数据结构】七大排序算法（超详细）
m0_59176913的博客
06-10 3515
本文详细介绍了数据结构中的七大排序算法
Python 实现七大排序算法
最新发布
2401_84563254的博客
04-28 850
本文用 Python 实现了插入排序、希尔排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序。先整体看一下各个算法之间的对比，然后再进行详细介绍：| 排序算法 | 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 | 排序方式 | 稳定性 || 插入排序 | O(n²) | O(n) | O(n²) | O(1) | In-place | 稳定 || 冒泡排序 | O(n²) | O(n) | O(n²) | O(1) | In-place | 稳定 |
七大排序算法的Java代码实现
Rory安杰尔的博客
03-06 876
七大排序算法的Java代码实现 1.两句口诀： 平均时间复杂度：快（快速排序）以nlogn速度归（归并排序）队（堆排序）。 稳定性：情绪不稳定，快（快速排序）些（希尔排序）选（选择排序）堆（堆排序）好友来聊天。 2.七大排序（从小到大）算法的代码实现 2.1.冒泡排序 空间复杂度为O(1)，时间复杂度为O(n^2)。如果数组已经有序，不会发生交换，时间复杂度为O(n)。 2.2.选择排序 空间复杂度为O(1)，时间复杂度为O(n^2)。 2.3.插入排序 空间复杂度为O(1)，平均时间复杂度为O(n^2)，
七大排序算法——快速排序
暴躁小吕的博客
11-04 1291
现在我们开始进入算法模块，在分享数据结构的知识的同时开始分享编程的算法，欢迎大家交流，有不对的地方欢迎大家斧正，也希望大家集思广益，拓展思维。快排总结：1.确定数组q，确定左端点l，确定右端点r。2.确定划分边界x3.按照划分的边界x将数组分成=x的两个区间。4.分别递归处理两个区间。快排定下划分边界x后就从左右端点位置开始向中间走，两个区间中不满足就停下，同时停下了就交换数据然后继续向下走，直到两个下标相等了或者左边区间的下标大于右边区间的下标了就停止，也就完成了快排。
七大排序算法——快速排序，通俗易懂的思路讲解与图解(完整Java代码)
The_emperoor_man的博客
07-14 1821
本文介绍的是七大算法排序中的快速排序，用大白话讲解，配有图解与完整代码(内含注释)，还实现了对快速排序代码的优化。快进来轻松学会快速排序。
七大经典排序算法总结详解
12-29
以上七大排序算法各有特点，选择哪种取决于具体的应用场景。例如，如果数据基本有序，插入排序可能更合适；对于大规模数据，快速排序或归并排序是更好的选择。理解这些排序算法，不仅有助于编程实践，也有助于提升...
Java语言：七大排序算法精彩讲解+详细代码+思路分析+最佳优化！
02-05
七大排序算法精彩讲解+详细代码+思路分析+最佳优化！七大排序算法精彩讲解+详细代码+思路分析+最佳优化！七大排序算法精彩讲解+详细代码+思路分析+最佳优化！七大排序算法精彩讲解+详细代码+思路分析+最佳优化！七大...
七大排序算法总结
m0_57945021的博客
12-06 511
作为刚入门的小白对七大算法自己的一点见解
JAVA中 常用七大排序算法
IT小郭的技术博客
07-04 1029
Java中常用的排序算法 简单选择排序 注意区别：冒泡排序跟直接选择排序都是依次比较相邻的记录，但是冒泡排序是一有反序立即交换，而直接插入排序则是出现反序将最小值记录下来，最后再发生交换。 三、直接插入排序（ Straight Insertion Sort） 四、希尔排序（Shell Sort） 五、堆排序（Heap Sort） 六、归并排序（Merge Sort） 通俗概述：将无序数组进行两两分段，并将相邻两段进行比较排序，最后扩大..................
数据结构c++代码实现
qq_45976950的博客
09-25 2974
顺序表 #include<iostream> #include<string> using namespace std; //#define MAX_SIZE 100 // //typedef struct //{ // int *elems; //顺序表的基地址 // int length; //长度 // int size; //总空间大小 //}SqList; template <typename T> class SqList { public:
五大核心算法
qq_45976950的博客
09-25 2805
动态规划算法 #include<iostream> using namespace std; /*递归实现机器人台阶走法统计 参数： n - 台阶个数 返回：上台阶总的走法 f(n) = f(n-1) + f(n-2); */ //分治算法 int WalkCount1(int n) { if (n < 0) return 0; if (n == 1) return 1; //一级台阶，一种走法 else if (n == 2) return 2; //二级台阶，两种
C++学习笔记：利用虚函数面积计算
qq_45976950的博客
02-10 528
抽象基类 Shape.h #pragma once class Shape { public: virtual void shapeName()const = 0; //定义两个纯虚函数 virtual void printArea()const = 0; //输出面积 }; 圆形 Circle.h #pragma once #include "Shape.h" #include&l...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值