数据结构（十六）——左高树（含合并过程详细图解）

文章目录

前言
左高树
- 什么是左高树?
- 为什么要使用左高树?
最大左高树实现及复杂度分析
- 节点类和最大左高树类
- 合并方法
- 插入(push)、删除(pop）
- 初始化
左高树合并图解

前言

看到左高树的时候，对左高树的印象大概只有左高树这三个字了。看的时候费劲了一点，因为不知道这个数据结构是干嘛的。网上的资料也比较少。所以这篇文章理解能力有限，请见谅。

左高树

什么是左高树?

左高树大致分为高度优先左高树和重量优先左高树两类。
本文以高度优先左高树为例。

左高树中定义了几个新的概念，比如外部节点、内部节点和扩充二叉树。

外部节点：一类特殊的节点，假设原本的树中节点x的任意孩子节点为空，可以将该指针指向外部节点。
内部节点：至少有一个孩子节点不为空的节点叫做内部节点。
扩充二叉树：增加了外部节点的二叉树。

我原以为这是很重要的概念，但是后面函数实现中却不曾用过。所以我暂且认为这几个概念是为了更形象的定义s(x)。

s(x)是一个函数，代表了内部节点x到其子树外部节点的最短路径。

如果x是外部节点，那么s(x）= 0。

如果x是内部节点 ,那么s(x) >= 1.

如果x的一个孩子s(x1) = 1,另一个孩子s(x2) = 2,那么s(x) = 2

一颗二叉树称为高度优先二叉树（height-biased leftist tree,HBLT）。当且仅当其任何一个内部节点的左孩子的s(x) 值都大于或等于右孩子的s值。

++++++++++++++++++++分割线+++++++++++++++++++++++++++++++++++++++++++

在之后的二叉树实现中，所有结点都为内部节点，即叶节点也为内部节点，且叶节点的s(x) = 1。也就是说外部节点隐式存在。

为什么要使用左高树?

书上的解释为堆(Heap)并不适合所有优先级队列的应用，尤其是当两个优先级队列或多个长度不同的队列需要合并时，需要使用左高树，左高树可在对数时间内实现两个优先级队列的合并。

假设有两个优先级队列，节点数为n、m。且n>m。
不考虑节点数的增长，用堆实现合并时间复杂度至少需要O(mlogn)，即一个节点一个节点插进去。
而左高树的可以在 O(log(mn)) 的时间复杂度下实现合并。

优势已经显现

撒，我们马上实现试试！

最大左高树实现及复杂度分析

最大左高树：是左高树也是大根树。
因为左高树需要表示优先级队列，需要维护节点的优先级，所以是一颗左高树的同时也需要是一颗大根/小根树。

节点类和最大左高树类

template <class T>
class HBLTNode
{friend MaxHBLT<T>;
public:HBLTNode(const T& e, const int s){data = e;this->s = s;leftChild = rightChild = NULL;}private:int s;T data;HBLTNode<T>* leftChild;HBLTNode<T>* rightChild;};// 最大HBLT类template <class T>
class MaxHBLT
{public:MaxHBLT(){root = NULL;}~MaxHBLT(){free(root);}const T& top(){if(!root) throw "Tree is empty.";}void push(const T& x);const T& pop();MaxHBLT<T>& meld(HBLTNode<T>& x){meld(root, x.root);x.root = NULL;return *this;}void initialize(T a[], int n);private:void free(HBLTNode* t);void meld(HBLTNode* x, HBLTNode* y);HBLTNode* root;
};

合并方法

template <class T>
void mexHBLT<T> :: meld(HBLTNode* x, HBLTNode* y)
{// 合并后左高树以x为根，返回x的指针if(y == NULL)return;if(x == NULL){x = y;return;}// x和y都不空，必要时交换x和y,直接交换节点地址，真ne到if(x->data < y->data)swap(x, y);// 目前x->data >= y->data// 继续在右路径合并meld(x->rightChild, y);// 因为swap函数不处理空对象，单独交换if(x->leftChild == NULL){x->leftChild = x->rightChild;x->rightChild = NULL;x->s = 1;}else // 如果右边的s(x)比左边大，不符合左高树规则，交换{if(x->leftChild->s < x->rightChild->s)swap(x->leftChild, x->rightChild);x->s = x->rightChild->s + 1;}
}

时间复杂度：

遍历沿右路径进行，所以递归次数应该为两个树根节点的s(x)加起来，设两个树的节点数目为m、n。那么两颗树的s(x)最大为log(m+1)、log(n+1)（因为s(x)小于等于完全二叉树的高度）。
那么时间复杂度为O(logm+logn) = O(log(mn))

插入(push)、删除(pop）

template <class T>
void MaxHBLT<T> :: push(const T& x)
{HBLTNode<T> *q = new HBLTNode<T>(x, 1);meld(root,q);
}template class<T>
const T& MaxHBLT<T> :: pop()
{T res;if(root == NULL)throw "The tree is empty.";res = root->data;HBLTNode<T>* l = root->leftChild;HBLTNode<T>* r = root->rightChild;delete root;root = l;meld(root, R);return res;
}

时间复杂度：

插入每次插入一个节点，逻辑为只有一个节点的树与原有的树合并，根据合并的时间复杂度，m = 1,插入时间复杂度为O(logn)。

删除的逻辑为删除根节点，分为两颗左高树，再将两颗树合并，时间复杂度为O(logn)。

初始化

template <class T>
void MaxHBLT<T> :: initialize(T a[], int n)
{Queue<HBLTNode<T>> q(n);free(root); //删除原来的树for(int i = 1; i <= n; i++){HBLTNode<T> *t = new HBLTNode(a[i], 1);q.push(t);}for(int i = 1; i <= n-1; i++){HBLTNode<T> *a = q.pop();HBLTNode<T> *b = q.pop();meld(a, b);q.push(a);}if(n > 0)root = q.pop();
}

时间复杂度：

初始化的逻辑为，假设有n个元素，提供一队列，每次pop出两颗树（一个节点也视为一颗左高树），合并后，加入队列，合并(n-1)次，队列中剩下的唯一一颗树变为实现完成的最大左高树。

为什么合并n-1次？

当n为偶数时
假设存在一个以2为公比的等比数列，由求和公式有以下等式成立：

第n项 = 前n-1项部分和 + 1

合并次数就是前n-1项部分和，节点个数便是第n项。
比如有8个元素，需要先合并4次，再合并2次，最后合并1次，共合并7次。

当n为奇数时
可视为在偶数的基础上加了一个元素，多一次合并操作，仍然还是需要合并n-1次。

左高树合并图解

因为左高树合并操作我没有找到很细致的图，在理解时捋的合并方法代码，不直观，便自己画了一个，希望可以帮助理解。