二叉树及其延伸：BST、AVL、SplayTree、SkipList

在学习基本数据结构过程中，我们常碰到二叉树，二叉树是一棵每个节点至多只有两个孩子的数，学习其常见的操作和变换可以参见我的另一篇博文《c++二叉树构建及面试常见问题代码实现》，在这儿，二叉树中引用得比较广的二叉搜索树（BSF）、平衡二叉树（AVL）及其AVL的常用替代结构伸展树（Splay Tree）和跳表（Skip List）。

二叉搜索树（BST）

• 介绍：二叉排序树（Binary Sort Tree）又称二叉查找树（Binary Search Tree），具有查找快速的特点，复制度logN，基本性质：左子树<节点<右子树，基本操作包括：插入、查找、删除。前两种比较简单，删除元素包括三种情况，代码中有详细介绍。
• 代码：

头文件：binaryTree.h

#ifndef __BINARYTREE_H__
#define __BINARYTREE_H__
#include <iostream>

//节点 
template<typename Element>
 class CTreeNode
 {
 	public:
	  Element key;
	  CTreeNode<Element> *lchild;
	  CTreeNode<Element> *rchild;
	  CTreeNode(Element value):key(value),lchild(NULL), rchild(NULL){};
	  ~CTreeNode(){lchild = NULL; rchild = NULL;};
 };
 
 //二叉树 
 template <typename Element>
 class CBinaryTree
 {
	 public:
		  CBinaryTree();
		  ~CBinaryTree();
		  bool treeEmpty();                                  //树是否为空
		  bool insertElement(Element value);                 //插入元素
		  bool reinsertElement(CTreeNode<Element> * &proot,Element value);	//使用递归的插入                          
		  void inorderTree(CTreeNode<Element> *root);        //中序遍历
		  CTreeNode<Element> * minValue(CTreeNode<Element> * root);     //返回最小值结点
		  CTreeNode<Element> * maxValue(CTreeNode<Element> * root);     //返回最大值结点
		  CTreeNode<Element> * search( Element value);                  //查找元素
		  bool deleteValue(Element value);                              //删除元素
		  CTreeNode<Element> * parent(CTreeNode<Element> * child);      //查找父结点
		  CTreeNode<Element> * postNode(CTreeNode<Element> * node);     //后继结点
		  void deleteTree(CTreeNode<Element> * root); 					//删除一棵树 
	 public:
		  CTreeNode<Element> *root;
 };
#endif

源文件：binaryTree.cpp

#include "binaryTree.h"
using namespace std;

//构造函数 
template<typename Element>
CBinaryTree<Element>::CBinaryTree()
{
 	root = NULL;
}

//析构函数 
template<typename Element>
CBinaryTree<Element>::~CBinaryTree()
{
	deleteTree(root);//释放空间 
 	root = NULL;
}

//判断树是否为空 
template<typename Element>
bool CBinaryTree<Element>::treeEmpty()
{
	 return root == NULL;
}

//插入元素 
template<typename Element>
bool CBinaryTree<Element>::insertElement(Element value)
{
	//找到插入点父节点q 
	 CTreeNode<Element> *p = root;
	 CTreeNode<Element> *q = NULL;
	 while ( p != NULL )
	 {
	  q = p;//记录要插入点的父节点 
	  if ( value < p->key )
	   p = p->lchild;
	  else if ( value > p->key ) p = p->rchild;
	  else return false;//表示有相同元素，插入不成功 
	 }
	 
	 if ( q == NULL )//树为空情况 
	 {
	  root = new CTreeNode<Element>(value);
	  return true;
	 }
	 
	 if ( value < q->key )//树不为空 
	 {
	  q->lchild = new CTreeNode<Element>(value);
	  return true;
	 }else
	 { 
	  q->rchild = new CTreeNode<Element>(value);
	  return true;
	 }
} 

//使用递归的插入,看起来更简洁 
template<typename Element>
bool CBinaryTree<Element>::reinsertElement(CTreeNode<Element> * &proot,Element value)
{
	if(!proot) 
	{
		proot=new CTreeNode<Element>(value);
		return true;
	}
	else if(value>proot->key) return reinsertElement(proot->rchild,value);
	else if(value<proot->key) return reinsertElement(proot->lchild,value);
	else return false;
}  


//中序遍历 
//二叉查找树一般只考虑中序遍历，因为中序遍历为有序数列 
template<typename Element>
void CBinaryTree<Element>::inorderTree(CTreeNode<Element> *root)
{
	 if ( root )
	 {
	  inorderTree(root->lchild);
	  cout<<root->key<<endl;
	  inorderTree(root->rchild);
	 }
}

//二叉树查找元素 ，也可以由递归的实现方法 
template<typename Element>
CTreeNode<Element> * CBinaryTree<Element>::search(Element value)
{
	 CTreeNode<Element> *p = root;
	 while ( p != NULL && p->key != value)
	 {
	  if ( value < p->key )
	   p = p->lchild;
	  else
	   p = p->rchild;
	 }
	 return p;
}

//得到父节点，主要用于删除元素时使用 
template<typename Element>
CTreeNode<Element> * CBinaryTree<Element>::parent(CTreeNode<Element> * child)
{
	 CTreeNode<Element> *p = root;
	 CTreeNode<Element> *q = NULL;
	 while ( p != NULL && p->key != child->key )
	 {
	  q = p;
	  if( p->key > child->key )
	  {
	   p = p->lchild;
	  }
	  else
	  {
	   p = p->rchild;
	  }
	 }
	 return q;
}

//得到最小值 
template<typename Element>
CTreeNode<Element> * CBinaryTree<Element>::minValue(CTreeNode<Element> * root)
{
	 if(!root)	return root; 
	 CTreeNode<Element> *p = root;
	 while ( p->lchild != NULL)
	 {
	  p = p->lchild;
	 }
	 return p;
}

//得到最大值 
template<typename Element>
CTreeNode<Element> * CBinaryTree<Element>::maxValue(CTreeNode<Element> * root)
{
	 if(!root)	return root; 
	 CTreeNode<Element> *p = root;
	 while ( p->rchild != NULL)
	 {
	  p = p->rchild;
	 }
	 return p;
}

//找到一个元素的后继元素 ，用于删除 
/*
这个程序值得分析，后继总共两种情况：
1.一个节点的右子树存在，则后继即为右子树的最小元素
2.右子树不存在，找父节点，往前回溯 
*/
template<typename Element>
CTreeNode<Element> * CBinaryTree<Element>::postNode(CTreeNode<Element> * node)
{
	 if( node->rchild != NULL )
	  return minValue(node->rchild);
	 CTreeNode<Element> *p = node;
	 CTreeNode<Element> *par = parent(p);
	 while ( par != NULL && par->rchild == p )
	 {
	  p = par;
	  par = parent(p);
	 }
	 return par;
}

//删除元素，分三种情况 
/*
1.叶子节点，直接删除 
2.有一个子树为空的节点，删除之后连接 
3.两个子树都不为空的节点，用后继节点替换，再删除后继节点 
当然了，这需要前面做好准备，写好求取父节点和后继元素的函数 
*/
template<typename Element>
bool CBinaryTree<Element>::deleteValue(Element Value)
{
	 CTreeNode<Element> * p = search(Value);
	 if(!p) return false; 
	 CTreeNode<Element> * q = NULL;
	 CTreeNode<Element> * s = NULL;
	 //情况1 
	 if ( p->lchild == NULL&&p->rchild == NULL )
	 {
	 	q=parent(p);
	 	if(q->lchild==p) q->lchild=NULL;
	 	else q->rchild=NULL;
	 	delete p;
	 	return true;
	 }else if(p->lchild == NULL||p->rchild == NULL)//情况2 
	 {
	 	q=parent(p);
	 	if(p->lchild)
	 	{
	 		if(q->lchild==p) q->lchild=p->lchild;
	 		else q->rchild=p->lchild;
		}else
		{
			if(q->lchild==p) q->lchild=p->rchild;
	 		else q->rchild=p->rchild;
		}
	 	delete p;
	 	return true;
	 }else//情况3 
	 {
	 	s=postNode(p);
	 	std::swap(s->key,p->key);
	 	return deleteValue(p->key);
	 } 
}

//删除一棵以root为根的树 
template<typename Element>
void CBinaryTree<Element>::deleteTree(CTreeNode<Element> * root)
{
	if(!root)
	{
		delete root;
		deleteTree(root->lchild);
		deleteTree(root->rchild);
	} 
} 

测试代码：

#include <iostream>
#include "binaryTree.h"
#include "binaryTree.cpp" //必不可少 
#include <cstdlib>
#include <ctime>
using namespace std;
int main()
{
 CBinaryTree<int> m_bTree;
 srand((unsigned)time(NULL));
 for(int i=0;i<20;i++)
	// m_bTree.insertElement(rand()%100);
	 m_bTree.reinsertElement(m_bTree.root,rand()%100);
 m_bTree.inorderTree(m_bTree.root);
 system("pause");
 m_bTree.deleteValue(m_bTree.maxValue(m_bTree.root)->key); 
 cout<<m_bTree.maxValue(m_bTree.root)->key<<endl;
 cout<<m_bTree.minValue(m_bTree.root)->key<<endl; 
}

平衡二叉树（AVL）

• 介绍：平衡二叉树是对二叉查找树的优化，为了解决二叉树插入变化过程中单链化，导致搜索效率降低的问题。这样平衡二叉树首先是一棵二叉查找树，这棵树的每个节点的平衡因子的绝对值不超过1，值得解释一下的是，节点的平衡因子表示节点左子树高度减去右子树高度。相对于BST，AVL增加的操作是通过四种旋转，保持二叉树的平衡。
• 代码：

头文件：AVLTree.h

#ifndef AVLTREE_H
#define AVLTREE_H

#include <iostream>
#include <list>
#include <utility>
using namespace std;

static const string PRINT_SPACES ="  ";

template <typename Object>
class AVLTree
{
public:
    AVLTree(){root=NULL;}								//构造函数 
    void insert(const Object &x)	{insert(x,root);}	//插入元素X 
    void remove(const Object &x)	{remove(x,root);}	//移除元素x 
    void print();										//打印AVLTree 

private:
    struct AVLnode
    {
        Object data;
        AVLnode *left;
        AVLnode *right;
        int height;	//还可以是平衡因子 
        AVLnode(Object ob,AVLnode *l,AVLnode *r,int h=0):data(ob),left(l),right(r),height(h){}
    };

    AVLnode *root;

    void insert(const Object &x,AVLnode * &t);

    void remove(const Object &x,AVLnode *&t);

    void leftSingleRotation(AVLnode * &t);
    void rightSingleRotation(AVLnode * &t);

    void leftDoubleRotation(AVLnode * &t);
    void rightDoubleRotation(AVLnode * &t);

    int height(AVLnode * &t)
    {
        //结点的高度,空结点的高度为-1
        return t==NULL?-1:t->height;
    }
    AVLnode * max_node(AVLnode * t)
    {
        if(!t)
            return NULL;
        if(t->right)
            return max_node(t->right);
        else
            return t;
    }

    AVLnode * min_node(AVLnode * t)
    {
        if(t)
            while(t->left)
                t=t->left;
        return t;
    }
};

#endif

源文件：AVLTree.cpp

#include "AVLTree.h" 
#include <cmath>
using namespace std;

template <typename Object>
void AVLTree<Object>::insert(const Object &x,AVLnode * &t)
{
    if(!t)//迭代终止条件，找到插入点 
        t=new AVLnode(x,NULL,NULL);
    else if(x<t->data)
    {
        insert(x,t->left);//最终插入之后 ，t为插入的父节点 
        if(height(t->left)-height(t->right)==2)//在左子树插入结点后,不可能右子树比左子树高2
            if(x<t->left->data)
                leftSingleRotation(t);//左单旋转
            else
                leftDoubleRotation(t);//左双旋转
        else//不需要调整就满足平衡条件的话,只需要重新计算其高度就好
            t->height=max(height(t->left),height(t->right))+1;
    }
    else if(x>t->data)
    {
        insert(x,t->right);
        if(height(t->right)-height(t->left)==2)
            if(x>t->right->data)
                rightSingleRotation(t);//右单旋转
            else
                rightDoubleRotation(t);//右双旋转
        else
            t->height=max(height(t->left),height(t->right))+1;
    }
    else return;//不考虑重复的值
}

template <typename Object>
void AVLTree<Object>::leftSingleRotation(AVLnode * &t)//左单旋转
{
    AVLnode *s=t->left;
    t->left=s->right;
    s->right=t;
    t->height=max(height(t->left),height(t->right))+1;//重新计算s和t的高度
    s->height=max(height(s->left),t->height)+1;
    t=s;
}

template <typename Object>
void AVLTree<Object>::rightSingleRotation(AVLnode * &t)
{
    AVLnode *s=t->right;
    t->right=s->left;
    s->left=t;
    t->height=max(height(t->left),height(t->right))+1;
    s->height=max(t->height,height(s->right))+1;
    t=s;
}

template <typename Object>
void AVLTree<Object>::leftDoubleRotation(AVLnode * &t)//左双旋转
{
    AVLnode *p=t->left;
    AVLnode *q=p->right;
    t->left=q->right;
    p->right=q->left;
    q->left=p;
    q->right=t;
    t->height=max(height(t->left),height(t->right))+1;//重新计算3个结点的高度
    p->height=max(height(p->left),height(p->right))+1;
    q->height=max(p->height,t->height)+1;
    t=q;
}

template <typename Object>
void AVLTree<Object>::rightDoubleRotation(AVLnode * &t)
{
    AVLnode *p=t->right;
    AVLnode *q=p->left;
    t->right=q->left;
    p->left=q->right;
    q->right=p;
    q->left=t;
    t->height=max(height(t->left),height(t->right))+1;
    p->height=max(height(p->left),height(p->right))+1;
    q->height=max(t->height,p->height)+1;
    t=q;
}

template <typename Object>
void AVLTree<Object>::remove(const Object &x,AVLnode *&t)
{
    if(!t)return;//没有找到要删除的值,do nothing
    if(x<t->data)
    {
        remove(x,t->left);
        if(height(t->right)-height(t->left)==2)
        {
            //右子树比左子树高2,那么在删除操作之前右子树比左子树高1,
            //也就是说t的右子树必然不为空,甚至必然有非空子树(高度至少为1).
            AVLnode *s=t->right;
            if(height(s->left)>height(s->right))
                rightDoubleRotation(t);//右双旋转
            else
                rightSingleRotation(t);//右单旋转
        }
        else
            //不需要调整就满足平衡条件的话,只需要重新计算其高度就好
            t->height=max(height(t->left),height(t->right))+1;
    }
    else if(x>t->data)
    {
        remove(x,t->right);
        if(height(t->left)-height(t->right)==2)
        {
            AVLnode *s=t->left;
            if(height(s->right)>height(s->left))
                leftDoubleRotation(t);//左双旋转
            else
                leftSingleRotation(t);//左单旋转
        }
        else
            t->height=max(height(t->left),height(t->right))+1;
    }
    else
    {
        if(t->left&&t->right)
        //t的左右子树都非空,把remove操作转移到只有一个非空子树的结点或者叶子结点上去
        {
            if(height(t->left)>height(t->right))
            //把remove操作往更高的那颗子树上转移
            {
                //左子树中的最大值
                t->data=max_node(t->left)->data;
                remove(t->data,t->left);
            }
            else
            {
                //右子树中的最小值
                t->data=min_node(t->right)->data;
                remove(t->data,t->right);
            }
        }
        else
        {
            AVLnode *oldnode=t;
            t=t->left?t->left:t->right;
            delete oldnode;
        }
    }
}

//使用队列层次遍历打印树
template <typename Object>
void AVLTree<Object>::print()
{
    if(!root)return;
    list<pair<AVLnode *,int> > lis;//int是标志位,0表示正常值,-1表示此处没有值,应打印空格
    lis.push_back(make_pair(root,0));
    AVLnode *em=new AVLnode(0,NULL,NULL);//一个空的点
    int count=1,j=0;//count表示当前行的最大结点数,j表示当前行已打印的结点数(空结点也计数)
    int hg=root->height;//当前行的高度,计算空格时使用

    while(hg>=0)//当hg<0时说明最后一行(树叶)已经打印完毕
    {
        while(j++!=count)
        {
            for(int i=1;i<pow(2,hg);i++)
                cout<<PRINT_SPACES;//打印前一部分空格
            if(lis.front().second==0)
                cout<<lis.front().first->data;
            else
                cout<<PRINT_SPACES;//int位为-1,则打印空格以对齐
            if(lis.front().first->left)//左子树入队
                lis.push_back(make_pair(lis.front().first->left,0));
            else
                lis.push_back(make_pair(em,-1));
            if(lis.front().first->right)//右子树入队
                lis.push_back(make_pair(lis.front().first->right,0));
            else
                lis.push_back(make_pair(em,-1));
            for(int i=0;i<pow(2,hg);i++)
                cout<<PRINT_SPACES;//打印后一部分空格
            lis.pop_front();
        }
        j=0;
        count*=2;//下一行的最大节点数是上一行的两倍
        --hg;//高度减1
        cout<<endl;    //换行
    }
    delete em;
    lis.clear();
}

测试代码：

#include "AVLTree.h" 
#include "AVLTree.cpp"
#include <cstdlib>
#include <ctime> 

int main()
{
	AVLTree<int> avl;
	srand((unsigned)time(NULL));
	for(int i=0;i<20;i++)
		avl.insert(rand()%100);
	avl.print();
	std::cout<<endl;
	avl.insert(123);
	avl.print();
	std::cout<<endl;
	avl.insert(124);//构造旋转 
	avl.print();
} 

伸展树（Splay）

• 介绍：伸展树是一棵二叉搜索树，是AVL树的一种挺好的替代结构，它要求每访问一个元素后，将新访问的元素移到树的根部，从而保证经常访问的元素靠近根节点而较少访问的元素位于树的较低层次上，这种将一个元素移到根部的操作叫做伸展。
• 代码：《伸展树c++ 实现》

跳表（Skip List）

• 介绍：有序的二分搜索有很高效的搜索效率，但是这种搜索方法不能在链表上进行，不适用于动态集，因为对于链表结构，难以有效计算中间节点的地址。跳表克服了这一问题，被认为是替代AVL的另一种选择，具有较好的搜索、插入、删除效率，并且易于实现。
• 代码：具体实现参见《跳跃表以及C++实现》