数据结构入门(C语言版)一篇文章教会你手撕八大排序

news2024/11/19 0:20:19

在这里插入图片描述

八大排序

  • 排序的概念
  • 常见的排序算法
  • 排序算法的实现
    • 一、直接插入排序
    • 二、希尔排序
    • 三、选择排序
    • 四、堆排序
    • 五、冒泡排序
    • 六、快速排序
      • 1.递归写法
        • ①三位取中函数
        • ②hoare版本
        • ③挖坑法
        • ④前后指针版本
        • ⑥快排主函数
      • 2.非递归写法
    • 七、归并排序
      • 1.递归写法
      • 2.非递归写法
    • 八、非比较排序
      • 1.基数排序
      • 2.计数排序
  • 排序算法复杂度及稳定性分析
  • 结语

排序的概念

排序:所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或递减的排列起来的操作。
稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳定的;否则称为不稳定的。
内部排序:数据元素全部放在内存中的排序。
外部排序:数据元素太多不能同时放在内存中,根据排序过程的要求不能在内外存之间移动数据的排序。

常见的排序算法

在这里插入图片描述

排序算法的实现

一、直接插入排序

直接插入排序是一种简单的插入排序法,其基本思想是:
把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直到所有的记录插入完为止,得到一个新的有序序列 。
实际中我们玩扑克牌时,就用了插入排序的思想
在这里插入图片描述
当插入第i(i>=1)个元素时,前面的array[0],array[1],…,array[i-1]已经排好序,此时用array[i]的排序码与array[i-1],array[i-2],…的排序码顺序进行比较,找到插入位置即将array[i]插入,原来位置上的元素顺序后移。
在这里插入图片描述

代码如下:

void InsertSort(int* a, int n)
{
	assert(a);

	for (int i = 0; i < n - 1; ++i)
	{
		// 将x插入[0, end]有序区间
		int end = i;
		int x = a[end+1];
		while (end >= 0)
		{
			if (a[end] > x)
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = x;
	}
}

直接插入排序是一种比较好理解的排序,在此不多赘述。
直接插入排序的特性总结:

  1. 元素集合越接近有序,直接插入排序算法的时间效率越高
  2. 时间复杂度:O(N^2)
  3. 空间复杂度:O(1),它是一种稳定的排序算法
  4. 稳定性:稳定

二、希尔排序

希尔排序法又称缩小增量法。希尔排序法的基本思想是:先选定一个整数,把待排序文件中所有记录分成个组,所有距离为的记录分在同一组内,并对每一组内的记录进行排序。然后,取,重复上述分组和排序的工作。当到达=1时,所有记录在统一组内排好序。
在这里插入图片描述
代码如下:

void ShellSort(int* a, int n)
{
	// 按gap分组数据进行预排序
	int gap = 3;

	for (int j = 0; j < gap; ++j)
	{
		for (int i = j; i < n - gap; i += gap)
		{
			int end = i;
			int x = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > x)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}

			a[end + gap] = x;
		}
	}
}

void ShellSort(int* a, int n)
{
	// 多次预排序(gap > 1) +直接插入 (gap == 1)
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		
		for (int i = 0; i < n - gap; ++i)
		{
			int end = i;
			int x = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > x)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}

			a[end + gap] = x;
		}
	}	
}

两种写法一个是给定gap值但有缺陷,而第二种则能够根据需要调整gap值,可以看到,当gap=1时,他就是直接插入排序,可以说,希尔排序就是直接插入排序的一种优化。
希尔排序的特性总结:

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序,目的是让数组更接近于有序。当gap == 1时,数组已经接近有序的了,这样就会很快。这样整体而言,可以达到优化的效果。
  3. 希尔排序的时间复杂度不好计算,因为gap的取值方法很多,导致很难去计算。大概是在O(n^1.25) 到 O(1.6*n^1.25)。
  4. 稳定性:不稳定

三、选择排序

选择排序基本思想:每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完
直接选择排序
★在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
★若它不是这组元素中的最后一个(第一个)元素,则将它与这组元素中的最后一个(第一个)元素交换
★在剩余的array[i]–array[n-2](array[i+1]–array[n-1])集合中,重复上述步骤,直到集合剩余1个元素
在这里插入图片描述
在这先写一个交换函数,下面的排序也会用到:

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

排序代码如下:

void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;
	
	while (begin < end)
	{
		int mini = begin, maxi = begin;
		for (int i = begin; i <= end; ++i)
		{
			if (a[i] < a[mini])
				mini = i;

			if (a[i] > a[maxi])
				maxi = i;
		}
		Swap(&a[begin], &a[mini]);
		if (begin == maxi)
			maxi = mini;

		Swap(&a[end], &a[maxi]);

		++begin;
		--end;
	}
}

直接选择排序的特性总结:

  1. 直接选择排序思考非常好理解,但是效率不是很好。实际中很少使用
  2. 时间复杂度:O(N^2)
  3. 空间复杂度:O(1)
  4. 稳定性:不稳定

四、堆排序

**堆排序(Heapsort)**是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。它是通过堆来进行选择数据。
代码如下:

void AdjustDown(int* a, int n, int parent)//向下调整
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		// 选出左右孩子中小的那一个
		if (child + 1 < n && a[child + 1] > a[child])
		{
			++child;
		}

		// 如果小的孩子小于父亲,则交换,并继续向下调整
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

// 堆排序 -- O(N*logN)
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;
	}
}

需要注意的是排升序要建大堆,排降序建小堆,这里的写法是升序。
直接选择排序的特性总结:

  1. 堆排序使用堆来选数,效率就高了很多。
  2. 时间复杂度:O(N*logN)
  3. 空间复杂度:O(1)
  4. 稳定性:不稳定

五、冒泡排序

交换排序基本思想:所谓交换,就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置
交换排序的特点是:将键值较大的记录向序列的尾部移动,键值较小的记录向序列的前部移动
冒泡排序:
在这里插入图片描述
代码如下:

void BubbleSort(int* a, int n)
{
	int end = n;
	while (end > 0)
	{
		int exchange = 0;
		for (int i = 1; i < end; ++i)
		{
			if (a[i - 1] > a[i])
			{
				exchange = 1;
				Swap(&a[i - 1], &a[i]);
			}
		}
		--end;

		if (exchange == 0)
		{
			break;
		}
	}
}

冒泡排序的特性总结

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度:O(N^2)
  3. 空间复杂度:O(1)
  4. 稳定性:稳定

六、快速排序

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

1.递归写法

①三位取中函数

代码如下:

int GetMidIndex(int* a, int left, int right)
{
	int mid = left + ((right - left) >> 1);
	if (a[left] < a[mid])
	{
		if (a[mid] < a[right])
		{
			return mid;
		}
		else if (a[left] > a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
	else
	{
		if (a[mid] > a[right])
		{
			return mid;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}

三位取中的目的是为了防止面对有序最坏情况,变成选中位数做key,变成最好情况。

②hoare版本

在这里插入图片描述

代码如下:

int Partion1(int* a, int left, int right)
{
	int mini = GetMidIndex(a, left, right);
	Swap(&a[mini], &a[left]);

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

	return left;
}

这里的主体思路是先指定首元素为key,先从数组尾部开始与key值比大小,直到找到比key小的元素再从左开始找比key大的元素,依次递归进行交换,直到left和right指针相遇中止,最后将key值与中间值交换,完成快排第一轮,再进入循环将中间值两边的值再操作,最终完成排序。需要注意的是,这里的三种写法都进行了三位取中优化。

③挖坑法

在这里插入图片描述

代码如下:

int Partion2(int* a, int left, int right)
{
	int mini = GetMidIndex(a, left, right);
	Swap(&a[mini], &a[left]);

	int key = a[left];
	int pivot = left;
	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;
	return pivot;
}

该思路是先将首位元素赋给key值,将首元素位置指定为坑位,同样是从右边开始进行比大小,找到比key值小,将该值赋给首元素位置(即坑位),此元素初始位置设为新坑位,再从左边找比key大的值,找到后放进右边坑位,以此往复,最后留下的坑位填补为key存放的值,最后的递归步骤同上。

④前后指针版本

在这里插入图片描述

代码如下:

int Partion3(int* a, int left, int right)
{
	int mini = GetMidIndex(a, left, right);
	Swap(&a[mini], &a[left]);

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

		++cur;
	}

	Swap(&a[prev], &a[keyi]);
	return prev;
}

此算法的基本思路为:先指定第一个元素为key值,再指定cur与prev两个指针,prev指针指向第一个元素,cur指针指向第二个元素,cur指针先走找到比key小的元素停止,prev再向前走,找到比key大的元素停止,prev与cur的值进行交换,cur指针继续向前寻找比key小的值,以此递归,直到cur指针越界停止循环,将首元素值与此时的prev指向的值进行交换,key此时为枢轴,后递归同上。

⑥快排主函数

void QuickSort(int* a, int left, int right)
{
	if (left >= right)
		return;
	{
		int keyi = Partion1(a, left, right);
		//int keyi = Partion2(a, left, right);
		//int keyi = Partion3(a, left, right);
		QuickSort(a, left, keyi - 1);
		QuickSort(a, keyi + 1, right);
	}	
}

递归程序的缺陷:

  1. 针对早期编译器相比循环程序,性能差;
  2. 递归深度太深,会导致栈溢出。(比如数组中都是相同数字的情况下)。

2.非递归写法

非递归写法是利用了栈,在C语言中,栈是需要自己写代码实现的,这里我套用的是之前写的关于栈的博客代码:
栈的介绍及接口实现
代码如下:

void QuickSortNonR(int* a, int left, int right)
{
	ST st;
	StackInit(&st);
	StackPush(&st, left);
	StackPush(&st, right);

	while (!StackEmpty(&st))
	{
		int end = StackTop(&st);
		StackPop(&st);

		int begin = StackTop(&st);
		StackPop(&st);

		int keyi = Partion3(a, begin, end);
		if (keyi + 1 < end)
		{
			StackPush(&st, keyi+1);
			StackPush(&st, end);
		}

		if (begin < keyi-1)
		{
			StackPush(&st, begin);
			StackPush(&st, keyi-1);
		}
	}

	StackDestroy(&st);
}

快速排序的特性总结:
在这里插入图片描述

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

七、归并排序

归并排序基本思想:
归并排序(MERGE-SORT)是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and
Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有
序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。 归并排序核心步骤:
在这里插入图片描述

1.递归写法

代码如下:

void _MergeSort(int* a, int left, int right, int* tmp)
{
	if (left >= right)
	{
		return;
	}

	int mid = (left + right) / 2;
	_MergeSort(a, left, mid, tmp);
	_MergeSort(a, mid + 1, right, tmp);

	int begin1 = left, end1 = mid;
	int begin2 = mid+1, end2 = right;
	int i = left;
	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++];
	}

	for (int j = left; j <= right; ++j)
	{
		a[j] = tmp[j];
	}
}

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int)*n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	_MergeSort(a, 0, n - 1, tmp);

	free(tmp);
	tmp = NULL;
}

2.非递归写法

代码如下:

void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int)*n);
	if (tmp == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	int gap = 1;
	while (gap < n)
	{
		for (int i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			if (end1 >= n || begin2 >= n)
			{
				break;
			}
			
			// end2 越界,需要归并,修正end2
			if (end2 >= n)
			{
				end2 = n- 1;
			}

			int index = i;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[index++] = a[begin1++];
				}
				else
				{
					tmp[index++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tmp[index++] = a[begin1++];
			}

			while (begin2 <= end2)
			{
				tmp[index++] = a[begin2++];
			}

			// 把归并小区间拷贝回原数组
			for (int j = i; j <= end2; ++j)
			{
				a[j] = tmp[j];
			}
		}

		gap *= 2;
	}

	free(tmp);
	tmp = NULL;
}

归并排序的特性总结:

  1. 归并的缺点在于需要O(N)的空间复杂度,归并排序的思考更多的是解决在磁盘中的外排序问题。
  2. 时间复杂度:O(N*logN)
  3. 空间复杂度:O(N)
  4. 稳定性:稳定

八、非比较排序

思想:计数排序又称为鸽巢原理,是对哈希直接定址法的变形应用。 操作步骤:

  1. 统计相同元素出现次数
  2. 根据统计的结果将序列回收到原来的序列中

1.基数排序

基数排序的思路由最大值的位数与基数的定义,比如这里我们是给数组排序,最大位数为3,将0-9定为基数,则基数是10,拿(278,109,63,930,589,184,505,269,8,83)这个数组来讲,排序过程如下图,首先从数组从左至右个位开始,0-9依次插入相应位置,再从0-9依次取出,需要注意的是,先取先放进去的,在进行十位排序,过程同上,后同理。
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
最后排序结果为(8,63,83,109,184,269,278,505,589,930)
这里采用的是C++的写法,方便调用队列,想用C语言写的小伙伴可以参考博主之前关于队列的博客,进行调用修改,步骤相差无几。
代码如下:

#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stdio.h>
#include<queue>
using namespace std;

#define K 3
#define RADIX 10

//定义基数
queue<int>Q[RADIX];

int GetKey(int value, int k)
{
 int key = 0;
 while (k >= 0)
 {
  key = value % 10;
  value /= 10;
  k--;
 }
 return key;
}
void Distribute(int arr[], int left, int right, int k)
{
 for (int i = left; i < right; ++i)
 {
  int key = GetKey(arr[i], k);
  Q[key].push(arr[i]);
 }
}

void Collect(int arr[])
{
 int k = 0;
 for (int i = 0; i < RADIX; ++i)
 {
  while (!Q[i].empty())
  {
   arr[k++] = Q[i].front();
   Q[i].pop();
  }
 }
}
void RadixSort(int arr[], int left, int right)//[left,right)
{
 for (int i = 0; i < K; ++i)
 {
  //分发数据
  Distribute(arr, left, right, i);
  //回收数据
  Collect(arr);
 }
}

基数排序的特性总结:

  1. 时间复杂度:O(关键字位数d*n)
  2. 空间复杂度:O(关键字位数d*n)
  3. 稳定性:稳定

2.计数排序

计数排序的思路是基于基数排序的一种变形,我们先参考下图,假定数组值范围为1-9,基数为绝对映射,思路同基数排序,如果是某个范围内,则为相对映射,基数起始值为数组最小值,最终值为最大值。
在这里插入图片描述

代码如下:

void CountSort(int* a, int n)
{
	int max = a[0], min = a[0];
	for (int i = 1; i < n; ++i)
	{
		if (a[i] > max)
		{
			max = a[i];
		}

		if (a[i] < min)
		{
			min = a[i];
		}
	}

	int range = max - min + 1;
	int* count = (int*)malloc(sizeof(int)*range);
	memset(count, 0, sizeof(int)*range);
	if (count == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	for (int i = 0; i < n; ++i)
	{
		count[a[i] - min]++;
	}

	int j = 0;
	for (int i = 0; i < range; ++i)
	{
		while (count[i]--)
		{
			a[j++] = i + min;
		}
	}
}

计数排序的特性总结:

  1. 计数排序在数据范围集中时,效率很高,但是适用范围及场景有限。
  2. 时间复杂度:O(MAX(N,范围d))
  3. 空间复杂度:O(范围d)
  4. 稳定性:稳定

排序算法复杂度及稳定性分析

排序方法平均情况最好情况最坏情况辅助空间稳定性
选择排序O(n^2)O(n^2)O(n^2)O(1)不稳定
希尔排序O(nlogn)~O(n^2)O(n^1.3)O(n^2)O(1)不稳定
插入排序O(n^2)O(n)O(n^2)O(1)稳定
冒泡排序O(n^2)O(n)O(n^2)O(1)稳定
堆排序O(nlogn)O(nlogn)O(nlogn)O(1)不稳定
快速排序O(nlogn)O(nlogn)O(n^2)O(logn)不稳定
归并排序O(nlogn)O(nlogn)O(nlogn)O(n)稳定
基数排序O(d*n)O(d*n)O(d*n)O(n)稳定
计数排序O(d+n)O(d+n)O(d+n)O(d)稳定

结语

有兴趣的小伙伴可以关注作者,如果觉得内容不错,请给个一键三连吧,蟹蟹你哟!!!
制作不易,如有不正之处敬请指出
感谢大家的来访,UU们的观看是我坚持下去的动力
在时间的催化剂下,让我们彼此都成为更优秀的人吧!!!
在这里插入图片描述

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

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

相关文章

倾斜摄影三维模型顶层合并技术及其实现方法

倾斜摄影三维模型顶层合并技术及其实现方法 倾斜摄影三维模型由于数据量大、结构复杂&#xff0c;常常需要进行顶层合并&#xff0c;以便更好地应用到城市规划、土地管理和文化遗产保护等领域。本文将介绍倾斜摄影三维模型顶层合并技术及其实现方法。 1、什么是顶层合并 倾斜…

【安全与风险】普适计算中的安全与隐私研究

普适计算中的安全与隐私研究 日常生活的数字化无处不在的计算对移动社交媒体的影响讨论更便宜的存储和更强大的处理的影响移动和普适计算的影响有时候&#xff0c;惊奇另一个例子攻击模型贡献是什么&#xff1f;智能家居的案例研究本文的主要内容如何自学? 日常生活的数字化 …

第三章 使用 Maven:命令行环境

第一节 实验一&#xff1a;根据坐标创建 Maven 工程 Maven 核心概念&#xff1a;坐标 ①数学中的坐标 使用 x、y、z 三个**『向量』作为空间的坐标系&#xff0c;可以在『空间』中唯一的定位到一个『点』**。 ②Maven中的坐标 [1]向量说明 使用三个**『向量』在『Maven的仓…

不知道今天吃什么?今天吃什么 API 告诉你

引言 在现代社会&#xff0c;由于生活节奏加快和繁忙的工作日程&#xff0c;越来越多的人感到选择今天吃什么餐点是一项繁琐且令人困扰的任务。为了解决这个问题&#xff0c;许多人会求助于在线菜谱和美食博客等渠道&#xff0c;但是这些选项通常是繁琐和耗时的。 幸运的是&a…

聚观早报 | 马斯克称星舰1-2个月内准备再发射;推特撤下官媒标签

今日要闻&#xff1a;马斯克称星舰1-2个月内准备再发射&#xff1b;推特撤下「官媒」标签&#xff1b;Pixel Fold 折叠机型首次被泄露&#xff1b;蔚来员工曝半年加班500小时&#xff1b;苹果Mac Pro和Mac Studio无缘WWDC 马斯克称星舰1-2个月内准备再发射 美国当地时间 4 月 …

关于GNSS技术介绍(二)

在上期文章中&#xff0c;我们介绍了GNSS技术的发展历程、原理&#xff0c;并对不同类型的定位技术进行了介绍&#xff0c;在本期文章中我们将继续讨论GNSS的优点与应用及其测试方法和解决方案。 GNSS的优点与应用 目前GNSS技术已经成为日常生活不可或缺的一部分&#xff0c;几…

自定义RecyclerView.LayoutManager实现类实现卡片层叠布局的列表效果

一.前言 先看效果&#xff08;大佬们请忽略水印&#xff09;&#xff1a; 卡片层叠列表的实现效果已经发布成插件&#xff0c;集成地址&#xff1a;implementation ‘com.github.MrFishC:YcrCardLayoutHepler:v1.1’&#xff1b; 先讲解如何快速实现&#xff0c;然后再来讲解…

小程序开发费用估算:如何控制项目成本?

在当今数字化的时代&#xff0c;小程序已经成为了很多企业和个人开展业务的重要手段。小程序的开发需要耗费时间和资源&#xff0c;因此在项目初期&#xff0c;了解预计的开发费用是非常重要的。本文将详细介绍如何估算小程序开发费用以及如何控制项目成本。 小程序开发费用 …

2023年重庆经济发展研究报告

第一章 发展概况 1.1 地理和人口发展概况 重庆&#xff08;简称“渝”&#xff09;位于中国西南地区&#xff0c;是中国四个直辖市之一&#xff0c;地处长江中上游&#xff0c;横跨东经10517到11011&#xff0c;北纬2810到3213之间。重庆市地势复杂&#xff0c;地形多山&…

风光场景削减及源荷不确定性的虚拟电厂随机优化调度研究(Matlab代码实现)

&#x1f4a5; &#x1f4a5; &#x1f49e; &#x1f49e; 欢迎来到本博客 ❤️ ❤️ &#x1f4a5; &#x1f4a5; &#x1f3c6; 博主优势&#xff1a; &#x1f31e; &#x1f31e; &#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 …

Ubuntu16.04配置使用robosense雷达18版本的rsview软件记录

目录 依赖安装boost安装下载源码解压编译安装更新一下系统的动态链接库 libpng16-16安装 rsview运行下载运行具体操作可以看doc文件夹内的说明文件 参考文章 依赖安装 boost安装 下载源码 boost1.65官方下载地址 解压 进入下载文件所在的文件夹 tar -zxvf boost_1_65_1.t…

托福高频真词List05 // 附托福TPO阅读真题

目录 4月23日单词 生词 熟词 4月24日真题 4月23日单词 生词 sparsethinly distributedadj 稀疏的sparselythinlyadv 稀疏地congestion / kənˈdʒestʃən / overcrowdingn 拥挤continuallyregularlyadv 持续的eradicateeliminatev 消除facilitatemake easiereasev 使..…

M2下通过docker安装sqlserver

背景&#xff1a;要做这一个需求&#xff0c;将txt文件格式化以后&#xff0c;入库到sqlserver中&#xff0c;没有测试环境&#xff0c;只能自己在本地搭建一个sqlserver的服务器 前提&#xff1a;安装好docker 第一步&#xff1a;在终端下查找sqlserver的镜像文件 我们可以选…

S7-1200通过模拟量的方式实现PID控制恒压供水的具体方法示例

S7-1200通过模拟量的方式实现PID控制恒压供水的具体方法示例 具体方法和步骤可参考以下内容: 创建工艺对象,如下图所示,有2种方式: PID_Compact指令需要在OB30中断组织块中调用,如下图所示, 使用 PID 控制器前,需要对其进行组态设置,分为基本设置、过程值设置、高级设…

Stm32开发环境从0搭建(Clion作为开发软件)

环境安装 1. 下载CLion开发软件和安装 https://www.jetbrains.com/zh-cn/clion/2. 安装msys2开发环境 一直下一步 参考文档 安装OpenOCD工具(烧录下载工具) 将压缩包解压到环境安装目录下: 安装Arm-Gcc编译环境 将此目录拷贝到安装目录&#xff0c;并解压 配置环境变量 …

实测有效!手把手带你将 Docker Image 体积减少 90%

Docker Image 体积越大,那部署要花的时间就越长;假如每个版本都有好几 GB,那并不是一个理想的状态;因此笔者开始动手实作,想看看到底能将 Docker Image 的体积缩小多少! 大纲 ㄧ、先初始化一个简易的 Node.js 专案 二、撰写 Dockefile,了解优化前体积有多大 三、使用 No…

嵌入式开发--无刷电机学习1--FOC简介

写在前面 最近刚学FOC电机控制&#xff0c;文中错误在所难免&#xff0c;欢迎批评指正&#xff0c;也欢迎在评论区留言讨论。 FOC意义 普通直流电机&#xff08;DC MOTOR&#xff09;的驱动是碳刷换向&#xff0c;能看到这篇文章的朋友应该不用我再去复述一遍直流电机的工作…

【论文阅读】You Are What You Do:通过数据来源分析寻找隐蔽的恶意软件

You Are What You Do: Hunting Stealthy Malware via Data Provenance Analysis NDSS-2020 伊利诺伊大学香槟分校、德克萨斯大学达拉斯分校 Wang Q, Hassan W U, Li D, et al. You Are What You Do: Hunting Stealthy Malware via Data Provenance Analysis[C]//NDSS. 2020. 目…

Java每日一练(20230424)

目录 1. 二叉树的中序遍历 &#x1f31f;&#x1f31f; 2. 两两交换链表中的节点 &#x1f31f;&#x1f31f; 3. 不同的子序列 &#x1f31f;&#x1f31f;&#x1f31f; &#x1f31f; 每日一练刷题专栏 &#x1f31f; Golang每日一练 专栏 Python每日一练 专栏 C/…

Python 基础(十一):集合

❤️ 博客主页&#xff1a;水滴技术 &#x1f338; 订阅专栏&#xff1a;Python 入门核心技术 &#x1f680; 支持水滴&#xff1a;点赞&#x1f44d; 收藏⭐ 留言&#x1f4ac; 文章目录 一、声明集合1.1、使用 {} 声明集合1.2、声明空的集合1.3、自动过滤重复元素 二、添加…