数据结构之排序（二）

鲨鱼吃橘子2024-08-26 5:08

目录

基本思想：

1.1冒泡排序

​编辑1.1.1代码实现

1.3冒泡排序的特性总结：

[2.1 快速排序](#2.1 快速排序)

2.1.1基本思想

2.2.2代码实现

[1. hoare版本](#1. hoare版本)

2.挖坑法

3.前后指针版本

[2.2.3 快速排序的优化（三数取中）](#2.2.3 快速排序的优化（三数取中）)

实现步骤

[3.1 快速排序非递归](#3.1 快速排序非递归)

3.1.1代码实现

快速排序的特性总结：

[二. 归并排序](#二. 归并排序)

基本思想：

代码实现

[非比较排序 （非递归）](#非比较排序 （非递归）)

归并排序的特性总结：

三.排序算法复杂度及稳定性分析

四、结尾

根据上文继续后文的排序数据结构之排序（一）-CSDN博客

一.交换排序

基本思想：

所谓交换，就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置，交换排 序的特点是：将键值较大的记录向序列的尾部移动，键值较小的记录向序列的前部移动。

1.1冒泡排序

1.1.1代码实现
复制代码 
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		bool exchange = false;
		for (int i = 1; i < n - j; i++)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = true;
			}
		}

		if (exchange == false)
		{
			break;
		}
	}
}
1.3冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序

  2. 时间复杂度：O(N^2)

  3. 空间复杂度：O(1)

  4. 稳定性：稳定

2.1 快速排序

2.1.1基本思想

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，其基本思想为：任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

将区间按照基准值划分为左右两半部分的常见方式有：

2.2.2代码实现

将区间按照基准值划分为左右两半部分的常见方式有：

1. hoare版本
cs 复制代码 
//三数取中
int GetMidNumi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else // a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
// hoare版本
void QuickSort(int* a, int left, int right)
{
	// 三数取中
	int midi = GetMidNumi(a, left, right);
	if (midi != left)
		swap(&a[midi], &a[left]);

	int key = left;
	while (left < right)
	{
		while (a[right] >= a[key])
			right--;

		while (left < right && a[left] <= a[key])
			left++;

		swap(&a[right], &a[left]);
	}
	swap(&a[key], &a[left]);

}
2.挖坑法
cs 复制代码 
//挖坑法
void PartSort2(int* a, int left, int right)
{
	// 三数取中
	int midi = GetMidNumi(a, left, right);
	if (midi != left)
		swap(&a[midi], &a[left]);

	if (left >= right)
		return;
	int key = a[left];
	int hole = left;
	while (left < right)
	{
		while (a[right] >= a[key])
			right--;
		
		a[hole] = a[right];
		hole = right;

		while (left < right && a[left] <= a[key])
			left++;

		a[right] = a[left];
		hole = left;

	}
	a[left] = key;
	hole = left;

	PartSort2(a, 0, hole - 1);
	PartSort2(a, hole + 1, right);

}
3.前后指针版本
cs 复制代码 
//前后指针法
void PartSort3(int* a, int left, int right)
{
	// 三数取中
	int midi = GetMidNumi(a, left, right);
	if (midi != left)
		swap(&a[midi], &a[left]);

	if (left >= right)
		return;
	int key = left;
	int prev = left;
	int cur = left + 1;
	while(cur <= right)
	{
		if (a[cur] < a[key])
		{
			prev++;
			swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	swap(&a[prev], &a[key]);
	
	PartSort3(a, 0, prev - 1);
	PartSort3(a, prev + 1, right);
}
2.2.3 快速排序的优化（三数取中）

三数取中的基本思想是：在待排序的数组（或子数组）中，取第一个元素、最后一个元素以及中间位置的元素，然后比较这三个元素的值，取它们的中间值作为基准值（pivot）。这样做的目的是尽可能选择一个位于数据中间的元素作为基准，以减少数据分区的不平衡性。

实现步骤
  1. 定位元素：首先，找到数组（或子数组）的第一个元素、最后一个元素和中间位置的元素。
  2. 比较元素：然后，比较这三个元素的值。
  3. 选择中间值：根据比较结果，将这三个元素按照从小到大的顺序排列（如果需要的话，可以交换它们的位置），然后取中间的元素作为基准值（pivot）。
  4. 进行分区：以这个基准值为依据，对数组进行分区操作，即小于基准值的元素放在基准值的左边，大于基准值的元素放在基准值的右边。
cs 复制代码 
//三数取中
int GetMidNumi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else // a[left] > a[mid]
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

3.1 快速排序非递归

3.1.1代码实现

非递归运用了栈的压栈和出栈来进行排序

cs 复制代码 
#include <stdio.h>
#include "Stack.h"

// 快速排序 非递归实现
void QuickSortNonR(int* a, int left, int right)
{
	Stack st;
	StackInit(&st);

	int end = right;
	int begin = left;

	StackPush(&st, end);
	StackPush(&st, begin);

	while (!StackEmpty(&st))
	{
		begin = StackTop(&st);
		StackPop(&st);
		end = StackTop(&st);
		StackPop(&st);
		int keyi = PartSort1(a, begin, end);
		//[begin , keyi - 1] [keyi] [keyi + 1 , end]
		if (end > keyi + 1)
		{
			StackPush(&st, end);
			StackPush(&st, keyi + 1);
		}
		if (keyi - 1 > begin)
		{
			StackPush(&st, keyi - 1);
			StackPush(&st, begin);
		}
	}
}
快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

  2. 时间复杂度：O(N*logN)

  3. 空间复杂度：O(logN)

  4. 稳定性：不稳定

二. 归并排序

基本思想：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。 归并排序核心步骤：

代码实现

cs 复制代码 
void _Catego(int* a, int begin, int end, int* copy)
{
	if (begin >= end)
		return;

		int i = begin;
		int mid = (begin + end) / 2;
		_Catego(a, begin, mid, copy);
		_Catego(a, mid+1, end, copy);

		int begin1 = begin; int end1 = mid;
		int begin2 = mid+1;  int end2 = end;
		while (begin2 <= end2 && begin1 <= end1)
		{
			if (a[begin1] > a[begin2])
			{
				copy[i++] = a[begin2++];
			}
			else
			{
				copy[i++] = a[begin1++];
			}
		}

		while (begin2 <= end2)
		{
			copy[i++] = a[begin2++];
		}

		while (begin1 <= end1)
		{
			copy[i++] = a[begin1++];
		}
	memcpy(a + begin, copy + begin, sizeof(int) * (end - begin + 1));
}


void CategoSort(int* a, int n)
{
	int* copy = (int*)malloc(sizeof(int) * n);
	if (copy == NULL)
	{
		perror("malloc");
		return;
	}

	_Catego(a, 0, n-1, copy);
	free(copy);
}

非比较排序 （非递归）

在非递归中需要考虑越界的问题：end1，begin2，end2，分别进行导论

cs 复制代码 
void CatagoSort(int *a,int n)
{
	int* copy = (int*)malloc(sizeof(int) * n);
	if (copy == NULL)
	{
		perror("malloc");
		return;
	}


	int gap = 1;


	while (gap < n)
	{
		int j = 0;
		int i = 0;
		for (int i = 0; i < n; i += 2*gap)
		{
			int begin1 = i; int end1 = i + gap -1;
			int begin2 = i + gap; int end2 = i + 2 * gap -1;

			// 间距为gap的多组数据，归并完以后，一把拷贝(梭哈)

			if (end1 >= n)
			{
				end1 = n - 1;
				begin2 = n;
				end2 = n-1;
			}
			else if (begin2 >= n)
			{
				begin2 = n;
				end2 = n - 1;
			}
			else if (end2 >= n)
			{
				end2 = n - 1;
			}

			printf("[%d] [%d] [%d] [%d]", begin1, end1, begin2, end2);
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] > a[begin2])
				{
					copy[j++] = a[begin2++];
				}
				else
				{
					copy[j++] = a[begin1++];
				}
			}
			while (begin1 <= end1)
			{
				copy[j++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				copy[j++] = a[begin2++];
			}
		}
		printf("\n");
		memcpy(a, copy, sizeof(int) * n);
		gap *= 2;
	}
	memcpy(a, copy, sizeof(int) * n);
	free(copy);
}

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail\n");
		return;
	}

	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			// [begin1,end1][begin2, end2]
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			//printf("[%d,%d][%d,%d] ", begin1, end1,begin2,end2);

			if (end1 >= n || begin2 >= n)
			{
				break;
			}

			if (end2 >= n)
			{
				end2 = n - 1;
			}

			printf("[%d,%d][%d,%d] ", begin1, end1, begin2, end2);

			int j = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}

			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}

			// 归并一部门拷贝一部分
			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}

		printf("\n");

		gap *= 2;
	}

	free(tmp);
}

归并排序的特性总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

  2. 时间复杂度：O(N*logN)

  3. 空间复杂度：O(N)

  4. 稳定性：稳定

三.排序算法复杂度及稳定性分析

四、结尾

如果有什么建议和疑问，或是有什么错误，希望大家可以在评论区提一下。

希望大家以后也能和我一起进步！！

如果这篇文章对你有用的话，希望能给我一个小小的赞！

相关推荐
Musennn2 小时前
leetcode98.验证二叉搜索树：递归法中序遍历的递增性验证之道
java·数据结构·算法·leetcode
reduceanxiety3 小时前
机试 | vector/array Minimum Glutton C++
数据结构·c++·算法
2301_794461573 小时前
力扣-最大连续一的个数
数据结构·算法·leetcode
MonKingWD4 小时前
【redis原理篇】底层数据结构
数据结构·数据库·redis
清心歌5 小时前
二叉树遍历
数据结构·算法
ghie90906 小时前
基于MATLAB的大规模MIMO信道仿真
数据结构·算法·matlab
AncelyF8 小时前
【Harmony】【鸿蒙】List列表View如何刷新内部的自定义View的某一个控件
数据结构·list
阳洞洞8 小时前
leetcode 83和84 Remove Duplicates from Sorted List 和leetcode 1836
数据结构·leetcode·链表
Musennn9 小时前
leetcode617.合并二叉树：迭代法中层序遍历与队列操作的深度解析
java·数据结构·算法·leetcode
Mr_Kian10 小时前
《数据结构与算法分析》读书笔记：第一章 引 论
java·数据结构
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！03从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑04YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】05VMware虚拟机安装Win7专业版保姆级教程（附镜像包）06DeepSeek各版本说明与优缺点分析07【Ubuntu 22.04】解决Ubuntu 22.04终端行距过大的问题08组基轨迹建模 GBTM的介绍与实现（Stata 或 R）09Coze扣子平台完整体验和实践（附国内和国际版对比）10YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU