【数据结构】八大排序算法

news2024/7/6 19:18:37

目录

一、直接插入排序

二、希尔排序

三、选择排序

四、堆排序

五、冒泡排序

六、快速排序

  1、递归版本

     1.1 hoare 法

     1.2 挖坑法

     1.3 前后指针法

  2、非递归版本

  3、快速排序的优化

     3.1 三数取中

     3.2 小区间优化

七、归并排序

  1、递归版本

  2、非递归版本

八、计数排序

 

一、直接插入排序

动图演示：

思路：(1)首先先按一趟插入排序编写， 数组的最后一个元素为 end，将要插入数据就是临时数据tmp = a[end+1]，如果 tmp 小于 end 位置的数据，就将 end 位置的数据往后挪到 end+1的位置，直到插入到里面；(2)再按整体插入排序，进行插入，假设第一次数组里面就一个数据，所以 end 位置就是0，然后结束条件就是小于 n-1，否则就越界。

注意：先保存一下 end+1 位置的数据，否则在挪动的时候，就会被覆盖。

 

上面给出了两个动图演示，能更好的理解。

//插入排序    时间复杂度：O(N^2)
void InsertSort(int* a, int n)
{
	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;
	}
}

二、希尔排序

希尔排序可以缩小增量排序，又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成 几个 组，所有距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工 作。当到达 gap=1时，所有记录在统一组内排好序。 

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就 会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好多树中给出的希尔排序的时间复杂度都不固定。
//希尔排序      时间复杂度:O(N^1.3)
void ShellSort(int* a, int n)
{
	//gap > 1 预排序
	//gap越大，大的数可以更快的到后面，小的数可以更快的到前面。越不接近有序。
	//gap越小，数据跳动越慢，越接近有序。
	//gap == 1 直接插入排序
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 2;
		//gap = gap / 3 + 1;
		for (int j = 0; j < gap; j++)//分gap组排序
		{
			for (int i = j; i < n - gap; i += gap)//每一个组进行插入排序
			{
				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;
			}
		}
	}
}

三、选择排序

动图演示：

思路：设两个变量mini，maxi分别存最小数据位置的下标和最大位置数据的下标，每次遍历数组标记出最大数据的下标和最小位置数据的下标，分别将其与最后一个数据和开头数据进行交换。

//选择排序     时间复杂度：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]);
		//begin跟maxi重叠了，第一步交换之后maxi位置变了
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&a[end], &a[maxi]);
		begin++;
		end--;
	}

注意：这种情况是特殊情况，最大值的位置(maxi)在 begin 处，交换完 a[begin] 和 a[mini] 时，此时 ，maxi 位置被交换到 mini 的位置了，所以 maxi 的位置发生了变化，需要我们处理一下 maxi 的位置。

四、堆排序

堆排序是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。本文建的是大堆，排升序。

//堆排序     时间复杂度：O(N*logN)
//交换
void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向下调整
void AdjustDown(int* a, int n, int parent)//n为数组的大小
{
	int child = parent * 2 + 1;//左孩子
	while (child < n)
	{
		//确认child指向大的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])//child+1 < n 右孩子存在的情况
		{
			++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;
	}
}

五、冒泡排序

动图演示：

思路：前后数据进行对比，若前面数据大于后面的数据就交换，这样经过第一轮的排序，最大值就被换到了最后的位置，然后再进行第二轮排序，这样以此往复，第二大的数据被放到倒数第二的位置，直到所有数据排序完毕。

//冒泡排序    时间复杂度：O(N^2)
void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		int exchange = 0;
		for (int i = 1; i < n - j; i++)
		{
			if (a[i - 1] > a[i])
			{
				Swap(&a[i - 1], &a[i]);
				exchange = 1;
			}
		}
		//一趟冒泡过程中，没有发生交换，说明已经有序了，不需要进行处理
		if (exchange == 0)
		{
			break;
		}
	}
}

六、快速排序

基本思想为：任取待排序元素序列中 的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右 子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

快速排序的阶段性结果特点：第 i 趟完成时，会有 i 个以上的数据出现在它最终要出现的位置。

  1、递归版本

     1.1 hoare 法

 动图演示：

思路：(1)选取key位置，通常选在最开始的left位置(或最后面right位置)。

            (2)如果key选在left位置，则 right 先走，找到比 key 位置小的数据停下。

            (3)left 再走，找到比 key 位置大的数据停下。

            (4)交换 left 和 right 位置的数据，一直重复以上操作，直到left 和 right 相遇结束。

            (5)相遇结束后，此时交换 key 位置和 left 位置(就是相遇的位置)的数据， 这个时候相遇位置的左边的数据小于等于相遇位置的数据，右边的数据大于等于相遇位置的数据。所以，这个数据就调整到了它的正确位置。

//Hoare
int PartSort1(int* a, int begin, int end)
{
	int left = begin, right = end;
	int key = left;
	while (left < right)
	{
		//右边先走，找小
		while (left < right && a[right] >= a[key])//left < right条件是防止越界
		{
			right--;
		}
		//左边再走，找大
		while (left < right && a[left] <= a[key])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[left], &a[key]);
	key = left;
	return key;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	if ((end - begin + 1) < 15)
	{
		//优化方法:小区间用直接插入替代，减少递归调用次数
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int key = PartSort1(a, begin, end);

		//[begin,key-1] key [key+1 , end] 三段位置
		QuickSort(a, begin, key - 1);
		QuickSort(a, key + 1, end);
	}
}

     1.2 挖坑法

 动图演示：

思路：(1)把数组 left 位置的数据赋值给 key ，形成了第一个坑位 hole 就是 left 位置，要保存 key 位置的值。

           (2)right 先走，找到比 key 位置数据小的值，就停下，将此处的数据放到坑位 hole 中，此时right 位置就形成了新的坑位。

           (3)然后 left 再走，找到比 key 位置数据大的值，就停下，将此处的数据放到坑位 hole 中，此时，left 位置就形成新的坑位。

           (4)当 left 和 right 相遇时，将 key 位置的数据放入到坑位中，此时，key 数据就放到了正确的位置。

//挖坑法
int PartSort2(int* a, int begin, int end)
{
	int left = begin, right = end;
	int key = left;
	int hole = left;
	while (left < right)
	{
		//右边找小，填到左边的坑里面
		if (left < right && a[right] >= a[key])
		{
			right--;
		}
		a[hole] = a[right];
		hole = right;
		//左边找大，填到右边的坑里面
		if (left < right && a[left] <= a[key])
		{
			left++;
		}
		a[hole] = a[left];
		hole = left;
	}
	a[hole] = a[key];
	return hole;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}

	if ((end - begin + 1) < 15)
	{
		//优化方法:小区间用直接插入替代，减少递归调用次数
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int key = PartSort2(a, begin, end);

		//[begin,key-1] key [key+1 , end] 三段位置
		QuickSort(a, begin, key - 1);
		QuickSort(a, key + 1, end);
	}
}

     1.3 前后指针法

 动图演示：

思路：(1)首先假设 key 是数组最开始位置，然后用前后指针法，prev 指向第一个元素，cur 指向第二个元素。

           (2)cur 先移动，找到比 key 位置数据小的停下。

           (3)++prev，交换 prev 与 cur 位置的数据。

           (4)当 cur 指向数组最后一个位置的下一个位置时，循环停止。

           (5)交换 key 下标与 prev 下标的数据。

//前后指针法
int PartSort3(int* a, int begin, int end)
{
	int prev = begin;
	int cur = begin + 1;
	int key = begin;
	while (cur <= end)
	{
		//找到比key小的值时，跟++prev位置交换，小的往前翻，大的往后翻
		while (a[cur] < a[key] && ++prev != cur)
        {
            //满足条件，进行交换
            Swap(&a[prev], &a[cur]);
        }
		cur++;
	}
	Swap(&a[key], &a[prev]);
	key = prev;
	return key;
}
void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	if ((end - begin + 1) < 15)
	{
		//优化方法:小区间用直接插入替代，减少递归调用次数
		InsertSort(a + begin, end - begin + 1);
	}
	else
	{
		int key = PartSort3(a, begin, end);

		//[begin,key-1] key [key+1 , end] 三段位置
		QuickSort(a, begin, key - 1);
		QuickSort(a, key + 1, end);
	}
}

  2、非递归版本

思路：通过非递归的方式实现的话，我们要借助栈的内存结构让先入的后出，所以要先进 begin 再进 end，出的顺序就是先出右再出左再先排右边再排左边。

//非递归版本
void QuickSortNonR(int* a, int begin, int end)
{
	//借助栈实现非递归
	ST st;
	StackInit(&st);
	StackPush(&st, begin);
	StackPush(&st, end);
	while (!StackEmpty(&st))
	{
		int right = StackTop(&st);
		StackPop(&st);
		int left = StackTop(&st);
		StackPop(&st);

		int key = PartSort1(a, left, right);
		//[left,key-1] key [key+1,right]
		if (key + 1 < right)
		{
			StackPush(&st, key + 1);
			StackPush(&st, right);
		}
		if (left < key - 1)
		{
			StackPush(&st, left);
			StackPush(&st, key - 1);
		}
	}
	StackDestory(&st);
}

  3、快速排序的优化

     3.1 三数取中

三数取中是一种优化算法，为了防止 key 位置的数据是该数组中的最小值，进行一趟快速排序后，没有什么变化，我们采用的三数取中的方法，在一个数组中选取一个中间值作为 key ，来进行快速排序，这样的效率会大大的提升。

int GetMidIndex(int* a, int begin, int end)
{
	int mid = (begin + end) / 2;
	if (a[begin] < a[mid])
	{
		if (a[mid] < a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return begin;
		}
		else
		{
			return end;
		}
	}
	else  //a[begin] > a[mid]
	{
		if (a[mid] > a[end])
		{
			return mid;
		}
		else if (a[begin] > a[end])
		{
			return end;
		}
		else
		{
			return begin;
		}
	}
}

     3.2 小区间优化

快排的思想就是不断地分割小序列，然后再递归实现，它的每一层的递归次数以2倍的次数进行增长。当元素较多时以递归的方法实现是不错的，但是当序列元素较少时，再使用递归就没有必要了，我们可以选择使用其他的排序方法来实现小序列的排序。

void QuickSort1(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	if ((end - begin + 1) < 10)
	{
		InsertSort(a, (end - begin + 1));
	}
	int mid = GetMidIndex(a, begin, end);
	swep(&a[begin], &a[mid]);
	int keyi = PartSort3(a, begin, end);
	QuickSort1(a, begin, keyi - 1);
	QuickSort1(a, keyi+1, end);
}

七、归并排序

  1、递归版本

 动图演示：

归并的思想：

        归并排序是建立在 归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。
        将已有序的子序列合并，得到完全有序的序列；
        即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

//归并排序    时间复杂度：O(N*logN)   空间复杂度：O(N)
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);

	//归并
	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");
		exit(-1);
	}
	_MergeSort(a, 0, n - 1, tmp);

	free(tmp);
	tmp = NULL;
}

  2、非递归版本

 我们就控制每个区间就可以归并了，因为归并是二分。

rangeN 表示：每组归并的数据个数。

//非递归归并排序
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	//归并每组数据个数，从1开始，因为1个认为是有序的，可以直接归并
	int rangeN = 1;
	while (rangeN < n)
	{
		for (int i = 0; i < n; i += rangeN * 2)
		{
			//[begin1,end1] [begin2,end2]  归并
			int begin1 = i, end1 = i + rangeN - 1;
			int begin2 = i + rangeN, end2 = i + 2 * rangeN - 1;
			int j = i;
			//end1  begin2 end2越界
			if (end1 >= n)
			{
				break;
			}
			else if (begin2 >= n)//begin2 end2 越界
			{
				break;
			}
			else if (end2 >= n)//end2 越界
			{
				//修正区间
				end2 = n - 1;
			}
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] <= a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}
			//归并一部分，拷贝一部分
			memcpy(a + i, tmp + i, sizeof(int) * (end2 - i + 1));
		}
		rangeN *= 2;
	}
	free(tmp);
	tmp = NULL;
}

注意：写代码时，需要严密的控制区间，要不然会发生溢出，导致程序崩溃。

有以下三种情况：(1)end1越界，begin2越界，end2越界;(2)begin2越界，end2越界;(3)end2越界

八、计数排序

计数排序的核心思想：其实就是映射，将待排序的数据通过映射，放到辅助空间相对应的位置，然后通过统计出现的次数，最后再放回原先的数组。

//计数排序
void CountSort(int* a, int n)
{
	assert(a);
	int min = a[0];
	int max = a[0];
	for (int i = 1; i < n; ++i)
	{
		//求最大值和最小值
		if (a[i] < min)
			min = a[i];
		if (a[i] > max)
			max = a[i];
	}
	int range = max - min + 1;
	int* countArr = (int*)malloc(sizeof(int) * range);
	memset(countArr, 0, sizeof(int) * range);
	//统计次数
	for (int i = 0; i < n; ++i)
	{
		countArr[a[i] - min]++;
	}
	//排序
	int index = 0;
	for (int j = 0; j < range; ++j)
	{
		while (countArr[j]--)
		{
			//相对位置
			a[index++] = j + min;
		}
	}
	free(countArr);
}

九、排序的比较：

排序方法时间复杂度空间复杂度稳定性
冒泡排序O(n^{2})O(1)稳定
选择排序O(n^{2})O(1)不稳定
插入排序O(n^{2})O(1)稳定
希尔排序O(n^{1.3})O(1)不稳定
堆排序O(N*logN)O(1)不稳定
归并排序O(N*logN)O(N)稳定
快速排序O(N*logN)O(logN)不稳定
计数排序O(N)O(Max-Min+1)不稳定

 

 

本文要是有不足的地方，欢迎大家在下面评论，我会在第一时间更正。

 

 老铁们，记着点赞加关注!!!  

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

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

相关文章

【Spring Security】的RememberMe功能流程与源码详解

【Spring Security】的RememberMe功能流程与源码详解

文章目录 前言原理 基础版搭建初始化sql依赖引入配置类验证 源码分析 进阶版集成源码分析疑问1疑问2 鉴权 升级版集成初始化sql配置类验证 源码分析鉴权流程 扩展版 前言 之前我已经写过好几篇权限认证相关的文章了&#xff0c;有想复习的同学可以查看【身份权限认证合集】。今…
阅读更多...
Ada Tutorial（3）SPARK2——Post condition + Loop Invariant 后置条件 + 循环不变量

Ada Tutorial（3）SPARK2——Post condition + Loop Invariant 后置条件 + 循环不变量

文章目录 divmod循环不变量 v.s. 后置条件扩展思考 divmod -- divmod.adb package body DivMod with SPARK_Mode isprocedure DivMod(X : Positive; N : Positive; K : out Natural; Remainder : out Natural)isY : Natural : X;beginK : 0;while Y > N loopY : Y - N;K : …
阅读更多...
MySQL 日期与时间函数

MySQL 日期与时间函数

一、获取日期、时间 函数用法CURDATE()&#xff0c;CURRENT_DATE()返回当前日期&#xff0c;只包含年、月、日CURTIME() &#xff0c; CURRENT_TIME()返回当前时间&#xff0c;只包含时、分、秒NOW() &#xff0c; SYSDATE()&#xff0c;CURRENT_TIMESTAMP() &#xff0c; LOC…
阅读更多...
为什么企业和品牌一定要创建百度百科词条呢？

为什么企业和品牌一定要创建百度百科词条呢？

在企业和品牌宣传推广方面&#xff0c;百度百科作为一个权威的知识平台&#xff0c;早已成为了宣传阶段非常重要的一环。本文伯乐网络传媒将从以下几个方面探讨为什么企业和品牌一定要创建百度百科词条。 一、提升企业和品牌知名度 在信息时代&#xff0c;信息的获取渠道变得更…
阅读更多...
PySpark简单使用(零)

PySpark简单使用(零)

介绍 Spark是Apache基金会旗下的顶级开源项目&#xff0c;用于对海量数据进行大规模分布式计算。PySpark是Spark的Python实现&#xff0c;是Spark为Python开发者提供的编程入口&#xff0c;用于以Python代码完成Spark任务的开发PySpark不仅可以作为Python第三方库使用&#xf…
阅读更多...
【深入浅出 Spring Security（九）】解决跨域问题和 Axios 所需配置

【深入浅出 Spring Security（九）】解决跨域问题和 Axios 所需配置

跨域 一、SpringMVC 跨域的解决方案CrossOrigin&#xff08;注解的方式解决&#xff09;addCorsMappings&#xff08;实现WebMvcConfigurer接口&#xff0c;重写方法&#xff09; 二、Spring Security 跨域的解决方案前后端跨域测试&#xff08;前端相关配置&#xff09; 啥是跨…
阅读更多...
计算机提示“找不到vcruntime140.dll,无法继续执行代码可”以这样子修复

计算机提示“找不到vcruntime140.dll,无法继续执行代码可”以这样子修复

首先&#xff0c;对于那些不熟悉的人来说&#xff0c;vcruntime140.dll是一个关键文件&#xff0c;用于在Windows操作系统上运行使用C语言编写的大型应用程序。如果你正在运行或安装这样的应用程序&#xff0c;但找不到vcruntime140.dll文件&#xff0c;那么你的应用程序可能无…
阅读更多...
word插入图片为何无法显示？

word插入图片为何无法显示？

word是我们常用的软件&#xff0c;在使用过程中&#xff0c;我们难免会遇到这样或那样的问题&#xff0c;解决问题的思路我认为首先要找出原因&#xff0c;然后再想办法解决才是最好的方案。 如果在 Word 文档中插入的图片无法显示&#xff0c;可能是以下原因之一&#xff1a;…
阅读更多...
安装ORB-SLAM2纯记录（caffe）

安装ORB-SLAM2纯记录（caffe）

ubuntu20.04 显卡配置3050TI 显卡驱动&#xff1a; NVIDIA-SMI 525.116.04 Driver Version: 525.116.04 cuda:Cuda compilation tools, release 11.0, V11.0.221 eigen:3.4.0 opencv 3.4.9 opencv下载链接 pangolin :高翔SLAM十四讲中的 没有安装最新版本 安装pangolin时候出…
阅读更多...
有趣的图(二)(56)

有趣的图(二)(56)

小朋友们好&#xff0c;大朋友们好&#xff01; 我是猫妹&#xff0c;一名爱上Python编程的小学生。 和猫妹学Python&#xff0c;一起趣味学编程。 今日主题 咱们书接上回&#xff0c;上次学了图的基本概念&#xff0c;你都学会了吗&#xff1f; 咱们今天要学习内容如下&a…
阅读更多...
通过Appium Desktop实现录制功能并导出自动化脚本

通过Appium Desktop实现录制功能并导出自动化脚本

1、我们进入下面这个界面 图中红色标记1为 “top by coordinates” 按钮&#xff0c; 这是一种通过坐标定位元素的方式。 图中红色标记2为 “Start Recording” 按钮&#xff0c; 选中表示处理录制状态。 2、点击“top by coordinates” 按钮&#xff0c;再点击 “Start Recor…
阅读更多...
vue3基础知识的简单应用

vue3基础知识的简单应用

vue3基础知识的简单应用 vue3基础知识的简单应用运行结果 vue3基础知识的简单应用 父组件代码 <template><div class"home"><img alt"Vue logo" src"../assets/logo.png"><HelloWorld msg"Welcome to Your Vue.js A…
阅读更多...
linux opencv4.2静态库编译及链接

linux opencv4.2静态库编译及链接

1. 编译静态库 拉取opencv源码&#xff1a; https://github.com/opencv/opencv.git进入源码根目录&#xff0c;在platforms/linux目录下创建编译脚本build_linux.sh cd platforms/linux vi build_linux.sh脚本里配置cmake编译参数&#xff0c;这里编译静态库需要将 -DBUILD_S…
阅读更多...
华为OD机试真题 JavaScript 实现【勾股数元组】【2022Q4 100分】，附详细解题思路

华为OD机试真题 JavaScript 实现【勾股数元组】【2022Q4 100分】，附详细解题思路

一、题目描述 如果三个正整数A、B、C ,ABC则为勾股数 如果ABC之间两两互质&#xff0c;即A与B&#xff0c;A与C&#xff0c;B与C均互质没有公约数&#xff0c; 则称 其为勾股数元组。 请求出给定n~m范围内所有的勾股数元组。 二、输入描述 起始范围 1 < n < 10000 n &…
阅读更多...
[数据结构初阶]单链表

[数据结构初阶]单链表

顾名思义&#xff0c;单链表就是一个相邻节点用一个单向指针串起来&#xff0c;形成一种链式结构&#xff0c;那怎么将这些节点连结起来方便管理呢&#xff1f; 目录 单链表定义 申请空间 创建节点 打印链表 尾插 尾删 头插 头删 查找 插入 删除 pos后删除 pos位置删除…
阅读更多...
Python 接口测试之接口关键字封装

Python 接口测试之接口关键字封装

引言 我们使用RF做UI自动化测试的时候&#xff0c;使用的是关键字驱动。同样&#xff0c;Python做接口自动化测试的时候&#xff0c;也可以使用关键字驱动。但是这里并不是叫关键字驱动&#xff0c;而是叫数据驱动。而接口测试的关键字是什么呢&#xff1f; 我们数据驱动的载体…
阅读更多...
知识图谱实战应用15-知识图谱在生物基因学上的应用，实现基因与疾病关联查询

知识图谱实战应用15-知识图谱在生物基因学上的应用，实现基因与疾病关联查询

大家好，我是微学AI，今天给大家介绍一下知识图谱实战应用15-知识图谱在生物基因学上的应用，实现基因与疾病关联查询。知识图谱在生物基因学中的应用非常广泛，可以帮助研究人员更好地理解和发现基因与疾病之间的关联关系，并推进相关领域的发展。 目录 引言知识图谱简介生物…
阅读更多...
Linux之命令别名---alias

Linux之命令别名---alias

Linux之命令别名 定义 别名是命令的快捷方式。为那些需要经常执行&#xff0c;但需要很长时间输入的长命令创建快捷方式很有用 语法格式 alias 别名’原命令 -选项/参数’ 基本用法 查看设置的别名 [redhat8alocalhost ~]$ alias 删除别名 [redhat8alocalhost ~]$ unalia…
阅读更多...
你见过的这里都有，开源Web性能测试工具集合

你见过的这里都有，开源Web性能测试工具集合

1、JMeter。这个也不用多介绍&#xff0c;基本属于做过Web性能测试都会接触的工具。Apache旗下的开源项目&#xff0c;属于一个Java桌面应用程序。优势是开源免费&#xff0c;扩展能力强。自身性能是硬伤。 2、Locust。Web性能测试的蝗药师&#xff0c;开源免费&#xff0c;并发…
阅读更多...
C语言解决任意一个整数分解,逆序输出

C语言解决任意一个整数分解,逆序输出

C语言解决任意一个整数分解,逆序输出 输入&#xff1a;1234 输出&#xff1a;1 2 3 4 思路&#xff1a; 对于任意一个整数num, &#xff08;1&#xff09;num%10就可以得到其个位数的数字&#xff0c;例如&#xff1a;1234%104 &#xff08;2&#xff09;num/10就可以获取到这个…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023