【数据结构】论如何拿捏快速排序？（含非递归）

news2024/11/15 4:55:45

目录

一，快速排序（递归）

1，快排思想

2，霍尔排序

3，挖坑法

4，前后指针法

5，快速排序优化

1，三数取中法选key

2，小区间优化

二，快速排序（非递归）

Stack.h

Stack.c

三，快速排序源代码

一，快速排序（递归）

1，快排思想

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

基本代码思想如下： 

// 假设按照升序对array数组中[left, right)区间中的元素进行排序
void QuickSort(int array[], int left, int right)
{
 if(right < left)
 return;
 
 // 按照基准值对array数组的 [left, right)区间中的元素进行划分
 int div = partion(array, left, right);
 
 // 划分成功后以div为边界形成了左右两部分 [left, div) 和 [div+1, right)
 // 递归排[left, div)
 QuickSort(array, left, div);
 
 // 递归排[div+1, right)
 QuickSort(array, div+1, right);
}

上述为快速排序递归实现的主框架，发现与二叉树前序遍历规则非常像，同学们在写递归框架时可想想二叉树前序遍历规则即可快速写出来，后序只需分析如何按照基准值来对区间中数据进行划分的方式即可；

2，霍尔排序

根据快排思想，我们需要实现的就是 partion 函数了----将区间按照基准值划分为左右两半部分；

常见的方式有很多，我们先来了解最初的版本 【霍尔排序】

思想图解：

对就是这样的，右边的小人先出发向左移动，找到比 key 小的数，然后左边的小人向右移动找到比  key 大的数，然后交换两个小人的值，直至他们相遇然后再交换 key 与任意一个小人的值；

这样一趟下来，他们相遇后，左边的数都比 key 小，右边的数都比 key 大；

思路实现：

//霍尔排序
int PartSort1(int* arr, int left, int right)
{
	int keyi = left;
	while (left < right)
	{
		//右边先走
		while (left<right && arr[right]>=arr[keyi])
		{
			right--;
		}
		//左边后走
		while (left < right && arr[left] <= arr[keyi])
		{
			left++;
		}
		//交换
		Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[keyi]);
	return left;
}

然后我们运行一下：

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)
	{
		return NULL;
	}
    //霍尔法
	int keyi = PartSort1(arr, begin, end);
	//排序[begin,keyi) & [keyi+1,end]
	QuickSort(arr, begin, keyi);
	QuickSort(arr, keyi + 1, end);
}

int main()
{
	int arr[] = { 9,1,2,5,7,4,8,6,3,5 };

	//快速排序
	QuickSort(arr, 0,sizeof(arr) / sizeof(arr[0])-1);
	PrintSort(arr, sizeof(arr) / sizeof(arr[0]));
	return 0;
}

可以看到是有序的，选择排序就 OK 了；

3，挖坑法

然后我们再来认识另一种方式 【挖坑法】，其实跟【霍尔排序】思路差不多，不过更容易理解一点；

思想图解:

对还是一样的思路，让第一个元素为坑位，然后右边的小人先出发向左走找比 key 小的数，然后填充坑位并且右边小人的位置变为新坑位，然后左边的小人向右走找比 key 大的数，然后填充坑位并且左边小人的位置变为新坑位，直至两个小人相遇于坑位然后再给坑位赋值 key ；

这样一趟下来，坑位左边的数都比 key 小，右边的数都比 key 大；

思路实现：

//挖坑法
int PartSort2(int* arr, int left, int right)
{
	int key = arr[left];
    //坑位
	int hole = left;
	while (left < right)
	{
        //右边找小
		while (left < right && arr[right] >= key)
		{
			right--;
		}
		arr[hole] = arr[right];
		hole = right;
        //左边找大
		while (left < right && arr[left] <= key)
		{
			left++;
		}
		arr[hole] = arr[left];
		hole = left;
	}
	arr[hole] = key;
	return hole;
}

然后我们运行一下：

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)
	{
		return NULL;
	}
    //挖坑法
	int keyi = PartSort2(arr, begin, end);
	//排序[begin,keyi) & [keyi+1,end]
	QuickSort(arr, begin, keyi);
	QuickSort(arr, keyi + 1, end);
}

可以看到是有序的，选择排序就 OK 了；

4，前后指针法

然后呢，在介绍最后一种排序方式了 【前后指针】法；

这个呢就比较新颖了，跟之前的都不一样；

请看图解：

这个呢就是，定义两个指针，从首元素开始走，快指针（cur）刚开始领先慢指针（prev）一个身位，然后 cur 先走找比 key 小的数，然后与 prev 的下一个数交换，直至 cur 越界，然后再让 prev 与 key 交换；

这样一趟下来，prev 左边的数都比 key 小，右边的数都比 key 大；

 思路实现：

//前后指针法
int PartSort3(int* arr, int left, int right)
{
	int keyi = left;
	int slow = left, fast = left+1;
	while (fast<=right)
	{
		if (arr[fast] < arr[keyi] && ++slow!=fast)
		{
			//交换
			Swap(&arr[fast], &arr[slow]);
		}
		fast++;
	}
	Swap(&arr[slow], &arr[keyi]);
	return slow;
}

然后我们运行一下：

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	if (begin >= end)
	{
		return NULL;
	}
	int keyi = PartSort3(arr, begin, end);
	//排序[begin,keyi) & [keyi+1,end]
	QuickSort(arr, begin, keyi);
	QuickSort(arr, keyi + 1, end);
}

可以看到是有序的，选择排序就 OK 了；

5，快速排序优化

1，三数取中法选key

这第一个呢，就是对 key 的取值进行优化，当 key 的值太过于小或者大时，遍历数组的时间会增加，所以我们尽量让 key 的取值随机；

我们可以取首元素，尾元素，中间元素的值进行比较选 key ；

思路实现：

//三数取中
int middle(int* arr, int left, int right)
{
	//int mid = (left +right)/ 2;
	if (arr[left] < arr[mid])
	{
		if (arr[mid] < arr[right])
		{
			return mid;
		}
		if (arr[left] < arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	//arr[mid]<=arr[left]
	else
	{
		if (arr[mid] > arr[right])
		{
			return mid;
		}
		if (arr[left] > arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
}

这样我们选择的 key 就不会受 首元素的束缚了；

我们还可不可以在这个基础上再优化一下呢？

答案是肯定的！

我们可以用随机数来取代中间数；

//三数取中
int middle(int* arr, int left, int right)
{
	//随机数取中
	int mid = left + (rand() % (right - left));
	if (arr[left] < arr[mid])
	{
		if (arr[mid] < arr[right])
		{
			return mid;
		}
		if (arr[left] < arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	//arr[mid]<=arr[left]
	else
	{
		if (arr[mid] > arr[right])
		{
			return mid;
		}
		if (arr[left] > arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
}

这样子才是真正意义上的随机值，这样 key 就不受束缚了，再任何场景下都可以排序自如；

我们选完 key 的下标后，要让数组首元素的值与之交换，这样后面不动就 OK 了；

以【前后指针法】为例：

//前后指针法
int PartSort3(int* arr, int left, int right)
{
	//三数取中
	int ret = middle(arr, left, right);
	Swap(&arr[left], &arr[ret]);
	int keyi = left;
	int slow = left, fast = left+1;
	while (fast<=right)
	{
		if (arr[fast] < arr[keyi] && ++slow!=fast)
		{
			//交换
			Swap(&arr[fast], &arr[slow]);
		}
		fast++;
	}
	Swap(&arr[slow], &arr[keyi]);
	return slow;
}

主函数需要写 srand 函数来引用随机值；

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	srand(time(0));
	if (begin >= end)
	{
		return NULL;
	}
	int keyi = PartSort3(arr, begin, end);
	//排序[begin,keyi) & [keyi+1,end]
	QuickSort(arr, begin, keyi);
	QuickSort(arr, keyi + 1, end);
}

现在我们运行测试一下：

其实速度是更快的，大家可以在【力扣】上测试一下；

2，小区间优化

还有一种优化方式是当递归到小的子区间时，可以考虑使用插入排序；

当数组的区间不大时，使用【插入排序】是会更快的，同时也可以减少压栈的次数，也就是降低【空间复杂度】；

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	srand(time(0));
	if (begin >= end)
	{
		return NULL;
	}
	if (end - begin <10)
	{
		InsertSort1(arr,begin,end);
	}
	else
	{
		int keyi = PartSort3(arr, begin, end);
		//排序[begin,keyi) & [keyi+1,end]
		QuickSort(arr, begin, keyi);
		QuickSort(arr, keyi + 1, end);
	}
}

然后我们还需要改变一下插入排序，之前都是传数组元素个数的，现在我们要传区间需要改造一下；

//插入排序(改造版)
void InsertSort1(int* arr, int left, int right)
{
	int i = 0;
	for (i = left; i < right; i++)
	{
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] >= tmp)
			{
				//交换
				Swap(&arr[end], &arr[end + 1]);
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}

这样就可以了，现在我们运行测试一下：

可以看到是有序的，选择排序就 OK 了；

二，快速排序（非递归）

之前咱们拿捏了递归版的快速排序，现在咱们来秒杀非递归版的快速排序；

我们之前了解到，快速排序与二叉树的前序遍历相似，所以我们非递归也要用这种手法来表示；

所以我们需要借助【栈】来帮助我们来实现；

因为【栈】的特性（后进先出）很符合二叉树的前序遍历的思想，这样我们可以先排序最左边的序列，在排序右边的，前面的都放在【栈】里等后面排序；

所以我们需要一个【栈】：

Stack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>

typedef int STDataType;
typedef struct StackTop
{
	STDataType* a;
	int top;
	int capacity;
}ST;

//初始化
void STInit(ST* ps);
//销毁
void STDestroy(ST* ps);
//插入
void STPush(ST* ps, STDataType x);
//删除
void STPop(ST* ps);
//返回栈顶
STDataType STInsert(ST* ps);
//数量
int STSize(ST* ps);
//判断是否为空
int STEmpty(ST* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

//初始化
void STInit(ST* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
//销毁
void STDestroy(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}
//插入
void STPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		ps->capacity = ps->top == 0 ? 4 : ps->capacity*2;
		ps->a = (STDataType*)realloc(ps->a,sizeof(STDataType)*ps->capacity);
	}
	ps->a[ps->top] = x;
	ps->top++;
}
//删除
void STPop(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	ps->top--;
}
//返回栈顶
STDataType STInsert(ST* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top-1];
}
//数量
int STSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//判断是否为空
int STEmpty(ST* ps)
{
	assert(ps);
	if (ps->top == 0)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

然后我们就可以实现代码了；

我们的思路是：

将两边的下标存进【栈】，然后再取栈顶元素进行排序（霍尔或者其他），每取一个栈顶元素之后要把栈顶元素删除，然后再存放 keyi 两边的区间，再重复上面的过程，直至【栈】为空排序结束；

//快速排序(非递归)
void QuickNon(int* arr, int begin, int end)
{
	srand(time(0));
	ST ps;
	//初始化
	STInit(&ps);
	if (begin >= end)
	{
		return;
	}
	//插入
	STPush(&ps, end);
	STPush(&ps, begin);
	//栈不为空就进去
	while (!STEmpty(&ps))
	{
		int left = STInsert(&ps);//栈顶元素
		STPop(&ps);//删除
		int right = STInsert(&ps);
		STPop(&ps);

		int keyi = PartSort1(arr, left, right);
		//排序[left,keyi-1] & [keyi+1,right]
		if (keyi + 1 < right)
		{
			//插入
			STPush(&ps, right);
			STPush(&ps, keyi + 1);
		}
		if (left < keyi - 1)
		{
			//插入
			STPush(&ps, keyi - 1);
			STPush(&ps, left);
		}
	}
	//销毁
	STDestroy(&ps);
}

我们运行测试一下：

可以看到也是完全 OK 的；

这就是快速排序的非递归实现！

三，快速排序源代码

以上的快速排序的全部代码如下（不包括【栈】）：

//三数取中
int middle(int* arr, int left, int right)
{
	//int mid = (left +right)/ 2;
	//随机数取中
	int mid = left + (rand() % (right - left));
	if (arr[left] < arr[mid])
	{
		if (arr[mid] < arr[right])
		{
			return mid;
		}
		if (arr[left] < arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	//arr[mid]<=arr[left]
	else
	{
		if (arr[mid] > arr[right])
		{
			return mid;
		}
		if (arr[left] > arr[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
}

//霍尔排序
int PartSort1(int* arr, int left, int right)
{
	//三数取中
	int ret = middle(arr, left, right);
	Swap(&arr[left], &arr[ret]);
	int keyi = left;
	while (left < right)
	{
		//右边先走
		while (left<right && arr[right]>=arr[keyi])
		{
			right--;
		}
		//左边后走
		while (left < right && arr[left] <= arr[keyi])
		{
			left++;
		}
		//交换
		Swap(&arr[left], &arr[right]);
	}
	Swap(&arr[left], &arr[keyi]);
	return left;
}

//挖坑法
int PartSort2(int* arr, int left, int right)
{
	//三数取中
	int ret = middle(arr, left, right);
	Swap(&arr[left], &arr[ret]);
	int key = arr[left];
	int hole = left;
	while (left < right)
	{
		while (left < right && arr[right] >= key)
		{
			right--;
		}
		arr[hole] = arr[right];
		hole = right;
		while (left < right && arr[left] <= key)
		{
			left++;
		}
		arr[hole] = arr[left];
		hole = left;
	}
	arr[hole] = key;
	return hole;
}

//前后指针法
int PartSort3(int* arr, int left, int right)
{
	//三数取中
	int ret = middle(arr, left, right);
	Swap(&arr[left], &arr[ret]);
	int keyi = left;
	int slow = left, fast = left+1;
	while (fast<=right)
	{
		if (arr[fast] < arr[keyi] && ++slow!=fast)
		{
			//交换
			Swap(&arr[fast], &arr[slow]);
		}
		fast++;
	}
	Swap(&arr[slow], &arr[keyi]);
	return slow;
}

//插入排序(改造版)
void InsertSort1(int* arr, int left, int right)
{
	int i = 0;
	for (i = left; i < right; i++)
	{
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] >= tmp)
			{
				//交换
				Swap(&arr[end], &arr[end + 1]);
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}

//快速排序
void QuickSort(int* arr, int begin, int end)
{
	srand(time(0));
	if (begin >= end)
	{
		return NULL;
	}
	if (end - begin <10)
	{
		InsertSort1(arr,begin,end);
	}
	else
	{
		int keyi = PartSort1(arr, begin, end);
		//排序[begin,keyi) & [keyi+1,end]
		QuickSort(arr, begin, keyi);
		QuickSort(arr, keyi + 1, end);
	}
}

//快速排序(非递归)
void QuickNon(int* arr, int begin, int end)
{
	srand(time(0));
	ST ps;
	//初始化
	STInit(&ps);
	if (begin >= end)
	{
		return;
	}
	//插入
	STPush(&ps, end);
	STPush(&ps, begin);
	//栈不为空就进去
	while (!STEmpty(&ps))
	{
		int left = STInsert(&ps);//栈顶元素
		STPop(&ps);//删除
		int right = STInsert(&ps);
		STPop(&ps);

		int keyi = PartSort1(arr, left, right);
		//排序[left,keyi-1] & [keyi+1,right]
		if (keyi + 1 < right)
		{
			//插入
			STPush(&ps, right);
			STPush(&ps, keyi + 1);
		}
		if (left < keyi - 1)
		{
			//插入
			STPush(&ps, keyi - 1);
			STPush(&ps, left);
		}
	}
	//销毁
	STDestroy(&ps);
}
 特性总结：

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

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

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

4， 稳定性：不稳定

第三阶段就到这里了，带大家啃块硬骨头磨磨牙！

后面博主会陆续更新；

如有不足之处欢迎来补充交流！

完结。。

再次祝大家国庆节快乐！

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

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

相关文章

超大视频如何优雅切片

超大视频如何优雅切片

背景 有一次录屏产生了一个大小为33G的文件, 我想把他上传到B站, 但是B站最大只支持4G. 无法上传, 因此做了一个简单的探索. 质疑与思考 a. 有没有一个工具或一个程序协助我做分片呢? 尝试 a. 必剪 > 有大小限制, 添加素材加不进去(而且报错信息也提示的不对) b. PR &…
阅读更多...
深入剖析红黑树：优雅地平衡二叉搜索树

深入剖析红黑树：优雅地平衡二叉搜索树

目录 一.红黑树的概念二.插入操作三.与AVL树的比较 一.红黑树的概念 在之前的学习中&#xff0c;我们了解了二叉搜索平衡树&#xff0c;AVL树通过控制每个结点中的平衡因子的绝对值不超过1&#xff0c;实现了一个高性能的树。而相较于AVL的高度平衡&#xff0c;红黑树觉得AVL为…
阅读更多...
Java 基于 SpringBoot+Vue 的留守儿童关爱网站

Java 基于 SpringBoot+Vue 的留守儿童关爱网站

文章目录 1.研究背景2. 技术栈3.系统分析4系统设计5系统的详细设计与实现5.1系统功能模块5.2管理员功能模块 源码下载地址 1.研究背景 以往的留守儿童爱心的管理&#xff0c;一般都是纸质文件来管理留守儿童爱心信息&#xff0c;传统的管理方式已经无法满足现代人们的需求&…
阅读更多...
《存储IO路径》-进程、线程和任务的区别

《存储IO路径》-进程、线程和任务的区别

在Linux IO系统架构中&#xff0c;我们经常会听到进程、线程、任务、jbobs&#xff0c;QD&#xff0c;这些词汇常常会有一些模糊和混淆&#xff0c;本文我们主要对比下这几个概念的区别。 我们来看看这些术语在Linux IO路径中的角色&#xff1a; Process&#xff08;进程&…
阅读更多...
基于STM32 ZigBee无线远程火灾报警监控系统物联网温度烟雾

基于STM32 ZigBee无线远程火灾报警监控系统物联网温度烟雾

实践制作DIY- GC00168---ZigBee无线远程监控系统 一、功能说明&#xff1a; 基于STM32单片机设计---ZigBee无线远程监控系统 二、功能说明&#xff1a; 1个主机&#xff1a;STM32F103C系列单片机LCD1602显示器蜂鸣器 ZigBee无线模块3个按键&#xff08;设置、加、减&#xff0…
阅读更多...
计算机竞赛 题目：基于FP-Growth的新闻挖掘算法系统的设计与实现

计算机竞赛 题目：基于FP-Growth的新闻挖掘算法系统的设计与实现

文章目录 0 前言1 项目背景2 算法架构3 FP-Growth算法原理3.1 FP树3.2 算法过程3.3 算法实现3.3.1 构建FP树 3.4 从FP树中挖掘频繁项集 4 系统设计展示5 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 基于FP-Growth的新闻挖掘算法系统的设计与实现…
阅读更多...
Gallery2分析

Gallery2分析

本文分析的代码基于 Android 4.x 文章目录 Gallery2介绍基本数据数据源DataManager数据管理LocalSource本地数据源Media数据的加载过程Gallery2页面结构ActivityStateStateManagerGalleryAppImplAbstractGalleryActivityGalleryActivityAlbumSetPage数据加载和渲染过程分析第四…
阅读更多...
Python操作MongoDb创建文档及CRUD基本操作

Python操作MongoDb创建文档及CRUD基本操作

Python3中类的高级语法及实战 Python3(基础|高级)语法实战(|多线程|多进程|线程池|进程池技术)|多线程安全问题解决方案 Python3数据科学包系列(一):数据分析实战 Python3数据科学包系列(二):数据分析实战 Python3数据科学包系列(三):数据分析实战 MongoDB 操作手册----文档…
阅读更多...
Access注入---偏移注入 | Mysql注入---DNS注入 | MSSQL---反弹注入

Access注入---偏移注入 | Mysql注入---DNS注入 | MSSQL---反弹注入

伪静态---假的静态页面判断页面是否为静态&#xff1a;document.lastModified偏移注入使用场景&#xff1a;遇到知道表明&#xff0c;但不知道字段名的情况下使用表.* >&#xff08;核心&#xff09;information_schema.tables&#xff08;去information_schema库里面选中ta…
阅读更多...
头戴式耳机怎么戴好看？头戴式耳机正确代法

头戴式耳机怎么戴好看？头戴式耳机正确代法

走在大街上总能看到那么一些人&#xff0c;他们眼神时而朦胧涣散&#xff0c;时而精神奕奕&#xff0c;全身上下始终散发着#请勿打扰#的气息&#xff0c;因为他们都戴着头&#xff01;戴&#xff01;式&#xff01;耳&#xff01;机&#xff01;但是头戴式耳机把头压得扁扁的&a…
阅读更多...
UG\NX CAM二次开发 创建加工环境 UF_SETUP_create

UG\NX CAM二次开发 创建加工环境 UF_SETUP_create

文章作者：代工 来源网站：NX CAM二次开发专栏 简介： UG\NX CAM二次开发 创建加工环境 UF_SETUP_create,我们ug编程也是要进去加工模块加载环境，选择模板的这是我们加工编程的第一步 代码实现进入加工环境： void MyClass::do_it() { // 创建加工设置 UF_SETUP…
阅读更多...
1300*D. Alice, Bob and Candies（模拟）

1300*D. Alice, Bob and Candies（模拟）

Problem - 1352D - Codeforces 解析&#xff1a; 模拟即可。 #include<bits/stdc.h> using namespace std; #define int long long const int N2e55; int t,n,a[N]; signed main(){scanf("%lld",&t);while(t--){scanf("%lld",&n);for(int i…
阅读更多...
XPD977协议系列-支持 XPD-LINK™互联 USB 三端口控制器

XPD977协议系列-支持 XPD-LINK™互联 USB 三端口控制器

XPD977 是一款集成 USB Type-C、USB Power Delivery&#xff08;PD&#xff09; 3.0/2.0 以及 PPS、QC3.0/2.0CLASS B 快充协议、华为 FCP/SCP 快充协议、三星 AFC 快充协议、VOOC 2.0 快 充协议、BC1.2 DCP 以及苹果设备 2.4A 充电规范的多功能 USB 三端口控制器&#xff0c;为…
阅读更多...
【LeetCode刷题笔记】二维数组

【LeetCode刷题笔记】二维数组

498.对角线遍历 解题思路&#xff1a; 简化问题&#xff0c;首先考虑按照逐条对角线打印元素&#xff0c;而不考虑翻转的情况。 M 行 N 列的二维矩阵总共有 M N - 1 条对角线&#xff08; 右上 -> 左下 &#xff09; 1&#xff09;如何遍历&#xff1a; 从左往右遍历 对角…
阅读更多...
【小沐学C++】git和github常见问题汇总

【小沐学C++】git和github常见问题汇总

文章目录 1、简介2、下载和安装2.1 Git2.2 TortoiseGit 3、相关功能3.1 基本命令3.2 更新子模块命令 4、常见问题4.1 GitHub访问慢或者无法访问4.1.1 修改本地hosts映射4.1.2 通过Gitee中转fork仓库下载 4.2 OpenSSL SSL_read: Connection was reset, errno 10054 结语 1、简介…
阅读更多...
怎么将Linux上的文件上传到github上

怎么将Linux上的文件上传到github上

文章目录 1. 先在window浏览器中创建一个存储项目的仓库2. 复制你的ssh下的地址1) 生成ssh密钥 : 在Linux虚拟机的终端中,运行以下命令生成ssh密钥2)将ssh密钥添加到github账号 : 运行以下命令来获取公钥内容:3. 克隆GitHub存储库：在Linux虚拟机的终端中，导航到您想要将文件上…
阅读更多...
redis的持久化消息队列

redis的持久化消息队列

Redis Stream Redis Stream 是 Redis 5.0 版本新增加的数据结构。 Redis Stream 主要用于消息队列&#xff08;MQ&#xff0c;Message Queue&#xff09;&#xff0c;Redis 本身是有一个 Redis 发布订阅 (pub/sub) 来实现消息队列的功能&#xff0c;但它有个缺点就是消息无法…
阅读更多...
OOTD | 美式复古穿搭耳机，复古轻便的头戴式耳机推荐

OOTD | 美式复古穿搭耳机，复古轻便的头戴式耳机推荐

复古耳机更能带来年代感的复古数码产品&#xff0c;头戴式耳机就好似是时光滤镜的时髦配饰&#xff0c;不说功能实用性&#xff0c;在造型上添加就很酷。 随着时代的发展&#xff0c;时尚有了新的定义。对如今的消费者来说&#xff0c;时尚不仅是美学与个性的展现&#xff0c;…
阅读更多...
各种机器码的本质（原码、反码、补码、移码、IEEE754格式阶码）

各种机器码的本质（原码、反码、补码、移码、IEEE754格式阶码）

总述 无论使用什么格式的机器码来表示真值&#xff0c;若取一定位数n以后&#xff0c;各个比特位的排列个数是一定的&#xff0c;为 2 n 2^n 2n种排列&#xff0c;所以选择什么格式的机器码实质上选择什么映射方式来完成从这 2 n 2^n 2n种离散排列到离散的整数真值的映射&…
阅读更多...
Open X-Embodiment Robotic Learning Datasets and RT-X Models

Open X-Embodiment Robotic Learning Datasets and RT-X Models

文章目录 简介论文链接项目链接Reference 简介 为什么机器人技术远远落后于 NLP、视觉和其他 AI 领域&#xff1f;除其他困难外&#xff0c;数据短缺是罪魁祸首。谷歌 DeepMind 联合其他机构推出了 Open X-Embodiment 数据集&#xff0c;并训练出了能力更强的 RT-X 模型。 Dee…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023