【数据结构1.0】快速排序

已于 2024-07-06 18:33:08 修改
阅读量688 收藏 11
点赞数 12
分类专栏： 数据结构1.0 文章标签： 数据结构 排序算法 算法 c语言
于 2024-05-14 21:42:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x__cheng/article/details/138825336
版权

最近学习了快速排序，鼠鼠俺来做笔记了！

本篇博客用排升序为例介绍快速排序！

目录

1.快速排序

1.1.快速排序的”单趟“

1.1.1.hoare版本

1.1.2.挖坑法版本

1.1.3.前后指针版本

1.2.快速排序的递归写法 

1.3.快速排序的非递归写法

2.快速排序递归写法优化 

2.1.三数取中法选基准值

2.2.小区间优化

1.快速排序

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

如果对上面的介绍蒙圈的话，没关系，我们继续看下面的内容，会仔细介绍的！

1.1.快速排序的”单趟“

快速排序的”单趟“简单来说就是在需排序数组中任取一个元素作为基准值，经过”单趟“过后，大于或者等于基准值的元素都排在基准值的后面，小于或者等于基准值的元素都排在基准值的前面，也就是说基准值所在的位置就是它应该出现的位置，这个基准值就排好了！

对于”单趟“的实现方法有但不限于下面三种：

1.1.1.hoare版本

这个动图就是hoare版本的”单趟“实现方法！这里取第一个元素6为基准值；R从最”右边“开始找比基准值小的元素，L从最”左边“开始找比基准值大的元素， 然后交换下标为R和L的元素；R继续找比基准值小的元素，L继续找比基准值大的元素，再交换下标为R和L的元素…………直到R和L相遇，将基准值和相遇位置的元素即可！

其实这个本质就是将比基准值大的元素”甩“到”后面“，将比基准值小的元素”甩“到”前面“。

也许会有疑问，怎么保证相遇位置的元素一定不大于基准值呢？

因为只要是R先动，L后动的话必然能保证相遇的元素一定不大于基准值！

相遇无非两种情况：

1.R遇L：R在去找小于基准值的元素的过程中，下标为L的元素必然是不大于基准值的元素。当R去找小于基准值的元素没有找到却遇到L时， 那么相遇位置的值就是不大于基准值的元素。

2.L遇R：由于R先动，那么L在找大于基准值的元素的过程中，下标为R的元素必然是不大于基准值的元素。当L去找大于基准值的元素没有找到却遇到R时，那么相遇位置的值就是不大于基准值的元素。

 hoare版本的“单趟”代码如下，需排序数组下标为begin—end：

//hoare版本
	int keyi = begin;
	int left = begin, right = end;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[right]);
	keyi = right;

由于hoare版本写起来很容易出错误，所以我们一般写下面两种版本！

1.1.2.挖坑法版本

也是取第一个元素6为基准值。初始坑位设置为基准值下标。让R从最“右边”开始找比基准值小的元素，找到后将下标为R的元素填入坑位，那么新的坑位就变成了R；让L从最“左边”开始找比基准值大的元素，找到后将下标为L的元素填入坑位，那么新的坑位就变成了L；R再找比基准值小的元素……直到R和L相遇，将基准值填入坑位即可。

本质就是R找小填入“左边”坑位，L找大填入“右边”坑位，最后一个坑位必定是R和L相遇位置，填入基准值就好。

挖坑法版本“单趟”代码如下，需排序数组下标为begin—end：

//挖坑法版本
	int  key=a[begin];
	int left = begin, right = end;
	int hole = begin;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;;
		}
		a[hole] = a[right];
		hole = right;
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	int keyi = hole;
1.1.3.前后指针版本

取第一个元素6为基准值。prev初始指向基准值，cur初始指向基准值的下一个元素。cur遍历数组：如果cur遇到大于基准值的元素，++cur；否则++prev、cur指向的元素和prev指向的元素交换、++cur。

前后指针版本“单趟”代码如下， 需排序数组下标为begin—end：

//前后指针版本
	int cur = begin + 1, prev = begin;
	int keyi = begin;
	while (cur <= end)
	{
		if (a[cur] > a[keyi])
		{
			++cur;
		}
		else
		{
			++prev;
			Swap(&a[prev], &a[cur]);
			++cur;
		}
	}
	Swap(&a[keyi], &a[prev]);
	keyi = prev;

这里指针写成了下标的形式，思想没变，本质上还是一样的！

1.2.快速排序的递归写法 

经过“单趟”过后，被选中的基准值就排在了它该出现的位置，就是说当数组排好变得有序后，基准值就在“单趟”过后出现的位置！

既然基准值已经排好了，如果基准值的“左边”的元素集合能有序并且基准值的“右边”的元素集合能有序，那么需排序数组就排好了，变得有序了。举个例子：

如图， 所以说快速排序一种二叉树结构的交换排序方法。进行“单趟”排好基准值，递归“左边”元素集合…………“左边”元素集合排好后，递归“右边”元素集合…………“右边”元素集合排好后就搞定了！

递归结束条件：当元素集合只有1个值或为空。

看看快速排序的递归写法代码：

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	
	//hoare版本
	/*int keyi = begin;
	int left = begin, right = end;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[right]);
	keyi = right;*/

	//挖坑法版本
	int  key=a[begin];
	int left = begin, right = end;
	int hole = begin;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;;
		}
		a[hole] = a[right];
		hole = right;
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	int keyi = hole;

	//前后指针版本
	/*int cur = begin + 1, prev = begin;
	int keyi = begin;
	while (cur <= end)
	{
		if (a[cur] > a[keyi])
		{
			++cur;
		}
		else
		{
			++prev;
			Swap(&a[prev], &a[cur]);
			++cur;
		}
	}
	Swap(&a[keyi], &a[prev]);
	keyi = prev;*/

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

我们试试这个快速排序：

#include<stdio.h>

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

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	
	//hoare版本
	/*int keyi = begin;
	int left = begin, right = end;
	while (left < right)
	{
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[right]);
	keyi = right;*/

	//挖坑法版本
	/*int  key=a[begin];
	int left = begin, right = end;
	int hole = begin;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;;
		}
		a[hole] = a[right];
		hole = right;
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = key;
	int keyi = hole;*/

	//前后指针版本
	int cur = begin + 1, prev = begin;
	int keyi = begin;
	while (cur <= end)
	{
		if (a[cur] > a[keyi])
		{
			++cur;
		}
		else
		{
			++prev;
			Swap(&a[prev], &a[cur]);
			++cur;
		}
	}
	Swap(&a[keyi], &a[prev]);
	keyi = prev;

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

int main()
{
	int a[] = { 9,8,5,47,6,3,2,10 };
	PrintArrar(a, sizeof(a) / sizeof(a[0]));
	QuickSort(a, 0, sizeof(a) / sizeof(a[0]) - 1);
	PrintArrar(a, sizeof(a) / sizeof(a[0]));
	return 0;
}

没问题的：

1.3.快速排序的非递归写法

鼠鼠这里介绍一种快速排序的非递归写法。

需要用到鼠鼠前面博客 介绍的栈，利用到栈写的快速排序没有用到递归但思想却很像递归！

 非递归写法思想如上图。我们看快速排序非递归代码如下，其中变量s是栈。鼠鼠这里“单趟”选择挖坑法版本，当然老爷们可以用其他版本：

void QuickSortNonr(int* a, int begin, int end)
{
	Stack s;
	StackInit(&s);
	StackPush(&s, end);
	StackPush(&s, begin);
	while (!StackEmpty(&s))
	{
		int start = StackTop(&s);
		StackPop(&s);
		int finish = StackTop(&s);
		StackPop(&s);

		int  key = a[start];
		int left = start, right = finish;
		int hole = start;
		while (left < right)
		{
			while (left < right && a[right] >= key)
			{
				right--;;
			}
			a[hole] = a[right];
			hole = right;
			while (left < right && a[left] <= key)
			{
				left++;
			}
			a[hole] = a[left];
			hole = left;
		}
		a[hole] = key;

		if (start < left - 1)
		{
			StackPush(&s, left - 1);
			StackPush(&s, start);
		}
		if (left + 1 < finish)
		{
			StackPush(&s, finish);
			StackPush(&s, left + 1);
		}
	}
	StackDestroy(&s);
}

我们要用到栈，所以记得将我们自己写的栈的头文件和源文件拷贝一份到快速排序的工程目录下 ，再包栈的头文件就可以用了。我们试试：

#include<stdio.h>
#include"Stack.h" //注意包含栈的头文件

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

void QuickSortNonr(int* a, int begin, int end)
{
	Stack s;
	StackInit(&s);
	StackPush(&s, end);
	StackPush(&s, begin);
	while (!StackEmpty(&s))
	{
		int start = StackTop(&s);
		StackPop(&s);
		int finish = StackTop(&s);
		StackPop(&s);

		int  key = a[start];
		int left = start, right = finish;
		int hole = start;
		while (left < right)
		{
			while (left < right && a[right] >= key)
			{
				right--;;
			}
			a[hole] = a[right];
			hole = right;
			while (left < right && a[left] <= key)
			{
				left++;
			}
			a[hole] = a[left];
			hole = left;
		}
		a[hole] = key;

		if (start < left - 1)
		{
			StackPush(&s, left - 1);
			StackPush(&s, start);
		}
		if (left + 1 < finish)
		{
			StackPush(&s, finish);
			StackPush(&s, left + 1);
		}
	}
	StackDestroy(&s);
}

int main()
{
	int a[] = { 9,8,5,47,6,3,2,10 };
	PrintArrar(a, sizeof(a) / sizeof(a[0]));
	QuickSortNonr(a, 0, sizeof(a) / sizeof(a[0]) - 1);
	PrintArrar(a, sizeof(a) / sizeof(a[0]));
	return 0;
}

 没问题吧！

2.快速排序递归写法优化 

2.1.三数取中法选基准值

对于递归写法来说，对于需排序数组本身就是升序或者降序的情况适应的不是很好，因为：

1.固定了选择元素集合第一个元素为基准值，每次“单趟”过后都会导致基准值某一边元素集合为空的情况。这样的话如果本身就是升序或者降序的需排序数组个数有n个的话，就要递归n层，很容易栈溢出！

2.每层只有一个递归，每个递归是一次“单趟”，所以每层“单趟”时间复杂度是O(N)，递归n层的话快速排序时间复杂度是O(N^2)，时间效率不划算！

所以我们有三数取中选基准值，我们取元素集合第一个元素、最后一个元素和中间那个元素，这三个元素比较得出第二大的元素，将这个元素与元素集合第一个元素交换再进行“单趟”。

这样的话就能很好适应需排序数组本身就是升序或者降序的情况，因为这样经过“单趟”之后，基准值一定会出现在“中间”。这样子去递归的话，每一层递归都会被“二分”，递归层数大大减少，递归log(N)层就行！

加入了三数取中选基准值的递归写法的快速排序时间复杂度是O(N*logN)。因为每层有多个递归，每个递归是一次“单趟”，每层递归所有“单趟”加起来时间消耗时O(N)。一共有logN层，所以时间复杂度是O(N*logN)。

而且加入了三数取中选基准值的递归写法的快速排序对于需排序数组本身不是升序或者降序的情况一样有帮助，可以让每层递归尽量“二分”，从而减少递归层数！

三数取中法代码：

int GetMidi(int* a, int begin, int end)
{
	int midi = begin + (end - begin) / 2;
	if (a[begin] > a[midi])
	{
		if (a[begin] > a[end])
		{
			if (a[midi] > a[end])
			{
				return midi;
			}
			else
				return end;
		}
		else
		{
			return begin;
		}
	}
	else
	{
		if (a[midi] > a[end])
		{
			if (a[end] > a[begin])
			{
				return end;
			}
			else
			{
				return begin;
			}
		}
		else
		{
			return midi;
		}
	}
}

当没有加入三数取中选基准值的递归写法的快速排序排10000个升序元素组成的数组时，在Debug环境下就会崩溃，栈溢出了：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

int GetMidi(int* a, int begin, int end)
{
	int midi = begin + (end - begin) / 2;
	if (a[begin] > a[midi])
	{
		if (a[begin] > a[end])
		{
			if (a[midi] > a[end])
			{
				return midi;
			}
			else
				return end;
		}
		else
		{
			return begin;
		}
	}
	else
	{
		if (a[midi] > a[end])
		{
			if (a[end] > a[begin])
			{
				return end;
			}
			else
			{
				return begin;
			}
		}
		else
		{
			return midi;
		}
	}
}

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}

	//三数取中选基准值
	/*int midi = GetMidi(a, begin, end);
	Swap(&a[begin], &a[midi]);*/

	//前后指针版本
	int cur = begin + 1, prev = begin;
	int keyi = begin;
	while (cur <= end)
	{
		if (a[cur] > a[keyi])
		{
			++cur;
		}
		else
		{
			++prev;
			Swap(&a[prev], &a[cur]);
			++cur;
		}
	}
	Swap(&a[keyi], &a[prev]);
	keyi = prev;

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

int main()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand((unsigned int)time(0));
	a[0] = rand();
	for (int i = 1; i < n ; i++)
	{
		a[i] = a[i-1] + 1;
	}
	int begin = clock();
	QuickSort(a, 0, n - 1);
	int end = clock();
	printf("%d\n", end - begin);
	return 0;
}

结果：

当加入三数取中选基准值的递归写法的快速排序，排100w个升序元素组成的数组都没问题，Debug环境下：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

int GetMidi(int* a, int begin, int end)
{
	int midi = begin + (end - begin) / 2;
	if (a[begin] > a[midi])
	{
		if (a[begin] > a[end])
		{
			if (a[midi] > a[end])
			{
				return midi;
			}
			else
				return end;
		}
		else
		{
			return begin;
		}
	}
	else
	{
		if (a[midi] > a[end])
		{
			if (a[end] > a[begin])
			{
				return end;
			}
			else
			{
				return begin;
			}
		}
		else
		{
			return midi;
		}
	}
}

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}

	//三数取中选基准值
	int midi = GetMidi(a, begin, end);
	Swap(&a[begin], &a[midi]);

	//前后指针版本
	int cur = begin + 1, prev = begin;
	int keyi = begin;
	while (cur <= end)
	{
		if (a[cur] > a[keyi])
		{
			++cur;
		}
		else
		{
			++prev;
			Swap(&a[prev], &a[cur]);
			++cur;
		}
	}
	Swap(&a[keyi], &a[prev]);
	keyi = prev;

	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

int main()
{
	int n = 1000000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand((unsigned int)time(0));
	a[0] = rand();
	for (int i = 1; i < n ; i++)
	{
		a[i] = a[i-1] + 1;
	}
	int begin = clock();
	QuickSort(a, 0, n - 1);
	int end = clock();
	printf("%d\n", end - begin);
	return 0;
}

 结果：

2.2.小区间优化

递归到小的子区间（数量少的元素集合）时，可以考虑使用插入排序。这样子可以减少大部分的递归，因为大部分的递归都是由小的子区间产生的。不过由于编译器优化的厉害，小区间优化效果不是很明显，鼠鼠就在这里顺便提一提算了！

3.快速排序的特性总结

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

2.时间复杂度：O(N*logN)。没有加入三数取中法选基准值的递归写法的快速排序也是，只有当它应用于需排序数组本身就是升序或者降序的情况下时间复杂度是O(N^2)。

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

4.快速排序是不稳定的。因为每个“单趟”只是将基准值排好，与基准值相同的数据是排在基准值的“左边”还是“右边”就无从得知了，会打乱相对顺序。比如：5，5，7，1，6，2；排升序。

感谢阅读！

X_chengonly
关注
专栏目录
038-数据结构-五中排序算法--快速排序（1.0 ）--（加了详细注释）
Y_principal的博客
09-06 190
#include<stdio.h> #include<malloc.h> #include<stdlib.h> int find_post(int*a, int low, int high) { //【2.1.1】第一个元素给到临时变量 int val = a[low];//a[0] 应该写a[low] //测试是不传递了a ...
数据结构--快速排序
weixin_41563161的博客
10-02 336
快速排序最全详解（java） 快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。 该方法的基本思想是： 1．先从数列中取出一个数作为基准数。 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。 3...
快速排序1.0
小蚂蚁慢慢爬
08-15 416
//quickSort.h #include #include using namespace std; template void quickSort(vector &v,int begin,int end){ int i=begin; int j=end; if(i<j){ for(;i!=j;){ if(v[i]>v[j]){ swap1(v[i],v[j]);
快速排序（v 1.0)
rush2012的专栏
05-12 132
快速排序法（quick sort）是目前所公认最快的排序方法之一，虽然快速排序法在最差状况下可以达O(n2)，但是在多数的情况下，快速排序法的效率表现是相当不错的。 快速排序法的基本思想是在数组中找出适当的轴心，然后将数组一分为二，分别对左边与右边数组进行排序，而影响快速排序法效率的正是轴心的选择。 这边所介绍的第一个快速排序法版本，是在多数的教科书上所提及的版本，因为它最容易理解，也...
快速排序-
zeronose的博客
03-07 80
快速排序1.0 时间复杂度：O(N^2) class QuickSort: def quick_sort(self, arr): if arr is None or len(arr) < 2: return self.process1(arr, 0, len(arr) - 1) def process1(self, arr, l, r): if l >= r: return
数据结构与算法思维导图V1.0
02-13
在这个“数据结构与算法思维导图V1.0”中，我们涵盖了多个关键概念，包括线性表、顺序结构、链式结构、栈与队列、串、二叉树以及相关的遍历和查找方法，还有各种排序算法。 首先，线性表是最基本的数据结构之一，它...
数据的排序 1.0.zip易语言项目例子源码下载
03-22
本项目包含的源码将展示如何利用这些工具实现常见的排序算法，如冒泡排序、选择排序、插入排序、快速排序等。 1. 冒泡排序：是最简单的排序算法之一，通过重复遍历待排序的数列，一次比较两个元素，如果他们的顺序...
《数据结构与算法 LeetCode刷题宝典V1.0》.pdf
05-03
《数据结构与算法 LeetCode刷题宝典V1.0》这本手册是一份系统性地整理了LeetCode上算法题目的解决方案的参考资料。其内容覆盖了数据结构与算法领域中最为关键的知识点，包括双指针技术、集合技术、字典技术、排序...
数据结构——冒泡排序vs快速排序
君陌的博客
11-21 673
冒泡排序和快速排序都是我们比较常用的排序方法（可能快速排序不是），这里进行了两种算法的效率比较，数量级为10,100,1K，10K，100K，1M。 代码如下： #include <iostream> #include <fstream> #include <ctime>//clock_t #include <windows.h>//dword,la...
排序算法——随机快速排序
Morty的技术乐园
04-26 6020
引言 随机快排是一个非常有意思的排序排序算法，它的算法思想用到了如递归、荷兰国旗问题等诸多元素，还意外的引入了随机性的概念。 以下将逐步总结三个版本的快速排序，由浅入深总结快速排序的经典实现过程。 荷兰国旗问题参考：《荷兰国旗问题》 一、快速排序1.0 在荷兰国旗问题中，我们通过简单的逻辑可以将一个数组分为两个区域或三个区域，但往往需要在题目之初给定一个 target 作为目标数以此划分。 而在快速排序算法中，这个 target 选为排序范围上的最右边的数——arr[R]，我们以 R 上的数为
java|快速排序
weixin_60619970的博客
07-03 124
java|快速排序
Java经典算法之快速排序算法
weixin_56154577的博客
03-10 4794
快速排序是一种分治法（Divide and Conquer）的排序算法，由英国计算机科学家Tony Hoare于1960年提出。其基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有元素均比另一部分的元素小，然后分别对这两部分继续进行排序，最终达到整个序列有序的效果。
快速排序 — — 递归、非递归实现【十大经典排序算法】
weixin_45565886的博客
08-09 309
快速排序 — — 递归、非递归实现【十大经典排序算法】
快速排序三个版本（1.0,2.0,3.0）
qq_45599754的博客
10-10 431
快速排序 三个版本
【算法&数据结构体系篇class05】partition、荷兰国旗、快速排序
studyday1的博客
02-16 602
核心点：递归实际上是系统帮我们记录了每一次递归的边界范围信息，是系统栈保存了这些信息，那么要用非递归的形式，那么就需要我们自己定义一个栈，或者队列也可以，保存每一次的边界范围信息，才能遍历进行下一次的数组快排。1）用arr[R]对该范围做partition，
课设实验-数据结构-线性表-手机销售
ADCvbV的博客
10-02 365
【代码】数据结构-线性表-课设实验-手机销售。
【数据结构】双向链表（Doubly Linked List）
最新发布
2301_77727857的博客
10-05 256
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构-3.10.队列的应用
ADCvbV的博客
10-01 343
与5结点相邻的结点只有7，8结点没被处理过(6结点已经入队列了)，因此只需7，8结点入队列，之后5结点出队列；同理处理2结点，与2相邻的1结点已经被处理过，因此无需入队，与2相邻的4结点没被处理过，4结点入队列，最后。之后的结点处理方式与上述同理，直到队列为空就完成了对图的广度优先遍历。遍历到4时，发现它没有子节点，所以4直接出队列即可，无需入子节点。
德塔数据结构变量快速转换引擎系统1.0：160种数据类型互换源码
德塔数据结构变量快速转换引擎系统1.0是一个专门设计的工具，用于在多种常见的数据结构之间实现高效和灵活的转换。该系统的重点在于处理160种不同类型的载体对象，包括但不限于map、list、object、table、hash、tree...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

X_chengonly

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值