【排序算法】实现快速排序值（霍尔法三指针法挖坑法优化随即选key中位数法小区间法非递归版本）

请添加图片描述

文章目录

  • 📝快速排序
    • 🌠霍尔法
    • 🌉三指针法
    • 🌠挖坑法
      • ✏️优化快速排序
  • 🌠随机选key
    • 🌉三位数取中
  • 🌠小区间选择走插入，可以减少90%左右的递归
  • 🌉 快速排序改非递归版本
  • 🚩总结

📝快速排序

快速排序是一种分治算法。它通过一趟排序将数据分割成独立的两部分,然后再分别对这两部分数据进行快速排序。

本文将用3种方法实现：

🌠霍尔法

霍尔法是一种快速排序中常用的单趟排序方法，由霍尔先发现。

它通过选定一个基准数key（通常是第一个元素），然后利用双指针left和right的方式进行排序，right指针先找比key基准值小的数，left然后找比key基准值大的数，找到后将两个数交换位置，同时实现大数右移和小数左移，当left与right相遇就排序完成，然后将下标key的值与left交换，返回基准数key的下标，完成了单趟排序。这一过程使得基准数左侧的元素都比基准数小，右侧的元素都比基准数大。

如图动图展示：
请添加图片描述
以下是单趟排序的详解图解过程：

  • begin和end记录区间的范围，left记录做下标，从左向右遍历，right记录右下标，从右向左遍历，以第一个数key作为基基准值
    在这里插入图片描述
  • 先让right出发，找比key值小的值，找到就停下来
    在这里插入图片描述
  • 然后left再出发，找比key大的值，若是找到则停下来，与right的值进行交换
    在这里插入图片描述
  • 接着right继续找key小的值，找到后才让left找比key大的值，直到left相遇right，此时left会指向同一个数
    在这里插入图片描述
    在这里插入图片描述
  • 将left与right指向的数与key进行交换，单趟排序就完成了，最后将基准值的下标返回
    在这里插入图片描述
    为啥相遇位置比key要小->右边先走保证的
  1. L遇R: R先走,R在比key小的位置停下来了，L没有找到比key大的，就会跟R相遇相遇位置R停下的位置，是比key小的位置
  2. R遇L:第一轮以后的，先交换了，L位置的值小于key,R位置的值大于key ，R启动找小，没有找到，跟L相遇了，相遇位置L停下位置，这个位置比key小
  • 第一轮R遇L，那么就是R没有找到小的，直接就一路左移，遇到L，也就是key的位置

代码实现

void Swap(int* px, int* py)
{
	int tmp = *px;
	*px = *py;
	*py = tmp;
}

//Hoare经典随机快排
void QuickSort1(int* a, int left, int right)
{
	// 如果左指针大于等于右指针,表示数组为空或只有一个元素,直接返回
	if (left >= right)
		return;

	// 区间只有一个值或者不存在就是最小子问题
	int begin = left, end = right;// begin和end记录原始整个区间
	// keyi为基准值下标,初始化为左指针
	int keyi = left;

	 // 循环从left到right
	while (left < right)
	{
		// right先走，找小，这里和下面的left<right一方面也是为了防止,right一路走出区间，走到left-1越界
		while (left<right && a[right] >= a[keyi])
		{
			--right;
		}
		// 左指针移动,找比基准值大的元素   
		while (left<right && a[left] <= a[keyi])
		{
			++left;
		}
		Swap(&a[left], &a[right]);
	}
	// 交换左右指针所指元素
	Swap(&a[left], &a[keyi]);
	// 更新基准值下标
	keyi = left;
	
	// 递归排序左右两部分
	//[begin , keyi-1]keyi[keyi+1 , end]
	QuickSort1(a, begin, keyi - 1);
	QuickSort1(a, keyi + 1, end);

}

🌉三指针法

定义一个数组，第一个元素还是key基准值，定义前指针prev指向第一个数，后指针cur指向第二个数，让cur走，然后遍历数组，cur找到大于等于key基准值的数，cur++让cur向前走一步。当cur指针小于key基准值时，后指针加一走一步（++prev），然后交换prev和cur所指的值进行交换，因为这样cur一直都是小于key的值，让他继续向前不断找大的，而prev一直在找小的。依次类推，到cur遍历完数组，完成单趟排序。
如此动图理解：
请添加图片描述
简单总结：
在这里插入图片描述
以下是单趟排序的详解图解过程：

  1. 一开始，让prev指向第一个数，cur指向prev的下一位，此时cur位置的数比key基准值小，所以prev加一后，与cur位置的数交换，由于此时prev+1 == cur，自己跟自己交换，交换没变，完了让cur++走下一个位置。
    在这里插入图片描述
    紧接着：
    在这里插入图片描述

  2. cur继续前进，此时来到了7的位置，大于key的值6，cur++继续向前走，来到9位置，9还是大于6，OK ! 我cur再cur++，来到3的位置，也是看到cur与prev拉开了距离，所以他又叫前后指针，这就体现出来，往下看–》
    在这里插入图片描述
    在这里插入图片描述

  3. 此时此刻，我cur的值小于key基准值，先让prev走一步，然后与cur的值交换交换
    在这里插入图片描述
    在这里插入图片描述

  4. 同样的步骤，重复上述遍历，直到遍历完数组

在这里插入图片描述在这里插入图片描述

  1. cur遍历完数组后，将交换prev的值key的基准值进行交换，交换完，将key的下标更新为prev下标的，然后返回key下标，完成单趟。
    在这里插入图片描述
    代码如下：
void QuickSort2(int* a, int left, int right)
{
	// 如果左指针大于等于右指针,表示数组为空或只有一个元素,直接返回
	if (left >= right)
		return;
		
	// keyi为基准值下标,初始化为左指针
	int keyi = left;
	
	// prev记录每次交换后的下标
	int prev = left;

	// cur为遍历指针
	int cur = left+1;
	
	// 循环从左指针+1的位置开始到右指针结束
	while (cur <= right)
	{
		// 如果cur位置元素小于基准值,并且prev不等于cur
	    // 就将prev和cur位置元素交换
	    // 并将prev后移一位
		if (a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[prev], &a[cur]);

		++cur;//不管是cur小于还是大于，是否交换,cur都后移一位      cur都++
	}
	// 将基准值和prev位置元素交换
	Swap(&a[keyi], &a[prev]);
	 // 更新基准值下标为prev
	keyi = prev;
	
	// 递归调用左右两部分
	// [left, keyi-1]keyi[keyi+1, right]
	QuickSort2(a, left, keyi - 1);
	QuickSort2(a, keyi + 1, right);
}

🌠挖坑法

挖坑法也是快速排序的一种单趟排序方法。它也是利用双指针，但与霍尔法不同的是，挖坑法在每次找到比基准数小的元素时，会将其值填入基准数所在的位置，然后将基准数所在的位置作为“坑”，接着从右边开始找比基准数大的元素填入这个“坑”，如此往复，直到双指针相遇。最后，将基准数填入最后一个“坑”的位置。
请添加图片描述
挖坑法思路：
您提到的挖坑法是一种快速排序的实现方式。

  1. 选择基准值(key),将其值保存到另一个变量pivot中作为"坑"
  2. 从左往右扫描,找到小于基准值的元素,将其值填入"坑"中,然后"坑"向右移动一个位置
  3. 从右往左扫描,找到大于或等于基准值的元素,将其值填入移动后的"坑"中
  4. 重复步骤2和3,直到左右两个指针相遇
  5. 将基准值填入最后一个"坑"位置
  6. 对基准值左右两边递归分治，【begin,key-1】key 【key+1，end】重复上述过程,实现递归排序

与双指针法相比,挖坑法在处理基准值时使用了额外的"坑"变量,简化了元素交换的操作,但思想都是利用基准值将数组分割成两部分。

代码如下：

//挖坑法
void Dig_QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	//一趟的实现
	int key = a[begin];
	int pivot = begin;
	int left = begin;
	int right = end;
	while (left < right)
	{
		while (left < right && a[right] >= key)
		{
			right--;
		}
		a[pivot] = a[right];
		pivot = right;
		while (left < right && a[left] <= key)
		{
			left++;
		}
		a[pivot] = a[left];
		pivot = left;
	}

	//补坑位
	a[pivot] = key;
	
	//递归分治
	//[begin, piti - 1] piti [piti + 1, end]
	Dig_QuickSort(a, begin, pivot - 1);
	Dig_QuickSort(a, pivot + 1, end);
}

当你讨厌挖左边的坑，可以试试右边的坑😉：
代码如下：

// 交换元素
void swap(int* a, int* b) 
{
    int t = *a;
    *a = *b;
    *b = t;
}

// 分区操作函数
int partition(int arr[], int low, int high) 
{

    // 取最后一个元素作为基准值
    int pivot = arr[high];

    // 初始化左右索引  
    int i = (low - 1);

    // 从左到右遍历数组
    for (int j = low; j <= high - 1; j++) 
    {

        // 如果当前元素小于或等于基准值
        if (arr[j] <= pivot) 
        {

            // 左索引向右移动一位
            i++;

            // 将当前元素与左索引位置元素交换  
            swap(&arr[i], &arr[j]);
        }
    }

    // 将基准值和左索引位置元素交换
    swap(&arr[i + 1], &arr[high]);

    // 返回基准值的最终位置
    return (i + 1);
}


// 快速排序主函数
void quickSort(int arr[], int low, int high) 
{

    // 如果低位索引小于高位索引,表示需要继续排序
    if (low < high) 
    {

        // 调用分区函数,得到基准值的位置
        int pi = partition(arr, low, high);

        // 对基准值左边子数组递归调用快速排序
        quickSort(arr, low, pi - 1);

        // 对基准值右边子数组递归调用快速排序   
        quickSort(arr, pi + 1, high);
    }
}

// 测试
int main() 
{
    // 测试数据
    int arr1[] = { 5,3,6,2,10,1,4 };
    int n1 = sizeof(arr1) / sizeof(arr1[0]);
    quickSort(arr1, 0, n1 - 1);
    // 输出排序结果
    for (int i = 0; i < n1; i++)
    {
        printf("%d ", arr1[i]);
    }
    printf("\n");

    int arr2[] = { 5,3,6,2,10,1,4,29,44,1,3,4,5,6 };
    int n2 = sizeof(arr2) / sizeof(arr2[0]);
    quickSort(arr2, 0, n2 - 1);
    // 输出排序结果
    for (int i = 0; i < n2; i++)
    {
        printf("%d ", arr2[i]);
    }
    printf("\n");

    // 测试数据
    int arr3[] = { 10,1,4,5,3,6,2,1 };
    int n3 = sizeof(arr3) / sizeof(arr3[0]);
    quickSort(arr3, 0, n3 - 1);
    // 输出排序结果
    for (int i = 0; i < n3; i++)
    {
        printf("%d ", arr3[i]);
    }
    printf("\n");

    return 0;
}

运行启动：
在这里插入图片描述

✏️优化快速排序

🌠随机选key

为什么要使用随机数选取key?
避免最坏情况,即每次选择子数组第一个或最后一个元素作为key,这样会导致时间复杂度退化为O(n^2)。
随机化可以减少排序不均匀数据对算法性能的影响。
相比固定选择第一个或最后一个元素,随机选择key可以在概率上提高算法的平均性能。

这里是优化快速排序使用随机数选取key的方法:

  1. 在划分子数组前,随机生成一个[left,right]区间中的随机数randi，
  2. 将随机randi处的元素与区间起始元素left交换
  3. 使用这个随机索引取出子数组中的元素作为keyi。

随机选key逻辑代码：

//快排，随机选key
void QuickSort3(int* a, int left, int right) 
{

  //区间只有一个值或者不存在就是最小子问题
  if (left >= right)
    return;

  int begin = left, end = right;

  //选[left,right]区间中的随机数做key
  int randi = rand() % (right - left + 1);  
  //rand() % N生成0到N-1的随机数
  randi += left;  

  //将随机索引处的元素与区间起始元素交换
  Swap(&a[left], &a[randi]);

  //用交换后的元素作为基准值keyi
  int keyi = left;

  while (left < right) 
  {
    
    //从右向左找小于key的元素
    while (left < right && a[right] >= a[keyi]) 
    {
      --right;
    }
    
    //从左向右找大于key的元素      
    while (left < right && a[left] <= a[keyi]) 
    {
      ++left; 
    }

    //交换元素
    Swap(&a[left], &a[right]);
  }

  //将基准值与交叉点元素交换
  Swap(&a[left], &a[keyi]);
  keyi = left;

  //递归处理子区间
  QuickSort3(a, begin, keyi - 1);
  QuickSort3(a, keyi + 1, end);
}

🌉三位数取中

有无序数列数组的首和尾后，我们只需要在首，中，尾这三个数据中，选择一个排在中间的数据作为基准值(keyi)，进行快速排序，减少极端情况,进一步提高快速排序的平均性能。
代码实现：

// 三数取中  left  mid  right
// 大小居中的值，也就是不是最大也不是最小的
int GetMidi(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	
	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;
		}
	}
}

取中的返回函数接收：

		int begin = left, end = right;
		// 三数取中
		int midi = GetMidi(a, left, right);
		//printf("%d\n", midi);
		Swap(&a[left], &a[midi]);

整体函数实现：

//三数取中  left  mid  right
//大小居中的值，也就是不是最大，也不是最小的
int GetMid(int* a, int left, int right)
{
	int mid = (left + right) / 2;
	
	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[right] > a[left])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}


void QuickSort4(int* a, int left, int right)
{
	if (left >= right)
		return;

	int begin = left, end = right;
	//三数取中
	int midi = GetMid(a, left, right);
	//printf("%d\n",midi);
	Swap(&a[left], &a[midi]);

	int keyi = left;
	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[left], &a[keyi]);
	keyi = left;

	QuickSort4(a, begin, keyi - 1);
	QuickSort4(a, keyi + 1, end);

}

🌠小区间选择走插入，可以减少90%左右的递归

对于小区间,使用插入排序而不是递归进行快速排序。
在快速排序递归中,检查子问题的区间长度是否小于某个阈值(如10-20)，如果区间长度小于阈值,则使用插入排序进行排序，否则使用快速排序递归进行划分。
而这个(如10-20)刚好可以在递归二叉树中体现出来。
如图：
在这里插入图片描述
当然从向下建堆优于向上建堆，也可以体现出来：
在这里插入图片描述

优点在于:对于小区间,插入排序效率高于快速排序的递归开销大部分数组元素位于小区间中，采用插入排序可以省去90%左右的递归调用，但整体数组规模大时,主要工作还是由快速排序完成

与三数取中进行合用

void QuickSort5(int* a, int left, int right)
{
	if (left >= right)
		return;

	// 小区间选择走插入，可以减少90%左右的递归
	if (right - left + 1 < 10)
	{
		InsertSort(a + left, right - left + 1);
	}
	else
	{
		int begin = left, end = right;
		//三数取中
		int midi = GetMid(a, left, right);
		//printf("%d\n",midi);
		Swap(&a[left], &a[midi]);

		int keyi = left;
		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[left], &a[keyi]);
		keyi = left;

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

🌉 快速排序改非递归版本

逻辑原理：
非递归版本的快速排序利用了栈来模拟递归的过程。它的基本思想是：将待排序数组的起始和结束位置压入栈中，然后不断出栈，进行单趟排序，直到栈为空为止。在单趟排序中，选取基准数，将小于基准数的元素移到基准数左边，大于基准数的元素移到基准数右边，并返回基准数的位置。然后根据基准数的位置，将分区的起始和结束位置入栈，继续下一轮排序，直到所有子数组有序。
在这里插入图片描述

代码实现步骤:

  1. 初始化一个栈用于保存待排序子数组的起始和结束位置。
  2. 将整个数组的起始和结束位置压入栈中。
  3. 循环执行以下步骤，直到栈为空：
    出栈，获取当前待排序子数组的起始和结束位置。
    进行单趟排序，选取基准数，并将小于基准数的元素移到左边，大于基准数的元素移到右边。
    根据基准数的位置，将分区的起始和结束位置入栈。
  4. 排序结束。

代码实现

#include "Stack.h"

void QuickSortNonR(int* a, int left, int right)
{
	ST st;
	STInit(&st);
	STPush(&st, right);
	STPush(&st, left);

	while (!STEmpty(&st))
	{
		int begin = STTop(&st);
		STPop(&st);

		int end = STTop(&st);
		STPop(&st);

		//单趟
		int keyi = begin;
		int prev = begin;
		int cur = begin + 1;

		while (cur <= end)
		{
			if (a[cur] < a[keyi] && ++prev != cur)
				Swap(&a[prev], &a[cur]);
			++cur;
		}

		Swap(&a[prev], &a[keyi]);
		keyi = prev;

		//[begin,keyi-1]keyi[keyi+1,end]
		if (keyi + 1 < end)
		{
			STPush(&st, end);
			STPush(&st, keyi + 1);
		}

		if (keyi - 1 > begin)
		{
			STPush(&st, keyi - 1);
			STPush(&st, begin);
		}
	}
	
	STDestroy(&st);
}

以下是栈的实现：
Stack.c

#include"Stack.h"

void STInit(ST* ps)
{
	assert(ps);

	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

void STDestroy(ST* ps)
{
	assert(ps);

	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

// 栈顶
// 11:55
void STPush(ST* ps, STDataType x)
{
	assert(ps);

	// 满了， 扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}

		ps->a = tmp;
		ps->capacity = newcapacity;
	}

	ps->a[ps->top] = x;
	ps->top++;
}

void STPop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

	ps->top--;
}

STDataType STTop(ST* ps)
{
	assert(ps);
	assert(!STEmpty(ps));

	return ps->a[ps->top - 1];
}

int STSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

bool STEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

栈的头文件实现：

#pragma once

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

typedef int STDataType;
typedef struct Stack
{
	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 STTop(ST* ps);
int STSize(ST* ps);
bool STEmpty(ST* ps);

🚩总结

快速排序的特性总结：

  1. 快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序
  2. 时间复杂度：O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：不稳定

快排可以很快，你的点赞也可以很快，哈哈哈，感谢💓 💗 💕 💞，喜欢的话可以点个关注，也可以给博主点一个小小的赞😘呀
请添加图片描述

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

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

相关文章

工业相机采图方式、图像格式（BYTE、HObject和Mat）转换

工业相机采图方式、图像格式（BYTE、HObject和Mat）转换

1、概述 机器视觉项目中&#xff0c;如何采集到合适的图像是项目的第一步&#xff0c;也是最重要的一步&#xff0c;直接关系到后面图像处理算法及最终执行的结果。所以采用不同的工业相机成像以及如何转换成图像处理库所需要的格式成为项目开发中首先要考虑的问题。 2、工业…
阅读更多...
分布式组件 Nacos

分布式组件 Nacos

1.在之前的文章写过的就不用重复写。 写一些没有写过的新东西 2.细节 2.1命名空间 &#xff1a; 配置隔离 默认&#xff1a; public &#xff08;默认命名空间&#xff09;:默认新增所有的配置都在public空间下 2.1.1 开发 、测试 、生产&#xff1a;有不同的配置文件 比如…
阅读更多...
【ZYNQ】基于ZYNQ 7020的OPENCV源码交叉编译

【ZYNQ】基于ZYNQ 7020的OPENCV源码交叉编译

目录 安装准备 检查编译器 安装OpenCV编译的依赖项 下载OpenCV源码 下载CMake 编译配置 编译器说明 参考链接 安装准备 使用的各个程序的版本内容如下&#xff1a; 类别 软件名称 软件版本 虚拟机 VMware VMware-workstation-full-15.5.0-14665864 操作系统 Ub…
阅读更多...
【QT入门】 Qt实现自定义信号

【QT入门】 Qt实现自定义信号

往期回顾&#xff1a; 【QT入门】图片查看软件(优化)-CSDN博客 【QT入门】 lambda表达式(函数)详解-CSDN博客 【QT入门】 Qt槽函数五种常用写法介绍-CSDN博客 【QT入门】 Qt实现自定义信号 一、为什么需要自定义信号 比如说现在一个小需求&#xff0c;我们想要实现跨ui通信&a…
阅读更多...
Hive入门

Hive入门

什么是hive&#xff1f; - Hive是Facebook开发并贡献给Hadoop开源社区的。它是建立在 Hadoop体系架构上的一层 SQL抽象&#xff0c;使得数据相关人 员使用他们最为熟悉的SQL语言就可以进行海量数据的处理、 分析和统计工作 - Hive将数据存储于HDFS的数据文件映射为一张数据库…
阅读更多...
Java程序设计 4、5章 练习题

Java程序设计 4、5章 练习题

一、填空题 1.假设有 String s1 "Welcome to Java"; String s2 s1; String s3 new String("Welcome to Java"); 那么下面表达式的结果是什么&#xff1f; (1) s1 s2 ___________true_______________ (2) s1 s3 ______…
阅读更多...
SOPHON算能服务器SDK环境配置和相关库安装

SOPHON算能服务器SDK环境配置和相关库安装

目录 1 SDK大包下载 2 安装libsophon 2.1 安装依赖 1.2 安装libsophon 2 安装 sophon-mw 参考文献&#xff1a; 1 SDK大包下载 首先需要根据之前的博客&#xff0c;下载SDK大包&#xff1a;SOPHON算能科技新版SDK环境配置以及C demo使用过程_sophon sdk yolo-CSDN博客 …
阅读更多...
RedisObject是什么？

RedisObject是什么？

阅读更多...
第 6 章 ROS-xacro练习(自学二刷笔记)

第 6 章 ROS-xacro练习(自学二刷笔记)

重要参考&#xff1a; 课程链接:https://www.bilibili.com/video/BV1Ci4y1L7ZZ 讲义链接:Introduction Autolabor-ROS机器人入门课程《ROS理论与实践》零基础教程 6.4.3 Xacro_完整使用流程示例 需求描述: 使用 Xacro 优化 URDF 版的小车底盘模型实现 结果演示: 1.编写 X…
阅读更多...
idea使用token方式登录GitHub

idea使用token方式登录GitHub

总体上分为两大步&#xff1a;1.GitHub生成token。2.idea配置token登录GitHub。 注&#xff1a;idea配置GitHub的前提是本地已经安装了git程序。 一、GitHub生成token 1.登录GitHub 2.进入token创建页面&#xff08;右上角点击头像–>settings–>页面向下滚动左侧菜单栏…
阅读更多...
linux热键,man手册介绍

linux热键,man手册介绍

目录 热键 tab ctrl c ctrl r man 区段 快捷键 热键 tab 可以看到以输入的内容为开头的指令,但无法选择: 当输入的内容匹配到的内容只有一个时,可以自动补全 可以用于输入路径时,自动补全文件名 ctrl c 让当前的程序停掉,可以在 程序或指令出问题而自己无法停止时 使用…
阅读更多...
HSP_01章_Python 语言概述

HSP_01章_Python 语言概述

文章目录 06 开发环境安装10 注意事项11 学习方法14 Pycharm 常用快捷键14 Python 常用转义字符15 Python 注释Comment16 [Python 中文文档地址](https://docs.python.org/zh-cn/3.11/) 06 开发环境安装 python 版本命令: python cmd 退出: exit() 环境变量配置: 计算机 > 高…
阅读更多...
【Linux】从零认识进程 — 中下篇

【Linux】从零认识进程 — 中下篇

送给大家一句话&#xff1a; 人一切的痛苦&#xff0c;本质上都是对自己无能的愤怒。而自律&#xff0c;恰恰是解决人生痛苦的根本途径。—— 王小波 从零认识进程 1 进程优先级1.1 什么是优先级1.2 为什么要有优先级1.3 Linux优先级的特点 && 查看方式1.4 其他概念 2…
阅读更多...
如何鉴别真假ZLibrary？2024 ZLibrary最新可用地址，持续更新，2024年在 zlibrary 上发现几本有意思的电子书

如何鉴别真假ZLibrary？2024 ZLibrary最新可用地址，持续更新，2024年在 zlibrary 上发现几本有意思的电子书

之前分享过全网电子书都在这了&#xff1a;ZLibrary 官方通道来了&#xff0c;不再担心找不到最新地址&#xff0c;配合这个脚本简直完美&#xff0c;最新ZLibrary可用地址 zlibrary-sg.se 如何确认一个网站是真的ZLibrary &#xff1f;存在一个API 接口/eapi/info &#xff0…
阅读更多...
pytest全局配置+前后只固件配置

pytest全局配置+前后只固件配置

pytest全局配置前后只固件配置 通过读取pytest.ini配置文件运行通过读取pytest.ini配置文件运行无条件跳过pytest.initest_mashang.pyrun.py 有条件跳过test_mashang.py pytest框架实现的一些前后置&#xff08;固件、夹具&#xff09;处理方法一&#xff08;封装&#xff09;方…
阅读更多...
【C++航海王：追寻罗杰的编程之路】stack

【C++航海王：追寻罗杰的编程之路】stack

目录 1 -> stack的介绍和使用 1.1 -> stack的介绍 1.2 -> stack的使用 1.3 -> stack的模拟实现 1 -> stack的介绍和使用 1.1 -> stack的介绍 stack的文档介绍 1. stack是一种容器适配器&#xff0c;专门用在具有后进先出操作的上下文环境中&#xff0c…
阅读更多...
MTransE翻译

MTransE翻译

MTransE翻译 阅读时间&#xff1a;2024.03.23 领域&#xff1a;知识图谱&#xff0c;知识对齐 作者&#xff1a;Muhao Chen等人 UCLA 出处&#xff1a;IJCAI Multilingual Knowledge Graph Embeddings for Cross-lingual Knowledge Alignment 用于交叉知识对齐的多语言知识图…
阅读更多...
基于java+springboot+vue实现的外卖平台系统（文末源码+Lw+ppt）23-568

基于java+springboot+vue实现的外卖平台系统（文末源码+Lw+ppt）23-568

摘 要 伴随着我国社会的发展&#xff0c;人民生活质量日益提高。于是对外卖平台系统进行规范而严格是十分有必要的&#xff0c;所以许许多多的信息管理系统应运而生。此时单靠人力应对这些事务就显得有些力不从心了。所以本论文将设计一套外卖平台系统&#xff0c;帮助商家进…
阅读更多...
鸿蒙实战开发-如何通过拖动滑块调节应用内字体大小

鸿蒙实战开发-如何通过拖动滑块调节应用内字体大小

介绍 本篇Codelab将介绍如何使用基础组件Slider&#xff0c;通过拖动滑块调节应用内字体大小。要求完成以下功能&#xff1a; 实现两个页面的UX&#xff1a;主页面和字体大小调节页面。拖动滑块改变字体大小系数&#xff0c;列表页和调节页面字体大小同步变化。往右拖动滑块字…
阅读更多...
飞企互联-FE企业运营管理平台uploadAttachmentServlet 任意文件上传漏洞

飞企互联-FE企业运营管理平台uploadAttachmentServlet 任意文件上传漏洞

产品简介 飞企互联-FE企业运营管理平台是一个基于云计算、智能化、大数据、物联网、移动互联网等技术支撑的云工作台。这个平台可以连接人、链接端、联通内外&#xff0c;支持企业B2B、C2B与O2O等核心需求&#xff0c;为不同行业客户的互联网转型提供支持。其特色在于提供云端…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站