数据结构——排序（交换排序）

jiao000012024-10-10 2:38

目录

一、交换排序的总体概念

二、冒泡排序

三、快速排序

1.挖坑法

2.左右指针

3.前后指针

一、交换排序的总体概念

交换排序是一类排序算法，它的核心思想是通过交换元素的位置来达到排序的目的。在排序过程中，比较数组中的元素对，如果它们的顺序不符合排序要求，就交换它们的位置。在这里主要讲冒泡排序和快速排序。

二、冒泡排序

基本概念：

  • 冒泡排序是一种简单的交换排序算法。它的基本思想是通过反复比较相邻的元素，根据排序要求（升序或降序）交换它们的位置，使得每一轮比较后，最大（或最小）的元素像气泡一样 "浮" 到数组的一端。

工作原理：

  • 对于一个包含 n 个元素的数组，进行 n - 1 轮比较。在每一轮比较中，从数组的第一个元素开始，依次比较相邻的两个元素。如果它们的顺序不符合排序要求（例如在升序排序中，前面的元素大于后面的元素），则交换这两个元素的位置。这样，在每一轮比较结束后，未排序部分的最大元素就会被交换到该轮比较范围的末尾。
  • 随着比较轮数的增加，每一轮需要比较的元素数量逐渐减少。例如，第一轮需要比较 n - 1 对相邻元素，第二轮需要比较 n - 2 对相邻元素，以此类推，最后一轮只需要比较 1 对相邻元素。

特点：

  • 时间复杂度：
    • 最坏情况和平均情况的时间复杂度都是O(n*n)。当数组是逆序（对于升序排序要求）时，每一轮比较都需要进行最多的交换操作，总共需要进行 n - 1 轮比较，所以时间复杂度为O(n*n)。
    • 最好情况时间复杂度为O(n)，当数组已经有序时，只需要进行一轮比较，且不进行任何交换操作，就可以确定数组已经有序。
  • 空间复杂度：空间复杂度为O(1)，因为它只需要一个临时变量来辅助交换相邻元素，属于原地排序算法。
  • 稳定性：冒泡排序是一种稳定的排序算法。在比较相邻元素时，如果两个元素相等，不进行交换，所以相同元素的相对顺序不会改变。

主要步骤

  • 外层循环控制遍历趟数 ：
    • for (int j = 0; j < n; ++j)外层循环控制整个排序过程的趟数。每一趟都会将当前未确定位置的最大元素移动到正确的位置上。随着趟数的增加，已确定位置的元素越来越多，未确定位置的元素越来越少。
  • 内层循环进行相邻元素比较和交换 ：
    • int exchange = 0;在内层循环开始前，初始化一个标志变量exchange为 0，表示在当前这一趟中还没有进行过交换。
    • for (int i = 1; i < n - j; ++i)内层循环从数组的第二个元素开始，依次比较相邻的两个元素。如果前一个元素大于后一个元素，就进行交换。
    • if (a[i - 1] > a[i])如果a[i - 1]大于a[i]，则执行交换操作Swap(&a[i - 1], &a[i])，并将exchange设置为 1，表示在这一趟中有过交换。
  • 提前结束排序的条件 ：
    • if (exchange == 0)在每一趟遍历结束后，检查exchange的值。如果exchange为 0，说明在这一趟中没有进行过交换，即数组已经有序，此时可以提前结束排序。
cs 复制代码 
//冒泡排序
void BubbleSort(int* a, int n)
{
	//控制躺数
	for (int j = 0; j < n; ++j)
	{
		int exchange = 0;
		//控制交换次数
		for (int i = 1; i < n - j; ++i)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}

		if (exchange == 0)
		{
			break;
		}
	}
}

三、快速排序

基本概念：

  • 快速排序是一种高效的交换排序算法，它基于分治策略。其基本思想是选择一个基准元素（pivot），将数组分为两部分，使得左边部分的元素都小于等于基准元素，右边部分的元素都大于等于基准元素，然后对这两部分分别进行快速排序，直到整个数组有序。

工作原理：

  • 首先选择一个基准元素，通常可以选择数组的第一个元素、最后一个元素或中间元素等。以选择第一个元素为基准为例。
  • 设置两个指针，一个从数组的第二个元素开始（左指针），一个从数组的最后一个元素开始（右指针）。左指针向右移动，寻找大于基准元素的元素；右指针向左移动，寻找小于基准元素的元素。当左指针找到大于基准元素的元素，右指针找到小于基准元素的元素时，交换这两个元素的位置。
  • 不断重复上述步骤，直到左指针和右指针相遇。此时，将基准元素与相遇位置的元素交换，这样就将数组分为了两部分，左边部分的元素都小于等于基准元素，右边部分的元素都大于等于基准元素。
  • 然后对这两部分子数组分别递归地应用快速排序算法，直到子数组的长度为 1 或 0，此时数组已经有序

特点：

  • 时间复杂度：
    • 平均时间复杂度为O(n*logn)。在每次划分操作中，如果能够将数组比较均匀地分为两部分，那么总共需要进行次划分操作，每次划分操作需要遍历数组中的大部分元素，时间复杂度约为O(n)，所以平均时间复杂度为O(n*logn)。
    • 最坏情况时间复杂度为O(n*n)，当数组已经有序或者逆序（对于选择第一个元素作为基准的情况）时，每次划分得到的两部分子数组长度相差很大，例如一个子数组长度为 n - 1，另一个子数组长度为 0，这样就会导致划分次数达到 n - 1 次，时间复杂度变为O(n*n)。
  • 空间复杂度：
    • 最好情况空间复杂度为O(logn)，这是因为在快速排序的递归过程中，需要使用栈来保存每次划分的子数组信息，在平均情况下，递归深度为logn，所以空间复杂度为O(logn)。
    • 最坏情况空间复杂度为O(n)，当递归深度达到 n 时，例如数组已经有序的情况，需要占用较多的栈空间。
  • 稳定性：快速排序是一种不稳定的排序算法。因为在划分过程中，交换元素的操作可能会改变相同元素的相对顺序。

主要步骤

cs 复制代码 
/快速排序
// 三数取中
//GetMidIndex三数取中  校招一般不写
// 防止快速排序遇见有序情况是时间复杂度和直接插入的数量级一样
int GetMidIndex(int* a, int left, int right)
{
	int mid = (left + right) >> 1;
	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;
		}
	}
}

GetMidIndex函数实现了 "三数取中" 策略，目的是为了在快速排序算法中选择一个较合理的基准值（pivot），以避免在特殊情况下（如数组已基本有序）快速排序算法的性能退化到与直接插入排序相近的时间复杂度。
*

1.挖坑法

cs 复制代码 
// 挖坑法  只写了一趟，若需完整算法，应在QuickSort调用或进行递归
int PartSort1(int* a, int left, int right)
{
	int index = GetMidIndex(a, left, right);
	Swap(&a[left], &a[index]);

	int begin = left, end = right;
	int pivot = begin;
	int key = a[begin];

	// O（N）
	while (begin < end)
	{
		// 右边找小，放到左边
		while (begin < end && a[end] >= key)
			--end;

		// 小的放到左边的坑里，自己形成新的坑位
		a[pivot] = a[end];
		pivot = end;

		// 左边找大
		while (begin < end && a[begin] <= key)
			++begin;

		// 大的放到右边的坑里，自己形成新的坑位
		a[pivot] = a[begin];
		pivot = begin;
	}
	pivot = begin;
	a[pivot] = key;
	return pivot;
}

  • 选择基准值并进行交换：

    • int index = GetMidIndex(a, left, right);调用 "三数取中" 函数GetMidIndex选择一个相对中间的元素索引。
    • Swap(&a[left], &a[index]);将这个中间元素与数组最左端的元素交换，使得后续操作可以以a[left]作为基准值进行划分。

  • 初始化变量：

    • int begin = left, end = right;分别定义了两个指针begin和end，分别指向数组的左端和右端。
    • int pivot = begin;定义了一个变量pivot，表示当前的 "坑位" 索引，初始值为begin。
    • int key = a[begin];将基准值存储在变量key中。

  • 划分过程：

    • while (begin < end)循环用于进行划分操作，直到两个指针相遇。
    • 右边找小 ：
      • while (begin < end && a[end] >= key)从右往左扫描，找到第一个小于基准值的元素。
      • --end;如果找到小于基准值的元素，将指针end向左移动一位。
      • a[pivot] = a[end];将找到的小于基准值的元素放入当前的 "坑位"，同时更新 "坑位" 索引为end。
    • 左边找大 ：
      • while (begin < end && a[begin] <= key)从左往右扫描，找到第一个大于基准值的元素。
      • ++begin;如果找到大于基准值的元素，将指针begin向右移动一位。
      • a[pivot] = a[begin];将找到的大于基准值的元素放入当前的 "坑位"，同时更新 "坑位" 索引为begin。

2.左右指针

cs 复制代码 
//左右指针：在挖坑法的基础上，begin找大，end找小
//只不过没有坑了，而是把左右指针换了
//只写了一趟，若需完整算法，应在QuickSort调用或进行递归
int PartSort2(int* a, int left, int right)
{
	int index = GetMidIndex(a, left, right);//三数取中
	Swap(&a[left], &a[index]);//永远把关键字放在最左边

	int begin = left, end = right;
	int keyi = begin;

	while (begin < end)
	{
		// 找小
		while (begin < end && a[end] >= a[keyi])
		{
			--end;
		}

		// 找大
		while (begin < end && a[begin] <= a[keyi])
		{
			++begin;
		}

		Swap(&a[begin], &a[end]);
	}

	Swap(&a[begin], &a[keyi]);//把之前找的关键字存在begin和end相遇的地方
	return begin;//返回相遇的地方
}

  • 选择基准值并进行交换：

    • int index = GetMidIndex(a, left, right);调用 "三数取中" 函数选择一个相对中间的元素索引。
    • Swap(&a[left], &a[index]);将中间元素与数组最左端的元素交换，这样后续操作可以以a[left]作为基准值进行划分。

  • 初始化变量：

    • int begin = left, end = right;定义两个指针分别指向数组的左端和右端。
    • int keyi = begin;将基准值的索引初始化为begin。

  • 划分过程：

    • while (begin < end)循环用于进行划分操作，直到两个指针相遇。
    • 找小 ：
      • while (begin < end && a[end] >= a[keyi])从右往左扫描，找到第一个小于基准值的元素。如果当前元素大于等于基准值，继续向左移动指针end。
      • --end;当找到小于基准值的元素时，将指针end向左移动一位。
    • 找大 ：
      • while (begin < end && a[begin] <= a[keyi])从左往右扫描，找到第一个大于基准值的元素。如果当前元素小于等于基准值，继续向右移动指针begin。
      • ++begin;当找到大于基准值的元素时，将指针begin向右移动一位。
    • Swap(&a[begin], &a[end]);当找到一 "小" 一 "大" 两个元素后，交换它们的位置。

  • 确定基准值的最终位置并返回：

    • Swap(&a[begin], &a[keyi]);当左右指针相遇时，将基准值与相遇位置的元素交换，确定基准值的最终位置。
    • return begin;返回相遇位置的索引，即基准值在排序后的位置。

3.前后指针

cs 复制代码 
//前后指针法：cur找小，每次遇到比key小的值，就停下来，++prev
//然后交换cur和prev位置的值
//核心思想就是把小的值往前移
int PartSort3(int* a, int left, int right)
{
	int index = GetMidIndex(a, left, right);//三数取中
	Swap(&a[left], &a[index]);
    int keyi = left;//永远把关键字放在最左边
	int prev = left, cur = left + 1;//形成前后指针
	while (cur <= right)
	{
		if (a[cur] < a[keyi]
         && ++prev != cur)//如果++prev和cur相等，不用换，提高效率
		{
			Swap(&a[prev], &a[cur]);
		}

		++cur;//不论是否小于，cur都要往前移，所以cur和prev也许中间隔了好几个大的数
	}

	Swap(&a[keyi], &a[prev]);//把关键字放在此时prev的位置
	return prev;
}

  • 选择基准值并进行交换：

    • int index = GetMidIndex(a, left, right);调用 "三数取中" 函数选取相对中间的元素索引。
    • Swap(&a[left], &a[index]);将中间元素与数组最左端的元素交换，后续以a[left]作为基准值进行划分。

  • 初始化变量：

    • int keyi = left;将基准值的索引设置为left，表示基准值在数组的最左端。
    • int prev = left, cur = left + 1;初始化前后指针，prev初始指向基准值，cur指向基准值的下一个位置。

  • 划分过程：

    • while (cur <= right)循环用于遍历数组，进行划分操作。
    • if (a[cur] < a[keyi] && ++prev!= cur)如果当前元素小于基准值，且prev自增后不等于cur，说明需要交换。交换a[prev]和a[cur]，这样就将小于基准值的元素移动到了左边。
    • ++cur;无论当前元素是否小于基准值，cur都要向前移动，继续检查下一个元素。

  • 确定基准值的最终位置并返回：

    • Swap(&a[keyi], &a[prev]);循环结束后，将基准值与prev位置的元素交换，确定基准值在排序后的位置。
    • return prev;返回基准值的最终位置索引。
相关推荐
tjjingpan18 分钟前
在 VSCode 中，c_cpp_properties.json文件主要有以下作用
c语言·ide·vscode
Mrceel23 分钟前
MAC端VSCode code-runner插件配置 c/c++编译后 文件生成路径
c语言·vscode·macos
管家罢了1 小时前
C++-容器适配器- stack、queue、priority_queue和仿函数
开发语言·数据结构·c++
十一29284 小时前
C语言--预处理详解（宏定义#define,#和##运算符，#undef，条件编译，头文件的包含）
c语言
Gdut杰哥4 小时前
C（十一）scanf、getchar（第三弹）
c语言
Kalika0-04 小时前
温度转换-C语言
c语言·开发语言·数据结构·算法
梓桐5 小时前
【算法】- 查找 - 散列表查询（哈希表）
c语言·算法·哈希算法·散列表
luthane5 小时前
python 实现algorithm topo卡恩拓扑算法
数据结构·python·算法
Mr_Xuhhh7 小时前
数据结构阶段测试2的一点小补充
android·开发语言·汇编·数据结构·c++·算法
热门推荐
01【经验分享】Ubuntu22.04安装微信(linux官方版)02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）03RAG 实践- Ollama+RagFlow 部署本地知识库04海康Visionmaster-通讯管理：使用 Modbus TCP 通讯 协议与流程交互05安卓系列机型永久去除data分区加密 详细步骤解析06yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）07【C语言】逗号运算符详解 - 《不起眼的 “逗号”》08【极空间NAS】使用WebDAV服务 + DDNSTO内网穿透 实现思源笔记的内外网同步09苍穹外卖面试总结10CANoe Trace窗口过滤栏消失的几种解决方法（附上最终解决方案）