[数据结构1.0]快速排序

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

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

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);
}

我们试试这个快速排序：

#define _CRT_SECURE_NO_WARNINGS
#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);
}

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

#define _CRT_SECURE_NO_WARNINGS
#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)。

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

三数取中法代码：

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环境下就会崩溃，栈溢出了：

#define _CRT_SECURE_NO_WARNINGS
#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环境下：

#define _CRT_SECURE_NO_WARNINGS
#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.小区间优化

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

感谢阅读！

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

(四)Spring教程——控制反转或依赖注入与Java的反射技术

(四)Spring教程——控制反转或依赖注入与Java的反射技术

IoC的底层实现技术是反射技术&#xff0c;目前Java、C#、PHP 等语言均支持反射技术。 在运行状态中&#xff0c;对于任意一个类&#xff0c;都能够获取到这个类的所有属性和方法&#xff1b;对任意一个对象&#xff0c;都能够调用它的任意方法和属性&#xff08;包括私有的方法…
阅读更多...
【数据可视化01】matplotlib实例3之数据统计

【数据可视化01】matplotlib实例3之数据统计

目录 一、引言二、实例介绍1.百分位数为横条形图2.箱线图定制化3.带有自定义填充颜色的箱线图4.箱线图5.箱线图和小提琴图6.二维数据集的置信椭圆 一、引言 matplotlib库 可以用来创建各种静态、动态、交互式的图形&#xff0c;并广泛应用于数据分析和数据可视化领域。 二、实…
阅读更多...
6. 第K小的和-二分

6. 第K小的和-二分

6.第K小的和 - 蓝桥云课 (lanqiao.cn) #include <bits/stdc.h> #define int long long #define endl \n using namespace std; int n,m,k,an[100005],bm[100005]; int check(int x){int res0;//序列C中<x的数的个数for(int i0;i<n;i){//遍历数组A&#xff0c;对于每…
阅读更多...
【Linux】如何在Linux中配置自己的环境变量？

【Linux】如何在Linux中配置自己的环境变量？

文章目录 配置环境变量方法一&#xff1a;【>>】使用追加重定向方法二&#xff1a;使用【export PATH$PATH:/路径】(推荐) 配置环境变量 那要怎么去将一个系统路径添加到【环境变量】中呢 方法一&#xff1a;【>>】使用追加重定向 &#x1f6a9;这里一定要主要覆盖…
阅读更多...
mongodb备份还原指南

mongodb备份还原指南

MongoDB 提供的命令行实用程序mongodump和mongorestore创建备份和恢复数据的过程。 一、数据备份 mongorestore和mongodump实用程序可处理BSON数据转储&#xff0c;对于创建小型部署的备份非常有用。要实现弹性且无中断的备份&#xff0c;请将文件系统快照或区块级磁盘快照与…
阅读更多...
Git 的原理与使用（中）

Git 的原理与使用（中）

Git 的原理与使用&#xff08;上&#xff09;中介绍了Git初识&#xff0c;Git的安装与初始化以及工作区、暂存区、版本库相关的概念与操作&#xff0c;本文接着上篇的内容&#xff0c;继续深入介绍Git在的分支管理与远程操作方面的应用。 目录 五、分支管理 1.理解分支 2.创…
阅读更多...
免费Premiere模板，几何图形元素动画视频幻灯片模板素材下载

免费Premiere模板，几何图形元素动画视频幻灯片模板素材下载

Premiere Pro模板&#xff0c;几何图形元素动画视频幻灯片模板 &#xff0c;组织良好&#xff0c;易于自定义。包括PDF教程。 项目特点&#xff1a; 使用Adobe Premiere Pro 2021及以上版本。 19201080全高清。 不需要插件。 包括帮助视频。 免费下载&#xff1a;https://prmu…
阅读更多...
PyQt6--Python桌面开发（14.QCommandLinkButton命令链接按钮控件）

PyQt6--Python桌面开发（14.QCommandLinkButton命令链接按钮控件）

QCommandLinkButton命令链接按钮控件
阅读更多...
Java毕业设计 基于SpringBoot vue药店管理系统

Java毕业设计 基于SpringBoot vue药店管理系统

Java毕业设计 基于SpringBoot vue药店管理系统 SpringBoot 药店管理系统 功能介绍 员工 登录 个人中心 修改密码 个人信息 查看供应商信息 查看药品 查看进货 查看销售 管理员 登录 个人中心 修改密码 个人信息 供应商类型管理 供应商信用等级类型管理 药品类型管理 供应商信…
阅读更多...
【Web后端】MVC模式

【Web后端】MVC模式

1、简介 MVC模式&#xff0c;全称Model-View-Controller&#xff08;模型-视图-控制器&#xff09;模式&#xff0c;是一种软件设计典范&#xff0c;它将应用程序的用户界面&#xff08;视图&#xff09;和业务逻辑&#xff08;模型&#xff09;分离&#xff0c;同时提供了一个…
阅读更多...
langchain_community FAISS保存与加载faiss index

langchain_community FAISS保存与加载faiss index

参考： https://github.com/langchain-ai/langchain/issues/18285 https://api.python.langchain.com/en/latest/vectorstores/langchain_community.vectorstores.faiss.FAISS.html#langchain_community.vectorstores.faiss.FAISS 1、保存save_local import pandas as pd ##…
阅读更多...
（深度估计学习）Win11复现DepthFM

（深度估计学习）Win11复现DepthFM

目录 1. 系统配置2. 拉取代码&#xff0c;配置环境3.开始深度预测4.运行结果 论文链接&#xff1a;https://depthfm.github.io/ 讲解链接&#xff1a;https://www.php.cn/faq/734404.html 1. 系统配置 本人系统&#xff1a;Win11 CUDA12.2 python3.11.5 这里附上几个CUDA安装链…
阅读更多...
iOS——runtime

iOS——runtime

什么是runtime 我们都知道&#xff0c;将源代码转换为可执行的程序&#xff0c;通常要经过三个步骤&#xff1a;编译、链接、运行。 C 语言 作为一门静态类语言&#xff0c;在编译阶段就已经确定了所有变量的数据类型&#xff0c;同时也确定好了要调用的函数&#xff0c;以及函…
阅读更多...
算法提高之加成序列

算法提高之加成序列

算法提高之加成序列 核心思想&#xff1a;迭代加深 dfs 从上往下逐渐增大depth 这样下面没有用的方案就不用遍历了 #include <iostream>#include <cstring>#include <algorithm>using namespace std;const int N 110;int n;int path[N];//当前求哪个位置…
阅读更多...
如何去掉图片背景改成透明的?一键图片去底色工具推荐

如何去掉图片背景改成透明的?一键图片去底色工具推荐

如何去掉图片背景改成透明的&#xff1f;在很多比较特殊的场景中&#xff0c;我们需要把图片背景底色去除后再进行使用&#xff0c;比如一些商品展示图或者是网页设计中的一些logo图标&#xff0c;专业人士会直接选择使用ps来处理&#xff0c;但是也有许多新手小白不知道怎么去…
阅读更多...
steam商店打不开、steam商店错误代码-118的解决方法

steam商店打不开、steam商店错误代码-118的解决方法

现在steam已经开始了&#xff0c;有很多好玩的游戏都在这段时间相继打折&#xff0c;虽然游戏众多&#xff0c;但是不是所有人都能把这些游戏都买下来&#xff0c;有一些小伙伴喜欢的游戏苦于没有足够的资本去购买&#xff0c;steam会以各种名义举办特惠活动吸引玩家们&#xf…
阅读更多...
如何实现微信扫码登录windows操作系统

如何实现微信扫码登录windows操作系统

将微信扫码登录功能集成到Windows操作系统级别的身份认证系统&#xff08;如你所提到的“安当ASP身份认证系统”&#xff09;是一个复杂的任务&#xff0c;因为Windows操作系统本身并不直接支持第三方应用&#xff08;如微信&#xff09;作为登录凭证。然而&#xff0c;你可以通…
阅读更多...
Docker 部署 Nginx 实现一个极简的 负载均衡

Docker 部署 Nginx 实现一个极简的 负载均衡

背景: Nginx是异步框架的网页服务器&#xff0c;其常用作反向代理(负载均衡器)。在一般的小项目中, 服务器不多, 如果不考虑使用服务注册与发现, 使用Nginx 可以容易实现负载均衡。 在特此写一个快速入门 Nginx 的技术贴, 使用 Docker 部署 Nginx, 实现一个极简的加权轮询负载均…
阅读更多...
obsidian 外观设置解毒

obsidian 外观设置解毒

前言 一入obsidian深似海&#xff0c;外观设置也是五花八门&#xff0c;仿佛回到读书时期折腾桌面一样。 我对比了AnuPpuccin、minimal和其他的一些外观主题&#xff0c;设置都太复杂了&#xff0c;尤其是需要调整CSS文件&#xff0c;最后发现一款&#xff0c;非常好用&#…
阅读更多...
OpenHarmony 3.1 Release实战开发 + Linux 原厂内核Launcher起不来问题分析报告

OpenHarmony 3.1 Release实战开发 + Linux 原厂内核Launcher起不来问题分析报告

1、关键字 Launcher 无法启动&#xff1b;原厂内核&#xff1b;Access Token ID&#xff1b; 2、问题描述 芯片&#xff1a;rk3566&#xff1b;rk3399 内核版本&#xff1a;Linux 4.19&#xff0c;是 RK 芯片原厂发布的 rk356x 4.19 稳定版内核 OH 版本&#xff1a;OpenHa…
阅读更多...
最新文章

Copyright @ 2022~2023