AVL树的介绍与实现

2024-06-04 23:28
文章标签 实现 介绍 avl

本文主要是介绍AVL树的介绍与实现，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

前言

我们上一期介绍了二叉搜索树并做了实现，本期我们来继续学习另一个更优的树即AVL树！

本期内容介绍

什么是AVL树？

AVL树的实现

AVL树的性能分析

在正式的介绍AVL树之前，我们先来回忆一下二叉搜索树的特点：左子树的值一定小于根节点的值，右子树的值一定大于根节点的值；基于他的这个特点，可以缩短查找的区间即可以提升查找的效率！但是他在有些情况下效率并不是很好。例如：当数据是有序或接近有序时，查找得需要O(N)的时间复杂度即退化成单链就和和链表一样了，效率不太好！为了解决这个问题，有人就提出了AVL树！

什么是AVL树？

为了解决二叉搜索树的弊端，在1962年来自俄罗斯的两位数学家G.M.Adelson-Velskii和E.M.Landis研究出了一种解决上述问题的方法：当向二叉树种插入新节点时，如果保每个节点的左右子树的高度的绝对值之差不超过1（如果超过了1需要内部调整）既可以降低树的高度，从而减少平均查找长度！符合这样的二叉搜索树就叫做平衡二叉搜索树即AVL树。也就是：

一颗AVL树要么是空树要么是符合下面性质的二叉搜索树：

该二叉搜索树的左右子树都是AVL树；

它的左右子树高度差（简称平衡因子）的绝对值不超过1（-1/0/1）；

平衡因子可以是左减右，也可以右减左；这里采用后者！

所以，下面这棵二叉搜索树就是一个AVL树：

AVL树的实现

还是和以前一样先搭个架子出来，多次用到节点的开辟等操作，所以我们创建一个专门的AVL节点类！在创建一个AVL树的类用于插入查找等操作！

template<class K, class V>
struct AVLTreeNode
{AVLTreeNode<K, V>* _left;//左子节点AVLTreeNode<K, V>* _right;//右子节点AVLTreeNode<K, V>* _parent;//父节点pair<K, V> _kv;int _bf;//平衡因子AVLTreeNode(const pair<K,V>& kv):_left(nullptr),_right(nullptr),_parent(nullptr),_kv(kv),_bf(0)//默认一个新节点是叶子节点，左右子树都为空所以高度差（平衡因子）为0{}
};template<class K, class V>
class AVLTree
{typedef AVLTreeNode<K, V> Node;
public:private:Node* _root = nullptr;//这里只有一个成员可以给一个缺省值就不用写构造函数了
};

AVL树的插入

AVL树的本质还是二叉搜索树，所以插入的时候还是遵循二叉搜索树的特点的！但是多了一个平衡因子，所以他的插入是分为两步的：

1、按照二叉搜索树的规则插入

2、调节平衡因子

前者很好理解，这里主要解释一下后者：我们采用的平衡因子的方式是右子树的高度 - 左子树高度，所以当新插入节点后,要更新其父先节点的平衡因子，如果插入的节点是在parent的左,平衡因子--; 如果是右平衡parent的因子++；

1、如果更新后父节点的平衡因子是0，即原先的parent左或右是有一个孩子的，现在是插入到原先没有孩子的那边了即平衡了，此时直接结束调节平衡因子；

2、如果更新parent的平衡因子后不是0，而是-1/1则需要继续向上更新！(直到cur更新到根节点，停止)

3、如果更新后父节点的平衡因子的绝对值超过了1就要旋转。(旋转后面单独介绍)

OK,举个例子：

这里咱们先暂时不管旋转是怎么旋转的，我们先把上一般的给搞出来：

bool Insert(const pair<K, V>& kv)
{Node* parent = nullptr;//记录插入位置的父节点Node* cur = _root;//当前插入节点//第一次插入if (_root == nullptr){_root = new Node(kv);return true;}//不是第一次插入，寻找插入位置while (cur){if (cur->_kv.first < kv.first)//插入节点的键值比当前比较的节点的键值大{parent = cur;cur = cur->_right;//去当前节点的右子树查找}else if(cur->_kv.first > kv.first)//插入节点的键值比当前比较的节点的键值小{parent = cur;cur = cur->_left;//去当前节点的左子树查找}else{return false;//要插入的节点存在}}cur = new Node(kv);//找到插入位置//判断是parent的左子树还是右子树if (parent->_kv.first < kv.first){parent->_right = cur;}else{parent->_left = cur;}cur->_parent = parent;//将当前节点的父节点设置是为parent//调节平衡因子 ---> bf = right - leftwhile (parent){//更新当前节点的父节点的平衡因子if (cur == parent->_left)//在parent的左{parent->_bf--;//bf--}else{parent->_bf++;//在parent的右, bf++}if (parent->_bf == 0)//如果更新完，cur的parent的bf，发现是0。说明是 -1/1 --> 0 即parent原先左或右是有一个孩子的{break;//更新结束}else if (parent->_bf == 1 || parent->_bf == -1)//如果是parent的bf是1/-1{cur = parent;parent = parent->_parent;//需要继续更新其祖先节点}else{//此时parent的bf是-2/2需要旋转break;//旋转结束跳出平衡因子的调节}}return true;//插入成功
}

OK，先来验证一下，目前的逻辑对不对？AVL树的本质还是搜索树，所以他的中序是有序的，所以可以通过走中序验证目前的对不对：

中序遍历

实现思路：左->中->右

注意：由于AVL树的根节点是私有的，类的外面是访问呢不到的，所有以下三种思路：

1、将中序设置为友元（强烈不推荐）

2、提供get和set函数

3、通过子函数（推荐）

void _InOrder(const Node* root)
{if (root == nullptr)return;_InOrder(root->_left);cout << root->_kv.first << ":" << root->_kv.second << endl;_InOrder(root->_right);
}

这是子函数，因为只有AVL类里面专用所以可以将它设置为私有的！

OK，就以上面介绍过的为例：

我们乱序插入到当前的AVL树中，如果中序是有序的说明我们的当前逻辑是对的！

OK,现在parent的bf==1/-1以及等于0的情况解决了，剩下的就是parent的bf是-2/2的情况了，此时就需要旋转了！我们下面来专门谈一谈旋转！

AVL树的旋转

旋转是由于parent的bf到了-2/2，此时的结构不符合AVL的平衡了；而parent为-2/2是由其孩子造成的，而孩子有两种情况即左边和右边即cur是-1/1；所以此时就有四种情况：
1、parent == -2 && cur == -1即父亲的左边高、孩子(左子树)的左边高 --> 右单旋

2、parent == 2  && cur == 1即父亲的右边高、孩子(右子树)的右边高 --> 左单旋

3、parent == -2 && cur == 1即父亲的左边高、孩子(左子树)的右边高 --> 左右双旋

4、parent == 2  && cur == -1即父亲的右边高、孩子(右子树)的左边高 --> 右左双旋

右单旋

parent的左边高，并且他的左孩子也高！

void RotateR(const Node* parent)
{Node* subL = parent->_left;//parent的左子树parent->_left = subL->_right;//将subL的又给parent的左if (subL->_right)//如果subL的右不为空subL->_right = parent;//此时subL右的父节点就是parentNode* ppNode = parent->_parent;//记录parent的父节点方便后面subL不是root时候的链接subL->_right = parent;//将parent连接到subL的右边parent->_parent = subL;//将parent的父节点设置为subLif (parent == _root)//当前的parent是根节点{_root = subL;//新的根节点就是subLppNode = nullptr;//根节点的父亲为空}else//当前的parent不是根节点{if (ppNode->_left == parent)//如果parent的是ppNode的左{ppNode->_left = subL;//将subL连接到ppNode的左边}else//parent的是ppNode的右{ppNode->_right = subL;//将subL连接到ppNode的右边}subL->_parent = ppNode;//subL的父节点指向ppNode}subL->_bf = parent->_bf = 0;//右单旋后subL和parent的bf都是0
}

左单旋

parent的右边高，并且他的右孩子也高！

void RotateL(const Node* parent)
{Node* subR = parent->_right;//parent的右子树parent->_right = subR->_left;//将subR的左子树给parent的右if (subR->_left)//如果subR的左不为空subR->_left->_parent = parent;//subR的左的父亲就是parentNode* ppNode = parent->_parent;//记录parent的父节点方便后面subL不是root时候的链接subR->_left = parent;//将parent连接到subR的左parent->_parent = subR;//parent的父节点就是subRif (parent == _root)//parent是根节点{_root = subR;//此时subR就是新的根_root->_parent = nullptr;}else//parent不是根节点{if (ppNode->_left == parent)//parent是ppNode的左{ppNode->_left = subR;//将subR连接到ppNode的左}else//parent是ppNode的右{ppNode->_right = subR;//将subR连接到ppNode的右}subR->_parent = ppNode;//subR的父节点指向ppNode}subR->_bf = parent->_bf = 0;//左单旋后subR和parent的bf都是0
}

左右双旋

parent的左孩子高，并且他左孩子的右边高！

void RotateLR(const Node* parent)
{Node* subL = parent->_left;//左子树Node* subLR = subL->_right;//左子树的右子树int bf = subLR->_bf;RotateL(parent->_left);//先对左子树左旋RotateR(parent);//在对整个树进行右旋if (bf == 0){subL->_bf = 0;subLR->_bf = 0;parent->_bf = 0;}else if (bf == 1){subL->_bf = -1;subLR->_bf = 0;parent->_bf = 0;}else if (bf == -1){subL->_bf = 0;subLR->_bf = 0;parent->_bf = 1;}else{assert(false);//正常不可能到这，这里是防止一开始就不是AVL}
}

右左双旋

parent的右孩子高，他的右孩子的左边高！

void RotateRL(const Node* parent)
{Node* subR = parent->_right;//右子树Node* subRL = subR->_left;//右子树的左子树int bf = subRL->_bf;RotateR(parent->_right);//先对右子树右旋RotateL(parent);//在对整个树进行左旋if (bf == 0){subR->_bf = 0;subRL->_bf = 0;parent->_bf = 0;}else if (bf == 1){subR->_bf = 0;subRL->_bf = 0;parent->_bf = -1;}else if (bf == -1){subR->_bf = 1;subRL->_bf = 0;parent->_bf = 1;}else{assert(false);//正常不可能到这，这里是防止一开始就不是AVL}
}

ok，这就是所有的情况，我们现在加上旋转来看看，为了验证是否是平衡的，我们可以写一个判断是否平衡的函数：

判断平衡

实现思路：某一个节点的左右子树的差的绝对值不可以超多1

由于AVLTree类外面访问不到根，所以我们还是写成子函数的形式：
 

bool _IsBalance(const Node* root)
{if (root == nullptr)//空树也平衡return true;int left = _Hight(root->_left);//求左子树的高度int right = _Hight(root->_right);//求右子树的高度if (abs(left - right) >= 2)//如果左右子树的高度差的绝对值差超过1则就是不平衡return false;if (right - left != root->_bf)//不平衡，打印出他的节点的key值{cout << root->_kv.first << endl;return false;}return _IsBalance(root->_left) && _IsBalance(root->_right);//左右子树都得平衡
}int _Hight(Node* root)
{if (root == nullptr)//空树的个数是0return 0;return max(_Hight(root->_left), _Hight(root->_right)) + 1;//不是空返回左右子树的较大值 + 本身
}

ok ，验证一下：

OK，没有问题！我们再来把其他的完善一下：

AVL树的查找

实现思路：和二叉搜索树的一样，比根的去右边找，比根小去左边找！

Node* Find(const K& k)
{Node* cur = _root;while (cur){if (cur->_kv.first < k)//插入节点的键值比当前比较的节点的键值大{cur = cur->_right;//去当前节点的右子树查找}else if (cur->_kv.first > k)//插入节点的键值比当前比较的节点的键值小{cur = cur->_left;//去当前节点的左子树查找}else{return cur;//找到了}}return nullptr;//没找到
}

获取高度

实现思路：左子树 + 右子树 + 1（本身）

int _Hight(Node* root)
{if (root == nullptr)//空树的个数是0return 0;return max(_Hight(root->_left), _Hight(root->_right)) + 1;//不是空返回左右子树的较大值 + 本身
}

获取节点个数

实现思路：左子树的节点 + 右子树的节点 + 根

int _Size(const Node* root)
{if (root == nullptr)//空树return 0;return _Size(root->_left) + _Size(root->_right) + 1;//左子树+右子树+本身
}

AVL树的性能分析

AVL树是一颗绝对平衡的二叉搜索树，其要求每个节点的左右子树差都不超过1，这样可以保证查询高效的同时复杂度不会达到和二叉搜索树的极端情况的O(N)而是在logN；但是如果对AVL树做一些结构的修改，例如：插入太多次旋转也就多了，更差的是在删除时有可能旋转到根；因此如果需要一种查询且有序的数据结构，再者数据为静态的（不会改变）AVL树是一种不错的选择，但是如果经常修改其行能就不太好了，那要是既要改变还要效率高该如何弄呢？那就是下期介绍的红黑树了！！！

全部源码

#pragma once
#include <assert.h>template<class K, class V>
struct AVLTreeNode
{AVLTreeNode<K, V>* _left;//左子节点AVLTreeNode<K, V>* _right;//右子节点AVLTreeNode<K, V>* _parent;//父节点pair<K, V> _kv;int _bf;//平衡因子AVLTreeNode(const pair<K, V>& kv):_left(nullptr), _right(nullptr), _parent(nullptr), _kv(kv), _bf(0)//默认一个新节点是叶子节点，左右子树都为空所以高度差（平衡因子）为0{}
};template<class K, class V>
class AVLTree
{typedef AVLTreeNode<K, V> Node;
public:bool Insert(const pair<K, V>& kv){Node* parent = nullptr;//记录插入位置的父节点Node* cur = _root;//当前插入节点//第一次插入if (_root == nullptr){_root = new Node(kv);return true;}//不是第一次插入，寻找插入位置while (cur){if (cur->_kv.first < kv.first)//插入节点的键值比当前比较的节点的键值大{parent = cur;cur = cur->_right;//去当前节点的右子树查找}else if (cur->_kv.first > kv.first)//插入节点的键值比当前比较的节点的键值小{parent = cur;cur = cur->_left;//去当前节点的左子树查找}else{return false;//要插入的节点存在}}cur = new Node(kv);//找到插入位置//判断是parent的左子树还是右子树if (parent->_kv.first < kv.first){parent->_right = cur;}else{parent->_left = cur;}cur->_parent = parent;//将当前节点的父节点设置是为parent//调节平衡因子 ---> bf = right - leftwhile (parent){//更新当前节点的父节点的平衡因子if (cur == parent->_left)//在parent的左{parent->_bf--;//bf--}else{parent->_bf++;//在parent的右, bf++}if (parent->_bf == 0)//如果更新完，cur的parent的bf，发现是0。说明是 -1/1 --> 0 即parent原先左或右是有一个孩子的{break;//更新结束}else if (parent->_bf == 1 || parent->_bf == -1)//如果是parent的bf是1/-1   0 ---> -1/1{cur = parent;parent = parent->_parent;//需要继续更新其祖先节点}else//此时parent的bf是-2/2需要旋转 -1/1 --> 2/-2{if (parent->_bf == -2 && cur->_bf == -1)//父亲和孩子的左边都高，右单旋{RotateR(parent);}else if (parent->_bf == 2 && cur->_bf == 1)//父亲和孩子的右边都高，左单旋{RotateL(parent);}else if (parent->_bf == -2 && cur->_bf == 1)//父亲的左边高，孩子的右边高，先左单旋，在右单旋{RotateLR(parent);}else if (parent->_bf == 2 && cur->_bf == -1)//父亲的右边高，孩子的左边高，先右单旋，在左单旋{RotateRL(parent);}else{assert(false);//正常情况不可能走到这里，这里是防止一开始就不是AVL树的情况}break;//旋转结束跳出平衡因子的调节}}return true;//插入成功}Node* Find(const K& k){Node* cur = _root;while (cur){if (cur->_kv.first < k)//插入节点的键值比当前比较的节点的键值大{cur = cur->_right;//去当前节点的右子树查找}else if (cur->_kv.first > k)//插入节点的键值比当前比较的节点的键值小{cur = cur->_left;//去当前节点的左子树查找}else{return cur;//找到了}}return nullptr;//没找到}void InOrder(){return _InOrder(_root);}bool IsBalance(){return _IsBalance(_root);}int Hight(){return _Hight(_root);}int Size(){return _Size(_root);}private:void _InOrder(const Node* root){if (root == nullptr)return;_InOrder(root->_left);cout << root->_kv.first << ":" << root->_kv.second << endl;_InOrder(root->_right);}void RotateR(Node* parent){Node* subL = parent->_left;//parent的左子树parent->_left = subL->_right;//将subL的又给parent的左if (subL->_right)//如果subL的右不为空subL->_right->_parent = parent;//此时subL右的父节点就是parentNode* ppNode = parent->_parent;//记录parent的父节点方便后面subL不是root时候的链接subL->_right = parent;//将parent连接到subL的右边parent->_parent = subL;//将parent的父节点设置为subLif (parent == _root)//当前的parent是根节点{_root = subL;//新的根节点就是subL_root->_parent = nullptr;//根节点的父亲为空}else//当前的parent不是根节点{if (ppNode->_left == parent)//如果parent的是ppNode的左{ppNode->_left = subL;//将subL连接到ppNode的左边}else//parent的是ppNode的右{ppNode->_right = subL;//将subL连接到ppNode的右边}subL->_parent = ppNode;//subL的父节点指向ppNode}subL->_bf = parent->_bf = 0;//右单旋后subL和parent的bf都是0}void RotateL(Node* parent){Node* subR = parent->_right;//parent的右子树parent->_right = subR->_left;//将subR的左子树给parent的右if (subR->_left)//如果subR的左不为空subR->_left->_parent = parent;//subR的左的父亲就是parentNode* ppNode = parent->_parent;//记录parent的父节点方便后面subL不是root时候的链接subR->_left = parent;//将parent连接到subR的左parent->_parent = subR;//parent的父节点就是subRif (parent == _root)//parent是根节点{_root = subR;//此时subR就是新的根_root->_parent = nullptr;}else//parent不是根节点{if (ppNode->_left == parent)//parent是ppNode的左{ppNode->_left = subR;//将subR连接到ppNode的左}else//parent是ppNode的右{ppNode->_right = subR;//将subR连接到ppNode的右}subR->_parent = ppNode;//subR的父节点指向ppNode}subR->_bf = parent->_bf = 0;//左单旋后subR和parent的bf都是0}void RotateLR(Node* parent){Node* subL = parent->_left;//左子树Node* subLR = subL->_right;//左子树的右子树int bf = subLR->_bf;RotateL(parent->_left);//先对左子树左旋RotateR(parent);//在对整个树进行右旋//重新更新平衡因子if (bf == 0){subL->_bf = 0;subLR->_bf = 0;parent->_bf = 0;}else if (bf == 1){subL->_bf = -1;subLR->_bf = 0;parent->_bf = 0;}else if (bf == -1){subL->_bf = 0;subLR->_bf = 0;parent->_bf = 1;}else{assert(false);//正常不可能到这，这里是防止一开始就不是AVL}}void RotateRL(Node* parent){Node* subR = parent->_right;//右子树Node* subRL = subR->_left;//右子树的左子树int bf = subRL->_bf;RotateR(parent->_right);//先对右子树右旋RotateL(parent);//在对整个树进行左旋//重新更新平衡因子if (bf == 0){subR->_bf = 0;subRL->_bf = 0;parent->_bf = 0;}else if (bf == 1){subR->_bf = 0;subRL->_bf = 0;parent->_bf = -1;}else if (bf == -1){subR->_bf = 1;subRL->_bf = 0;parent->_bf = 0;}else{assert(false);//正常不可能到这，这里是防止一开始就不是AVL}}bool _IsBalance(const Node* root){if (root == nullptr)//空树也平衡return true;int left = _Hight(root->_left);//求左子树的高度int right = _Hight(root->_right);//求右子树的高度if (abs(left - right) >= 2)//如果左右子树的高度差的绝对值差超过1则就是不平衡return false;if (right - left != root->_bf)//不平衡，打印出他的节点的key值{cout << root->_kv.first << endl;return false;}return _IsBalance(root->_left) && _IsBalance(root->_right);//左右子树都得平衡}int _Hight(Node* root){if (root == nullptr)//空树的个数是0return 0;return max(_Hight(root->_left), _Hight(root->_right)) + 1;//不是空返回左右子树的较大值 + 本身}int _Size(const Node* root){if (root == nullptr)//空树return 0;return _Size(root->_left) + _Size(root->_right) + 1;//左子树+右子树+本身}private:Node* _root = nullptr;//这里只有一个成员可以给一个缺省值就不用写构造函数了
};

ok，本期分享就到这里，好兄弟。我们下期再见！

结束语：不要因为被人的三言两语就打破你原本的深思熟虑！

这篇关于AVL树的介绍与实现的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1031424。

相关文章

性能测试介绍

性能测试介绍

性能测试是一种测试方法，旨在评估系统、应用程序或组件在现实场景中的性能表现和可靠性。它通常用于衡量系统在不同负载条件下的响应时间、吞吐量、资源利用率、稳定性和可扩展性等关键指标。 为什么要进行性能测试 通过性能测试，可以确定系统是否能够满足预期的性能要求，找出性能瓶颈和潜在的问题，并进行优化和调整。 发现性能瓶颈：性能测试可以帮助发现系统的性能瓶颈，即系统在高负载或高并发情况下可能出现的问题
阅读更多...
水位雨量在线监测系统概述及应用介绍

水位雨量在线监测系统概述及应用介绍

在当今社会，随着科技的飞速发展，各种智能监测系统已成为保障公共安全、促进资源管理和环境保护的重要工具。其中，水位雨量在线监测系统作为自然灾害预警、水资源管理及水利工程运行的关键技术，其重要性不言而喻。 一、水位雨量在线监测系统的基本原理 水位雨量在线监测系统主要由数据采集单元、数据传输网络、数据处理中心及用户终端四大部分构成，形成了一个完整的闭环系统。 数据采集单元：这是系统的“眼睛”，
阅读更多...
Hadoop数据压缩使用介绍

Hadoop数据压缩使用介绍

一、压缩原则 （1）运算密集型的Job，少用压缩 （2）IO密集型的Job，多用压缩 二、压缩算法比较 三、压缩位置选择 四、压缩参数配置 1）为了支持多种压缩/解压缩算法，Hadoop引入了编码/解码器 2）要在Hadoop中启用压缩，可以配置如下参数
阅读更多...
hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

hdu1043（八数码问题，广搜 + hash（实现状态压缩） ）

利用康拓展开将一个排列映射成一个自然数，然后就变成了普通的广搜题。 #include<iostream>#include<algorithm>#include<string>#include<stack>#include<queue>#include<map>#include<stdio.h>#include<stdlib.h>#include<ctype.h>#inclu
阅读更多...
【C++】_list常用方法解析及模拟实现

【C++】_list常用方法解析及模拟实现

相信自己的力量，只要对自己始终保持信心，尽自己最大努力去完成任何事，就算事情最终结果是失败了，努力了也不留遗憾。💓💓💓 目录   ✨说在前面 🍋知识点一：什么是list？ •🌰1.list的定义 •🌰2.list的基本特性 •🌰3.常用接口介绍 🍋知识点二：list常用接口 •🌰1.默认成员函数 🔥构造函数（⭐） 🔥析构函数 •🌰2.list对象
阅读更多...
【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

【Prometheus】PromQL向量匹配实现不同标签的向量数据进行运算

✨✨ 欢迎大家来到景天科技苑✨✨ 🎈🎈 养成好习惯，先赞后看哦~🎈🎈 🏆 作者简介：景天科技苑 🏆《头衔》：大厂架构师，华为云开发者社区专家博主，阿里云开发者社区专家博主，CSDN全栈领域优质创作者，掘金优秀博主，51CTO博客专家等。 🏆《博客》：Python全栈，前后端开发，小程序开发，人工智能，js逆向，App逆向，网络系统安全，数据分析，Django，fastapi
阅读更多...
让树莓派智能语音助手实现定时提醒功能

让树莓派智能语音助手实现定时提醒功能

最初的时候是想直接在rasa 的chatbot上实现，因为rasa本身是带有remindschedule模块的。不过经过一番折腾后，忽然发现，chatbot上实现的定时，语音助手不一定会有响应。因为，我目前语音助手的代码设置了长时间无应答会结束对话，这样一来，chatbot定时提醒的触发就不会被语音助手获悉。那怎么让语音助手也具有定时提醒功能呢？ 我最后选择的方法是用threading.Time
阅读更多...
Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

Android实现任意版本设置默认的锁屏壁纸和桌面壁纸（两张壁纸可不一致）

客户有些需求需要设置默认壁纸和锁屏壁纸  在默认情况下 这两个壁纸是相同的  如果需要默认的锁屏壁纸和桌面壁纸不一样 需要额外修改 Android13实现 替换默认桌面壁纸： 将图片文件替换frameworks/base/core/res/res/drawable-nodpi/default_wallpaper.*  （注意不能是bmp格式） 替换默认锁屏壁纸： 将图片资源放入vendo
阅读更多...
C#实战|大乐透选号器[6]：实现实时显示已选择的红蓝球数量

C#实战|大乐透选号器[6]：实现实时显示已选择的红蓝球数量

哈喽，你好啊，我是雷工。 关于大乐透选号器在前面已经记录了5篇笔记，这是第6篇； 接下来实现实时显示当前选中红球数量，蓝球数量； 以下为练习笔记。 01 效果演示 当选择和取消选择红球或蓝球时，在对应的位置显示实时已选择的红球、蓝球的数量； 02 标签名称 分别设置Label标签名称为：lblRedCount、lblBlueCount
阅读更多...
图神经网络模型介绍（1）

图神经网络模型介绍（1）

我们将图神经网络分为基于谱域的模型和基于空域的模型，并按照发展顺序详解每个类别中的重要模型。 1.1基于谱域的图神经网络         谱域上的图卷积在图学习迈向深度学习的发展历程中起到了关键的作用。本节主要介绍三个具有代表性的谱域图神经网络：谱图卷积网络、切比雪夫网络和图卷积网络。 （1）谱图卷积网络 卷积定理：函数卷积的傅里叶变换是函数傅里叶变换的乘积，即F{f*g}
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2