邓俊辉数据结构学习-7-BST
二叉搜索树(Binary-Search-Tree)--BST
要求:AVL树是BBST的一个种类,继承自BST,对于AVL树,不做太多掌握要求
- 四种旋转,旋转是BBST自平衡的基本,变换,主要掌握旋转的思想。
- 3+4重构,重点明白为什么可以3+4重构,而不是使用旋转
- 对于AVL插入和删除做了解,知道其为什么比不过红黑树就可以了。
循关键码访问(call-by-key)
- 关键码:就是所谓的key
- 条件:
- 关键码之间支持大小比较
- 支持相等比对
- 在BST中,所有数据都统一实现和表示为entry(entry是什么?)
entry(词条)其实就是(key-value)对
同时还支持大小比较和相等比对(通过比较词条的key)的方式。
概念
- 词条,二叉树的节点,关键码三者之间在不做具体强调的时候,概念等同。
BST特征
- 顺序性:任意节点均不小于其左后代。且其右后代也均不小于其节点。
- 数学语言描述就是
one-of-left-node <= V <= one-of-right-node
- 注意这里是
后代
,不是孩子
- 数学语言描述就是
- 简化条件:禁止重复词条, 意识就是目前不考虑重复key的存在
- 经过简单扩容后就可以支持重复词条。
- BST的中序遍历必然单调。因此就得到了
判断树是否是BST的方法
。
注意key-value的映射为单一映射,不存在单一key映射多个value,但不同key可以映射相同value,具体
设计看自己
接口
查找 search
search查找的本质就是二分查找。
BST<T>::searchIn(BinNodePos(T) &v , const T &key, BinNodePos(T) &hot /*记忆热点*/)
{
if(!v || (key == v->data)) return v;
hot = v;
return searchIn(( key < v->data ? v->lc : v->rc), key, hot);
- 代码本身没有难度,这里主要注重接口语义:
- hot的语义: 查找成功时,返回命中节点的父亲。 查找失败时,返回最后返回的一个存在的非空节点。
- 语义统一: 假设我们在查找失败的时候引入假想的哨兵节点,且其key值正好等于我们要找的key。则search
返回的就是目标节点。hot返回的就是目标节点的父亲。 - 注意返回值,和第一个参数,都是使用的指针的引用。这样做的目的是让search的返回值后续被其他接口
调用,而且主需要改变这个返回值,就可以改变指针的指向,所以指针配合引用的方式取缔了二级指针的使用,
熟悉了后,感到很方便。
插入 insert
再次重申,我们当前认为不存在重复节点。那么,我们要插入的元素,通过search(e)接口的调用,
就会发现返回的位置恰好就是我们当初假想的哨兵。也就是e应该存在的位置。
那么就很简单了, 直接操作返回位置。就可以了。
现在明白为什么当初返回的是BinNodePos(T) & 了。
BinNodePos(T)
BST<T>::insert(const T &e)
{
BinNodePos(T) x = search(e);
if(!x) // 保证插入元素不存在
{
x = new BinNode(e, _hot); // 很方便的完成了parent的回指,
/* ----- 要记得维护该有的数据项 ----- */
++_size;
updateHeightAbove(_hot); // 从插入节点的父亲节点开始更新高度,逐步向上
}
return x;
}
有些数据结构时不维护height的,但是接下使用的AVL树需要使用height
删除 remove
删除同插入一样,在删除之后,依然要保持这个BST的有序性。而且同样需要维护height和size。
因此,删除比较复杂的情况在于删除目标元素后,目标元素后面的元素有一个替换的过程。
bool remove(const T &e)
{
BinNodePos(T) x = search(e);
if(!x) return false;
removeAt(x, _hot);
--_size;
updateHeightAbove(_hot);
return true;
}
void removeAt(BinNodePos(T) &x, BinNodePos(T) &hot)
{
BinNodePos(T) w = x; // 保存删除节点位置
BinNodePos(T) succ = nullptr;
if(!x->lc && !x->rc)
{
// do nothing
}
else if(!x->lc) // 左树为空的情况下
{
succ = x = x->rc;
/* 拆开来理解
x = x->rc; 直接让删除节点的后继覆盖删除节点
succ = x; 然后然明文后继指向后继,标记后继位置
*/
}
else if(!x->rc)
{
succ = x = x->lc;
}
else{ // 哇,最喜欢这里
w = w->succ(); // w指向自己的中序后继, 这里要从中序遍历的序列理解,删除一个树的节点,
// 我们先将这个树的值和其中序遍历后继替换再删,就是相当于交换了有序的向量 的下一个值,然后删下
// 个值,没有任何影响,但是这个节点的中序遍历后继最多只可能有一个孩子, 因为当前节点左右孩子
// 都有,那么其后继一定在右孩子中的最左分支。那么其就不能有右孩子。最多只能有一个右孩子。
std::swap(w->data, x->data);
// 到目前为止,w依然保留着删除节点位置(虽然它动了)
BinNodePos(T) u = w->parent;
if(u == x) // 即使w->rc为nullptr也没关系
u->rc = succ = w->rc;
else
u->lc = succ = w->rc
}
hot = w->parent;
if(succ) succ->parent = hot; // 如果删除节点的后继存在,还要进行回指
release(w->data);
release(w);
return succ;
}
/* 只会出现俩种情况 情况1
.─.
.─. ( X )
( X ) <- u ▪ `─' ▪
▪`─'▪ ▪ ▪
▪ ▪ ▪ ▪ .─.
▪ ▪.─. ▪ ( )
▪ ▪ ( W ) ▪ ▪`─'
▪▪▪ `─'▪ ▪ ▪ .─.▪
▪ ▪ ▪ ▪▪▪ u-> (...) ◀┐
▪ ▪ ▪ ▪ ▪ ▪`─' │ ┌────────────────┐
▪ ▪ ▪ ▪ ▪ ▪ └──│ may many nodes │
▪ ▪ ▪▪▪ ┌──────────────┐ ▪ ▪ .─.▪ └────────────────┘
▪ T ▪ ▪ ▪ ┌──│may not exist │ ▪ ▪ ( W )
▪ ▪ ▪ ▪ │ └──────────────┘ ▪ T ▪ `─'▪
▪ ▪ ▪ ▪ │ ▪ ▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪ ▪ ▪ ◀─┘ ▪ ▪ ▪
▪ T ▪ ▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪ ▪
▪ ▪ ▪▪▪ ┌──────────────┐
▪ ▪ ▪ ▪ ┌──│may not exist │
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪ ▪ ▪ │ └──────────────┘
▪ ▪ │
▪ ▪ ◀─┘
▪ T ▪
▪ ▪
▪ ▪
▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪▪
*/
平衡与代价
BST的所有查找,插入,删除均为O(h)的复杂度。
注意BST的高度并不是log(N);
最坏情况下是线性排列,那么h = n
这也就引入了AVL树和RB树。
理想平衡
在理想平衡下,树的高度总共不会超过logN,但是需要注意的是,维护这样一种状态,在插入和删除后进行的
状态调整代价可能会很高,因为我们寻求的是一种适度平衡。
平衡二叉搜索树 Balance-BST -- BBST
注意:对于BBST来说,仍然要保持BST的有序性,即中序遍历的序列不能发生变化。
这样俩个BST,我们称为等价BST,利用的就是中序遍历的歧义性。
等价BST变换规律:
- 上下可变: 祖先和后代关系可以发生颠倒, 在垂直方向有一定自由度
- 左右不乱: 在节点左侧的节点,经过调整后,依然在左侧,在右侧的节点经过调整后依然在右侧。
基本变换
任何BST之间的等价变换都是经过一系列的基本变换形成的。详细证明可以参考《数据结构与算法分析》
旋转操作
- 单旋转
俩种单旋转: - (向)右旋转——zig, (向)左旋转--zag
- 如果导致失衡,插入一定插入在较高的子树,平衡因子由原来的+1变为+2。
┌────────────────────┐ ┌────────────────────┐
│balfactor: +1 -> +2 │ │balfactor: +2 -> +1 │
└────────────────────┘ └────────────────────┘
┌────┐ .─. .─.
│ g │──────────────▶(50 ) (40 )
└────┘ ▪`─'▪ ▪`─'▪
▪ ▪ ─────────────────────▶ ▪ ▪
┌────┐ .─▪ ▪.─. .─.▪ ▪.─.
│ p │───────▶(40 ) (60 ) (35 ) (50 )
└────┘ ▪ `─'▪ `─' ▪`─' ▪`─'▪
▪ ▪ ▪ ▪ ▪
┌────┐ .─▪ .▪. ┌───────────────────┐ ▪ ▪ ▪
│ v │─▶(35 ) (45 )◀────────│ may not exist │ .─. .─. .─.
└────┘ ▫`─' `─' └───────────────────┘ (35 ) (45 ) (60 )
▫ `─' `─' `─'
▫
.─. ┌──────────────────────┐
(30 )◀────│ the new insert node │
`─' └──────────────────────┘
操作步骤:
- 首先得到一个临时的引用rc指向p
- g的左子树指向p的右子树
- 令g称为p的右孩子
- 将局部子树的根指向p,然后去掉rc
- zag左旋操作与此同理。
总的来说,单旋转呈现这么一种特性,即v,p,g分布单向,g为局部子树的根,调整完毕后,v,p,g自己可以形成
一个满树,p为局部子树的根
- 双旋转
- 此时v,p,g不再呈现一边的趋势,而是分开了。只需要执行一次zag左旋就可以达到之前的单旋转状态
┌────────────────────┐ ┌────────────────────┐
│balfactor: +1 -> +2 │ │balfactor: +2 -> +1 │
└────────────────────┘ └────────────────────┘
┌────┐ .─. .─.
│ g │──────────────▶(50 ) g-> (50 )
└────┘ ▪`─'▪ ▪`─'▪
▪ ▪ ─────────────────────▶ ▪ ▪
┌────┐ .─▪ ▪.─. .─.▪ ▪.─.
│ p │───────▶(40 ) (60 ) p-> (45 ) (60 )
└────┘ ▪ `─'▪ `─' ▪`─'▪ `─'
▪ ▪ ▪ ▪
.─▪ .▪. ▪ ▪
(35 ) ┌──▶(45 ) .─. .─.
`─' │ `─'▪ v-> (40 ) (48 )
│ ▪ ▪`─' `─'
│ ▪ ▪
┌────┐ │ .─. ┌──────────────────────┐ .─.
│ v ├─┘ (48 )◀──────│ the new insert node │ (35 )
└────┘ `─' └──────────────────────┘ `─'
- 使用rc临时引用指向v
- 让p的右子树指向v的左子树,
- 让v的左子树指向p
- 让局部子树的根指向v,并去掉rc
- 就得到可以进行单旋的状态。
让我们再次来复习下右旋。
- 让临时引用rc指向p
- 让g的左子树指向p的右子树
- 让p的右子树指向g
- 让局部子树的根指向p,并去掉rc
到此,俩类共4个旋转操作的文字说明和图示如上。接下来,看到底怎样使用基本操作将树由BST拉回BBST
具体的四种旋转,可以查看AVL的四种旋转
AVL树
AVL树是BBST的一个种类。
平衡因子:左子树的高度减去右子树的高度,
AVL树的平衡因子不会超过1。 AVL树| balFac(v) | <= 1
回忆:之前我们定义过,空树的高度为-1,有一个节点的树高度为0。
一颗树的高度,就是树中深度最大节点的深度。
可以将状态定义如下
#define BalFac(x) (stature((x).lc) - stature((x).rc)) //平衡因子
#define AvlBalanced(x) ((-2 < BalFac(x)) && (BalFac(x) < 2)) //AVL平衡条件
失衡
插入
插入一个新节点,会导致节点的所有祖先失衡。 最多logN个节点。
- 原因:插入一个新节点,会更新节点以及节点所有祖先。
- 但是插入操作反而比删除操作更为简便一些。经过一次调整就可以完成
- 特征
- 插入一个节点后,失衡节点集为新插入节点x的祖先,且高度均不低于新插入节点x的祖父。
- 这个高度最低的失衡节点我们标记为g
- g不一定是x的祖父,有可能是更高的祖先
插入重平衡
- 在x和g的通路上,我们设p为g的孩子,设置v为p的孩子。
实现:
- 找g节点:那么重平衡的关键就是首先要找到g,这个很简单,从x的parent的往上开始,找不满足avl平衡条件
的节点。 - 找p,v节点:找到g节点后,我们知道g节点是失衡的,因为新插入了x节点,那么其在通往x节点的通路上的高度
则会均大于他们的兄弟,借此,可以寻找p,v节点。其实就是找v节点就够了。p是v的parent。
宏代码如下所示,解读:
#define tallerChild(x) (\ /*说白了就是在找高度更高的孩子*
stature((x)->lc) > stature((x)->rc) ? (x)->lc : ( /*左高*/ \
stature((x)->lc) < stature((x)->rc) ? (x)->rc : ( /*右高*/ \
IsLchild(*(x)) ? (x)->lc : (x)->rc /*等高*/ \
)\
)\
)\
等高情况发生在AVL树删除的情况下, 在插入情况下不会发生。
代码如下
void insert(const T &e)
{
// 插入操作前面的代码和正常BST的插入一样
BinNodePos(T) & x = search(e);
if(x)
return ; // 目前不考虑重复元素
x = new BinNode(e, _hot); // 直接完成新节点的构建,paret指向_hot,回想之前search的语义
++_size;
BinNodePos(T) xx = x; // 接下来就是AVL树自己独有的部分
/* ------- AVL 特有部分-------- */
for(BinNodePos(T) g = xx->parent; g; g = g->parent)
{
if(!AvlBalanced(g)) // 根据g的定义找到g
{
// fromparentto返回当前节点父亲节点的指针域, 即局部子树的根引用
// 由此可推断,rotate返回的是p
FromParentTo(*g) = rotateAt(tallerChild( tallerChild(g) ));
break;
}
else{
updateHeightAbove(g); // 同时还要一步一步进行高度更新。但调整完毕后就直接退出了,
// 不需要更新了, 原因在于插入调整不会改变g的祖先的高度, 和插入前的高度保持一致
}
}
return xx;
}
效率:
可以看出,插入操作只需要执行O(logN)的查找时间,然后进行最多不超过O(logN)的平衡确认,如果失衡
执行不超过2次的旋转调整,由此AVL树的插入操作在O(logN)的时间内可以完成
删除
删除一个新节点,只会导致最多1个节点失衡。
- 原因:如果导致失衡,删除节点时,一定是删除更短的那个分支,而这个子树的高度担当还是在最长
子树那里。 - 特征
- 与插入不同的是,删除操作中失衡节点集始终最多只含有一个节点。
- 重平衡 教材P198页有详细讲解,这标记一下
- 寻找g:节点依然是按照之前的方法,通过被删除节点的parent向上查找,到不满足AVL平衡条件的那个
点 - 寻找p:作为失衡节点,其另一边的高度至少为1才能构成失衡。因此必定有一个非空的孩子p,且是
tallerchild - 寻找v:寻找v的时候,p的俩个孩子高度可能相等。此时我们优先选取和p同向者,单旋当然比双
旋简单。
- 寻找g:节点依然是按照之前的方法,通过被删除节点的parent向上查找,到不满足AVL平衡条件的那个
图片转自邓老师pdf,侵权必删
- Q:就图中而言,为什么v的T1, T0俩个后辈一定存在?
- A:如果v下面的俩个后辈不存在,而T2的后辈存在,那么此时T2高度更高,自然选取T2为v
实现代码如下
bool remove(const T &e)
{
/* ----- BST 删除操作(缺少一个高度更新,在AVL中更新) ----- */
BinNodePos(T) x = search(e);
if(!x)
return false; // 删除元素必须保证存在
BST<T>::removeAt(x, _hot);
--_size;
/* ----- AVL 删除所特有的 ----- */
for(BinNodePos(T) g = _hot; g; g = g->parent)
{
if(!AvlBalanced(*g)) // 如果不满足avl平衡条件
{
g = FromParentTo (*g) = rotateAt(tallerChild(tallerChild(g)));
updateHeight(g);
}
}
return true;
}
这里简单回忆下removeAt操作
void removeAt(bnp &x, bnp &hot)
{
bnp w = x;
bnp succ = nullptr;
if(!HasLc(x))
succ = x = x->rc;
if(!HasRc(x))
succ = x = x->lc;
else{
w = w->succ();
swap(x->data, w->data);
bnp u = w->parent;
((u == x) ? u->rc : u->lc) = succ = w->rc;
}
hot = w->parent;
//release(w->data);
if(succ) succ->parent = hot;
delete(w);
return succ;
}
失衡传播:
经过一次删除调整后,原先子树的高度有可能不变,有可能减一。如果发生了减一,那么就相当于从被删除节点
的父亲开始,每次都需要进行AVL平衡条件的检查,一直到树的根部。
树的真正调整
虽然我们已经学习了基本变换,但是我们并不适用,而是仅仅让其帮助我们理解,我们所仍然采用的方式
叫做3+4重构,直接将树的g, p, v拆开,按照a < b < c
的方式重新命名,同时其下面的四颗子树也按照
T0 < T1 < T2 < T3
的方式重新命名。最终的状态会达到
T0 < a < T1 < b(root) < T2 < c < T3
的状态
3+4重构在这里非常简洁,所以重点还是这里的rotateAt
template <typename T>
BinNodePos(T)
BST<T>::connect34( // 3+4 重构
BinNodePos(T) a, BinNodePos(T) b, BinNodePos(T) c,
BinNodePos(T) T0, BinNodePos(T) T1, BinNodePos(T) T2, BinNodePos(T) T3)
{
a->lc = T0; if(T0) T0->parent = a;
a->rc = T1; if(T1) T1->parent = a;
updateHeight(a);
c->lc = T2; if(T2) T2->parent = c;
c->rc = T3; if(T3) T3->parent = c;
updateHeight(c);
b->lc = a; a->parent = b;
b->rc = b; c->parent = b;
updateHeight(b);
return b;
}
// 根据我们之前讨论的四种旋转情况,在不同情况下进行a, b, c 以及T0, T1, T2, T3的排序
template <typename T>
BinNodePos(T)
BST<T>::rotateAt(BinNodePos(T) v) // 传入参数为孙子节点v
{
BinNodePos(T) g, p;
p = v->parent;
g = p->parent;
if(IsLChild(*p))
{
if(IsLChild(*v))
{
p->parent = g->parent; // 向上连接
return connect34(v, p, g, v->lc, v->rc, p->rc, g->rc);
}
else{
v->parent = g->parent;
return connect34(p, v, g, p->lc, v->lc, v->rc, g->rc);
}
}
else{
if(IsLChild(*v))
{
v->parent = g->parent;
return connect34(g, v, p, g->lc, v->lc, v->rc, p->rc);
}
else{
p->parent = g->parent;
return connect34(g, p, v, g->lc, p->lc, v->lc, v->rc);
}
}
}
综合评价
AVL树优点:查找,插入,删除均为O(logN)时间复杂度,O(N)的空间
AVL树缺点:
- 需要借助高度或平衡因子,需要改造元素结构,或额外封装,
过于做作
- 实测和理论尚有差距
- 最重要的因子,删除操作后,会经过一次旋转调整,但有可能导致整个局部的树高度比未删除之前减1,因此会再次出发调整,最
坏情况下全树需要做logN次调整, 变化量过于大
邓俊辉数据结构学习-7-BST的更多相关文章
- 邓俊辉数据结构学习-8-2-B树
B树 概述 动机: B树实现高速I/O 640K如何"满足"任何实际需求了-- 源自比尔·盖茨的一个笑话 前提知识 高速缓存 为什么高速缓存有效? 不同容量的存储器,访问速度差异悬 ...
- 清华大学慕课 (mooc) 数据结构-邓俊辉-讲义-合并版
邓公的数据结构一直好评如潮,可惜我如今才开始学习它.QAQ 昨天,<数据结构 (2020 春)>的讲义已经推到清华大学云盘上了.苦于 10 拼页的打印版不易在 PC 上阅读(手机上更是如此 ...
- 算法设计和数据结构学习_5(BST&AVL&红黑树简单介绍)
前言: 节主要是给出BST,AVL和红黑树的C++代码,方便自己以后的查阅,其代码依旧是data structures and algorithm analysis in c++ (second ed ...
- 数据结构学习之字符串匹配算法(BF||KMP)
数据结构学习之字符串匹配算法(BF||KMP) 0x1 实验目的 通过实验深入了解字符串常用的匹配算法(BF暴力匹配.KMP.优化KMP算法)思想. 0x2 实验要求 编写出BF暴力匹配.KM ...
- 数据结构学习之栈求解n皇后问题
数据结构学习之栈求解n皇后问题 0x1 目的 深入掌握栈应用的算法和设计 0x2 内容 编写一个程序exp3-8.cpp求解n皇后问题. 0x3 问题描述 即在n×n的方格棋盘上,放置n个皇后 ...
- 数据结构------------------二叉查找树(BST)的java实现
数据结构------------------二叉查找树(BST)的java实现 二叉查找树(BST)是一种能够将链表插入的灵活性和有序数组查找的高效性相结合的一种数据结构.它的定义如下: 二叉查找树是 ...
- 1.基础: 万丈高楼平地起——Redis基础数据结构 学习记录
<Redis深度历险:核心原理和应用实践>1.基础: 万丈高楼平地起——Redis基础数据结构 学习记录http://naotu.baidu.com/file/b874e2624d3f37 ...
- ES6中Map数据结构学习笔记
很多东西就是要细细的品读然后做点读书笔记,心理才会踏实- Javascript对象本质上就是键值对的集合(Hash结构),但是键只能是字符串,这有一定的限制. 1234 var d = {}var e ...
- 数据结构学习-BST二叉查找树 : 插入、删除、中序遍历、前序遍历、后序遍历、广度遍历、绘图
二叉查找树(Binary Search Tree) 是一种树形的存储数据的结构 如图所示,它具有的特点是: 1.具有一个根节点 2.每个节点可能有0.1.2个分支 3.对于某个节点,他的左分支小于自身 ...
随机推荐
- oracle取order by的第一条数据
SELECT * FROM (SELECT * FROM TABLE_NAME ORDER BY COL1) WHERE ROWNUM = 1; 备注: 1.不能给 (SELECT * FROM TA ...
- 【ARC077F】SS kmp+打表找规律
Description 如果某个串可以由两个一样的串前后连接得到,我们就称之为"偶串".比如说"xyzxyz"和"aaaaaa"是偶串, ...
- luogu3703 [SDOI2017]树点涂色(线段树+树链剖分+动态树)
link 你谷的第一篇题解没用写LCT,然后没观察懂,但是自己YY了一种不用LCT的做法 我们考虑对于每个点,维护一个fa,代表以1为根时候这个点的父亲 再维护一个bel,由于一个颜色相同的段一定是一 ...
- REST模式中HTTP请求方法(GET,POST,PUT,DELETE)
一直在测试REST模式的WEB SERVICE接口,客户端的HTTP的请求方式一般分为四种:GET.POST.PUT.DELETE,这四种请求方式有什么不同呢.简单的说,GET就是获取资源,POST就 ...
- Android ToggleButton(开关函数)与switch (开关按钮)
1.ToggleButton (1)介绍 (2)组件形状 (3)xml文件设置 <?xml version="1.0" encoding="utf-8"? ...
- window 安装 python
官网地址下载安装包 点击下载 会自动识别你当前的系统,或者点击你需要安装的平台 或者选择其他版本 执行安装 高级选项说明: Install for all users 所有用户可使用 Associat ...
- JavaScript 调用 Windows 的打印 代码
JavaScript 调用 Windows 的打印 代码 2009-02-24 10:36 <%@ Page Language="C#" AutoEventWireup=&q ...
- HDU_1043 Eight 【逆向BFS + 康托展开 】【A* + 康托展开 】
一.题目 http://acm.hdu.edu.cn/showproblem.php?pid=1043 二.两种方法 该题很明显,是一个八数码的问题,就是9宫格,里面有一个空格,外加1~8的数字,任意 ...
- linux环境下安装python
在linux系统中安装python解释器 打开官网www.python.org 选择合适的版本进行下载 将下载好的压缩包拖入Xshell中,依次输入一下命令即可 tar xf Python-.tar. ...
- 给小程序组件创建slot
<!--comviewonents/juan/juan.wxml--> <view class="model-wrapper" hidden="{{vi ...