平衡二叉排序树（Balanced Binary Tree），因由前苏联数学家Adelson-Velskii 和
Landis于1962年首先提出的，所以又称为AVL树。
平衡二叉树是一种特殊的二叉排序树，理解平衡二叉树首先要理解什么是二叉排序树。
如果已经了解二叉排序树可以直接看下面平衡二叉树内容。
所谓二叉排序树(BST)即：
（1）若该树的左子树不为空，那么左子树所有结点的值均小于其根结点的值。
（2）若该树的右子树不为空，那么右子树所有结点的值均大于其根结点的值。
（3）该树的左右子树也均为二叉排序树。
依此定义，我们可以通过比较根结点的值一层层地定位到所要查找的值。
例：如下图是一棵二叉排序树
比如我们要查找7，那么先从根结点开始比较，8>7查找左子树 ----> 3<7查找右子树 ----> 6>7查找右子树 ----> 最后7=7，找到了7。
这种查找算法与折半查找相似，也是逐步缩小搜索范围。
若中序遍历上图，则可以得到一个按数值大小排序的递增序列：1，3，4，6，7，8，10，13，15。
typedef struct BSTNode
{
int data=0;//数据项
struct BSTNode *lchild=NULL,*rchild=NULL;//左右子树
}BSTNode,*BSTree.
BSTree T 为二叉树根节点 ，int e 为查找的关键字。时间复制度为O(log2 n)。
int searchTree(BSTree T,int e)//在二叉树中查找给定关键字(函数返回值为成功1,失败0)
{
if (T==NULL)//无法查找到给定关键字
{
return 0;
}else if (e==T->data)//查找到关键字
{
return 1;
}else if (e<T->data)//小于根结点，向左子树查找
{
return searchTree(T->lchild,e);
}else if(e>T->data)//大于根结点，向右子树查找
{
return searchTree(T->rchild,e);
}
}
二叉排序树的插入算法基本过程也是查找，时间复制度也为O(log2 n)。
void InsertBST(BSTree &T,int e)//插入节点，根据节点值的大小插入
{//当二叉排序树中不存在关键字等于e的结点时，查找结束，插入结点
if (!T)//查找到插入位置
{
BSTNode *S; //生成新结点
S=new BSTNode;
S->data=e;//给新结点赋值
S->lchild=S->rchild=NULL;//将新结点作为叶子结点
T=S;//给查找到的插入位置赋值
}
else if (e<T->data)
{
InsertBST(T->lchild,e);//向左查找插入
}else if (e>T->data)
{
InsertBST(T->rchild,e);//向右查找插入
}
}
void CreatBST(BSTree &T)//创建二叉树
{
T=NULL;
int e,n,i;
scanf("%d",&n);
for (i=0;i<n;i++)
{
scanf("%d",&e);
InsertBST(T,e);
}
}
介绍完二叉排序树，我们就来看看平衡二叉树。
平衡二叉树就是在二叉排序树上建立的，可以说是具有以下两个特征的二叉排序树：
（1）左子树和右子树的深度之差的绝对值不超过1。
（2）左子树和右子树也是平衡二叉树。
为了方便记录和计算左右子树深度之差，我们引入一个概念叫平衡因子。
平衡因子就是该结点左右子树深度之差，由平衡二叉树的定义我们可以知道平衡二叉树上的平衡因子只可能是-1，0，1 。
typedef struct AVLNode
{
int data=0;//结点值
int depth=0;//深度，方便通过计算左右子树深度之差得到该结点的平衡因子
struct AVLNode *father=NULL;//父结点
struct AVLNode *lchild=NULL,*rchild=NULL;//左右结点
} AVLNode,*AVLTree; //结点结构体
计算平衡因子代码实现：
int count_depth(AVLTree &T)//计算各结点的深度
{
if(T==NULL)
{
return 0;
}
else
{
int l=count_depth(T->lchild);//左子树深度
int r=count_depth(T->rchild);//右子树深度
return T->depth=max(l,r)+1;//更新深度
}
}
int get_balance(AVLTree T)//读取深度
{
if(T)
{
return T->depth;
}
else
{
return 0;
}
}
int count_balance(AVLTree T)//计算平衡因子
{
if(!T)
{
return 0;
}
else
{
return get_balance(T->lchild)-get_balance(T->rchild);//平衡因子等于左右子树的深度之差
}
}
如何创建一棵平衡二叉树呢？
简单的来说就是：
（1）先按照我们创建二叉排序树的方法，找到结点插入位置，将结点插入二叉树中。
（2）然后我们来计算该插入结点父结点的平衡因子， 如果平衡因子绝对值大于1，代表该子树是不平衡的，那么对该子树进行调整，将其调整为平衡二叉树， 然后一层一层往上计算平衡因子和进行调整，直到根节点（根结点平衡因子绝对值大于1也要调整），最终把整棵树调整为平衡二叉树。
（3）第三步就重复上面操作，把一个一个结点插入二叉树中并进行调整，最终插入完所有结点并创建完成平衡二叉树。
平衡二叉树的调整有4种调整情况。
这里有一篇写得比较好的文章可以参考一下：平衡二叉树（AVL）图解与实现-zthgreat
(a) 图a中我们插入“16” 后计算平衡因子发现结点“31”的平衡因子为2，该树为非平衡树，需要进行调整，我们以结点“25”为旋转中心，将其父结点按顺时针旋转为其右子树，至此该树调整完毕。
注意：25的左结点16不进行旋转。
(b) 图b中我们插入“9”后计算平衡因子发现结点“31”的平衡因子为2，该树为非平衡树，需要进行调整，我们以结点“25”为旋转中心，将其父结点“31”按顺时针旋转为其右子树，再把旋转中心“25”的右子树调整为31的左子树，至此该树调整完毕。
我们总结出以下规律（参考下图）：将B结点作为根结点，A结点旋转为B结点的右子树，再把B结点本来的右子树连接为A结点的左子树，该树调整完成。
代码实现：
AVLTree LL_rotate(AVLTree T)
{
AVLTree parent=NULL,son;//son结点即为旋转中心
parent=T->father;//获取失衡结点的父节点
son=T->lchild;//获取失衡结点的左孩子
if (son->rchild!=NULL)//设置son结点右孩子的父指针
son->rchild->father=T;
T->lchild=son->rchild;//失衡结点的左孩子变更为son的右孩子
//T的子结点更新完毕
count_depth(T);//更新失衡结点的深度信息
son->rchild=T;//失衡结点变成son的右孩子
son->father=parent;//设置son的父结点为原失衡结点的父结点，连接整颗树
//如果失衡结点不是根结点，则更新父节点
if (parent!=NULL)
{
//如果父节点的左孩子是失衡结点，指向现在更新后的新孩子son
if (parent->lchild==T)
parent->lchild=son;
else //父节点的右孩子是失衡结点
parent->rchild=son;
}
T->father=son;//设置失衡结点的父亲
count_depth(son);//更新son结点的高度信息
return son;
}
(a) 图a中我们插入“69” 后计算平衡因子发现结点“31”的平衡因子为-2，该树为非平衡树，需要进行调整，我们以结点“47”为旋转中心，将其父结点按逆时针旋转为其左子树，至此该树调整完毕。
注意：47的右结点69不进行旋转。
(b) 图b中我们插入“76”后计算平衡因子发现结点“31”的平衡因子为2，该树为非平衡树，需要进行调整，我们以结点“47”为旋转中心，将其父结点“31”按逆时针旋转为其左子树，再把旋转中心“47”的左子树调整为31的右子树，至此该树调整完毕。
我们总结出以下规律（参考下图）：将B结点作为根结点，A结点旋转为B结点的左子树，再把B结点本来的左子树连接为A结点的右子树，该树调整完成。
可以看到LL型调整和RR型是左右相反的调整。
代码实现：
AVLTree RR_rotate(AVLTree T)
{
AVLTree parent=NULL,son;//son结点即为旋转中心
parent=T->father;//获取失衡结点的父节点
son=T->rchild;//获取失衡结点的右孩子
if (son->lchild!=NULL)//设置son结点左孩子的父指针
son->lchild->father=T;
T->rchild=son->lchild;//失衡结点的右孩子变更为son的左孩子
//T的子结点更新完毕
count_depth(T);//更新失衡结点的高度信息
son->lchild=T;//失衡结点变成son的右孩子
son->father=parent;//设置son的父结点为原失衡结点的父结点，连接整颗树
//如果失衡结点不是根结点，则更新父节点
if (parent!=NULL)
{
//如果父节点的左孩子是失衡结点，指向现在更新后的新孩子son
if (parent->lchild==T)
parent->lchild=son;
else //父节点的右孩子是失衡结点
parent->rchild=son;
}
T->father=son;//设置失衡结点的父亲
count_depth(son);//更新son结点的高度信息
return son;
}
(a) 图a中我们插入“28” 后计算平衡因子发现结点“31”的平衡因子为2，该树为非平衡树，需要进行调整。
(1)我们对25和28进行RR型旋转调整以结点“28”为旋转中心，将其父结点25按逆时针旋转为其左子树，再连接为31的左子树。
(2)观察到调整后的树是LL型，故以结点“28”为旋转中心，将其父结点31按顺时针旋转为其右子树，调整完毕。
(b) 图b中我们插入“26” 后计算平衡因子发现结点“31”的平衡因子为2，该树为非平衡树，需要进行调整。
(1)我们对25和28进行RR型旋转调整以结点“28”为旋转中心，将其父结点25按逆时针旋转为其左子树，“28”的左子树“26”连接为“25”的右子树，再将"28"连接为"31"的左子树。
(2)观察到调整后的树是LL型，故以结点“28”为旋转中心，将其父结点31按顺时针旋转为其右子树，调整完毕。
(c)图b中我们插入“30” 后计算平衡因子发现结点“31”的平衡因子为2，该树为非平衡树，需要进行调整。
(1)我们对25和28进行RR型旋转调整以结点“28”为旋转中心，将其父结点25按逆时针旋转为其左子树，再将"28"连接为"31"的左子树。
(2)观察到调整后的树是LL型，故以结点“28”为旋转中心，将其父结点31按顺时针旋转为其右子树，再将“28”（旋转中心）的右子树“30”连接为“31”的左子树，调整完毕。
我们总结出以下规律（参考下图）：LR型先对B,C进行RR型旋转(以B为旋转中心)，旋转后就变成LL型的非平衡树之后再对A，B，C进行LL型旋转调整(以B为旋转中心)。
代码实现：
AVLTree LR_rotate(AVLTree T)
{
RR_rotate(T->lchild);
return LL_rotate(T);
}
RL型就与LR型相反，先进行LL型旋转，再进行RR型旋转。如（a）图的旋转。
我们总结出以下规律（参考下图）：RL型先对B,C进行LL型旋转(以B为旋转中心)，旋转后就变成RR型的非平衡树之后再对A，B，C进行RR型旋转调整(以B为旋转中心)。
代码实现：
AVLTree RL_rotate(AVLTree T)
{
LL_rotate(T->rchild);
return RR_rotate(T);
}
了解完了如何调整非平衡二叉树，剩下工作就比较简单了，无非是在创建二叉排序树时，每次插入结点，把二叉树调整为平衡二叉树。
下面是代码实现：
void creativetree(AVLTree &T)//输入数据
{
T=NULL;
int e,n,i;
scanf("%d",&n);
for (i=0; i<n; i++)
{
scanf("%d",&e);
T=Insert(T,e);
}
}
AVLTree InsertAVL(AVLTree &T,int e,AVLTree parent)
{
if (!T)//找到结点插入位置
{
AVLNode *S;
S=new AVLNode;
S->data=e;
S->father=parent;
S->lchild=S->rchild=NULL;
T=S;
return S;
}
else if (e<T->data)//向左搜索
{
return InsertAVL(T->lchild,e,T);
}
else if (e>T->data)//向右搜索
{
return InsertAVL(T->rchild,e,T);
}
return NULL;//该结点已存在
}
AVLTree Insert(AVLTree &T,int e)
{
AVLNode *S;
S=new AVLNode;
S=InsertAVL(T,e,NULL);//插入结点
count_depth(T);//更新深度信息
T=AVLchange(T,S);//调整为平衡二叉树
return T;
}
AVLTree AVLchange(AVLTree &T,AVLTree S)//调整为平衡二叉树
{
int balance=0;//平衡因子
while (S)
{
count_depth(T);//计算深度
balance=count_balance(S);//计算平衡因子
if(balance>1||balance<-1)
{
if(balance>1)//L型
{
if(count_balance(S->lchild)>0)//LL型
{
S=LL_rotate(S);
}
else //LR型
{
S=LR_rotate(S);
}
}
if(balance<1)//R型
{
if (count_balance(S->rchild)<0) //RR型
S=RR_rotate(S);
else //RL型
S=RL_rotate(S);
}
if(S->father==NULL)//到达根节点，退出循环
{
T=S;//更新为新的根节点
break;
}
}
S=S->father;//一层一层往上调整
}
return T;
}
#include "stdio.h"
#include "malloc.h"
#include <iostream>
#include <stack>
#include <queue>
using namespace std;
typedef struct AVLNode
{
int data=0;//结点值
int depth=0;//深度
struct AVLNode *father=NULL;//父结点
struct AVLNode *lchild=NULL,*rchild=NULL;//左右结点
} AVLNode,*AVLTree; //结点结构体
int count_depth(AVLTree &T)//计算各结点的深度
{
if(T==NULL)
{
return 0;
}
else
{
int l=count_depth(T->lchild);//左子树深度
int r=count_depth(T->rchild);//右子树深度
return T->depth=max(l,r)+1;//更新深度
}
}
int get_balance(AVLTree T)//读取深度
{
if(T)
{
return T->depth;
}
else
{
return 0;
}
}
int count_balance(AVLTree T)//计算平衡因子
{
if(!T)
{
return 0;
}
else
{
return get_balance(T->lchild)-get_balance(T->rchild);//平衡因子等于左右子树的深度之差
}
}
AVLTree LL_rotate(AVLTree T)
{
AVLTree parent=NULL,son;//son结点即为旋转中心
parent=T->father;//获取失衡结点的父节点
son=T->lchild;//获取失衡结点的左孩子
if (son->rchild!=NULL)//设置son结点右孩子的父指针
son->rchild->father=T;
T->lchild=son->rchild;//失衡结点的左孩子变更为son的右孩子
//T的子结点更新完毕
count_depth(T);//更新失衡结点的深度信息
son->rchild=T;//失衡结点变成son的右孩子
son->father=parent;//设置son的父结点为原失衡结点的父结点，连接整颗树
//如果失衡结点不是根结点，则更新父节点
if (parent!=NULL)
{
//如果父节点的左孩子是失衡结点，指向现在更新后的新孩子son
if (parent->lchild==T)
parent->lchild=son;
else //父节点的右孩子是失衡结点
parent->rchild=son;
}
T->father=son;//设置失衡结点的父亲
count_depth(son);//更新son结点的高度信息
return son;
}
AVLTree RR_rotate(AVLTree T)
{
AVLTree parent=NULL,son;//son结点即为旋转中心
parent=T->father;//获取失衡结点的父节点
son=T->rchild;//获取失衡结点的右孩子
if (son->lchild!=NULL)//设置son结点左孩子的父指针
son->lchild->father=T;
T->rchild=son->lchild;//失衡结点的右孩子变更为son的左孩子
//T的子结点更新完毕
count_depth(T);//更新失衡结点的高度信息
son->lchild=T;//失衡结点变成son的右孩子
son->father=parent;//设置son的父结点为原失衡结点的父结点，连接整颗树
//如果失衡结点不是根结点，则更新父节点
if (parent!=NULL)
{
//如果父节点的左孩子是失衡结点，指向现在更新后的新孩子son
if (parent->lchild==T)
parent->lchild=son;
else //父节点的右孩子是失衡结点
parent->rchild=son;
}
T->father=son;//设置失衡结点的父亲
count_depth(son);//更新son结点的高度信息
return son;
}
AVLTree LR_rotate(AVLTree T)
{
RR_rotate(T->lchild);
return LL_rotate(T);
}
AVLTree RL_rotate(AVLTree T)
{
LL_rotate(T->rchild);
return RR_rotate(T);
}
AVLTree AVLchange(AVLTree &T,AVLTree S)//调整为平衡二叉树
{
int balance=0;//平衡因子
while (S)
{
count_depth(T);//计算深度
balance=count_balance(S);//计算平衡因子
if(balance>1||balance<-1)
{
if(balance>1)//L型
{
if(count_balance(S->lchild)>0)//LL型
{
S=LL_rotate(S);
}
else //LR型
{
S=LR_rotate(S);
}
}
if(balance<1)//R型
{
if (count_balance(S->rchild)<0) //RR型
S=RR_rotate(S);
else //RL型
S=RL_rotate(S);
}
if(S->father==NULL)//到达根节点，退出循环
{
T=S;//更新为新的根节点
break;
}
}
S=S->father;//一层一层往上调整
}
return T;
}
AVLTree InsertAVL(AVLTree &T,int e,AVLTree parent)
{
if (!T)//找到结点插入位置
{
AVLNode *S;
S=new AVLNode;
S->data=e;
S->father=parent;
S->lchild=S->rchild=NULL;
T=S;
return S;
}
else if (e<T->data)//向左搜索
{
return InsertAVL(T->lchild,e,T);
}
else if (e>T->data)//向右搜索
{
return InsertAVL(T->rchild,e,T);
}
return NULL;//该结点已存在
}
AVLTree Insert(AVLTree &T,int e)
{
AVLNode *S;
S=new AVLNode;
S=InsertAVL(T,e,NULL);//插入结点
count_depth(T);//更新深度信息
T=AVLchange(T,S);//调整为平衡二叉树
return T;
}
void creativetree(AVLTree &T)
{
T=NULL;
int e,n,i;
scanf("%d",&n);
for (i=0; i<n; i++)
{
scanf("%d",&e);
T=Insert(T,e);
}
}
int main()
{
AVLTree T;
creativetree(T);//建树
return 0;
}
平衡二叉树的删除操作和其他遍历操作与二叉排序树无异，其他操作可以参考这里 实现二叉排序树的各种算法
如何匹配未被反斜杠转义的平衡定界符对(其本身未被反斜杠转义)(无需考虑嵌套)？例如对于反引号，我试过了，但是转义的反引号没有像转义那样工作。regex=/(?!$1:"how\\"#expected"how\\`are"上面的正则表达式不考虑由反斜杠转义并位于反引号前面的反斜杠，但我愿意考虑。StackOverflow如何做到这一点？这样做的目的并不复杂。我有文档文本，其中包括内联代码的反引号，就像StackOverflow一样，我想在HTML文件中显示它，内联代码用一些spanMaterial装饰。不会有嵌套，但转义反引号或转义反斜杠可能出现在任何地方。
我有一个用户工厂。我希望默认情况下确认用户。但是鉴于unconfirmed特征，我不希望它们被确认。虽然我有一个基于实现细节而不是抽象的工作实现，但我想知道如何正确地做到这一点。factory:userdoafter(:create)do|user,evaluator|#unwantedimplementationdetailshereunlessFactoryGirl.factories[:user].defined_traits.map(&:name).include?(:unconfirmed)user.confirm!endendtrait:unconfirmeddoenden
华为OD机试题本篇题目：明明的随机数题目输入描述输出描述：示例1输入输出说明代码编写思路最近更新的博客华为od2023|什么是华为od，od薪资待遇，od机试题清单华为OD机试真题大全，用Python解华为机试题|机试宝典【华为OD机试】全流程解析+经验分享,题型分享,防作弊指南华为o
HashMap中为什么引入红黑树，而不是AVL树呢1.概述开始学习这个知识点之前我们需要知道，在JDK1.8以及之前，针对HashMap有什么不同。JDK1.7的时候，HashMap的底层实现是数组+链表JDK1.8的时候，HashMap的底层实现是数组+链表+红黑树我们要思考一个问题，为什么要从链表转为红黑树呢。首先先让我们了解下链表有什么不好？？？2.链表上述的截图其实就是链表的结构，我们来看下链表的增删改查的时间复杂度增：因为链表不是线性结构，所以每次添加的时候，只需要移动一个节点，所以可以理解为复杂度是N(1)删：算法时间复杂度跟增保持一致查：既然是非线性结构，所以查询某一个节点的时候
C#实现简易绘图工具一.引言实验目的:通过制作窗体应用程序(C#画图软件),熟悉基本的窗体设计过程以及控件设计,事件处理等,熟悉使用C#的winform窗体进行绘图的基本步骤,对于面向对象编程有更加深刻的体会.Tutorial任务设计一个具有基本功能的画图软件**·包括简单的新建文件,保存,重新绘图等功能**·实现一些基本图形的绘制,包括铅笔和基本形状等,学习橡皮工具的创建**·设计一个合理舒适的UI界面**注明:你可能需要先了解一些关于winform窗体应用程序绘图的基本知识,以及关于GDI+类和结构的知识二.实验环境Windows系统下的visualstudio2017C#窗体应用程序三.
MIMO技术的优缺点优点通过下面三个增益来总体概括：阵列增益。阵列增益是指由于接收机通过对接收信号的相干合并而活得的平均SNR的提高。在发射机不知道信道信息的情况下，MIMO系统可以获得的阵列增益与接收天线数成正比复用增益。在采用空间复用方案的MIMO系统中，可以获得复用增益，即信道容量成倍增加。信道容量的增加与min(Nt,Nr)成正比分集增益。在采用空间分集方案的MIMO系统中，可以获得分集增益，即可靠性性能的改善。分集增益用独立衰落支路数来描述，即分集指数。在使用了空时编码的MIMO系统中，由于接收天线或发射天线之间的间距较远，可认为它们各自的大尺度衰落是相互独立的，因此分布式MIMO
遍历文件夹我们通常是使用递归进行操作，这种方式比较简单，也比较容易理解。本文为大家介绍另一种不使用递归的方式，由于没有使用递归，只用到了循环和集合，所以效率更高一些！一、使用递归遍历文件夹整体思路1、使用File封装初始目录，2、打印这个目录3、获取这个目录下所有的子文件和子目录的数组。4、遍历这个数组，取出每个File对象4-1、如果File是否是一个文件，打印4-2、否则就是一个目录，递归调用代码实现publicclassSearchFile{publicstaticvoidmain(String[]args){//初始目录Filedir=newFile("d:/Dev");Datebeg
通常，数组被实现为内存块，集合被实现为HashMap，有序集合被实现为跳跃列表。在Ruby中也是如此吗？我正在尝试从性能和内存占用方面评估Ruby中不同容器的使用情况 最佳答案 数组是Ruby核心库的一部分。每个Ruby实现都有自己的数组实现。Ruby语言规范只规定了Ruby数组的行为，并没有规定任何特定的实现策略。它甚至没有指定任何会强制或至少建议特定实现策略的性能约束。然而，大多数Rubyist对数组的性能特征有一些期望，这会迫使不符合它们的实现变得默默无闻，因为实际上没有人会使用它:插入、前置或追加以及删除元素的最坏情况步骤复
在ruby中，你可以这样做:classThingpublicdeff1puts"f1"endprivatedeff2puts"f2"endpublicdeff3puts"f3"endprivatedeff4puts"f4"endend现在f1和f3是公共(public)的，f2和f4是私有(private)的。内部发生了什么，允许您调用一个类方法，然后更改方法定义？我怎样才能实现相同的功能(表面上是创建我自己的java之类的注释)例如...classThingfundeff1puts"hey"endnotfundeff2puts"hey"endendfun和notfun将更改以下函数定
我目前有一个reddit克隆类型的网站。我正在尝试根据我的用户之前喜欢的帖子推荐帖子。看起来K最近邻或k均值是执行此操作的最佳方法。我似乎无法理解如何实际实现它。我看过一些数学公式(例如k表示维基百科页面)，但它们对我来说并没有真正意义。有人可以推荐一些伪代码，或者可以查看的地方，以便我更好地了解如何执行此操作吗？ 最佳答案 K最近邻(又名KNN)是一种分类算法。基本上，您采用包含N个项目的训练组并对它们进行分类。如何对它们进行分类完全取决于您的数据，以及您认为该数据的重要分类特征是什么。在您的示例中，这可能是帖子类别、谁发布了该项