[数据结构]————排序总结——插入排序（直接排序和希尔排序）—选择排序（选择排序和堆排序）-交换排序（冒泡排序和快速排序）—归并排序（归并排序）

news2024/10/6 1:46:35

 

 

文章涉及具体代码gitee： 登录 - Gitee.com

 

目录

1.插入排序

1.直接插入排序

 总结

 2.希尔排序

总结 

 2.选择排序

1.选择排序

​编辑

总结 

2.堆排序

总结 

3.交换排序

1.冒泡排序

总结 

2.快速排序

总结 

4.归并排序

总结 

5.总的分析总结 

1.插入排序

具体分析过程见我的博客插入排序：http://t.csdnimg.cn/FauY7

1.直接插入排序

void InsertSort(int* a, int n)
{
	// [0, end] end+1
	for (int i = 0; i < n - 1; ++i)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp < a[end])
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}

		a[end + 1] = tmp;
	}
}

 总结

直接插入排序是一种简单观的排序算法，它基本思想是将待排序的元逐个插入到已经排好序的序列中，直到所有元素都插入完成为止下面是对直接插入排序的析总结：

  1. 时间复杂度：

    • 最好情况下待排序序列已经是有序的此时只需要比较n-1次，时间复杂度为O（n）。
    • 最坏情况下，待排序序列是逆序的，此时需要比较和移动元素的次数最多，时间复杂度为O(n^2)。
    • 平均情况下，假设待排序序列中的每个元素都等概率地出现在任何位置，那么平时间复杂度为O(n^2)。

  2. 空间复杂度： 直接插入排序是一种原地排序算法，不需要额外的空间存储数据，所以空间复杂度为O(1)。

  3. 稳定性： 直接插入排序是一种稳定的排序算法，相等元素的相对位置在排序前后不会发生改变。

  4. 适用性：

    • 对于小规模的数据或者基本有序的数据，直接插入排序是一种简单高效的排序算法。
    • 但对于大规模乱序的数据，直接插入排序的性能较差，不如快速排序、归并排序等高效。

 2.希尔排序

void ShellSort(int* a, int n)
{
	int gap = n;

	// gap > 1时是预排序，目的让他接近有序
	// gap == 1是直接插入排序，目的是让他有序
	while (gap > 1)
	{
		//gap = gap / 2;
		gap = gap / 3 + 1;

		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0)
			{
				if (tmp < a[end])
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}

}

总结 

希尔排序是一种基于插入排序的排序算法，它通过将待排序的元素按照一定的间隔分组，对每个分组进行插入排序，然后逐渐缩小间隔，直到间隔为1，最后进行一次完整的插入排序。希尔排序的主要思想是通过较大的步长先将数组局部有序，然后逐渐减小步长，最终使得整个数组有序。

希尔排序的分析总结如下：

  1. 时间复杂度：希尔排序的时间复杂度与步长序列的选择有关。最好情况下，当步长序列为1时，希尔排序的时间复杂度为O(nlogn)；最坏情况下，当步长序列为2^k-1时，希尔排序的时间复杂度为O(n^2)；平均情况下，希尔排序的时间复杂度为O(nlogn)。
  2. 空间复杂度：希尔排序的空间复杂度为O(1)，即不需要额外的空间存储数据。
  3. 稳定性：希尔排序是不稳定的排序算法，即相同元素的相对位置可能会发生改变。
  4. 对于大规模数据和中等规模数据，希尔排序相对于其他简单的排序算法（如插入排序、冒泡排序）具有较好的性能。

 2.选择排序

具体分析过程见我的博客插入排序：

1.选择排序

// 时间复杂度：O(N^2)
// 最好的情况下：O(N^2)
void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;

	while (begin < end)
	{
		int mini = begin, maxi = begin;
		for (int i = begin + 1; i <= end; ++i)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}

			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}

		Swap(&a[begin], &a[mini]);
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);

		++begin;
		--end;
	}
}

总结 

选择排序是一种简单直观的排序算法，其基本想是每次从待排序的元素中选择最小（或最大）的元素，放到已排序序列的末尾。选择排序的分析总结如下：

  1. 时间复杂度：选择排序的时间复杂度为O(n^2)，其中n是待排序序列的长度。因为每次都需要在剩余的未排序元素中找到最小（或最大）的元素，需要进行n-1次比较和交换操作。

  2. 空间复杂度：选择排序的空间复杂度为O(1)，即不需要额外的空间来存储数据。

  3. 稳定性：选择排序是一种不稳定的排序算法。在每次选择最小（或最大）元素时，可能会改变相同元素之间的相对顺序。

  4. 适用性：选择排序适用于小规模数据的排序，但对于大规模数据效率较低。由于其简单直观的思想，选择排序在教学和理解排序算法的过程中具有一定的价值。

2.堆排序

void AdjustDown(int* a, int size, int parent)
{
	int child = parent * 2 + 1;

	while (child < size)
	{
		// 假设左孩子小，如果解设错了，更新一下
		if (child + 1 < size && a[child + 1] > a[child])
		{
			++child;
		}

		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

// 升序
void HeapSort(int* a, int n)
{
	// O(N)
	// 建大堆
	for (int i = (n - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}

	// O(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

总结 

堆排序是一种高效的排序算法，它利用了堆这种数据结构的特性来进行排序。下面是对堆排序的分析总结：

  1. 堆的构建：首先需要将待排序的数组构建成一个堆。堆是一个完全二叉树，可以使用数组来表示。通过从最后一个非叶子节点开始，依次向上调整每个节点，使得每个节点都满足堆的性质。

  2. 堆的调整：构建好堆之后，将堆顶元素（最大值或最小值）与最后一个元素交换位置，并将堆的大小减一。然后再对堆顶元素进行调整，使得剩余元素重新满足堆的性质。重复这个过程，直到堆的大小为1，即完成了排序。

  3. 时间复杂度：堆排序的时间复杂度为O(nlogn)，其中n是待排序数组的长度。堆的构建需要O(n)的时间复杂度，而每次调整堆的操作需要O(logn)的时间复杂度，总共需要进行n-1次调整。

  4. 空间复杂度：堆排序的空间复杂度为O(1)，只需要常数级别的额外空间来存储中间变量。

  5. 稳定性：堆排序是一种不稳定的排序算法，因为在调整堆的过程中，可能会改变相同元素的相对顺序。

3.交换排序

具体分析过程见我的博客插入排序：

1.冒泡排序

// 时间复杂度：O(N^2)
// 最好情况是多少：O(N)
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. 基本思想：冒泡排序的基本思想是通过相邻元素的比较和交换来实现排序。每一轮比较都会将当前未排序部分的最大（或最小）元素“冒泡”到末尾。

  2. 时间复杂度：冒泡排序的时间复杂度为O(n^2)，其中n是待排序数组的长度。这是因为冒泡排序需要进行n-1轮比较，每轮比较需要遍历未排序部分的元素。

  3. 空间复杂度：冒泡排序的空间复杂度为O(1)，即不需要额外的空间来存储数据。

  4. 稳定性：冒泡排序是一种稳定的排序算法，即相等元素的相对顺序在排序后不会改变。

  5. 最佳情况和最差情况：无论是最佳情况还是最差情况，冒泡排序的时间复杂度都是O(n^2)。最佳情况是待排序数组已经有序，此时只需要进行n-1轮比较即可。最差情况是待排序数组逆序，需要进行n-1轮比较，并且每轮比较都需要交换元素。

2.快速排序

// 挖坑法
int PartSort2(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	Swap(&a[midi], &a[begin]);

	int key = a[begin];
	int hole = begin;
	while (begin < end)
	{
		// 右边找小，填到左边的坑
		while (begin < end && a[end] >= key)
		{
			--end;
		}

		a[hole] = a[end];
		hole = end;

		// 左边找大，填到右边的坑
		while (begin < end && a[begin] <= key)
		{
			++begin;
		}

		a[hole] = a[begin];
		hole = begin;
	}

	a[hole] = key;
	return hole;
}

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

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

总结 

快速排序是一种常用的排序算法，它的基本思想是通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据小，然后再按此方法对这两部分数据分别进行快速排序，整个过程递归进行，以达到整个数据变成有序序列的目的。

快速排序的分析总结如下：

  1. 时间复杂度：平均情况下，快速排序的时间复杂度为O(nlogn)，最坏情况下为O(n^2)。最坏情况发生在待排序序列已经有序或基本有序的情况下，此时每次划分只能减少一个元素，需要进行n-1次划分，因此时间复杂度较高。但是通过优化措施（如随机选择基准元素），可以避免最坏情况的发生。
  2. 空间复杂度：快速排序的空间复杂度为O(logn)，主要是由于递归调用造成的栈空间使用。
  3. 稳定性：快速排序是一种不稳定的排序算法，因为在交换元素的过程中可能改变相同元素的相对顺序。
  4. 应用场景：快速排序在实际应用中广泛使用，特别适用于大规模数据的排序。它的性能优于其他常见的排序算法，如冒泡排序和插入排序。

4.归并排序

具体分析过程见我的博客插入排序：

void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
		return;

	int mid = (begin + end) / 2;
	// [begin, mid][mid+1, end]
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid + 1, end, tmp);

	// [begin, mid][mid+1, end]归并
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, end2 = end;
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}

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

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

	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}

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

	_MergeSort(a, 0, n - 1, tmp);

	free(tmp);
}

总结 

归并排序是一种经典的排序算法，它采用分治的思想来实现排序。下面是对归并排序的分析总结：

  1. 算法思想：归并排序将待排序的序列不断地分割成两个子序列，直到每个子序列只有一个元素，然后将这些子序列两两合并，直到最终得到有序的序列。

  2. 时间复杂度：归并排序的时间复杂度为O(nlogn)，其中n是待排序序列的长度。这是因为每次合并操作都需要O(n)的时间，而分割操作需要O(logn)次。

  3. 空间复杂度：归并排序需要额外的O(n)空间来存储临时数组，用于合并操作。

  4. 稳定性：归并排序是一种稳定的排序算法，即相等元素的相对顺序在排序后保持不变。

  5. 优点：归并排序具有稳定性和适应性好的特点，适用于各种数据类型和数据规模。

  6. 缺点：归并排序需要额外的空间来存储临时数组，对于大规模数据排序时可能会占用较多的内存。

5.总的分析总结 

插入排序是一种简单直观的排序算法，它的基本思想是将待排序的元素逐个插入到已排序序列中的适当位置，直到全部元都插入完毕。插入排序包直接插入排序和希尔排序。

  1. 直接插入排序：

    • 算法思想：将待排序序列分为已排序和未排序两部分，初始时已排序部分只有一个元素。然后从未排序部分依次取出元素，与已排序部分的元素进行比较并插入到合适的位置。
    • 时间复杂度：最好情况下为O（n），最坏情况下为O（n^2），平均情况下为O（n^2）。
    • 空间复杂度：O（1）。
    • 稳定性：稳定。

  2. 希尔排序：

    • 算法思想：希尔排序是直接插入排序的改进版，通过设置一个增量序列，将待排序序列分割成若干个子序列，对每个子序列进行直接插入排序。然后逐步缩小增量，最终完成整个序列的排序。
    • 时间复杂度：平均情况下为O（nlogn），最坏情况下为O（n^2）。
    • 空间复杂度：O（1）。
    • 稳定性：不稳定。

选择排序是一种简单直观的排序算法，它的基本思想是每次从待排序序列中选择最小（或最大）的元素放到已排序序列的末尾。选择排序包括选择排序和堆排序。

  1. 选择排序：

    • 算法思想：将待排序序列分为已排序和未排序两部分，初始时已排序部分为空。每次从未排序部分选择最小（或最大）的元素，放到已排序部分的末尾。
    • 时间复杂度：最好情况下为O(n^2)，最坏情况下为O(n^2)，平均情况下为O(n^2)。
    • 空间复杂度：O（1）。
    • 稳定性：不稳定。

  2. 堆排序：

    • 算法思想：堆排序利用堆这种数据结构进行排序。首先将待排序序列构建成一个大顶堆（或小顶堆），然后依次将堆顶元素与末尾元素交换，并重新调整堆，直到整个序列有序。
    • 时间复杂度：平均情况下为O(nlogn)，最坏情况下为O(nlogn)。
    • 空间复杂度：O（1）。
    • 稳定性：不稳定。

交换排序是一种通过元素之间的交换来进行排序的算法，包括冒泡排序和快速排序。

  1. 冒泡排序：

    • 算法思想：冒泡排序通过依次比较相邻的元素，并交换它们的位置，使得每一轮循环都能将最大（或最小）的元素移动到末尾。重复这个过程，直到整个序列有序。
    • 时间复杂度：最好情况下为O（n），最坏情况下为O（n^2），平均情况下为O（n^2）。
    • 空间复杂度：O（1）。
    • 稳定性：稳定。

  2. 快速排序：

    • 算法思想：快速排序通过选择一个基准元素，将待排序序列分成两部分，一部分小于基准元素，一部分大于基准元素。然后对这两部分分别进行快速排序，直到整个序列有序。
    • 时间复杂度：平均情况下为O（nlogn），最坏情况下为O（n^2）。
    • 空间复杂度：平均情况下为O(logn)，最坏情况下为O(n)。
    • 稳定性：不稳定。

归并排序是一种基于分治思想的排序算法。

  1. 归并排序：
    • 算法思想：归并排序将待排序序列递归地分成两个子序列，对每个子序列进行归并排序，然后将两个有序子序列合并成一个有序序列。重复这个过程，直到整个序列有序。
    • 时间复杂度：平均情况下为O(nlogn)，最坏情况下为O(nlogn)。
    • 空间复杂度：O(n)。
    • 稳定性：稳定。

优缺点和注意实现分析总结：

  • 直接插入排序和冒泡排序简单易懂，但对于大规模数据排序效率较低。
  • 希尔排序通过设置增量序列，可以在一定程度上提高排序效率。
  • 选择排序和堆排序的时间复杂度较高，但堆排序在大规模数据排序时相对较快。
  • 快速排序是一种高效的排序算法，但在最坏情况下可能会退化为O(n^2)的时间复杂度。
  • 归并排序具有稳定性和较高的时间复杂度，适用于大规模数据排序。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1642685.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

用队列实现栈——leetcode刷题

用队列实现栈——leetcode刷题

题目的要求是用两个队列实现栈&#xff0c;首先我们要考虑队列的特点&#xff1a;先入先出&#xff0c;栈的特点&#xff1a;后入先出&#xff0c;所以我们的目标就是如何让先入栈的成员后出栈&#xff0c;后入栈的成员先出栈。 因为有两个队列&#xff0c;于是我们可以这样想&…
阅读更多...
[Java EE] 多线程(七): 锁策略

[Java EE] 多线程(七): 锁策略

&#x1f338;个人主页:https://blog.csdn.net/2301_80050796?spm1000.2115.3001.5343 &#x1f3f5;️热门专栏:&#x1f355; Collection与数据结构 (90平均质量分)https://blog.csdn.net/2301_80050796/category_12621348.html?spm1001.2014.3001.5482 &#x1f9c0;Java …
阅读更多...
ZOC8 for Mac v8.08.1激活版：卓越性能的SSH客户端

ZOC8 for Mac v8.08.1激活版：卓越性能的SSH客户端

在远程连接和管理的世界中&#xff0c;ZOC8 for Mac以其卓越的性能和丰富的功能&#xff0c;成为了众多专业人士的首选SSH客户端。它支持SSH1、SSH2、Telnet、Rlogin、Serial等多种协议&#xff0c;让您轻松连接到远程服务器。ZOC8拥有简洁直观的界面和强大的功能设置&#xff…
阅读更多...
VMware虚拟机中ubuntu使用记录（6）—— 如何标定单目相机的内参（张正友标定法）

VMware虚拟机中ubuntu使用记录（6）—— 如何标定单目相机的内参（张正友标定法）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、张正友相机标定法1. 工具的准备2. 标定的步骤(1) 启动相机(2) 启动标定程序(3) 标定过程的操作(5)可能的报错 3. 标定文件内容解析 前言 张正友相机标定法…
阅读更多...
语义分割——铁路轨道数据集

语义分割——铁路轨道数据集

引言 亲爱的读者们&#xff0c;您是否在寻找某个特定数据集&#xff0c;用于研究或项目实践&#xff1f;欢迎您在评论区留言&#xff0c;或者通过公众号私信告诉我&#xff0c;您想要的数据集的类型主题。小编会竭尽全力为您寻找&#xff0c;并在找到后第一时间与您分享。 重…
阅读更多...
typescript 对象数组和函数

typescript 对象数组和函数

typescript 对象数组和函数 对象 在JavaScript中&#xff0c;对象属于非原始类型。对象也是一种符合数组类型&#xff0c;由若干个对象属性构成。对象属性可以是任意数据类型&#xff0c;比如数组&#xff0c;函数或者对象等。当对象属性为函数的时候&#xff0c;称为方法。 …
阅读更多...
vue3--element-plus-抽屉文件上传和富文本编辑器

vue3--element-plus-抽屉文件上传和富文本编辑器

一、封装组件 article/components/ArticleEdit.vue <script setup> import { ref } from vue const visibleDrawer ref(false)const open (row) > {visibleDrawer.value trueconsole.log(row) }defineExpose({open }) </script><template><!-- 抽…
阅读更多...
Java与Go: 生产者消费者模型

Java与Go: 生产者消费者模型

什么是生产者消费者模型 生产者-消费者模型&#xff08;也称为生产者-消费者问题&#xff09;是一种常见的并发编程模型&#xff0c;用于处理多线程或多进程之间的协同工作。该模型涉及两个主要角色&#xff1a;生产者和消费者&#xff0c;一个次要角色&#xff1a;缓冲区。 生…
阅读更多...
全方位解析Node.js：从模块系统、文件操作、事件循环、异步编程、性能优化、网络编程等高级开发到后端服务架构最佳实践以及Serverless服务部署指南

全方位解析Node.js：从模块系统、文件操作、事件循环、异步编程、性能优化、网络编程等高级开发到后端服务架构最佳实践以及Serverless服务部署指南

Node.js是一种基于Chrome V8引擎的JavaScript运行环境&#xff0c;专为构建高性能、可扩展的网络应用而设计。其重要性在于革新了后端开发&#xff0c;通过非阻塞I/O和事件驱动模型&#xff0c;实现了轻量级、高并发处理能力。Node.js的模块化体系和活跃的npm生态极大加速了开发…
阅读更多...
【React】React-redux多组件间的状态传递

【React】React-redux多组件间的状态传递

效果&#xff08;部分完整代码在最底部&#xff09;&#xff1a; 编写 Person 组件 上面的 Count 组件&#xff0c;已经在前面几篇写过了&#xff0c;也可以直接翻到最底部看 首先我们需要在 containers 文件夹下编写 Person 组件的容器组件 首先我们需要编写 index.jsx 文件…
阅读更多...
一种算法分类方式及其应用

一种算法分类方式及其应用

在计算机科学领域&#xff0c;算法是解决问题的有效方法&#xff0c;而对算法进行分类有助于理解它们的特性、优劣以及在不同场景下的应用。常见的算法分类方法&#xff0c;包括按设计思想、问题类型、数据结构和应用领域等&#xff0c;每一类算法会对应有其典型和实际应用。 算…
阅读更多...
连接HiveMQ代理器实现MQTT协议传输

连接HiveMQ代理器实现MQTT协议传输

先下载MQTTX: MQTTX: Your All-in-one MQTT Client Toolbox 使用线上免费的MQTTX BROKER:The Free Global Public MQTT Broker | Try Now | EMQ 打开MQTTX&#xff0c;创建连接&#xff0c;点击NEW SUBSCRIPTION,创建一个主题&#xff0c;这里使用test/topic,在下面Json中填写…
阅读更多...
大语言模型教程与实践（开源）

大语言模型教程与实践（开源）

1.简介 大语言模型&#xff08;Large Language Models, LLMs&#xff09;的兴起确实始于OpenAI在2018年发布的GPT&#xff08;Generative Pre-trained Transformer&#xff09;&#xff0c;这一开创性工作引领了自然语言处理领域的新纪元。随后&#xff0c;2022年底ChatGPT的横…
阅读更多...
DDD：根据maven的脚手架archetype生成ddd多模块项目目录结构

DDD：根据maven的脚手架archetype生成ddd多模块项目目录结构

随着领域驱动的兴起&#xff0c;很多人都想学习如何进行ddd的项目开发&#xff0c;那ddd的项目结构是怎么样的&#xff1f;又是如何结合SpringBoot呢&#xff1f;那么针对这个问题&#xff0c;笔者使用maven的archetype封装一个相对通用的ddd的项目目录&#xff0c;方便一键生成…
阅读更多...
Redisson 分布式锁和同步器

Redisson 分布式锁和同步器

系列文章目录 文章目录 系列文章目录前言前言 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你的码吧。 redisson 是基于redis的扩展库，使得redis除了应用于缓存以外，还能做队列…
阅读更多...
Excel 批量创建sheet页

Excel 批量创建sheet页

参考资料 最巧妙的Excel批量创建工作表方法 一. 需求 ⏹有如下模板&#xff0c;现想根据提供的姓名&#xff0c;批量创建sheet页&#xff0c;要求每个sheet页拥有相同的模板 二. 通过透视表&#xff0c;批量创建sheet页面 ⏹如下图所示的步骤&#xff0c;创建透视表后&#…
阅读更多...
3.3Java全栈开发前端+后端（全栈工程师进阶之路）-前端框架VUE3框架-企业级应用-Vue组合式API

3.3Java全栈开发前端+后端（全栈工程师进阶之路）-前端框架VUE3框架-企业级应用-Vue组合式API

为什么要使用Composition API 一个Options API实例 在前面的课程中&#xff0c;我们都是采用 Options API&#xff08;基于选项的 API &#xff09; 来写一个组件的。下面是一个实例&#xff1a; <template> Count is: {{ count }}, doubleCount is: {{ doubleCount…
阅读更多...
brpc中http2 grpc协议解析

brpc中http2 grpc协议解析

搭建gRPC服务 | bRPC https://blog.csdn.net/INGNIGHT/article/details/132657099 global.cpp http2_rpc_protocol.cpp ParseH2Message解析frame header信息 ParseResult H2Context::ConsumeFrameHead( 这个是固定长度的9字节帧头部&#xff0c;length是&#xff0c;3*8bit…
阅读更多...
七. Django项目之电商购物商城 -- 退出登录

七. Django项目之电商购物商城 -- 退出登录

Django项目之电商购物商城 – 退出登录状态 需要开发文档和前端资料的可私聊 退出登录主要是基于Django自带的logout模块 , 该功能只有在登录是保存了用户状态才可以实现调用 一. 创建退出视图 class LogoutView(View):def get(self , request):# 删除用户数据logout(reque…
阅读更多...
etcd源码流程---调试环境的搭建

etcd源码流程---调试环境的搭建

etcd启动命令&#xff1a; name必须设置&#xff0c;否则会用default&#xff0c;集群内不同etcd实例的名字应该是唯一的&#xff0c;因为他会有一个map(name->ip)。如果initial-cluster-state设置为new&#xff0c;那么他会创建一个新的clusterid。需要在initial-cluster中…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023