简单的内排序

已于 2022-09-06 20:58:53 修改
阅读量149 收藏
点赞数
文章标签： 排序算法 数据结构 算法
于 2022-09-06 20:57:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63045003/article/details/126280632
版权

  1.插入排序

1.1直接插入排序

将一组数据分成有序区和无序区

然后将无序区中第一个元素和有序区从大到小依此比较并交换

#include<stdio.h>
void InsertSort(int* arr, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}

void PrintInsertSort(int* arr,int  n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
	int arr[] = { 5,4,1,2,3,6 };
	InsertSort(arr, sizeof(arr) / sizeof(int));
	PrintInsertSort(arr, sizeof(arr) / sizeof(int));
	return 0;
}

时间复杂度O(n^{2}) 

 1.2折半插入排序

 利用一组有序数组的下标取去中间值与无序数组第一个元素比较

依此递归

具体过程看：(9条消息) 【排序】折半插入排序_Adelaide_Guo的博客-CSDN博客_折半插入排序https://blog.csdn.net/Adelaide_Guo/article/details/82149098?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166052390616782388095140%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=166052390616782388095140&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~baidu_landing_v2~default-1-82149098-null-null.142%5Ev40%5Epc_search_integral,185%5Ev2%5Econtrol&utm_term=%E6%8A%98%E5%8D%8A%E6%8F%92%E5%85%A5%E6%8E%92%E5%BA%8F%E5%8A%A8%E5%9B%BE&spm=1018.2226.3001.4187

#include<stdio.h>
void BinInsertSort(int* arr, int n)
{
	for (int i = 1; i < n;  i++)
	{
		int low = 0;
		int hight = i - 1;
		int temp = arr[i];
		while (low<=hight)               //递归
		{
			int mid = (low + hight) / 2;
			if (arr[mid] > temp)
			{
				hight = mid - 1;
			}
			else
			{
				low = mid + 1;
			}
		}
		for (int j = i - 1; j > hight; j--)
		{
			arr[j + 1] = arr[j];
		}
		arr[hight + 1] = temp;
	}
}

void PrintBinInsertSort(int* arr,int  n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
	int arr[] = { 5,4,1,2,3,6 };
	BinInsertSort(arr, sizeof(arr) / sizeof(int));
	PrintBinInsertSort(arr, sizeof(arr) / sizeof(int));
	return 0;

时间复杂度： O(n^{2}) 

1.3希尔排序

按间隔比较排序

#include<stdio.h>
void ShellSort(int* arr, int n)
{
	int d = n / 3;
	while (d>0)
	{
		for (int i = 0; i < n-d ; ++i)
		{
			int end = i;
			int tmp = arr[end + d];
			while (end >= 0)
			{
				if (arr[end] > arr[end + d])
				{
					arr[end + d] = arr[end];
					end = end - d;
				}
				else
				{
					break;
				}
				
			}
			arr[end + d] = tmp;
			
		}
		d = d / 2;
	}
}

void PrintShellSort(int* arr,int  n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
	int arr[] = { 5,4,1,2,3,6 };
	ShellSort(arr, sizeof(arr) / sizeof(int));
	PrintShellSort(arr, sizeof(arr) / sizeof(int));
	return 0;
}

 时间复杂度：O(n^{1.5})

2.交换排序

2.1冒泡排序

两个元素比较，依此递推，将最大或者最小排的后面

#include<stdio.h>
void BubbleSort(int* arr, int n)
{
	for (int i = 0; i < n - 1; ++i)
	{
		for (int j = 0; j < n - i - 1; ++j)
		{
			if (arr[j] > arr[j + 1])
			{
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}

void PrintBubbleSort(int* arr,int  n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
	int arr[] = { 5,4,1,2,3,6 };
	BubbleSort(arr, sizeof(arr) / sizeof(int));
	PrintBubbleSort(arr, sizeof(arr) / sizeof(int));
	return 0;
}

时间复杂度： O(n^{2})  

2.2快速排序

取一元素将大于该元素放一边小于该元素放另一边

依此递归

#include<stdio.h>
void QuickSort(int* arr, int left,int right)
{
	if (left >= right)
	{
		return;
	}

	int begin = left;
	int end = right;
	int pivot = begin;
	int key = arr[begin];
	while (begin<end)
	{
		while (begin<end && arr[end]>=key)
		{
			--end;
		}

		arr[pivot] = arr[end];
		pivot = end;


		while (begin < end && arr[begin] <= key)
		{
			++begin;
		}

		arr[pivot] = arr[begin];
		pivot = begin;
	}
	pivot = begin;
	arr[pivot] = key;
	QuickSort(arr, left, pivot - 1);
	QuickSort(arr, pivot + 1, left);
}

void PrintQuickSort(int* arr,int  n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ",arr[i]);
	}
}
int main()
{
	int arr[] = { 5,4,1,2,3,6 };
	QuickSort(arr, 0,(sizeof(arr) / sizeof(int))-1);
	PrintQuickSort(arr, sizeof(arr) / sizeof(int));
	return 0;
}

时间复杂度： O（n{log_2{n}}^{}）

3.选择排序

3.1简单选择排序

将一组数组分为有序区间（开始可以只有一个元素）和无序区间

然后在无序区间中找到该区间最大或者最小值

将该值与有序区间中依此比较并插入

#include<stdio.h>
void SelectSort(int* arr, int n)
{
	for (int i = 0; i < n - 1; ++i)
	{
		int k = i;
		for (int j = i + 1; j < n; ++j)       //类似快慢指针
		{
			if (arr[j] < arr[k])
				k = j;
		}
		if (k != i)
		{
			int tmp = arr[i];
			arr[i] = arr[k];
			arr[k] = tmp;
		}
	}
}

void PrintSelectSort(int* arr,int  n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr[] = { 5,4,1,2,3,6 };
	SelectSort(arr ,sizeof(arr) / sizeof(int));
	PrintSelectSort(arr, sizeof(arr) / sizeof(int));
	return 0;
}

时间复杂度： O(n^{2})

3.2堆排序

堆排序条件：左右子树必须是大堆或者小堆

先建堆后向下调整算法排序

升序建小堆

降序建大堆

将数组以二叉树形式储存

#include<stdio.h>
PrintHeapSort(int* arr,int  n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
}
void AdjustDwon(int* arr, int n, int root)        //建堆
{
	int parent = root;
	int child = parent * 2 + 1;
	while (child<n)
	{
		if (child+1<n&&arr[child + 1] > arr[child])
		{
			++child;
		}
		if (arr[child] > arr[parent])
		{
			int tmp = arr[child];
			arr[child] = arr[parent];
			arr[parent] = tmp;
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
void HeapSort(int* arr, int n)
{
	for (int i = (n - 2) / 2; i >= 0; --i)
	{
		AdjustDwon(arr, n, i);         //从下向上建堆
	}
	int end = n - 1;
	while (end > 0)
	{
		int tmp = arr[0];
		arr[0] = arr[end];
		arr[end] = tmp;
		AdjustDwon(arr, end, 0);         //排序；
		--end;
	}
}
int main()
{
	int arr[] = { 5,4,1,2,3,6 };
	HeapSort(arr ,sizeof(arr) / sizeof(int));
	PrintHeapSort(arr, sizeof(arr) / sizeof(int));
	return 0;
}

时间复杂度： O（n{log_2{n}}^{}）

4.归并排序

4.1二路归并排序

可以看下面链接的简述 

http://t.csdn.cn/t7shphttp://t.csdn.cn/t7shp

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<malloc.h>
#include<assert.h>
void merge(int *arr, int low,int mid, int hight)
{
	int* arr1=	NULL;
	int i = low, j = mid + 1, k = 0;
	arr1 = (int*)malloc(sizeof(int) * (hight - low + 1));
	assert(arr1);
	while (i<=mid&&j<=hight)
	{
		if (arr[i] < arr[j])
		{
			arr1[k] = arr[i];
			++k;
			++i;
		}
		else
		{
			arr1[k] = arr[j];
			++k;
			++j;
		}
	}
	while (i <= mid)
	{
		arr1[k] = arr[i];
		++k;
		++i;
	}
	while (j <= hight)
	{
		arr1[k] = arr[j];
		++k;
		++j;
	}
	for (k = 0, i = low; i <= hight; ++i, ++k)
	{
		arr[i] = arr1[k];
	}
	free(arr1);
}
void MergeSort(int *arr, int low, int hight)
{
	int mid = 0;
	if (low < hight)
	{
		mid = (low + hight) / 2;
		MergeSort(arr, low, mid);
		MergeSort(arr, mid + 1, hight);
		merge(arr, low, mid, hight);
	}
}

void PrintMergeSort(int* arr,int  n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr[] = { 5,4,1,2,3 ,6};
	MergeSort(arr ,0 , (sizeof(arr) / sizeof(int))-1);
	PrintMergeSort(arr, sizeof(arr) / sizeof(int));
	return 0;
}

时间复杂度： O（n{log_2{n}}^{}）

4.2三路归并排序

4.基数排序

低头看月亮！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++简单排序——冒泡排序
小天狼星_布莱克 的博客
06-25 2万+
冒泡排序，简单的排序方法，C++，适合初学者
内部排序算法比较.rar
05-22
（1）对以下6中常用的内部排序算法进行比较：冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序和堆排序。 （2）待排序表的表长不小于100；其中的数据要用伪随机数产生程序产生；至少要用5组不同的输入...
C语言的5种简单排序算法
Finecsr的博客
04-27 5万+
基本概要： 本文主要介绍五种简单常用的排序算法：冒泡排序，快速排序，插入排序，选择排序，希尔排序，包括它们的基本思想和代码实现。值得一说的是：插入排序，冒泡排序，选择排序平均情况下的时间复杂度为，因此在排序数据较少的情况下较好；而希尔排序和快速排序的平均时间复杂度为，因此在排序数据较多的情况下较好，但是对于快速排序而言，数据基本有序时反而不好，接下来会详细阐述。 1.冒泡排序（Bubble Sort） 基本思想： 冒泡排序是一个非常好理解的排序，顾名思义——冒泡，此时将要排序的数据从上至下排列，从最
内部排序与外部排序简单比较
黄庆庆的世界
06-03 1万+
前言本篇文章主要介绍内部排序与外部排序的知识，如果你和我一样还不知道内部排序和外部排序为何物的话，不妨看看我的理解正文由于待排序的记录数量不同，使得排序过程中涉及的存储器不同，可将排序方法分为两大类：内部排序与外部排序。概念内部排序：待排序记录存放在计算机随机存储器中（说简单点，就是内存）进行的排序过程。外部排序：待排序记录的数量很大，以致于内存不能一次容纳全部记录，所以在排序过程中需要对外存进行...
C语言——冒泡排序
热门推荐
记录学习点滴
03-13 42万+
冒泡排序的原理是：从左到右，相邻元素进行比较。每次比较一轮，就会找到序列中最大的一个或最小的一个。这个数就会从序列的最右边冒出来。 以从小到大排序为例，第一轮比较后，所有数中最大的那个数就会浮到最右边；第二轮比较后，所有数中第二大的那个数就会浮到倒数第二个位置……就这样一轮一轮地比较，最后实现从小到大排序。 代码如下 #include<stdio.h> void BBsort(int arr[], int size) { int j,i,tem; for (i = 0; i ..
超详细！各种内部排序算法的比较
KK_2018的技术博客_程序员不止是程序员
11-30 2164
先来个表格总结直观展示下： 各种内部排序算法的性质 算法种类 时间复杂度 空间复 杂度 稳定性 最好情况 平均情况 最坏情况 插入排序 直接插入排序 O(n) O(n^2) O(n^2) O(1) 稳定 折半插入排序 O(n) O(n^2) O(n^2) O(1) 稳定 希尔排序 O(n^1.3) O(nlogn) ...
算法 - 内部排序方法总结
了解➔熟悉➔掌握➔精通
03-05 3万+
分享一个大牛的人工智能教程。零基础！通俗易懂！风趣幽默！希望你也加入到人工智能的队伍中来！请点击http://www.captainbed.net 各种排序方法的性能比较 排序方法 最好时间复杂度 平均时间复杂度 最坏时间复杂度 空间复杂度 稳定性 直接插入排序 O(n) O(n2) O(n2) O(1) 稳定 简单选择排...
排序——简单排序
魔筝炼药师
03-25 6387
简单排序有三种，包括选择排序（Selection Sort）、冒泡排序（Bubble Sort）和插入排序（Insert Sort）。 选择排序每次都选择最小的关键码记录，直到完全排序。实质上就是起泡排序。选择排序第 i 趟选择的是数组中第 i 小的记录，并将这个记录放到数组的第 i 个位置。 特点：大部分时间都在比较，很少交换。 在寻找下一个较小的数时，需要检索整个未排序的序列，但只用一...
十大排序算法详解（一）冒泡排序、选择排序、插入排序、快速排序、希尔排序
HK的博客
06-27 18万+
冒泡排序、选择排序、插入排序、快速排序、希尔排序
简单选择排序详解
weixin_44713306的博客
02-22 6586
1、什么是选择排序？ 选择排序是第一次从待排序的元素中选取最大值（或者最小值），将其放在序列的最前面，再从剩下的待排序元素中选取最大值（或者最小值）放入序列的最后，重复该操作直到剩下的待排序的元素的个数是0，选择排序是一种简单直观的排序算法。 2、简单选择排序和堆排序的关联 选择排序是从待排序的元素中选择最大值（或者最小值），然后将其放入序列中排序。选择排序分为简单选择排序和堆排序，简单选择排序和堆排序的区别在：从待排序的元素中选择最大值（或者最小值）的方式不同，简单排...
八大排序算法（C语言实现）
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
数据机构综合课设内部排序算法比较.docx
03-26
简单选择排序；堆排序；归并排序；基数排序。 （2）待排序表的表长不少于100；其中的数据要用伪随机数产生程序产生；至少要用5组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字移动次数（关键字...
内部排序算法比较
06-14
1）比较范围：直接插入排序、冒泡法排序、简单选择排序、快速排序1（自己实现）、快速排序2（调用STL）、归并排序。 2）比较指标：a）关键字操作次数（比较次数和移动次数之和），b)排序时间。每个指标采用多次重复...
内排序算法比较
03-14
1) 对以下 6 种常用的内部排序算法进行比较：起泡排序，直接插入排序，简单选择排 序，快速排序，希尔排序，堆排序。 2) 待排序记录的文件个数不小于 1000( 其数据用伪随机数产生 )，至少用5 组不同的 输入数据作...
排序---基数排序
sunshine350的博客
06-09 488
排序
【每日刷题】Day63
2301_78022459的博客
06-13 1033
【每日刷题】Day63
有关排序的算法
最新发布
2401_82924480的博客
06-14 672
排序
排序---归并排序（简单优化前后比较）
sunshine350的博客
06-08 301
简单优化
如何使用Python中的collections模块提供的数据结构，如deque、Counter、OrderedDict等
2402_84885073的博客
06-09 477
Python 的模块提供了一些额外的数据结构，这些数据结构在内置的数据类型（如列表、字典、集合等）的基础上，增加了额外的功能或优化了性能。下面是如何使用模块中的dequeCounter和这三种数据结构的简单示例。
内部排序算法性能比较
09-26
简单排序方法中的直接插入排序是稳定的，而简单选择排序和冒泡排序是不稳定的。 综上所述，根据排序的规模和要求稳定性的需求，我们可以选择合适的排序算法。对于较小规模的排序或要求稳定性的排序，可以使用简单...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值