C语言数据结构-----二叉树(2)堆的深入理解及应用、链式二叉树的讲解及代码实现

news2024/9/28 9:33:09

前言

本篇文章讲述的内容有部分是上一节写过的。重复内容不会再进行说明，大家可以看上一节内容
链接: C语言数据结构-----二叉树(1)认识数、二叉树、堆及堆的代码实现

文章目录

  • 前言
  • 1.使用堆解决TOP-K问题
  • 2.向下调整堆的时间复杂度与向上调整堆的时间复杂度对比
  • 3.堆排序问题
  • 4.链式二叉树
    • 4.1 三种遍历二叉树
    • 4.2 求二叉树节点的个数
    • 4.3 求二叉树叶子节点(度为0的节点)的个数
    • 4.4 求二叉树的高度
    • 4.5 求二叉树第K层的节点个数
    • 4.6 求二叉树查找值为x的结点
    • 4.7 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
    • 4.8 销毁链式二叉树
    • 4.9 层序遍历
    • 4.10 判断是否为完全二叉树

1.使用堆解决TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

  1. 用数据集合中前K个元素来建堆
    前k个最大的元素，则建小堆
    前k个最小的元素，则建大堆
  2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
    将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

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

void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;

	while (child < size)
	{
		// 假设左孩子小，如果解设错了，更新一下

		if (child + 1 < size && a[child + 1] < a[child])
		{
			++child;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while (parent >= 0)
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
			//child = (child - 1) / 2;
			//parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void CreateNDate()//创建随机数文本
{
	// 造数据
	int n = 10000000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (int i = 0; i < n; ++i)
	{
		int x = (rand() + i) % 10000000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

void PrintTopK(const char* file, int k)
{
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	// 建一个k个数小堆
	int* minheap = (int*)malloc(sizeof(int) * k);
	if (minheap == NULL)
	{
		perror("malloc error");
		return;
	}

	// 读取前k个，建小堆
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &minheap[i]);
		AdjustUp(minheap, i);
	}

	int x = 0;
	while (fscanf(fout, "%d", &x) != EOF)
	{
		if (x > minheap[0])
		{
			minheap[0] = x;
			AdjustDown(minheap, k, 0);
		}
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", minheap[i]);
	}
	printf("\n");

	free(minheap);
	fclose(fout);
}

int main()
{
	 CreateNDate();
	PrintTopK("Data.txt", 5);

	return 0;
}

2.向下调整堆的时间复杂度与向上调整堆的时间复杂度对比

在这里插入图片描述
总体而言
①向下调整堆的时间复杂度为：O[N-log2(N+1)]，当N足够大时，约等于O(N)

②向上调整堆的时间复杂度为：在这里插入图片描述

3.堆排序问题

堆排序即利用堆的思想来进行排序，总共分为两个步骤：

  1. 建堆
    升序：建大堆
    降序：建小堆
  2. 利用堆删除思想来进行排序 建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

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

void AdjustDown(HPDataType* a, int size, int parent)
{
	int child = parent * 2 + 1;

	while (child < size)
	{
		// 假设左孩子小，如果解设错了，更新一下

		if (child + 1 < size && a[child + 1] < a[child])
		{
			++child;
		}

		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while (parent >= 0)
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
			//child = (child - 1) / 2;
			//parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	// 建大堆，向下调整
	// O(N*logN)
	/*for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}*/

	//建小堆，向上调整
	// O(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;
	}
}

int main()
{
	int a[] = { 4, 6, 2, 1, 5, 8, 2, 9 };
	HeapSort(a, sizeof(a)/sizeof(int));
	for (int i = 0; i < sizeof(a)/sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	return 0;
}

在这里插入图片描述

4.链式二叉树

在这里插入图片描述

4.1 三种遍历二叉树

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

  1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
  2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
  3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

以下是分别堆前序遍历、中序遍历、后序遍历的详细剖析！
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
前序遍历、中序遍历、后序遍历的代码实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<time.h>

typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}TreeNode;

TreeNode* BuyTreeNode(int x)
{
	TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
	assert(node);

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

TreeNode* CreateTree()
{
	TreeNode* node1 = BuyTreeNode(1);
	TreeNode* node2 = BuyTreeNode(2);
	TreeNode* node3 = BuyTreeNode(3);
	TreeNode* node4 = BuyTreeNode(4);
	TreeNode* node5 = BuyTreeNode(5);
	TreeNode* node6 = BuyTreeNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}

void PrevOrder(TreeNode* root)//前序遍历
{
	if (root == NULL)
	{
		printf("N ");//空
		return;
	}

	printf("%d ", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

void InOrder(TreeNode* root)//中序遍历
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

void AfterOrder(TreeNode* root)//后序遍历
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	AfterOrder(root->left);
	AfterOrder(root->right);
	printf("%d ", root->data);
}


int main()
{
	TreeNode* root = CreateTree();
	PrevOrder(root);
	printf("\n");

	InOrder(root);
	printf("\n");

	AfterOrder(root);
	printf("\n");

	return 0;
}

在这里插入图片描述
如图所示，结果和我们上面写的一样！
在这里插入图片描述

4.2 求二叉树节点的个数

错误法:
在这里插入图片描述
修改：
在这里插入图片描述
最优解：
也是递归思想

int TreeSize(TreeNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) +TreeSize(root->right) + 1;
	//如果是空那么节点为0，否则就是左子树的节点+右子树的节点+1(根节点)
}

在这里插入图片描述

4.3 求二叉树叶子节点(度为0的节点)的个数

int TreeLeafSize(TreeNode* root)//叶子节点的个数
{
	// 空 返回0
	if (root == NULL)
		return 0;
	// 不是空，是叶子 返回1
	if (root->left == NULL && root->right == NULL)
		return 1;

	// 不是空 也不是叶子  分治=左右子树叶子之和
	return TreeLeafSize(root->left) +TreeLeafSize(root->right);
}

4.4 求二叉树的高度

在这里插入图片描述

int TreeHeight(TreeNode* root)
{
	if (root == NULL)
		return 0;
	int leftHeight = TreeHeight(root->left);//记录数据
	int rightHeight = TreeHeight(root->right);//记录数据

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

注意这里记录数据很重要，如果不记录数据直接使用三目的话，会导致效率低下。只知道谁大，不知道具体数值是多少,要输出具体数值的时候要重新进行计算，会大大降低效率！！！！
在这里插入图片描述

4.5 求二叉树第K层的节点个数

在这里插入图片描述

int TreeLevelK(TreeNode* root, int k)
{
	assert(k > 0);
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	return TreeLevelK(root->left, k - 1)+ TreeLevelK(root->right, k - 1);
}

在这里插入图片描述

4.6 求二叉树查找值为x的结点

错误思想：
在这里插入图片描述
修改：

TreeNode* TreeFind(TreeNode* root, BTDataType x)// 二叉树查找值为x的结点
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	TreeNode* ret1 = TreeFind(root->left, x);
	if (ret1)
		return ret1;

	TreeNode* ret2 = TreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

其依然是一个复杂的递归，不过这里有记录了，返回也不是直接返回到最外面，而是返回到上一层递归！
在这里插入图片描述

4.7 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树

在这里插入图片描述
这样构建一棵树非常低效，我们可以利用前序遍历的值，直接构建好一棵树，这样效率大大提升！
在这里插入图片描述

TreeNode* TreeCreate(char* a, int* pi)// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
{
	if (a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}

	TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
	if (root == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	root->data = a[(*pi)++];

	root->left = TreeCreate(a, pi);
	root->right = TreeCreate(a, pi);
	return root;
}

这同样也是一个递归构建树的思路！
在这里插入图片描述

4.8 销毁链式二叉树

void DestroyTree(TreeNode* root)
{
	if (root == NULL)
		return;

	DestroyTree(root->left);
	DestroyTree(root->right);
	free(root);
}

摧毁二叉树用的是后序遍历的思想，从底层开始销毁!在这里插入图片描述
摧毁后置空！

4.9 层序遍历

层序遍历就是一层一层的读数据！具体过程如下：
在这里插入图片描述
但是层序遍历的本质是一个队列，我们要实现需要队列的代码，之前我介绍过队列，文章链接如下：
链接: C语言数据结构-----栈和队列(概念，代码实现及简单练习)

void LevelOrder(TreeNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	int levelSize = 1;//每一层的数据个数，控制一层一层出
	while (!QueueEmpty(&q))
	{
		// 一层一层出
		while (levelSize--)
		{
			TreeNode* front = QueueFront(&q);
			QueuePop(&q);

			printf("%d ", front->data);

			if (front->left)
				QueuePush(&q, front->left);

			if (front->right)
				QueuePush(&q, front->right);
		}
		printf("\n");

		levelSize = QueueSize(&q);//读取每一层的数据个数
	}
	printf("\n");

	QueueDestroy(&q);
}

在这里插入图片描述

4.10 判断是否为完全二叉树

// 判断二叉树是否是完全二叉树
bool TreeComplete(TreeNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	int levelSize = 1;
	while (!QueueEmpty(&q))
	{
		TreeNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front == NULL)
			break;

		QueuePush(&q, front->left);
		QueuePush(&q, front->right);
	}

	// 前面遇到空以后，后面还有非空就不是完全二叉树
	while (!QueueEmpty(&q))
	{
		TreeNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}

	QueueDestroy(&q);
	return true;
}

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

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

相关文章

Android多进程和跨进程通讯方式

Android多进程和跨进程通讯方式

前言 我们经常开发过程中经常会听到线程和进程&#xff0c;在讲述Android进程多进程前我打算先简单梳理一下这俩者。 了解什么是进程与线程 进程&#xff1a; 系统中正在运行的一个应用程序&#xff0c;某个程序一旦运行就是一个进程&#xff0c;是资源分配的最小单位&#…
阅读更多...
HarmonyOS--基础组件Text

HarmonyOS--基础组件Text

Text组件 可以包含Span子组件。 接口 Text(content? : string | Resource) string: Text(我是ttttt) Resource: Text($r(app.string.aaaaaa)) 先找限定词目录&#xff0c;找不到内容 找base目录 属性 除支持通用属性外&#xff0c;还支持以下属性&#xff1a; 名称 参数…
阅读更多...
玄关柜和鞋柜是一回事吗？福州中宅装饰，福州装修

玄关柜和鞋柜是一回事吗？福州中宅装饰，福州装修

玄关柜和鞋柜虽然都用于存放鞋子&#xff0c;但它们在概念上有所不同。玄关柜是一个更大的概念&#xff0c;它包括鞋柜和其他功能区域&#xff0c;可以说鞋柜是玄关柜的一部分。 1️⃣概念上的不同 玄关柜是一种集成了鞋柜、挂衣架、换鞋凳等多种功能于一体的家居家具&#xf…
阅读更多...
大数据安全 | 【实验】Diffie-Hellman密钥交换算法

大数据安全 | 【实验】Diffie-Hellman密钥交换算法

文章目录 &#x1f4da;关于DH密钥交换算法&#x1f4da;实验目的&#x1f4da;流程梳理&#x1f407;Step1&#xff1a;实现快速幂取模运算&#x1f407;Step2&#xff1a;根据算法原理分别定义公钥和共享密钥的计算&#x1f407;Step3&#xff1a;求解问题一&#x1f407;Ste…
阅读更多...
LeetCode-2487. 从链表中移除节点【栈 递归 链表 单调栈】

LeetCode-2487. 从链表中移除节点【栈 递归 链表 单调栈】

LeetCode-2487. 从链表中移除节点【栈 递归 链表 单调栈】 题目描述&#xff1a;解题思路一&#xff1a;可以将链表转为数组&#xff0c;然后从后往前遍历&#xff0c;遇到大于等于当前元素的就入栈&#xff0c;最终栈里面的元素即是最终的答案。解题思路二&#xff1a;递归&am…
阅读更多...
uniapp使用vue3的ref获取dom元素出现undefined

uniapp使用vue3的ref获取dom元素出现undefined

在我的代码里面&#xff0c;已经通过ref来定义想要获取的dom了&#xff0c;但是最后在页面渲染完之后&#xff0c;打印这个dom发现竟然是undefined&#xff1a; 获取不到dom元素&#xff1a; 最后查资料发现&#xff1a; 小程序中&#xff0c;uniapp的ref要绑定在子组件中才能…
阅读更多...
【算法】【动规】乘积为正数的最长子数组长度

【算法】【动规】乘积为正数的最长子数组长度

跳转汇总链接 &#x1f449;&#x1f517;算法题汇总链接 1.1 乘积为正数的最长子数组长度 &#x1f517;题目链接 给你一个整数数组 nums &#xff0c;请你求出乘积为正数的最长子数组的长度。 一个数组的子数组是由原数组中零个或者更多个连续数字组成的数组。 请你返回乘积…
阅读更多...
基于ssm生活缴费系统及相关安全技术的设计与实现论文

基于ssm生活缴费系统及相关安全技术的设计与实现论文

摘 要 互联网发展至今&#xff0c;无论是其理论还是技术都已经成熟&#xff0c;而且它广泛参与在社会中的方方面面。它让信息都可以通过网络传播&#xff0c;搭配信息管理工具可以很好地为人们提供服务。针对生活缴费信息管理混乱&#xff0c;出错率高&#xff0c;信息安全性差…
阅读更多...
AI会干掉美图秀秀们吗？

AI会干掉美图秀秀们吗？

网上流传着这样一个传说&#xff0c;亚洲有三大“邪术”&#xff0c;韩国整容术、日本化妆术&#xff0c;还有震惊世界的中国PS 术。虽然是网友的戏称&#xff0c;但也反映了PS美图技术在国内盛行一时。 而说起美图技术就不得不提到美图公司&#xff0c;但美图公司近些年的日子…
阅读更多...
陪玩系统圈子系统：打破孤单，寻找游戏共伴！APP小程序H5三端源码交付，支持二开！喜欢软件开发的朋友可以一起交流！

陪玩系统圈子系统：打破孤单，寻找游戏共伴！APP小程序H5三端源码交付，支持二开！喜欢软件开发的朋友可以一起交流！

在如今快节奏的生活中&#xff0c;游戏作为一种娱乐方式&#xff0c;早已融入了人们的生活&#xff0c;成为许多人放松心情、释放压力的方式之一。然而&#xff0c;与此同时&#xff0c;游戏中的孤独感也成为一些玩家所面临的问题。为了解决这个问题&#xff0c;陪玩系统圈子系…
阅读更多...
NorFlash 知识点总结

NorFlash 知识点总结

一、介绍 NorFlash&#xff08;也称为 NOR 型闪存&#xff09;是一种非易失性存储器&#xff0c;常用于嵌入式系统和存储设备中。NorFlash 是一种闪存类型&#xff0c;可以用于存储程序代码、固件、操作系统以及其他数据。与 NAND Flash 相比&#xff0c;NorFlash 具有较低的存…
阅读更多...
C语言之动态内存管理

C语言之动态内存管理

一、引言 当我们写了一段程序&#xff0c;创建了一个变量或者一个数组&#xff0c;这些操作都需要在内存中开辟出一块空间。但是我们过去的这些操作有一定的局限性&#xff1a;开辟的空间大小是固定的&#xff0c;并且数组在申明的时候&#xff0c;必须指定数组的长度&#xf…
阅读更多...
HarmonyOS创建属性动画

HarmonyOS创建属性动画

属性动画的使用 1 概述 属性动画&#xff0c;是最为基础的动画&#xff0c;其功能强大、使用场景多&#xff0c;应用范围较广。常用于如下场景中&#xff1a; 一、页面布局发生变化。例如添加、删除部分组件元素。二、页面元素的可见性和位置发生变化。例如显示或者隐藏部分…
阅读更多...
RHEL8中ansible的安装

RHEL8中ansible的安装

本章主要介绍在RHEL8中如何安装ansible ansible是如何工作的在RHEL8中安装ansible 1.1 ansible的工作原理 如果管理的服务器很多&#xff0c;如几十台甚至几百台&#xff0c;那么就需要一个自动化管理工具了&#xff0c; ansible就是这样的一种自动化管理工具 ansible是通过…
阅读更多...
用print太慢了！强烈推荐这款Python Debug工具~

用print太慢了！强烈推荐这款Python Debug工具~

作为程序员&#xff0c;我们都深知调试&#xff08;Debug&#xff09;在编程过程中的重要性。然而&#xff0c;使用传统的"print"语句进行调试可能效率较低&#xff0c;今天&#xff0c;笔者将推荐一款独具一格的Python调试工具——Reloadium。Reloadium为IDE添加了热…
阅读更多...
【PyTorch】卷积神经网络

【PyTorch】卷积神经网络

文章目录 1. 理论介绍1.1. 从全连接层到卷积层1.1.1. 背景1.1.2. 从全连接层推导出卷积层 1.2. 卷积层1.2.1. 图像卷积1.2.2. 填充和步幅1.2.3. 多通道 1.3. 池化层&#xff08;又称汇聚层&#xff09;1.3.1. 背景1.3.2. 池化运算1.3.3. 填充和步幅1.3.4. 多通道 1.4. 卷积神经…
阅读更多...
Google Tag Manager账号的创建

Google Tag Manager账号的创建

1&#xff0c;通过官网链接进入主页面 点击创建账号 官网链接-https://www.tagmanager.google.com 2&#xff0c;按提示填写账号名称 账号名称建议填写网址&#xff0c;或者公司名称&#xff0c;全称简称都可&#xff0c; 国家地区按默认的就好不用特地更改&#xff0c; 不…
阅读更多...
MySQL进阶2 - 索引

MySQL进阶2 - 索引

MySQL进阶1 - 索引 1. 索引概述2. 索引结构2.1 二叉树2.2 B-Tree(多路平衡查找树)2.3 BTree2.4 Hash 3. 索引分类4. 索引语法5. SQL性能分析5.1 SQL执行频率5.2 慢查询日志5.3 profile5.4 explain执行计划5.3.1 EXPLAIN执行计划各字段含义&#xff1a; 6. 索引使…
阅读更多...
vue实现滑动验证

vue实现滑动验证

效果图&#xff1a; 源码地址&#xff1a;github文档地址&#xff1a; https://github.com/monoplasty/vue-monoplasty-slide-verify 使用步骤&#xff1a;1&#xff0c;安装插件&#xff1a; npm install --save vue-monoplasty-slide-verify 在main.js中使用一下&#xff…
阅读更多...
记一次跨入smartKettle大门随即转身就走的简单体验过程

记一次跨入smartKettle大门随即转身就走的简单体验过程

目录 &#x1f4da;第一章 背景&#x1f4d7;目的&#x1f4d7;总体方向 &#x1f4da;第二章 源码解读&#x1f4d7;官方说明&#x1f4d7;controller接口&#x1f4d5;swagger&#x1f4d5;源码 &#x1f4d7;Kettle API &#x1f4da;第三章 总结⁉️问题记录❓问题一&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023