17*：查找专题之平衡二叉树以及散列查找技术
问题
平衡二叉树
散列查找技术
目录
平衡二叉树
散列查找技术
预备
正文
一：平衡二叉树
1：定义
平衡⼆叉树
平衡⼆叉树(Self-Balancing Binary Search Tree或Height-Balanced Binary Search Tree),是⼀ 种二叉排序树.其中每一个结点的左子树和右子树的高度差⾄多等于1
1：为啥要引入平衡二叉树呢？
对于一个数组，生成了二叉排序树，如果插入的序列越接近有序，生成的二叉搜索树就越像一个链表。如图
为了避免二叉搜索树变成“链表”，我们引入了平衡二叉树，即让树的结构看起来尽量“均匀”，左右子树的节点数尽量一样多。
2：AVL树
两位俄罗斯数学家 G.M.Adelson - Velskii 和 E.M.Landis 共同发明的一种解决平衡二叉树的算法. 也称为AVL树
⾼度平衡:意思是说,要么它是一颗空树,要么它的左子树和右子树都是平衡二叉树.且左子树和右子树的深度之差的绝对值不超过1;
平衡因子:我们将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF(Balance Factor)
那什么叫做高度平衡呢？意思是说，要么它是一棵空树，要么它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1。我们将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF（Balance Factor），那么平衡二叉树上所有结点的平衡因子只可能是-1、0和1。只要二叉树上有一个结点的平衡因子的绝对值大于1，则该二叉树就是不平衡的。
看下图，为什么图1是平衡二叉树，而图2却不是呢？这里就是考查我们对平衡二叉树的定义的理解，它的前提首先是一棵二叉排序树，右上图的59比58大，却是58的左子树，这是不符合二叉排序树的定义的。图3不是平衡二叉树的原因就在于，结点58的左子树高度为3，而右子树为空，二者差大于了绝对值1，因此它也不是平衡的。而经过适当的调整后的图4，它就符合了定义，因此它是平衡二叉树。
平衡二叉树构建的基本思想就是在构建二叉排序树的过程中，每当插入一个结点时，先检查是否因插入而破坏了树的平衡性，若是，则找出最小不平衡子树。在保持二叉排序树特性的前提下，调整最小不平衡子树中各结点之间的链接关系，进行相应的旋转，使之成为新的平衡子树。
为了能在讲解算法时轻松一些，我们先讲一个平衡二叉树构建过程的例子。假设我们现在有一个数组a[10]={3,2,1,4,5,6,7,10,9,8}需要构建二叉排序树。在没有学习平衡二叉树之前，根据二叉排序树的特性，我们通常会将它构建成如下图的图1所示的样子。虽然它完全符合二叉排序树的定义，但是对这样高度达到8的二叉树来说，查找是非常不利的。我们更期望能构建成如下图的图2的样子，高度为4的二叉排序树才可以提供高效的查找效率。那么现在我们就来研究如何将一个数组构建出图2的树结构。
仔细观察图11，发现根本原因在于结点7的BF是-2，而结点10的BF是1，也就是说，它们俩一正一负，符号并不统一，而前面的几次旋转，无论左还是右旋，最小不平衡子树的根结点与它的子结点符号都是相同的。这就是不能直接旋转的关键。那怎么办呢？
不统一，不统一就把它们先转到符号统一再说，于是我们先对结点9和结点10进行右旋，使得结点10成了9的右子树，结点9的BF为-1，此时就与结点7的BF值符号统一了，如上图的图12所示。
这样我们再以结点7为最小不平衡子树进行左旋，得到下图的图13。接着插入8，情况与刚才类似，结点6的BF是-2，而它的右孩子9的BF是1，如图14，因此首先以9为根结点，进行右旋，得到图15，此时结点6和结点7的符号都是负，再以6为根结点左旋，最终得到最后的平衡二叉树，如下图的图16所示。
平衡⼆二叉树结点结构设计
2：左旋
3：双旋
代码实现逻辑
#include "stdio.h" #include "stdlib.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 typedef int Status; //二叉树的二叉链表结点结构定义 //结点结构 typedef struct BiTNode{ //结点数据 int data; //结点的平衡因子 int bf; //结点左右孩子指针 struct BiTNode *lchild,*rchild; }BiTNode,*BiTree; //1.右旋 /* 对以p为根的二叉排序树作右旋处理; 处理之后p指向新的树根结点,即旋转处理之前的左子树的根结点; */ void R_Rotate(BiTree *p){ BiTree L; //① L是p的左子树; L = (*p)->lchild; //② L的右子树作为p的左子树 (*p)->lchild = L->rchild; //③ 将p作为L的右子树 L->rchild = (*p); //④ 将L替换原有p的根结点位置 *p = L; } /* 2.左旋 对以P为根的二叉排序树作左旋处理 处理之后P指向新的树根结点，即旋转处理之前的右子树的根结点 */ void L_Rotate(BiTree *p){ BiTree R; //① R是p的右子树 R = (*p)->rchild; //② R的左子树作为R的右子树 (*p)->rchild = R->lchild; //③ 将p作为R的左子树; R->lchild = (*p); //④ 将R替换原有p的根结点的位置 *p = R; } #define LH +1 /* 左高 */ #define EH 0 /* 等高 */ #define RH -1 /* 右高 */ /* 3. 对指针T所指结点为根的二叉树作左平衡旋转处理,算法结束后,指针T指向平衡处理后新的根结点 */ void LeftBalance(BiTree *T) { BiTree L,Lr; //1.L指向T的左子树根结点 L=(*T)->lchild; //2.检查T的左子树的平衡度，并作相应平衡处理 switch(L->bf) { //① 新结点插入在T的左孩子的左子树上，要作单右旋处理(如图1-平衡二叉树右旋解释图) case LH: //L的平衡因子为LH,即为1时,表示它与根结点BF符合相同,则将它们(T,L)的BF值都改为EH(0) (*T)->bf=L->bf=EH; //对最小不平衡子树T进行右旋; R_Rotate(T); break; //② LH的平衡因子为RH(-1)时,它与跟结点的BF值符合相反.此时需要做双旋处理(2次旋转处理) // 新结点插入在T的左孩子的右子树上，要作 双旋处理 case RH: //Lr指向T的左孩子的右子树根 Lr=L->rchild; //修改T及其左孩子的平衡因子 switch(Lr->bf) { case LH: (*T)->bf=RH; L->bf=EH; break; case EH: (*T)->bf=L->bf=EH; break; case RH: (*T)->bf=EH; L->bf=LH; break; } Lr->bf=EH; //对T的左子树作左旋平衡处理 L_Rotate(&(*T)->lchild); //对T作右旋平衡处理 R_Rotate(T); } } /* 4. 右平衡树失衡处理 对以指针T所指结点为根的二叉树作右平衡旋转处理 本算法结束时，指针T指向新的根结点 */ void RightBalance(BiTree *T) { BiTree R,Rl; //1.R指向T的右子树根结点 R=(*T)->rchild; //2. 检查T的右子树的平衡度，并作相应平衡处理 switch(R->bf) { //① 新结点插入在T的右孩子的右子树上，要作单左旋处理 case RH: (*T)->bf=R->bf=EH; L_Rotate(T); break; //新结点插入在T的右孩子的左子树上，要作双旋处理 case LH: //Rl指向T的右孩子的左子树根 Rl=R->lchild; //修改T及其右孩子的平衡因子 switch(Rl->bf) { case RH: (*T)->bf=LH; R->bf=EH; break; case EH: (*T)->bf=R->bf=EH; break; case LH: (*T)->bf=EH; R->bf=RH; break; } Rl->bf=EH; //对T的右子树作右旋平衡处理 R_Rotate(&(*T)->rchild); //对T作左旋平衡处理 L_Rotate(T); } } /* 5. 平衡二叉树的插入实现 若在平衡的二叉排序树T中不存在和e有相同关键字的结点，则插入一个数据元素为e的新结点，并返回1，否则返回0。若因插入而使二叉排序树失去平衡，则作平衡旋转处理，布尔变量taller反映T长高与否 思路: 1.如果T为空时,则创建一个新结点; 2.如果T不为空,判断是否存在相同的结点.如果二叉树中存在相同结点,则不需要插入; 3.如果新结点值e小于T的根结点值,则在T的左子树查找; -如果能在左子树中查找到,则不插入进去.返回False; 如果没有找到,则插入 -插入成功taller为TRUE,说明新结点e已经插入进去; 此时需要判断T的平衡因子; -如果平衡因子是1,则说明左子树高于右子树,那么需要调用leftBalance进行左平衡旋转处理; -如果为0或者-1,则说明新插入的结点没有让整颗二叉排序树失去平衡性,只需要修改BF值即可; 4.如果新结点值e大于T的根结点值,则在T的右子树查找; -如果能在右子树中查找到,则不插入进去.返回False; 如果没有找到,则插入 -插入成功taller为TRUE,说明新结点e已经插入进去; 此时需要判断T的平衡因子; -如果平衡因子是-1,则说明右子树高于左子树,那么需要调用RightBalance进行右平衡旋转处理; -如果为0或者1,则说明新插入的结点没有让整颗二叉排序树失去平衡性,只需要修改BF值即可; */ Status InsertAVL(BiTree *T,int e,Status *taller) { if(!*T) { //1.插入新结点，树“长高”，置taller为TRUE //① 开辟一个新结点T; *T=(BiTree)malloc(sizeof(BiTNode)); //② 对新结点T的data赋值,并且让其左右孩子指向为空,T的BF值为EH; (*T)->data=e; (*T)->lchild=(*T)->rchild=NULL; (*T)->bf=EH; //③ 新结点默认"长高" *taller=TRUE; } else { if (e==(*T)->data) { //2.树中已存在和e有相同关键字的结点则不再插入 *taller=FALSE; return FALSE; } if (e<(*T)->data) { //3.应继续在T的左子树中进行搜索 if(!InsertAVL(&(*T)->lchild,e,taller)) //未插入 return FALSE; //4.已插入到T的左子树中且左子树“长高” if(*taller) //5.检查T的平衡度 switch((*T)->bf) { case LH: //原本左子树比右子树高，需要作左平衡处理 LeftBalance(T); *taller=FALSE; break; case EH: //原本左、右子树等高，现因左子树增高而使树增高 (*T)->bf=LH; *taller=TRUE; break; case RH: //原本右子树比左子树高，现左、右子树等高 (*T)->bf=EH; *taller=FALSE; break; } } else { //6.应继续在T的右子树中进行搜索 //未插入 if(!InsertAVL(&(*T)->rchild,e,taller)) return FALSE; //已插入到T的右子树且右子树“长高” if(*taller) // 检查T的平衡度 switch((*T)->bf) { //原本左子树比右子树高，现左、右子树等高 case LH: (*T)->bf=EH; *taller=FALSE; break; //原本左、右子树等高，现因右子树增高而使树增高 case EH: (*T)->bf=RH; *taller=TRUE; break; // 原本右子树比左子树高，需要作右平衡处理 case RH: RightBalance(T); *taller=FALSE; break; } } } return TRUE; } /*6.二叉排序树查找*/ Status SearchBST(BiTree T,int key,BiTree f, BiTree *p){ if (!T) /* 查找不成功 */ { *p = f; return FALSE; } else if (key==T->data) /* 查找成功 */ { *p = T; return TRUE; } else if (key<T->data) return SearchBST(T->lchild, key, T, p); /* 在左子树中继续查找 */ else return SearchBST(T->rchild, key, T, p); /* 在右子树中继续查找 */ } int main(int argc, const char * argv[]) { // insert code here... printf("平衡二叉树 !\n"); int i; int a[10]={3,2,1,4,5,6,7,10,9,8}; //调整数组的顺序,最终生成的平衡二叉树高度是一样的. //int a[10]={8,9,1,4,5,6,7,10,2,3}; //int a[10]={9,4,1,2,7,6,5,10,3,8}; BiTree T=NULL; Status taller; int sum = 0; for(i=0;i<10;i++) { InsertAVL(&T,a[i],&taller); sum += taller; printf("插入%d,是否增加树的高度(%d)[YES->1 / NO->0]\n",a[i],taller); } printf("将数组a插入到平衡二叉树后,最终形成高度为%d的平衡二叉树\n",sum); BiTree p; int statusValue = SearchBST(T, 10, NULL, &p); printf("查找%d是否成功:%d (1->YES/0->NO)\n",p->data,statusValue); return 0; }
散列技术是在记录的存储位置和它的关键字之间建立一个确定的对应关系f，使得每个关键字key对应一个存储位置f(key)。建立了关键字与存储位置的映射关系，公式如下：
这里把这种对应关系f称为散列函数，又称为哈希（Hash）函数。
采用散列技术将记录存在在一块连续的存储空间中，这块连续存储空间称为散列表或哈希表。那么，关键字对应的记录存储位置称为散列地址。
散列技术既是一种存储方法也是一种查找方法。散列技术的记录之间不存在什么逻辑关系，它只与关键字有关，因此，散列主要是面向查找的存储结构。
所谓直接定址法就是说，取关键字的某个线性函数值为散列地址，即
优点：简单、均匀，也不会产生冲突。
缺点：需要事先知道关键字的分布情况，适合查找表较小且连续的情况。
由于这样的限制，在现实应用中，此方法虽然简单，但却并不常用。例如对0-100岁人口的统计
如果现在要存储某家公司的登记表，若用手机号作为关键字，极有可能前7位都是相同的，选择后四位成为散列地址就是不错的选择。若容易出现冲突，对抽取出来 的数字再进行反转、右环位移等。总的目的就是为了提供一个散列函数，能够合理地将关键字分配到散列表的各个位置。
数字分析法通过适合处理关键字位数比较大的情况，如果事先知道关键字的分布且关键字的若干位分布比较均匀，就可以考虑用这个方法。
取关键字平方后的中间几位作为散列地址。
先通过求关键字的平方值扩大相近数的差别，然后根据表长度取中间的几位数作为散列函数值。又因为一个乘积的中间几位数和乘数的每一位都相关，所以由此产生的散列地址较为均匀。
并且平方取中法并不仅仅局限于平方，立方、立方根、log等都可以作为运算方式
折叠法是将关键字从左到右分割成位数相等的几部分（注意最后一部分位数不够时可以短些），然后将这几部分叠加求和，并按散列表表长，取后几位作为散列地址。
比如关键字是9876543210，散列表表长为三位，将它分为四组，987|654|321|0，然后将它们叠加求和987 + 654 + 321 + 0 = 1962，再求后3位得到散列地址962。折叠法事先不需要知道关键字的分布，适合关键字位数较多的情况
此方法为最常用的构造散列函数方法。对于散列表长为m的散列函数公式为：
mod是取模（求余数）的意思。事实上，这方法不仅可以对关键字直接取模，也可以再折叠、平方取中后再取模。很显然，本方法的关键在于选择合适的p，p如果选不好，就可能会容易产生冲突。
根据前辈们的经验，若散列表的表长为m，通常p为小于或等于表长（最好接近m）的最小质数或不包含小于20质因子的合数。
选择一个随机数，取关键字的随机函数值为它的散列地址。也就是f(key) = random(key)。这里random是随机函数。当关键字的长度不等时，采用这个方法构造散列函数是比较合适的。
总之，现实中，应该视不同的情况采用不同的散列函数，这里只能给出一些考虑的因素来提供参考：
（1）计算散列地址所需的时间
（2）关键字的长度；
（3）散列表的长度；
（4）关键字的分布情况；
（5）记录查找的频率。
综合以上等因素，才能决策选择哪种散列函数更合适。
在理想的情况下，每一个关键字，通过散列函数计算出来的地址都是不一样的，可现实中，这只是一个理想。市场会碰到两个关键字key1 != key2，但是却有f(key1) = f(key2)，这种现象称为冲突。出现冲突将会造成查找错误，因此可以通过精心设计散列函数让冲突尽可能的少，但是不能完全避免。
所谓的开放定址法就是一旦发生了冲突，就去寻找下一个空的散列地址，只要散列表足够大，空的散列地址总能找到，并将记录存入。
解决冲突的开放定址法称为 线性探测法
开放定址法公式2:;
解决冲突的开放定址法称为 二次探测法
对于散列表来说，可以事先准备多个散列函数。
这里RHi 就是不同的散列函数，可以把前面说的除留余数、折叠、平方取中全部用上。每当发生散列地址冲突时，就换一个散列函数计算。
这种方法能够使得关键字不产生聚集，但相应地也增加了计算的时间。
将所有关键字为同义词的记录存储在一个单链表中，称这种表为同义词子表，在散列表中只存储所有同义词子表前面的指针。对于关键字集合{12, 67, 56, 16, 25, 37, 22, 29, 15, 47, 48, 34}，用前面同样的12为余数，进行除留余数法，可以得到下图结构。
此时，已经不存在什么冲突换地址的问题，无论有多少个冲突，都只是在当前位置给单链表增加结点的问题。
链地址法对于可能会造成很多冲突的散列函数来说，提供了绝不会出现找不到地址的保证。当然，这也就带来了查找时需要遍历单链表的性能损耗
这个方法其实更好理解，你冲突是吧？那重新给你找个地址。为所有冲突的关键字建立一个公共的溢出区来存放。
在查找时，对给定值通过散列函数计算出散列地址后，先与基本表的相应位置进行比对，如果相等，则查找成功；如果不相等，则到溢出表中进行顺序查找。如果相对于基本表而言，有冲突的数据很少的情况下，公共溢出区的结构对查找性能来说还是非常高的。
如果没有冲突，散列查找是所介绍过的查找中效率最高的。因为它的时间复杂度为O(1)。但是，没有冲突的散列只是一种理想，在实际应用中，冲突是不可避免的。
那散列查找的平均查找长度取决于哪些因素呢？
（1）散列函数是否均匀
散列函数的好坏直接影响着出现冲突的频繁程度，但是，不同的散列函数对同一组随机的关键字，产生冲突的可能性是相同的（为什么？？），因此，可以不考虑它对平均查找长度的影响。
（2）处理冲突的方法
相同的关键字、相同的散列函数，但处理冲突的方法不同，会使得平均查找长度不同。如线性探测处理冲突可能会产生堆积，显然就没有二次探测好，而链地址法处理冲突不会产生任何堆积，因而具有更好的平均查找性能。
（3）散列表的装填因子
所谓的装填因子a = 填入表中的记录个数/散列表长度。a标志着散列表的装满的程度。当填入的记录越多，a就越大，产生冲突的可能性就越大。也就说，散列表的平均查找长度取决于装填因子，而不是取决于查找集合中的记录个数。不管记录个数n有多大，总可以选择一个合适的装填因子以便将平均查找长度限定在一个范围之内，此时散列表的查找时间复杂度就是O(1)了。为了这个目标，通常将散列表的空间设置的比查找表集合大。
散列技术最适合的求解问题是查找与给定值相等的记录。对于查找来说，简化了比较过程，效率会大大提高。
但是，散列技术不具备很多常规数据结构的能力，比如
同样的关键字，对应很多记录的情况，不适合用散列技术；
散列表也不适合范围查找等等。
#include "stdio.h" #include "stdlib.h" #include "math.h" #include "time.h" typedef int Status; #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 //存储空间初始分配量 #define SUCCESS 1 #define UNSUCCESS 0 //定义散列表长为数组的长度 #define HASHSIZE 12 #define NULLKEY -32768 typedef struct { //数据元素存储基址，动态分配数组 int *elem; //当前数据元素个数 int count; }HashTable; int m=0; /* 散列表表长，全局变量 */ //1.初始化散列表 Status InitHashTable(HashTable *H) { int i; //① 设置H.count初始值; 并且开辟m个空间 m=HASHSIZE; H->count=m; H->elem=(int *)malloc(m*sizeof(int)); //② 为H.elem[i] 动态数组中的数据置空(-32768) for(i=0;i<m;i++) H->elem[i]=NULLKEY; return OK; } //2. 散列函数 int Hash(int key) { //除留余数法 return key % m; } //3. 插入关键字进散列表 void InsertHash(HashTable *H,int key) { //① 求散列地址 int addr = Hash(key); //② 如果不为空，则冲突 while (H->elem[addr] != NULLKEY) { //开放定址法的线性探测 addr = (addr+1) % m; } //③ 直到有空位后插入关键字 H->elem[addr] = key; } //4. 散列表查找关键字 Status SearchHash(HashTable H,int key,int *addr) { //① 求散列地址 *addr = Hash(key); //② 如果不为空，则冲突 while(H.elem[*addr] != key) { //③ 开放定址法的线性探测 *addr = (*addr+1) % m; //④H.elem[*addr] 等于初始值或者循环有回到了原点.则表示关键字不存在; if (H.elem[*addr] == NULLKEY || *addr == Hash(key)) //则说明关键字不存在 return UNSUCCESS; } return SUCCESS; } int main(int argc, const char * argv[]) { // insert code here... printf("Hello, World!\n"); int arr[HASHSIZE]={12,67,56,16,25,37,22,29,15,47,48,34}; int i,p,key,result; HashTable H; //1.初始化散列表 InitHashTable(&H); //2.向散列表中插入数据 for(i=0;i<m;i++) InsertHash(&H,arr[i]); //3.在散列表查找key=39 key=39; result=SearchHash(H,key,&p); if (result) printf("查找 %d 的地址为：%d \n",key,p); else printf("查找 %d 失败。\n",key); //4.将数组中的key,打印出所有在散列表的存储地址 for(i=0;i<m;i++) { key=arr[i]; SearchHash(H,key,&p); printf("查找 %d 的地址为：%d \n",key,p); } return 0; }
注意
