数据结构与算法—插入排序选择排序

news2024/10/5 12:52:31

目录

一、排序的概念

二、插入排序  

1、直接插入排序 

直接插入排序的特性总结：

2、希尔排序

希尔排序的特性总结：

 三、选择排序

1、直接选择排序 

时间复杂度

2、堆排序—排升序(建大堆)

向下调整函数

堆排序函数

四、交换排序

1、冒泡排序 

时间复杂度 

代码完整版： 

 头文件

 函数文件

 测试文件

小白学习中，本文会不时更新哦！ 

一、排序的概念

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

 

二、插入排序  

比如，在实际中我们玩扑克牌时，就用了插入排序的思想

1、直接插入排序 

直接插入排序是一种简单的排序算法，它的基本思想是将一个记录插入到已经排序好的有序表中，从而得到一个新的、记录数增加1的有序表。这个算法适用于少量数据的排序，是稳定的排序方法，即相等的元素的顺序不会改变。

直接插入排序的算法过程如下：

  1. 从第一个元素开始，该元素可以认为已经被排序；
  2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
  3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
  4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
  5. 将新元素插入到该位置后；
  6. 重复步骤2~5。

如果我们将这个过程比作扑克牌的排序，每次我们都是从牌堆中拿出一张牌，然后将它插入到左手中正确的位置，最终左手中的牌都是排序好的。

 我们来看一下代码的运行过程：

void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++) {
		int end = i;
		int tmp = a[i + 1];
		while (end >= 0) {
			if (a[end] > tmp) {
				a[end + 1] = a[end];
				end--;
			}
			else {
				break;
			}
		}
		a[end + 1] = tmp;
	}
}
  • 函数参数：指针a接收数组，n接收数组元素个数。
  • 首先，外层循环从第一个元素开始遍历到倒数第二个元素，因为在内层循环中需要比较当前元素和前一个元素的大小，所以最后一个元素不需要再比较。
  • 在外层循环中，我们将当前元素的下一个元素作为待插入元素，将当前元素的下标保存在变量end中，这个变量表示当前元素在已排序部分中的位置。
  • 接下来while循环中，我们在已排序部分从后往前遍历，比较当前元素和已排序部分中的元素大小，如果当前元素小于已排序部分中的元素，则将已排序部分中的元素后移一位，直到找到当前元素的正确位置。
  • 最后，我们将待插入元素插入到正确的位置，即end+1的位置。
  • 内层循环结束后，当前元素已经被插入到了正确的位置，我们继续外层循环，处理下一个元素，直到所有元素都被插入到正确的位置。

直接插入排序的特性总结：

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

2、希尔排序

 希尔排序（Shell Sort）是一种改进的插入排序算法，它的基本思想是将待排序的序列分成若干个子序列，对每个子序列进行插入排序，然后再将整个序列进行一次插入排序。通过这种方式，可以使得序列中较小的元素尽可能地快速地移动到前面，从而减少了插入排序的比较次数和移动次数，提高了排序的效率。

希尔排序的算法过程如下：

  1. 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
  2. 按增量序列个数k，对序列进行k趟排序；
  3. 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m的子序列，分别对每个子序列进行插入排序；
  4. 将各个子序列中的排序结果合并成一个序列。

代码如下：

void ShellSort(int* a, int n)
{
	//1、gap >  1 预排序
	//2、gap == 1 直接插入排序
	int gap = n;
	while (gap > 1) {
		gap = gap / 3 + 1;// +1可以保证最后一次一定是1
		for (int i = 0; i < n - gap; i++) {
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0) {
				if (a[end] > tmp) {
					a[end + gap] = a[end];
					end -= gap;
				}
				else {
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}
  • 首先，我们选择一个增量gap=n，然后将序列分成若干个子序列，对每个子序列进行插入排序。
  • 在这个实现中，我们使用了一个while循环来计算增量gap，每次将gap除以3并加1，保证gap最小为1，此时进行直接插入排序。
  • 在外层while循环中，我们将序列分成若干个子序列，每个子序列的长度为gap。然后，我们对每个子序列进行插入排序，将子序列中的元素插入到已排序部分的正确位置。

  • 在内层循环中，我们使用了一个变量end来表示当前元素的下标，每次将end减去gap，直到找到当前元素的正确位置。然后，我们将待插入元素插入到正确的位置，即end+gap的位置。

  • 内层循环结束后，当前子序列已经排好序了，我们继续外层while循环，处理下一个子序列，直到所有子序列都被排好序了。

 以数组 a = [9, 8, 7, 6, 5, 4, 3, 3, 2, 1, 0]，长度 n = 11为例，演示排序过程

图中颜色相同的值为当前<间距gap>下的子序列，从前往后依次比较每个子序列（也就是相距 gap 个位置的值的大小）。

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。我们实现后可以进行性能测试的对比。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些书中给出的希尔排序的时间复杂度都不固定，但我们只需记住结论：O（N^ 1.3），复杂的推导和计算过程不需要了解。

 三、选择排序

1、直接选择排序 

直接选择排序通过每一轮的比较，找到最大值和最小值，将最大值的节点跟右边交换，最小值节点跟左边交换，达到排升序的效果。

我们先看代码，然后通过一个例子就能明白了。 

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

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

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

		Swap(&a[begin], &a[mini]);
		// 如果maxi和begin重叠，修正一下即可
		if (begin == maxi)
		{
			maxi = mini;
		}

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

		++begin;
		--end;
	}
}
  • 代码中的变量begin和end分别表示当前未排序的元素范围的起始和结束位置。
  • 在while循环中，每次从begin到end的范围内找到最大和最小的元素，分别用maxi和mini记录它们的下标。
  • 然后将mini所指向的元素与begin所指向的元素交换位置，将maxi所指向的元素与end所指向的元素交换位置。
  • 如果maxi和begin重叠，说明mini所指向的元素是当前未排序元素中最大的，需要将maxi更新为mini。
  • 最后，begin指针向后移动一位，end指针向前移动一位，继续进行下一轮排序。 

我们来用一个简单的例子演示一下这个选择排序算法的过程。

假设我们有一个数组`a`，它的元素为：[5, 3, 8, 6, 4, 2]，我们要对它进行排序。

首先，begin指向第一个元素，end指向最后一个元素：

begin = 0
end = 5

接下来，我们进入主循环，因为`begin`小于`end`，所以我们需要继续排序。在第一轮排序中，我们需要找到未排序部分的最大值和最小值。

首先，我们将`maxi`和`mini`都初始化为`begin`，也就是第一个元素的索引。然后，我们遍历未排序部分的元素，找到最大值和最小值的索引。在这个例子中，最大值的索引是2，最小值的索引是5。

maxi = 2
mini = 5

接下来，我们将未排序部分的最小值交换到开始位置，将未排序部分的最大值交换到结束位置。这时，数组的状态变为：[2, 3, 4, 6, 8, 5]

由于我们已经将当前范围的最大值和最小值放到了正确的位置，所以我们将`begin`向后移动一位，将`end`向前移动一位，继续进行下一轮排序。此时，`begin`指向第二个元素，`end`指向倒数第二个元素：

begin = 1
end = 4

在第二轮排序中，我们需要找到未排序部分的最大值和最小值。这时，最大值的索引是3，最小值的索引是1。

maxi = 3
mini = 1

接下来，我们将未排序部分的最小值交换到开始位置，将未排序部分的最大值交换到结束位置。这时，数组的状态变为：[2, 3, 4, 5, 6, 8]，所有元素都排序完成，排序结束。

时间复杂度

每一轮比较都需要遍历数组，查找最大最小值，第一轮遍历N个数据，第二轮是N-2个数据，第三轮N-4 …，遍历次数为：N+N-2+N-4+…+1，一个等差数列求和，所以总的时间复杂度为O(N^2)

2、堆排序—排升序(建大堆)

向下调整函数

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

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;
	}
}
  • 通过传入参数获取到当前的左子节点的位置。
  • 当child位置小于数组元素个数时进行判断。
  • 进入循环，首先判断检查右子节点是否存在并且比左子节点的值大，如果是，将 child 更新为右子节点的索引，以确保选择更小的子节点进行比较。
  • 比较选定的子节点的值与父节点的值，如果子节点的值大于父节点的值，就交换它们。
  • 更新parent为新的子节点位置，更新child为新的左子节点位置，然后继续比较和交换，直到不再需要交换为止。
  • 如果当前子节点不大于当前父节点则停止循环。

堆排序函数

// 排升序
void HeapSort(int* a, int n)
{
	// 建大堆
	for (int i = (n-1-1)/2; i >= 0; --i)
	{
		AdjustDown(a, n, i);
	}

	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}
  1.  在HeapSort函数中，第一个循环调用了AdjustDown函数，将待排序数组构建成了一个大堆。但是，这个大堆并不是完全有序的，只是满足了大堆的性质，即每个节点的值都大于或等于其左右子节点的值。因此，需要进行第二个while循环，将大堆中的元素依次取出，交换堆顶元素和数组末尾元素，并重新调整大堆，直到整个数组有序。
  2. 第二个while循环中，将堆顶元素与数组末尾元素交换，然后将剩余元素重新调整为大堆。这样，每次交换后，数组末尾的元素就是当前大堆中的大值，而剩余元素仍然满足大堆的性质。重复以上步骤，直到整个数组有序。

四、交换排序

1、冒泡排序 

void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; ++j)
	{
		bool exchange = false;
		for (int i = 1; i < n - j; i++)
		{
			if (a[i - 1] > a[i])
			{
				int tmp = a[i];
				a[i] = a[i - 1];
				a[i - 1] = tmp;

				exchange = true;
			}
		}

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

冒泡排序使用了两个循环，外层循环控制排序的轮数，内层循环控制每轮排序的次数。每轮排序都会将未排序部分的最大值交换到未排序部分的最后面，因此每轮排序都会将未排序部分的长度减1

  • 代码中的变量 j 表示已排序部分的长度，初始值为0，每轮排序结束后 j 的值加1。
  • 内层循环从第一个元素开始，依次比较相邻的两个元素，如果它们的顺序错误就交换它们的位置。
  • 如果在一轮排序中没有发生任何交换，说明已经排好序了，可以直接退出循环。

时间复杂度 

这个算法的时间复杂度是O(n^2)，因为它需要进行n轮排序，每轮排序需要比较n-j-1次相邻的元素，因此总共需要比较(n-1)+(n-2)+...+1=n*(n-1)/2次。 

代码完整版： 

 头文件

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

void PrintArray(int* a, int n);
void InsertSort(int* a, int n);
void ShellSort(int* a, int n);
void BubbleSort(int* a, int n);
void SelectSort(int* a, int n);

 函数文件

#include "sort.h"

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

void InsertSort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++) {
		int end = i;
		int tmp = a[i + 1];
		while (end >= 0) {
			if (a[end] > tmp) {
				a[end + 1] = a[end];
				end--;
			}
			else {
				break;
			}
		}
		a[end + 1] = tmp;
	}
}

void ShellSort(int* a, int n)
{
	//1、gap >  1 预排序
	//2、gap == 1 直接插入排序
	int gap = n;
	while (gap > 1) {
		gap = gap / 3 + 1;// +1可以保证最后一次一定是1
		for (int i = 0; i < n - gap; i++) {
			int end = i;
			int tmp = a[end + gap];
			while (end >= 0) {
				if (a[end] > tmp) {
					a[end + gap] = a[end];
					end -= gap;
				}
				else {
					break;
				}
			}
			a[end + gap] = tmp;
		}
	}
}

void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; ++j)
	{
		bool exchange = false;
		for (int i = 1; i < n - j; i++)
		{
			if (a[i - 1] > a[i])
			{
				int tmp = a[i];
				a[i] = a[i - 1];
				a[i - 1] = tmp;

				exchange = true;
			}
		}

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

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

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

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

		Swap(&a[begin], &a[mini]);
		// 如果maxi和begin重叠，修正一下即可
		if (begin == maxi)
		{
			maxi = mini;
		}

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

		++begin;
		--end;
	}
}

 测试文件

#include"Sort.h"
#include<time.h>

void TestInsertSort()
{
	//int a[] = { 4,7,1,9,3,4,5,8,3,2 };
	int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
	PrintArray(a, sizeof(a) / sizeof(int));
	InsertSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestSelectSort()
{
	//int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
	int a[] = { 9,7,1,3,3,0,5,8,3,2,3 };
	PrintArray(a, sizeof(a) / sizeof(int));
	SelectSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestShellSort()
{
	int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
	PrintArray(a, sizeof(a) / sizeof(int));
	InsertSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));

	ShellSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestHeapSort()
{
	int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
	PrintArray(a, sizeof(a) / sizeof(int));
	HeapSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestBubbleSort()
{
	int a[] = { 4,7,1,9,3,6,5,8,3,2,0 };
	PrintArray(a, sizeof(a) / sizeof(int));
	BubbleSort(a, sizeof(a) / sizeof(int));
	PrintArray(a, sizeof(a) / sizeof(int));
}

void TestOP()
{
	srand(time(0));
	const int N = 1000000;//运行时间较长可自行更改大小
	int* a1 = (int*)malloc(sizeof(int) * N);
	int* a2 = (int*)malloc(sizeof(int) * N);
	int* a3 = (int*)malloc(sizeof(int) * N);
	int* a4 = (int*)malloc(sizeof(int) * N);
	int* a5 = (int*)malloc(sizeof(int) * N);
	int* a6 = (int*)malloc(sizeof(int) * N);
	int* a7 = (int*)malloc(sizeof(int) * N);


	for (int i = 0; i < N; ++i)
	{
		a1[i] = rand();
		a2[i] = a1[i];
		a3[i] = a1[i];
		a4[i] = a1[i];
		a5[i] = a1[i];
		a6[i] = a1[i];
		a7[i] = a1[i];
	}

	int begin1 = clock();
	InsertSort(a1, N);
	int end1 = clock();

	int begin2 = clock();
	ShellSort(a2, N);
	int end2 = clock();

	int begin3 = clock();
	BubbleSort(a3, N);
	int end3 = clock();

	int begin4 = clock();
	SelectSort(a4, N);
	int end4 = clock();

	int begin5 = clock();
	HeapSort(a5, N);
	int end5 = clock();

	printf("InsertSort:%d\n", end1 - begin1);
	printf("ShellSort:%d\n", end2 - begin2);
	printf("BubbleSort:%d\n", end3 - begin3);
	printf("SelcetSort:%d\n", end4 - begin4);
	printf("HeapSort:%d\n", end5 - begin5);

	free(a1);
	free(a2);
	free(a3);
	free(a4);
	free(a5);
	free(a6);
	free(a7);
}

int main()
{
	//TestInsertSort();
	//TestShellSort();
	//TestSelectSort();
	//TestHeapSort();
    //TestBubbleSort();

	TestOP();

	return 0;
}

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

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

相关文章

vue+css动画 实现文字的上下轮播切换

vue+css动画 实现文字的上下轮播切换

突然间碰到一个比较丝滑的特效，就研究了一下想把它实现出来。 效果：渐隐消失，底部往上走覆盖出现 以下是完整代码，复制粘贴即可运行 <template><div class="aaa"><divclass="page1":class="{ private-fade-out: prevIndex === 1…
阅读更多...
window11安装nvm

window11安装nvm

链接 默认已经安装了node 没有安装的请看链接 github下载最新nvm https://github.com/coreybutler/nvm-windows/releases 找到github下面的 解压之后 安装exe文件 路径自己选择 配置路径和下载源 找到nvm安装路径 -> 找到 settings.txt 文件 -> 配置下载源 node_m…
阅读更多...
CSS 下拉菜单、提示工具、图片廊、计数器

CSS 下拉菜单、提示工具、图片廊、计数器

一、CSS 下拉菜单&#xff1a; CSS下拉菜单用于创建一个鼠标移动上去后显示下拉菜单的效果。示例&#xff1a; <style> .dropdown { position: relative; display: inline-block; } .dropdown-content { display: none; position: absolute; background-color: #f9f…
阅读更多...
下拉列表框Spinner

下拉列表框Spinner

在XML文件中的创建 <Spinnerandroid:id"id/spinner"android:layout_width"wrap_content"android:layout_height"wrap_content"/> 在Java文件中的设置 //获取Spinner对象 Spinner spinnerfindViewById(R.id.spinner); //创建数组…
阅读更多...
MoveFunsDAO 星航计划｜从Move入门Web3与深入实践「公益课堂」

MoveFunsDAO 星航计划｜从Move入门Web3与深入实践「公益课堂」

Move 语言作为最安全的编程语言之一&#xff0c;在资产的安全性和保护方面有着显著优势&#xff0c;被寄予引领 Web3 世界的全新叙事的厚望。 随着 Sui 在今年五月主网上线&#xff0c;它为 Move 生态带来一股新的浪潮。上线以来&#xff0c;Sui 公链的开发活跃度持续数月位居…
阅读更多...
C/C++轻量级并发TCP服务器框架Zinx-游戏服务器开发005：守护进程与进程监控

C/C++轻量级并发TCP服务器框架Zinx-游戏服务器开发005：守护进程与进程监控

文章目录 1 守护进程1.1 进程组和会话1.2 会话的相关概念1.3 守护进程的概念1.4 守护线程的特点1.5 守护进程创建的基本步骤1.6 本项目守护进程的实现 2 进程监控2.1 进程监控的实现 1 守护进程 1.1 进程组和会话 进程除了有进程的PID之外还有一个进程组&#xff0c;进程组是…
阅读更多...
【Git】Git 学习笔记_操作远程仓库

【Git】Git 学习笔记_操作远程仓库

1. SSH 配置和克隆仓库 ssh-keygen -t rsa -C "xxxqq.com"回车后出现以下内容&#xff0c;直接回车&#xff1a; Generating public/private rsa key pair. Enter file in which to save the key (/Users/your_user_directory/.ssh/id_rsa): (按回车键) Enter pass…
阅读更多...
摆脱千篇一律！一文说透如何快速管理超低温冰箱

摆脱千篇一律！一文说透如何快速管理超低温冰箱

超低温冰箱在当今的科学、医疗和工业领域扮演着至关重要的角色&#xff0c;它们被广泛用于储存生物样本、疫苗、药品和实验物品等高价值、温度敏感的产品。 然而&#xff0c;为了维持这种稳定的温度环境&#xff0c;必须采取有效的监控和控制措施&#xff0c;因为即使短暂的温度…
阅读更多...
嵌入式养成计划-48----QT--信息管理系统：百川仓储管理

嵌入式养成计划-48----QT--信息管理系统：百川仓储管理

一百二十二、信息管理系统&#xff1a;百川仓储管理 122.1 UI界面 122.2 思路 客户端&#xff1a; 用户权限有两种类型&#xff0c;一种是用户权限&#xff0c;一种是管理员权限&#xff0c;登录时服务器端会根据数据库查询到的此用户名的权限返回不同的结果&#xff0c;客户…
阅读更多...
[HCTF 2018]WarmUp最详细解释

[HCTF 2018]WarmUp最详细解释

查看源码找到提示 访问source.php 代码审计&#xff1a; class emmm{public static function checkFile(&$page){$whitelist ["source">"source.php","hint">"hint.php"]; 定义了一个名为emmm的类&#xff0c;在该类中有…
阅读更多...
[unity]切换天空盒

[unity]切换天空盒

序 unity是自带天空盒的&#xff1a; 但有的时候不想用自带的。怎么自定义&#xff1f;如何设置&#xff1f; 官方文档 Unity - Manual: The Lighting window (unity3d.com) 相关窗口的打开方法 天空盒对应的选项 实际操作 从标准材质球到天空盒材质球 新建一个材质球&…
阅读更多...
每日一题 2609. 最长平衡子字符串（简单）

每日一题 2609. 最长平衡子字符串（简单）

乍一看&#xff0c;简单题&#xff0c;思路也很简单&#xff0c;但代码有点不好写 思路无非就是从找到的第一个 ‘0’ 开始&#xff0c;一直找 ‘0’ 知道遇到一个 ‘1’&#xff0c;此时变换策略&#xff0c;一直找 ‘1’&#xff0c;知道遇到一个 ‘0’&#xff0c;就这样一…
阅读更多...
掌握 Figma 的自动布局，轻松设计 - 简化指南！

掌握 Figma 的自动布局，轻松设计 - 简化指南！

Figma作为一种基于浏览器操作的设计工具&#xff0c;改变了传统的设计软件工作模式&#xff0c;为我们在线合作设计奠定了基础。自推出以来&#xff0c;Figma的创新一直受到国内外众多UI设计师的关注&#xff0c;包括在推动设计团队开展高效设计工作方面&#xff0c;Figma推出了…
阅读更多...
计算机毕业设计基于springboot+java+vue的健身房课程预约信息网站

计算机毕业设计基于springboot+java+vue的健身房课程预约信息网站

运行环境 开发语言&#xff1a;Java 框架&#xff1a;springboot JDK版本&#xff1a;JDK1.8 服务器&#xff1a;tomcat7 数据库&#xff1a;mysql 数据库工具&#xff1a;Navicat11 开发软件&#xff1a;eclipse/myeclipse/idea Maven包&#xff1a;Maven 项目介绍 本健身网…
阅读更多...
win10安装.net3.5

win10安装.net3.5

运行 winver 对应Windows的版本下载相应的iso&#xff0c;可以在MSDN, 我告诉你 - 做一个安静的工具站 (itellyou.cn)下载&#xff0c;最新的去微软官方下载下载 Windows 10 (microsoft.com) 下载这个工具下载 将iso中的文件夹sxs里的内容拷贝到C:/windows/sxs里 管理员运行po…
阅读更多...
超简单超实用的网页视频下载方法

超简单超实用的网页视频下载方法

想必大家经常需要下载网页视频&#xff0c;以便自己离线观看&#xff0c;这篇文章就来说一种超简单超实用的快捷方法&#xff0c;无需下载软件&#xff0c;无需使用插件&#xff0c;三四步轻松搞定&#xff01; 目录 Google浏览器网页视频下载 Microsoft Edge浏览器网页视频…
阅读更多...
前端项目导入vue和element

前端项目导入vue和element

1.安装nodejs 下载链接https://cdn.npmmirror.com/binaries/node/v18.18.0/node-v18.18.0-x64.msi 进入cmd 命令行模式 管理员身份运行 输入 &#xff08;node -v&#xff09;能看到版本号 npm config set prefix "C:\Program Files\nodejs" 默认路径 npm config…
阅读更多...
网页【CSS】滚动条

网页【CSS】滚动条

前言 优化后的滚动条会提亮我们的网站页面。 例如&#xff1a;CSS-TRICKS这个网站如果采用的是浏览器默认的滚动条&#xff0c;不进行优化&#xff0c;页面会显得很不搭。 所以该网站的滚动条样式优化如下&#xff1a; html::-webkit-scrollbar {width: 30px;height: 30px; …
阅读更多...
基于Springboot的时装购物系统（有报告）。Javaee项目，springboot项目。

基于Springboot的时装购物系统（有报告）。Javaee项目，springboot项目。

演示视频&#xff1a; 基于Springboot的时装购物系统&#xff08;有报告&#xff09;。Javaee项目&#xff0c;springboot项目。 项目介绍&#xff1a; 采用M&#xff08;model&#xff09;V&#xff08;view&#xff09;C&#xff08;controller&#xff09;三层体系结构&…
阅读更多...
notepad++搜索结果窗口不见了

notepad++搜索结果窗口不见了

1、使用notepad打开一个文件文件 2、ctrlf&#xff0c;打开搜索窗口&#xff0c;随便搜索一个内容 3、按F7,然后AltF7 切换焦点到Find result. 会有一个小窗口出现&#xff0c;内容是&#xff1a;还原&#xff0c;移动&#xff0c;大小等 4&#xff0c;点移动&#xff0c;使…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023