数据结构伸展树

声明：本文是对某高中生的竞赛论文学习的文章

介绍：

　　二叉查找树能够支持多种动态集合操作。对于一个含有n个结点的完全二叉树，这些操作的最还情况运行时间是O(lgn)，但如果树是含有n个结点的线性链，则这些操作的最坏情况运行时间为O(n)。而像红黑树、AVL树这种二叉查找树的变形在最坏情况下，仍能保持较好性能。

　　本文将要介绍的伸展树也是二叉查找树的变形，它对空间要求及编程难度的要求相对不高。

伸展树:

　　伸展树与二叉查找树一样，具有有序性。即伸展树的每一个结点x满足：该结点的左子树中的每个元素都小于x,而其右子树的每一个元素都大于x。与二叉查找树不同的是，伸展树可以自我调整，也就是伸展操作(Splay)。

　　伸展操作Splay(x,S)

　　　　伸展操作是在保持伸展树有序的前提下，通过一系列旋转将伸展树T中的元素x调整至树的根部。在调整的过程中，分以下三种情况处理：

　　　　　　1、结点x的父节点y是根节点。

　　　　　　　　这时，如果x是y的左孩子，我们进行一次Zig(右旋)操作；

　　　　　　　　　　　如果x是y的右孩子，我们进行一次Zag(左旋)操作；

　　　　　　　　　　

　　　　　　2、结点x的父节点y不是根节点，y的父节点为z。

　　　　　　　　且x与y同时是各自父节点的左孩子，这时我们进行Zig-Zig操作；

　　　　　　　　或者是同时是各自父节点的右孩子，这时我们进行一次Zag-Zag操作。

　　　　　　　　　　

　　　　　　3、结点x的父节点y不是根节点，y的父节点为z。

　　　　　　　　且x与y分别是其父节点的左孩子和右孩子，这时我们进行一次Zig-Zag操作。

 　　　　　　　 或者是x与y分别是其父节点的右孩子和左孩子，这时我们进行一次Zag-Zig操作。

　　　　　　　　　　

　　　　如下图所示，执行Splay(1,T)，将元素1调整的树根的位置，执行Splay(2)将元素2调整到树根的位置。从直观上看，树比原来“平衡”多了，而伸展操作的过　　　　程并不复杂，只需要左旋和右旋。

　　　　　　　　　　

　　基本操作：

　　　　　　利用Splay可以在伸展树上T上作如下操作，　　

　　　　　　查找：判断元素x是否在伸展树T表示的有序集中；

　　　　　　　　　跟二叉查找树的查找操作一样，在伸展树中查找x，如果x在伸展树中，则再执行Splay(x,T)调整伸展树。

　　　　　　插入：将元素x插入到伸展树T表示的有序集中；

　　　　　　　　　跟二叉查找树的插入操作一样，将元素x插入到伸展树的相应位置，在执行Splay(x,T)调整伸展树。

　　　　　　删除：将元素x从伸展树T表示的有序集中删除；

　　　　　　　　  首先，查找的元素x所在的位置，如果x没有孩子或者只有一个孩子，直接删除掉x，再对x的父节点执行Splay，将x的父节点调整到根位置。否　　　　　　　　　　则，查找x的后继y，用y代替x的位置，然后执行Splay(y,T)，将y调整到根节点位子。

　　　　　　合并：将两个伸展树T1、T2合并成一个伸展树。其中S1中的所有元素都小于T2中的元素。

　　　　　　　　　　首先，找到T1中最大的元素x，在执行Splay(x,T1)将x调整到T1的根位置，然后将T2作为x的右子树就得到新的伸展树T。

　　　　　　　　　　　　

　　　　　　划分：以元素x为边界，将伸展树T划分成两个伸展树T1和T2，其中，T1中的元素都小于x，T2中的元素都大于x。

　　　　　　　　　首先，执行查找操作，将元素x调整为根位置，x的左子树为T1，右子树为T2。

　　　　　　　　　　

　　　　　除了上述操作外，伸展树还可以有其他的操作。

时间复杂度：

　　　　　　所有的操作其平摊复杂度为O(lgn)。

程序实现：

package datastructure;  4 import java.util.List;
import java.util.ArrayList;

public class SplayTree {
    class TreeNode{
        private int key;
        private String data;
        private TreeNode left;
        private TreeNode right;
        private TreeNode parent;
        
        public TreeNode(int key,String data,TreeNode left,TreeNode right,TreeNode parent) {
            this.key = key;
            this.data = data;
            this.left = left;
            this.right = right;
            this.parent = parent;
        }
        public int getKey() {
            return key;            
        }
        public String toString(){
            String leftKey = (left == null ? " " : String.valueOf(left.key));
            String rightKey = (right == null ? " " : String.valueOf(right.key));
            return "(" + leftKey +"," +  key + "," + rightKey + ")";
        }
    }
    private TreeNode root = null;
    public boolean IsEmpty() 
    {
         if(root == null)
            {
                return true;
            }
            else
            {
                return false;
            }
    }
    public TreeNode Insert(int key) {
        TreeNode parentNode = null;
        TreeNode newNode = new TreeNode(key, "v", null, null, null);
        TreeNode pNode = root;
        if(pNode == null)
        {
            root = newNode;
            return root ;
        }
        while(pNode != null)
        {
            parentNode = pNode;
            if(key < pNode.key)
            {
                pNode = pNode.left;
            }
            else if(key > pNode.key)
            {
                pNode = pNode.right;                  
            }
            else
            {
                return pNode;//树中已存在与新结点的关键字相同的结点
            }
        }
        newNode.parent = parentNode;
        if(newNode.key < parentNode.key)
        {
            parentNode.left = newNode; 
            return parentNode.left;
        }
        else
        {
              parentNode.right = newNode;
              return parentNode.right;
        } 
       
        
    }
    private List<TreeNode> nodeList = new ArrayList<TreeNode>();
    
    public List<TreeNode> getNodeList() {
        return nodeList;
    }
    
    //获取中序列表
    public List<TreeNode> Inorder_SplayTree_WalkList()
    {
        if(nodeList != null)
        {
            nodeList.clear();
        }
        Inorder_SplayTree_Walk(root);
        return nodeList;
    }
    //中序遍历树
    private void Inorder_SplayTree_Walk(TreeNode root)
    {
        if(root != null)
        {
            Inorder_SplayTree_Walk(root.left);
            nodeList.add(root);
            Inorder_SplayTree_Walk(root.right);
        }
    }
    //给定关键字key,查找到该结点
    private TreeNode Search(int key)
    {
        TreeNode pNode = root;
        while(pNode != null && pNode.key != key)
        {
            if(key<pNode.key)
            {
                pNode = pNode.left;
            }
            else {
                pNode = pNode.right;
            }
        }
        return pNode;
    }
    //左旋转:x的右孩子y不空,以x与y之间的链为之架
    private void leftRotate(TreeNode pNode)
    {
        TreeNode xNode = pNode;
        TreeNode yNode = xNode.right;
        xNode.right = yNode.left;
        if(yNode.left != null)
        {
            yNode.left.parent = xNode;
        }
        yNode.parent = xNode.parent;
        if(xNode.parent == null)
        {
            root = yNode;
        }
        else if(xNode.parent.left == xNode)
        {
            xNode.parent.left = yNode;
        }else {
            xNode.parent.right = yNode;
        }
        yNode.left = xNode;
        xNode.parent = yNode;
    }
    //右旋转：x的左孩子y不空，以x与y之间的链为支架右旋转
    private void rightRotate(TreeNode pNode)
    {
        TreeNode xNode = pNode;
        TreeNode yNode = xNode.left;
        xNode.left = yNode.right;
        if(yNode.right != null)
        {
            yNode.right.parent = xNode;
        }
        yNode.parent = xNode.parent;
        if(xNode.parent == null)
        {
            root = yNode;
        }else if(xNode.parent.left == xNode)
        {
            xNode.parent.left = yNode;
        }
        else {
            xNode.parent.right = yNode;
        }
        yNode.right = xNode;
        xNode.parent = yNode;    
    }
    
    public void Splay(int key)
    {
        TreeNode xNode = Search(key);
        if(xNode == null)
        {
            return;
        }
        SplayT(xNode,this.root);
    }
    
    //伸展树的Splay操作展操作是在保持伸展树有序的前提下，
    //通过一系列旋转将伸展树T中的元素x调整至树的根部。
    //在调整的过程中，分以下三种情况处理：
    private void SplayT(TreeNode xNode,TreeNode Troot)
    {
        
        if(Troot == null || xNode == Troot)
        {
            return ;
        }
        while(xNode.parent != null) //x是否到达根位置
        {
            //　1、结点x的父节点y是根节点。
            if(xNode.parent == Troot)
            {
                if (xNode.parent.left == xNode)
                {
                    //如果x是y的左孩子，我们进行一次Zig(右旋)操作；
                    rightRotate(xNode.parent);
                }
                else 
                {
                    //如果x是y的右孩子，我们进行一次Zag(左旋)操作；
                    leftRotate(xNode.parent);
                }
            }
            else
            {
                //2、结点x的父节点y不是根节点，y的父节点为z。
                TreeNode yNode = xNode.parent;
                if(yNode != null)
                {
                    TreeNode zNode = yNode.parent;
                    if(xNode == yNode.left && yNode ==zNode.left)
                    {
                        //x与y同时是其父节点的左孩子
                        rightRotate(zNode);
                        rightRotate(yNode);
                    }
                    else if(xNode == yNode.right && yNode == zNode.right)
                    {
                        //x与y同时是其父节点的右孩子
                        leftRotate(zNode);
                        leftRotate(yNode);    
                    }else if (xNode==yNode.left && yNode == zNode.right) 
                    {
                        //x是其父节点的左孩子，y是父节点的右孩子
                        rightRotate(xNode.parent);
                        leftRotate(xNode.parent);    
                        
                    }else
                    {
                        //x是其父节点的右孩子，y是父节点的左孩子
                        leftRotate(xNode.parent);
                        rightRotate(xNode.parent);
                    }
                }
            }
                
        }        
    }
    //伸展树的查找操作    
    public void SplayTree_Search(int x,TreeNode Troot)
    {
        TreeNode xNode = Search(x);
        if(xNode == null)
        {
            return;    
        }
        SplayT(xNode, Troot);
    }
    //伸展树的插入操作
    public void SplayTree_Insert(int x,TreeNode Troot)
    {
        TreeNode xNode = Insert(x);
        if(xNode == null)
        {
            return;    
        }
        SplayT(xNode, Troot);
    }
    //伸展树的删除操作
    public void SplayTree_Delete(int x,TreeNode Troot) throws Exception
    {
        TreeNode xNode = Search(x);
        if(xNode == null)
        {
            throw new Exception("树中不存在要删除的元素x");
        }
        SplayTree_Remove(xNode,Troot);    
    }
    private void SplayTree_Remove(TreeNode xNode,TreeNode Troot) throws Exception
    {
        
        if(xNode == null)
        {
            return;
        }
        TreeNode parentNode = xNode.parent;
        if(xNode.left == null && xNode.right == null)
        {
            if(parentNode.left == xNode)
            {
                parentNode.left = null;
                SplayT(parentNode, Troot);
            }
            if(parentNode.right == xNode)
            {
                parentNode.right = null;
                SplayT(parentNode,Troot);
            }
        }
        if(xNode.left != null && xNode.right == null)
        {
            if(parentNode.left == xNode)
            {
                xNode.left.parent = parentNode;
                parentNode.left = xNode.left;
                SplayT(parentNode, Troot);
            }
            if(parentNode.right == xNode)
            {
                xNode.left.parent = parentNode;
                parentNode.right = xNode.left;
                SplayT(parentNode,Troot);
            }    
        }
        if(xNode.left == null && xNode.right != null)
        {
            if(parentNode.left == xNode)
            {
                xNode.right.parent = parentNode;
                parentNode.left = xNode.right;
                SplayT(parentNode, Troot);
            }
            if(parentNode.right == xNode)
            {
                xNode.right.parent = parentNode;
                parentNode.right = xNode.right;
                SplayT(parentNode, Troot);
            }
        }
        //x的左右儿子都不为空，就删除后继，让后继的内容，代替当前内容                          
        TreeNode successorNode = SplayTree_Successor(xNode);
        xNode.key = successorNode.key;
        xNode.data = successorNode.data;
        SplayTree_Remove(successorNode,Troot);
        SplayT(successorNode, Troot);
    }
    public TreeNode SplayTree_Successor(TreeNode xNode) throws Exception
    {
              if(xNode == null)
              {
                  return null;
              }
              TreeNode pNode = xNode;
              //若右子树不空，则为右子树中最小的关键字
              if(pNode.right != null)
              {
                  return Tree_Minimum(pNode.right);
              }
              TreeNode parentNode = xNode.parent;
              //若右子树为空，且x有一个后继y.则y是x的最低祖先结点，且y的左儿子也是x的祖先
              while(parentNode != null && pNode == parentNode.right)
              {
                  pNode = parentNode;
                  parentNode = pNode.parent;
               }
              return parentNode;     
    }
    public TreeNode Tree_Maxmum(TreeNode Troot) throws Exception
    {
        if(Troot == null)
        {
            throw new Exception("树为空");
        }
        TreeNode xNode = Troot;
        while(xNode.right != null)
        {
            xNode = xNode.right;
        }
        return xNode;
    }
    public TreeNode Tree_Minimum(TreeNode Troot) throws Exception
    {
        if(Troot == null)
        {
            throw new Exception("树为空");
        }
        TreeNode xNode = Troot;
        while(xNode.left != null)
        {
            xNode = xNode.left;
        }
        return xNode;    
    }
    public void SplayTree_Minimum(TreeNode Troot) throws Exception
    {
        TreeNode xNode = Tree_Minimum(Troot);
        if(xNode == null)
        {
            return;
        }
        SplayT(xNode,Troot);
    }
    public TreeNode SplayTree_Join(TreeNode Troot1,TreeNode Troot2) throws Exception
    {
        TreeNode xNode = Tree_Maxmum(Troot1);
        if(xNode == null)
        {
            return null;
        }
        SplayT(xNode, Troot1);
        xNode.right = Troot2;
        Troot2.parent = xNode;
        return xNode;
        
    }
    
}