【数据结构与算法】：快速排序和冒泡排序

一，快速排序

快速排序是一种比较复杂的排序算法，它总共有4种实现方式，分别是挖坑法，左右"指针"法，前后"指针"法，以及非递归的快速排序，并且这些算法中也会涉及多种优化措施，比如三数取中，小区间优化，下面都会一一介绍。

由于它效率极高的缘故，快速排序也是日常开发中使用最多的，最重要的排序算法。

1. 挖坑法

1.1 基本思想：

任取待排序元素序列中的某元素(一般选最左边或最右边的元素)作为基准值(也叫做 key 关键字)，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

1.2 一趟排序图解如下：

给定一无序数组，选第一个元素为关键字 key = 6
在这里插入图片描述

我们选定关键字 key = 6后，就说明6的位置就可以被覆盖了，所以我们就说左边形成了一个****坑，用pivot 表示。

![!](https://img-blog.csdnimg.cn/direct/3d53fed3d5e64ef4a46eb2d2f4faf554.png

左边有坑，右边的 end 要从最后一个元素开始找比 key 小的数，找到后放到左边的坑里，所以5放进了坑中

在这里插入图片描述
5被拿走之后，右边它原来所在的位置就形成了一个新坑，此时，左边的 begin 要开始找比 key 大的数，找到后放到右边的坑里，所以7放进了坑中
在这里插入图片描述
7被拿走后，左边又形成了一个新坑，此时，end 又要开始找比 key 小的数放到左边的坑里，所以4放进了坑中

在这里插入图片描述
此时，右边又形成了新坑，begin 要开始找比 key 大的数，找到后放到右边的坑里，所以9放进了坑中

在这里插入图片描述
左边又形成了坑，右边 end 开始找，找到了3，放入坑中

在这里插入图片描述
最后一次 begin++ 后，begin 和 end 重叠了，并且它们一定相遇在坑中，此时，把 key 放入坑中即可。

在这里插入图片描述
上述操作只是第一趟排序，只排好了一个数，此时第一个基准 key = 6已经在它合适的位置上了(排好序后的位置)，后面对左右子序列排序时6不动。并且已经把数组分成了两个子序列，以 key 为基准，左边的元素都比它小，右边的元素都比它大。

1.3 单趟排序的代码实现如下：

注意：第二个和第三个 while 中的 begin < end 不能缺少，要防止在找大和找小的时候 begin 和 end 错开或是在极端情况下(比如已经升序时)end一直减导致越界。

int PartSort1(int* arr, int sz)
{

	int begin = 0;
	int end = sz -1;
	int key = arr[begin];
	int pivot = begin;

	//这是排一趟，只排好了一个数
	while (begin < end)
	{
		//左边有坑，右边end找比key小的
		while (begin < end && arr[end] > key)
		{
			end--;
		}

		//小的放到了左边的坑里，右边end自己形成了新的坑
		arr[pivot] = arr[end];
		pivot = end;

		//右边有坑，左边end找比key大的
		while (begin < end && arr[begin] < key)
		{
			begin++;
		}

		//大的放到右边的坑里，左边begin自己形成新的坑
		arr[pivot] = arr[begin];
		pivot = begin;
	}

	//最后begin和end相遇了，把key放入该位置
	pivot = begin;
	arr[begin] = key;

}

1.4 整体排序

要利用分治递归思想。第一趟排序把整个数组分割成了左子序列和右子序列，如果左右子序列都有序了，那么整个数组就有序了，所以再递归使用前面的挖坑算法，再找出关键字，再把左右子序列分割成子序列…… 直到关键字的左右两边只有一个数据不可再递归，或者是关键字的左序列，右序列都是有序，那么整体就有序了。

如图所示：
在这里插入图片描述

1.5 整体排序过程代码实现如下：

注意：因为是左右子序列，所以要控制一个区间。

void QuickySort(int* arr, int left,int right)
{
    //当左右子区间不存在，或只有一个元素时，
    //就不需要递归了，排序完成
	if (left >= right)
	{
		return;
	}

    int begin = left;
	int end = right;
	int key = arr[begin];
	int pivot = begin;

	//这是排一趟，只排好了一个数
	while (begin < end)
	{
		//左边有坑，右边end找比key小的
		while (begin < end && arr[end] > key)
		{
			end--;
		}

		//小的放到了左边的坑里，右边end自己形成了新的坑
		arr[pivot] = arr[end];
		pivot = end;

		//右边有坑，左边end找比key大的
		while (begin < end && arr[begin] < key)
		{
			begin++;
		}

		//大的放到右边的坑里，左边begin自己形成新的坑
		arr[pivot] = arr[begin];
		pivot = begin;
	}

	//最后begin和end相遇了，把key放入该位置
	pivot = begin;
	arr[begin] = key;

	//[left] pivot [right]
	// [left pivot-1]  pivot [pivot+1 right]
	//左子区间和右子区间有序，整体就有序了

	QuickySort(arr, left, pivot-1);
	QuickySort(arr, pivot+1, right);

}

2. 快速排序的优化

2.1 三数取中

上文快排的算法思想有一个致命的缺陷：那就是当数据为有序时，其时间复杂度为O(N*N)。

原因：这是因为在取关键字 key 的值时，一直都是选最左边(或最右边)的数据。当数组本为升序时，每次关键字的右子序列的值都比它大，再次递归调用时，右子序列的子序列也是如此(降序同理)。

所以这个缺陷的原因就是 key 的取值。
那该如何取 key的值呢？一个比较好的方法是三数取中。

三数取中：并不是指取所有数据中间的那数，而是指在三个数中取那个不大不小的中间数，这个数可能在最左边，也可能在最右边。

通过这种类似随机选数的方法，就能保证一定不是数据中最大或最小的值做 key。

2.1.1 三数取中的代码的实现：

//三数取中
int GetMidIndex(int* arr, int left, int right)
{
    //右移有除2的效果
	int mid = (left + right) >> 1;

	if (arr[mid] > arr[left])
	{
		if (arr[mid] < arr[right])
		{
			return mid;
		}
		else if(arr[left]>arr[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else   //arr[mid] < arr[left]
	{
		if (arr[mid] > arr[right])
		{
			return mid;
		}
		else if (arr[left] < arr[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

但是挖坑算法中我们习惯拿 begin 作为 key ，为了保持挖坑算法不被改变，我们把 begin 指向的值和通过三数取中选出的数的指向的值进行交换，确保 key 仍是begin指向的值。

代码实现为：


void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void QuickySort(int* arr, int left,int right)
{   
    //当左右子区间不存在，或只有一个元素时，
    //就不需要递归了，排序完成
	if (left >= right)
	{
		return;
	}
	
	int begin = left;
	int end = right;

    int index = GetMidIndex(arr, left, right);
    Swap(&arr[index], &arr[left]);//交换一下，保证key还是最左边的数

	int key = arr[begin];
	int pivot = begin;

	//这是排一趟，只排好了一个数
	while (begin < end)
	{
		//左边有坑，右边end找比key小的
		while (begin < end && arr[end] > key)
		{
			end--;
		}

		//小的放到了左边的坑里，右边end自己形成了新的坑
		arr[pivot] = arr[end];
		pivot = end;

		//右边有坑，左边end找比key大的
		while (begin < end && arr[begin] < key)
		{
			begin++;
		}

		//大的放到右边的坑里，左边begin自己形成新的坑
		arr[pivot] = arr[begin];
		pivot = begin;
	}

	//最后begin和end相遇了，把key放入该位置
	pivot = begin;
	arr[begin] = key;

	// [left] pivot [right]
	// [left pivot-1]  pivot [pivot+1 right]
	// 左子区间和右子区间有序，整体就有序了

	QuickySort(arr, left, pivot-1);
	QuickySort(arr, pivot+1, right);

}

2.2 小区间优化

我们知道在函数调用的过程中会在内存中建立栈帧，栈帧的建立也是需要时间和空间的。假设用上述代码排100W个数据，则大致有20层的递归调用，但是在最后几层中就大概调用了80多万次函数，它占用了栈帧的绝大多数空间和时间。

那么有人就会想，能不能把最后几层的函数递归调用消除呢？

官方给出的一种方法是小区间优化法，用于减少递归调用次数。

就是在排序的过程中当左右子序列中的数据个数大于某个数量时，不进行递归了，而是选用其他排序算法进行排序。这里一般用插入排序。

2.2.1 小区间优化的代码实现：

(注意：插入排序的算法这里没有给出，想要了解的请前往我的主页。)

//小区间优化法:减少递归调用次数

//  keyindex - 1 - left 指子序列中的元素个数
//  > 10是我们控制的一个界限  
if (keyindex - 1 - left > 10)
{
	QuickySort(arr, left, keyindex - 1);
}
else
{  
    // arr + left 是指这时的子序列不一定从第一个元素开始
    //keyindex - 1 - left + 1 是指元素的个数
	InsertSort(arr + left, keyindex - 1 - left + 1);
}

if (right - (keyindex + 1) > 10)
{
	QuickySort(arr, keyindex + 1, right);
}
else
{
	InsertSort(arr + keyindex + 1, right - (keyindex + 1) + 1);
}

但是由于小区间优化所带来的效率提升并不显著，而且它是与我们所控制的那个界限有关，所以平时并没有过于注重这个优化。

3.挖坑法的完整排序代码


void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//三数取中
int GetMidIndex(int* arr, int left, int right)
{
    //右移有除2的效果
	int mid = (left + right) >> 1;

	if (arr[mid] > arr[left])
	{
		if (arr[mid] < arr[right])
		{
			return mid;
		}
		else if(arr[left]>arr[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else   //arr[mid] < arr[left]
	{
		if (arr[mid] > arr[right])
		{
			return mid;
		}
		else if (arr[left] < arr[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

//挖坑法
int PartSort1(int* arr, int left, int right)
{
	int index = GetMidIndex(arr, left, right);
	Swap(&arr[index], &arr[left]);//交换一下，保证key还是最左边的数

	int begin = left;
	int end = right;
	int key = arr[begin];
	int pivot = begin;

	//这是排一趟，只排好了一个数
	while (begin < end)
	{
		//左边有坑，右边end找比key小的
		while (begin < end && arr[end] > key)
		{
			end--;
		}

		//小的放到了左边的坑里，右边end自己形成了新的坑
		arr[pivot] = arr[end];
		pivot = end;

		//右边有坑，左边end找比key大的
		while (begin < end && arr[begin] < key)
		{
			begin++;
		}

		//大的放到右边的坑里，左边begin自己形成新的坑
		arr[pivot] = arr[begin];
		pivot = begin;
	}

	//最后begin和end相遇了，把key放入该位置
	pivot = begin;
	arr[begin] = key;

	return key;
}


void QuickySort(int* arr, int left,int right)
{   
    //当左右子区间不存在，或只有一个元素时，
    //就不需要递归了，排序完成
	if (left >= right)
	{
		return;
	}
	
    int keyindex = PartSort1(arr, left, right);

	// [left] keyindex [right]
	// [left keyindex -1]  keyindex [keyindex +1 right]
	// 左子区间和右子区间有序，整体就有序了

	QuickySort(arr, left, keyindex - 1);
    QuickySort(arr, keyindex + 1, right);
    
    //或是
    /*if (keyindex - 1 - left > 10)
{
	QuickySort(arr, left, keyindex - 1);
}
else
{  
    // arr + left 是指这时的子序列不一定从第一个元素开始
    //keyindex - 1 - left + 1 是指元素的个数
	InsertSort(arr + left, keyindex - 1 - left + 1);
}

if (right - (keyindex + 1) > 10)
{
	QuickySort(arr, keyindex + 1, right);
}
else
{
	InsertSort(arr + keyindex + 1, right - (keyindex + 1) + 1);

}*/

排序结果为：
在这里插入图片描述

3.1 时间复杂度与稳定性

挖坑法的时间复杂度是O(N*logN),是不稳定的排序。

3. 左右"指针"法

3.1 算法思想：

与挖坑法类似，一般也要用三数取中法选一个关键字做 key，最终也是把整个数组分割成左右两个子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值。

只是实现的方式不同，左右"指针"法是分别从数组的最左边和最右边开始找数，左边的 begin 找比 key大的数，右边的 end 找比 key 小的数，找到后把这两个位置上的数交换，直到分割成左右两个子序列，然后左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

3.2 单趟排序的图解如下：

给定一无序数组，选第一个元素为关键字 keyi = 6，这里的keyi是数组的下标
![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/d2905a16ec794096b226e39d8bcd8af6.png

begin++ 找比 keyi 大的数，end – 找比 keyi 小的数，找到后停下来交换
在这里插入图片描述
重复上述操作
在这里插入图片描述
最后当 begin 和 end 相遇时，把相遇位置上的数与关键字 keyi所在位置的数 交换
![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/450119654a7d4a46a921d89f45ad3bb7.png

最终排完第一趟后，以 keyi所指向的数6为基准，左边的元素都比它小，右边的元素都比它大。

3.3 单趟排序的代码实现：

注意：
1.代码中的三数取中函数与交换函数在上文，此处就直接调用
2.第二个和第三个while中的 begin < end 和 <= 中的等于号二者缺一不可。
在这里插入图片描述


//左右指针法
int PartSort2(int* arr, int left, int right)
{
	int index = GetMidIndex(arr, left, right);
	Swap(&arr[index], &arr[left]);//交换一下，保证key还是最左边的数

	int begin = left;
	int end = right;
	int keyi = begin;//第一个元素的下标

	while (begin < end)
	{
		//找比key小的
		while (begin < end && arr[keyi] <= arr[end])
		{
			end--;
		}
		//找比key大的
		while (begin < end && arr[keyi] >= arr[begin])
		{
			begin++;
		}
		Swap(&arr[begin], &arr[end]);
	}

	//当begin与end相遇时
	Swap(&arr[begin], &arr[keyi]);

	return begin;
}

4. 前后"指针"法

4.1 算法思想

与挖坑法类似，一般也要用三数取中法选一个关键字做 key，最终也是把整个数组分割成左右两个子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值。

只是实现方式不同，前后"指针"法是要定义两个前后变量( cur 和 prev，其中 cur 在前，prev 在后)分别指向数组的前两个元素，前面的 cur 先往前走，prev 后走，cur 找到比key 小的值，每次找到就停下来，prev++，再交换 prev 和 cur 所在位置的值。

直到分割成左右两个子序列，然后左右子序列重复该过程，直到所有元素都排列在相应位置上为止

4.2 单趟排序的部分图解如下：

给定一无序数组，选第一个元素为关键字 keyi = 6，这里的keyi是数组的下标

在这里插入图片描述
前几个数 cur 和 prev 重叠，省略图解

当cur在3的位置上时，prev指向7，此时，交换两数
在这里插入图片描述
再cur++指向了4，停下，prev++指向了9，此时再交换
在这里插入图片描述
………………(重复上述操作)

当cur超出数组界限时，把此时 prev 所指向的值和 keyi 所指向的关键字交换，最终的结果是：

在这里插入图片描述
最终排完第一趟后，以 keyi所指向的数6为基准，左边的元素都比它小，右边的元素都比它大。

4.3 单趟排序的代码实现如下：


//前后指针法
int  PartSort3(int* arr, int left, int right)
{
	int index = GetMidIndex(arr, left, right);
	Swap(&arr[index], &arr[left]);//交换一下，保证key还是最左边的数

	int keyi = left;
	int prev = left;
	int cur = left + 1;

	while (cur <= right)
	{
		if (arr[cur] < arr[keyi])
		{
			prev++;
			Swap(&arr[cur], &arr[prev]);
		}
		cur++;
	}
	
	Swap(&arr[keyi], &arr[prev]);

	return prev;
}

4.4 代码的小优化

通过上面的图解可知，当 cur 和 prev 重叠时，我们也进行了交换，但是这种自己和自己的交换其实是多于的。

优化代码如下：

在if判断条件中多了++prev != cur

int  PartSort3(int* arr, int left, int right)
{
	int index = GetMidIndex(arr, left, right);
	Swap(&arr[index], &arr[left]);//交换一下，保证key还是最左边的数

	int keyi = left;
	int prev = left;
	int cur = left + 1;

	while (cur <= right)
	{
	   //++prev != cur是指当cur和prev重合时不用多于的交换
		if (arr[cur] < arr[keyi]&& ++prev != cur)
		{
			Swap(&arr[cur], &arr[prev]);
		}
		cur++;
	}
	Swap(&arr[keyi], &arr[prev]);

	return prev;
}

二，快速排序总结：

  • 快速排序的三种思想虽然实现方式不同，但是最终结果都是以key为基准值把整个数组分割成左右两个子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值。
  • 在我们日常写快速排序算法时，那两种优化方式三数取中，最小区间优化并不是一定要有，可以根据情况自主添加。

1.比如没有优化的挖坑法的代码实现：


void QuickySort(int* arr, int left,int right)
{
    //当左右子区间不存在，或只有一个元素时，
    //就不需要递归了，排序完成
	if (left >= right)
	{
		return;
	}

    int begin = left;
	int end = right;
	int key = arr[begin];
	int pivot = begin;

	//这是排一趟，只排好了一个数
	while (begin < end)
	{
		//左边有坑，右边end找比key小的
		while (begin < end && arr[end] > key)
		{
			end--;
		}

		//小的放到了左边的坑里，右边end自己形成了新的坑
		arr[pivot] = arr[end];
		pivot = end;

		//右边有坑，左边end找比key大的
		while (begin < end && arr[begin] < key)
		{
			begin++;
		}

		//大的放到右边的坑里，左边begin自己形成新的坑
		arr[pivot] = arr[begin];
		pivot = begin;
	}

	//最后begin和end相遇了，把key放入该位置
	pivot = begin;
	arr[begin] = key;

	//[left] pivot [right]
	// [left pivot-1]  pivot [pivot+1 right]
	//左子区间和右子区间有序，整体就有序了

	QuickySort(arr, left, pivot-1);
	QuickySort(arr, pivot+1, right);

}

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

}

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

	//快速排序
	QuickySort(arr, 0, sz - 1);
	PrintArray(arr, sz);
}

2.比如没有优化的前后"指针"法的代码实现：


void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void QuickySort(int* arr, int left,int right)
{
    //当左右子区间不存在，或只有一个元素时，
    //就不需要递归了，排序完成
	if (left >= right)
	{
		return;
	}

    int keyi = left;
	int prev = left;
	int cur = left + 1;

	while (cur <= right)
	{
	   //++prev != cur是指当cur和prev重合时不用多于的交换
		if (arr[cur] < arr[keyi]&& ++prev != cur)
		{
			Swap(&arr[cur], &arr[prev]);
		}
		cur++;
	}
	Swap(&arr[keyi], &arr[prev]);

	//[left] pivot [right]
	// [left pivot-1]  pivot [pivot+1 right]
	//左子区间和右子区间有序，整体就有序了

	QuickySort(arr, left, keyi-1);
	QuickySort(arr, keyi+1, right);

}

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

}

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

	//快速排序
	QuickySort(arr, 0, sz - 1);
	PrintArray(arr, sz);
}

三，冒泡排序

1.基本思想：

从序列的一端开始往另一端冒泡，依次比较相邻的两个数的大小。

设数组长度为N。

1.每轮比较相邻的前后两个数据，如果前面数据大于(或者小于)后面的数据，就将这两个个数据交换。

2.这样每轮对数组的第0个数据到N-1个数据进行一次遍历后，最大或者最小的一个数据就到数组第N-1个位置。

3.第一轮比较到下标为N-1的数据（最后一个），以后每次比较都-1。

2.图解冒泡排序：
以 [ 8，2，5，9，7 ] 这组数字来做示例：
从左往右依次冒泡，将小的往右移动(排降序)
第一轮冒泡：
在这里插入图片描述
首先比较第一个数和第二个数的大小，我们发现 2 比 8 要小，那么保持原位，不做改动。位置还是 8，2，5，9，7 。指针往右移动一格，接着比较：

在这里插入图片描述

比较第二个数和第三个数的大小，发现 2 比 5 要小，所以位置交换，交换后数组更新为：[ 8，5，2，9，7 ]。
指针再往右移动一格，继续比较：

在这里插入图片描述

比较第三个数和第四个数的大小，发现 2 比 9 要小，所以位置交换，交换后数组更新为：[ 8，5，9，2，7 ]。同样，指针再往右移动，继续比较：

在这里插入图片描述

比较第 4 个数和第 5 个数的大小，发现 2 比 7 要小，所以位置交换，交换后数组更新为：[ 8，5，9，7，2 ]。

下一步，指针再往右移动，发现已经到底了，则本轮冒泡结束，处于最右边的 2 就是已经排好序的数字。

通过这一轮不断的对比交换，数组中最小的数字移动到了最右边。

重复上述步骤，得到的最终结果是：

在这里插入图片描述
3.代码实现冒泡排序如下：


void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void BubbleSort(int* arr, int sz)
{
	for (int j = 0; j < sz; j++)
	{
		//一趟排序
		for (int i = 1; i < sz-j; i++)
		{
			if (arr[i - 1] < arr[i])
			{
				//前一个比后一个小，就交换
				Swap(&arr[i - 1], &arr[i]);
			}
		}
	}
}

4.冒泡排序的小优化：

假设我们要排降序，如果数组此时就是降序，那么在第一轮比较过后数据并没有发生交换，那就不要再进行多于的后续比较了，直接跳出循环即可。

void BubbleSort(int* arr, int sz)
{

	for (int j = 0; j < sz; j++)
	{
		int exchange = 0;//默认是有序的
		//一趟排序
		for (int i = 1; i < sz-j; i++)
		{
			if (arr[i - 1] > arr[i])
			{
				//前一个比后一个大，就交换
				Swap(&arr[i - 1], &arr[i]);
				
				//如果不是有序的就发生了交换，exchange=1
				exchange = 1; 
			}
		}
		//如果一趟比较过后发现是有序的，就直接跳出循环
		if (exchange == 0)
		{
			break;
		}
	}
}

5.时间复杂度和稳定性的分析

最好：就是顺序时，时间复杂度为O(N)
乱序时：时间复杂度为O(N*N)

所以冒泡排序的时间复杂度是O(N*N)。
冒泡排序算法是稳定的。

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

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

相关文章

Tokenize Anything via Prompting

Tokenize Anything via Prompting

SAM的延续&#xff0c;把SAM输出的token序列用来进行分类&#xff0c;分割和一个自然语言的decoder处理&#xff0c;但其实现在多模态的图像的tokenizer也几乎都是用VIT来实现的。一开始认为这篇文章可能是关于tokenize的&#xff0c;tokenize还是很重要的&#xff0c;后来看完…
阅读更多...
若依框架学习——分页查询列表

若依框架学习——分页查询列表

条件查询【多条件】列表展示【分页】SaCheckPermissionTableName TableId NotBlank Page分页 响应数据封装类
阅读更多...
JMeter+Ant+Jenkins构建接口报告(无人驾驶版）

JMeter+Ant+Jenkins构建接口报告(无人驾驶版）

展示结果&#xff1a; uc浏览器打开测试报告&#xff0c;绿色显示脚本结果 搭建操作步骤如下 1.jemter写好脚本 2.下载并配置ant环境变量&#xff1a;加上activation.jar、commons-lang3-3.8.1.jar、mail.jar 这3个包 mail.jar需要引用到jmeter 3.下载安装Jenkins 并进行构建…
阅读更多...
CKA 基础操作教程（六）

CKA 基础操作教程（六）

Kubernetes Deployments 理论学习 在 Kubernetes 中&#xff0c;Deployments 是一种资源对象&#xff0c;用于定义和管理容器化应用程序的部署过程&#xff0c; 容器化应用的声明式定义&#xff1a;使用 Deployments &#xff0c;可以声明性地定义应用程序的部署配置&#x…
阅读更多...
Vue使用高德地图

Vue使用高德地图

1.在高德平台注册账号 2.我的 > 管理管理中添加Key 3.安装依赖 npm i amap/amap-jsapi-loader --save 或 yarn add amap/amap-jsapi-loader --save 4.导入 AMapLoade import AMapLoader from amap/amap-jsapi-loader; 5.直接上代码&#xff0c;做好了注释&#xff08;初始化…
阅读更多...
初识ES（ES的基本概念、倒排索引、索引和文档的CRUD）

初识ES（ES的基本概念、倒排索引、索引和文档的CRUD）

1、ES是什么&#xff1f; 一个开源的分布式搜索引擎&#xff0c;可以用来实现搜索、日志统计、分析、系统监控等功能。ES的底层是基于Lucene实现的。 Lucene是一个Java语言的搜索引擎类库。 什么是elastic stack&#xff08;ELK&#xff09;&#xff1f; elasticsearch。存储、…
阅读更多...
实验室用进口高纯聚四氟乙烯材质PFA方盘抗酸碱耐高温PFA托盘

实验室用进口高纯聚四氟乙烯材质PFA方盘抗酸碱耐高温PFA托盘

PFA方盘又称托盘&#xff1a;耐高温、耐腐蚀。 进口透明可溶性聚四氟乙烯方盘。可应用于成膜实验&#xff0c;样品液体脱漏等。能放在电热板上直接加热使用&#xff0c;也可以用于烘箱烘干&#xff0c;实验室腐蚀性样品的转移和搬运&#xff0c;防止腐蚀性液体洒落。 产品特性…
阅读更多...
Python常用算法--解决数据结构问题【附源码】

Python常用算法--解决数据结构问题【附源码】

一、约瑟夫环问题 解释：约瑟夫环（Josephus Problem）是一个著名的数学问题，它描述了一个关于围坐一圈的人进行游戏的场景。游戏规则是从一个人开始，顺序报数，每报到特定数目的人将会被排除出圈子，然后从被排除的下一人开始继续报数，游戏继续进行直到最后剩下一个人。 …
阅读更多...
ETL工具-nifi干货系列 第九讲 处理器EvaluateJsonPath，根据JsonPath提取字段

ETL工具-nifi干货系列 第九讲 处理器EvaluateJsonPath，根据JsonPath提取字段

1、其实这一节课本来按照计划一起学习RouteOnAttribute处理器&#xff08;相当于java中的ifelse&#xff0c;switch case 控制语句&#xff09;&#xff0c;但是在学习的过程中遇到了一些问题。RouteOnAttribute 需要依赖处理器EvaluateJsonPath&#xff0c;所以本节课我们一起…
阅读更多...
如何确定螺栓的载荷和扭矩——SunTorque智能扭矩系统

如何确定螺栓的载荷和扭矩——SunTorque智能扭矩系统

智能扭矩系统-智能拧紧系统-扭矩自动控制系统-SunTorque 螺栓作为一种常见的紧固件&#xff0c;广泛应用于各种机械和设备中。正确确定螺栓的载荷及其扭矩对于确保设备的安全运行和延长其使用寿命至关重要。本文将探讨如何确定螺栓的载荷及其扭矩&#xff0c;帮助读者更好地理…
阅读更多...
将excel，csv中合并块中某条记录的值应用到整个块（使用多行的值，来填充新列数据）。

将excel，csv中合并块中某条记录的值应用到整个块（使用多行的值，来填充新列数据）。

背景描述 在excel中使用其它列的值&#xff0c;根据某种计算规则来填充另一列&#xff08;或新列&#xff09;很容易实现。但是如果需要根据合并块中的多行来填充列时&#xff0c;就不容易实现&#xff0c;由于对excel不是太常用&#xff0c;因此这里使用的命令行工具实现的。…
阅读更多...
K8s学习三（Pod与探针）

K8s学习三（Pod与探针）

深入学习Pod Pod配置文件 写一个自己的配置文件,nginx-po.yaml apiVersion: v1 #api文档版本 kind: Pod #资源类型对象&#xff0c;也可以配置为像Development&#xff0c;StatefulSet这一类的对象 metadata: # Pod相关的元数据&#xff0c;用于描述Pod的数据name: nginx-po…
阅读更多...
4月7号总结

4月7号总结

java学习 一.正则表达式 定义&#xff1a;正则表达式是一种用于描述字符串模式的表达式&#xff0c;通常被用于文本搜索、匹配和替换。它是一种强大的工具&#xff0c;可以在文本处理和文本分析中进行复杂的匹配和操作。 通过字符串引用里面的方法matches&#xff0c;然后执行…
阅读更多...
【Web】纯萌新的CISCN刷题记录(1)

【Web】纯萌新的CISCN刷题记录(1)

目录 [CISCN 2019华东南]Web11 [CISCN 2019华北Day2]Web1 [CISCN 2019初赛]Love Math [CISCN 2022 初赛]ezpop [CISCN 2019华东南]Double Secret [CISCN 2023 华北]ez_date [CISCN 2019华北Day1]Web1 [CISCN 2019华东南]Web4 [CISCN 2019华北Day1]Web2 [CISCN 2023 …
阅读更多...
【Django开发】前后端分离美多商城项目第6篇：用户部分,1. 业务说明【附代码文档】

【Django开发】前后端分离美多商城项目第6篇：用户部分,1. 业务说明【附代码文档】

美多商城项目4.0文档完整教程&#xff08;附代码资料&#xff09;主要内容讲述&#xff1a;美多商城&#xff0c;项目准备1.B2B--企业对企业,2.C2C--个人对个人,3.B2C--企业对个人,4.C2B--个人对企业,5.O2O--线上到线下,6.F2C--工厂到个人。项目准备&#xff0c;配置1. 修改set…
阅读更多...
微服务学习2

微服务学习2

目录 一.网关路由 1.1.认识网关 1.2网关快速入门 1.2.1.创建项目 1.2.2.引入依赖 1.2.3.启动类 1.2.4.配置路由 1.3.路由过滤 二.网关登录校验 2.1网关请求处理流程 2.2网关过滤器 2.2.2网关过滤器 2.3自定义GlobalFilter 2.4.登录校验 2.4.1.JWT工具 2.4.2.登…
阅读更多...
网络安全之代码签名证书申请

网络安全之代码签名证书申请

代码签名&#xff0c;作为一种数字安全机制&#xff0c;对于软件开发、分发及用户使用环节具有至关重要的意义。以下从六大方面阐述代码签名必不可少的重要性&#xff1a; 确保代码来源可信&#xff1a; 代码签名如同软件的“身份证”&#xff0c;通过数字证书对开发者身份进…
阅读更多...
【每日刷题】Day4

【每日刷题】Day4

【每日刷题】Day4 &#x1f955;个人主页&#xff1a;开敲&#x1f349; &#x1f525;所属专栏&#xff1a;每日刷题&#x1f34d; 目录 1. 83. 删除排序链表中的重复元素 - 力扣&#xff08;LeetCode&#xff09; 2. 88. 合并两个有序数组 - 力扣&#xff08;LeetCode&…
阅读更多...
(Git) gitignore基础使用

(Git) gitignore基础使用

文章目录 前言.gitignore 模式匹配注释 #转义 \直接匹配任意字符匹配 *单个字符匹配 ?目录分割 /多级目录 **范围匹配 []取消匹配 ! 检查是否生效父子文件END 前言 Git - gitignore Documentation (git-scm.com) 在使用git管理的项目中&#xff0c;可以通过.gitignore文件管理…
阅读更多...
蓝桥杯考前复习三

蓝桥杯考前复习三

1.约数个数 由乘法原理可以得出&#xff1a; import java.util.*; public class Main{static int mod (int)1e9 7;public static void main(String[] args){Map<Integer,Integer> map new HashMap<>(); //创建一个哈希表Scanner scan new Scanner(System.in);i…
阅读更多...
最新文章

Copyright @ 2022~2023