数据结构—二叉查找树

　　查找树是一种数据结构，二叉查找树是按二叉树结构来组织的。可以用链表结构表示，其中每一个结点就是一个对象。结点中包括：key、数据、left、right、p。其中left、right和p分别指向左儿子，右儿子和父结点。

　　二叉查找树中的关键字总是满足二叉查找树的性质：y是x左子树上的结点，则key[y]≤key[x]，如果y是x右子树上的结点，则key[y]≥key[x]。

　　遍历：

　　根据二叉查找树的性质，可以用一个递归算法按排列顺序输出树中的所有关键字。这种是中序遍历算法：因为一子树根的关键字在输出时介于左子树和右子树的关键字之间。那么，根据根所在的不同位置，还有前序遍历和后序遍历。

//中序递归遍历二叉树
    public void Inorder_Tree_Walk(TreeNode root)
    {
        if(root!=null)
        {
            Inorder_Tree_Walk(root.leftChild);
            nodeList.add(root);
            Inorder_Tree_Walk(root.rightChild);
        }
        
        
    }

　　查询：

　　在树中查找给定的关键字。下面代码从树的根节点开始进行查找，并沿着树下降。碰到节点x就比较节点x的key与给定k值比较。如果相同，则查找结束。如果k小于key[x]，则继续查找x的左子树，根据二叉查找树的性质可知，k不可能在x的右子树中。对称地，如果k大于key[x]，则继续查找x 的右子树。运行时间是O（lgn）。

//查找给定关键字k
        public TreeNode Tree_Seach(int key)
        {
            TreeNode pNode = root;
            while(pNode!=null && pNode.key != key)
            {
                if (key<pNode.key)
                    pNode = pNode.leftChild;
                else
                    pNode = pNode.rightChild;
            }
            return pNode;  
        }

　　最大最小关键字：

　　要查找二叉树中的最小关键字元素，只要从根节点开始，沿着各结点的left指针查找下去，直到遇到null为止，而要找到最大关键字元素，就沿着各节点right指针查找。　

  public TreeNode Tree_Minimum(TreeNode node) throws Exception
        {
            if(node == null)
            {
                throw new Exception("树为空");
            }
            TreeNode pNode  = node;
            while(pNode.leftChild != null)
            {
                pNode = pNode.leftChild;
            }
            return pNode;
        }
        public  TreeNode Tree_Maximum(TreeNode node)throws Exception
        {
            if(node == null)
            {
                throw new Exception("树为空");
            }
            TreeNode pNode = node;
            while(pNode.rightChild != null)
            {
                pNode = pNode.rightChild;
            }
            return pNode;
        }      

　　前趋和后继

　　　　给定一个二叉查找树中的结点，要求找出中序遍历下它的后继。就是：某结点x的后继，具有大于key[x]中的关键字中最小者的结点。根据二叉查找树的结构，不用进行比较就可以找到结点的后继。

　　　　后继：一、如果x的右子树不空，后继就是右子树中最小值。二、如果x的右子树为空，则x的后继是x的最低祖先结点，且后继的左儿子是x的祖先。如下代码：

public TreeNode Tree_Successor(TreeNode node) throws Exception
      {
          if(node == null)
          {
              return null;
          }
          TreeNode pNode = node;
          //若右子树不空，则为右子树中最小的关键字
          if(pNode.rightChild != null)
          {
              return Tree_Minimum(pNode.rightChild);
          }
          TreeNode parentNode = node.parent;
          //若右子树为空，且x有一个后继y.则y是x的最低祖先结点，且y的左儿子也是x的祖先
          while(parentNode != null && pNode == parentNode.rightChild)
          {
              pNode = parentNode;
              parentNode = pNode.parent;
           }
          return parentNode;     
      }

　　前驱：前驱和后继是对称的。一、如果x的左子树不空，前驱就是左子树中最大值。二、如果x的左子树为空，则x的前驱是x的最低祖先结点，且前驱的左儿子是x的祖先。

public TreeNode precessor(TreeNode node) throws Exception
      {
          TreeNode pNode = node;
          TreeNode parentNode = pNode.parent;
          if(pNode == null)
          {
              return null;
          }
          if(pNode.leftChild != null)
          {
              return Tree_Maximum(pNode.leftChild);
          }
          while(parentNode != null && pNode == parentNode.leftChild)
          {
              pNode = parentNode;
              parentNode = parentNode.parent;
          }
          return parentNode;
      }

 插入：将新的元素v插入树中，可以调用Tree_Insert过程。该过程的输入参数是一个结点z，且key[z] = v，z.leftChild = null，z.rightChild = null。该过程修改树T和z的域，并把z插入到树中适当的位置。运行时间为O（lgn）

　　

public void insert(int key)
      {
          TreeNode parentNode = null;
          TreeNode newNode = new TreeNode(key, "v", null, null, null);
          TreeNode pNode = root;
          if(root == null)
          {
              root = newNode;
              return ;
          }
          while(pNode != null)
          {
              parentNode = pNode;
              if(key < pNode.key)
              {
                  pNode = pNode.leftChild;
              }
              else if(key > pNode.key)
              {
                  pNode = pNode.rightChild;                  
              }
              else
              {
                  return;//书中已存在与新结点的关键字相同的结点
              }
          }
          newNode.parent = parentNode;
          if(newNode.key < parentNode.key)
          {
              parentNode.leftChild = newNode;   
          }
          else
          {
                parentNode.rightChild = newNode;
          }              
       }

删除：将给定结点z从二叉查找树中删除的过程：一、如果z没有子女，则修改其父节点z.parent，使其子女为空；二、如果z只有一个子女，则可以通过在其子结点和父节点之间建立一条链来删除z。三、如果z有两个子女，先删除z的后继y(y没有子女)，再用y的内容代替z的内容。运行时间为O(lgn)。

　　

  public  void Delete(int key) throws  Exception
      {
        TreeNode pNode = Tree_Seach(key);
        if(pNode == null)
        {
            throw new Exception("树中不存在要删除的关键字！");
        }
        Tree_Delete(pNode);
          
      }
      private  void Tree_Delete(TreeNode pNode) throws Exception
      {
          if(pNode == null)
          {
              return ;
          }
          TreeNode parentNode = pNode.parent;
          if(pNode.leftChild == null && pNode.rightChild == null)
          {
              if(parentNode.leftChild == pNode)
              {
                  parentNode.leftChild = null; 
              }
              else
              {
                  parentNode.rightChild = null;
              }
              return;             
          }
          if(pNode.leftChild == null && pNode.rightChild != null)
          {
              if(pNode == parentNode.leftChild)
              {
                  parentNode.leftChild = pNode.rightChild;
                  pNode.rightChild.parent = parentNode;
              }
              else
              {
                  parentNode.rightChild = pNode.rightChild;
                  pNode.rightChild.parent = parentNode;
              }
              return;
          }
          if(pNode.leftChild != null && pNode.rightChild == null)
          {
              if(pNode == parentNode.leftChild)
              {
                  parentNode.leftChild = pNode.leftChild;
                  pNode.leftChild.parent = parentNode;
              }
              else
              {
                  parentNode.rightChild = pNode.leftChild;
                  pNode.leftChild.parent = parentNode;
              }
              return;
          }        
          //左右儿子都不为空，就删除后继，让后继的内容，代替当前内容
          TreeNode successorNode = Tree_Successor(pNode);
          pNode.key = successorNode.key;
          pNode.data = successorNode.data;
          Tree_Delete(successorNode);
      }

 程序实现：

　　

package agrith;

import java.util.List;
import java.util.ArrayList;

public class BiSeachTree {    
     class TreeNode{
        private int key;
        private String data;
        private TreeNode leftChild;
        private TreeNode rightChild;
        private TreeNode parent;
        
        public TreeNode(int key,String data,TreeNode leftChild,TreeNode rightChild,TreeNode parent)
        {
            
            this.key = key;
                        this.data =data;
            this.leftChild = leftChild;
            this.rightChild = rightChild;
            this.parent = parent;
        }
        public int getKey()
        {
            return key;
        }
        public String toString()
        {
            String leftKey = (leftChild == null?" ":String.valueOf(leftChild.key));
            String rightKey = (rightChild == null?" ":String.valueOf(rightChild.key));
            return "("+leftKey+","+key+","+rightKey+")";
        }    
    }
    
    private TreeNode root = null;
    private List<TreeNode> nodeList = new ArrayList<TreeNode>();
    
    //获取中序二叉树列表
    public List<TreeNode> Inorder_Tree_WalkList()
    {
        
        if(nodeList != null )
        {
            nodeList.clear();
        }
        Inorder_Tree_Walk(root);
        return nodeList;
        
    }
    //中序递归遍历二叉树
    public void Inorder_Tree_Walk(TreeNode root)
    {
        if(root!=null)
        {
            Inorder_Tree_Walk(root.leftChild);
            nodeList.add(root);
            Inorder_Tree_Walk(root.rightChild);
        }        
    }
        //查找给定关键字k 非递归版本运行的快
        public TreeNode Tree_Seach(int key)
        {
            TreeNode pNode = root;
            while(pNode!=null && pNode.key != key)
            {
                if (key<pNode.key)
                    pNode = pNode.leftChild;
                else
                    pNode = pNode.rightChild;
            }
            return pNode;  
        }
         public TreeNode Tree_Minimum(TreeNode node) throws Exception
        {
            if(node == null)
            {
                throw new Exception("树为空");
            }
            TreeNode pNode  = node;
            while(pNode.leftChild != null)
            {
                pNode = pNode.leftChild;
            }
            return pNode;
        }
        public  TreeNode Tree_Maximum(TreeNode node)throws Exception
        {
            if(node == null)
            {
                throw new Exception("树为空");
            }
            TreeNode pNode = node;
            while(pNode.rightChild != null)
            {
                pNode = pNode.rightChild;
            }
            return pNode;
        }     
      public TreeNode Tree_Successor(TreeNode node) throws Exception
      {
          if(node == null)
          {
              return null;
          }
          TreeNode pNode = node;
          //若右子树不空，则为右子树中最小的关键字
          if(pNode.rightChild != null)
          {
              return Tree_Minimum(pNode.rightChild);
          }
          TreeNode parentNode = node.parent;
          //若右子树为空，且x有一个后继y.则y是x的最低祖先结点，且y的左儿子也是x的祖先
          while(parentNode != null && pNode == parentNode.rightChild)
          {
              pNode = parentNode;
              parentNode = pNode.parent;
           }
          return parentNode;  
      }
      public TreeNode Tree_precessor(TreeNode node) throws Exception
      {
          TreeNode pNode = node;
          TreeNode parentNode = pNode.parent;
          if(pNode == null)
          {
              return null;
          }
          if(pNode.leftChild != null)
          {
              return Tree_Maximum(pNode.leftChild);
          }
          while(parentNode != null && pNode == parentNode.leftChild)
          {
              pNode = parentNode;
              parentNode = parentNode.parent;
          }
          return parentNode;
      }
      public void Tree_Insert(int key)
      {
          TreeNode parentNode = null;
          TreeNode newNode = new TreeNode(key, "v", null, null, null);
          TreeNode pNode = root;
          if(root == null)
          {
              root = newNode;
              return ;
          }
          while(pNode != null)
          {
              parentNode = pNode;
              if(key < pNode.key)
              {
                  pNode = pNode.leftChild;
              }
              else if(key > pNode.key)
              {
                  pNode = pNode.rightChild;                  
              }
              else
              {
                  return;//书中已存在与新结点的关键字相同的结点
              }
          }
          newNode.parent = parentNode;
          if(newNode.key < parentNode.key)
          {
              parentNode.leftChild = newNode;   
          }
          else
          {
                parentNode.rightChild = newNode;
          }              
       }
    public boolean  IsEmpty()
    {
        if(root == null)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    public void  TreeEmpty() throws Exception
    {
        if(IsEmpty())
        {
            throw new Exception("树空异常！");
        }
    }
    //返回二叉查找树的关键字的有序链表
    public String toStringofOrderList(){
        StringBuilder sbBuilder = new  StringBuilder("[");
        for(TreeNode p :Inorder_Tree_WalkList())
        {
            sbBuilder.append(p.key);
            sbBuilder.append(" ");
        }
        sbBuilder.append("]");
        return sbBuilder.toString();
    }
    //返回二叉查找树的字符串表示
    public  String toString()
    {
        StringBuilder sbBuilder = new StringBuilder("[");
        for(TreeNode p:Inorder_Tree_WalkList())
        {
            sbBuilder.append(p);
            sbBuilder.append(" ");
        }
        sbBuilder.append("]");
        return sbBuilder.toString();
    }
    public TreeNode getRoot()
    {
        return root;
    }
}


/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package agrith;

import javax.swing.tree.TreeNode;

/**
 *
 * @author ning
 */
public class TreeMain {
    public static  void main(String [] args) throws Exception
    {
        try{
        BiSeachTree biTree = new BiSeachTree();
        System.out.println("二叉树是否为空？" + (biTree.IsEmpty()?"是":"否"));
        int [] keys = new int[]{ 15, 6, 18, 3, 7, 13, 20, 2, 9, 4 };
        for(int key:keys)
        {
            biTree.Tree_Insert(key);
        }
        System.out.println("二叉树是否为空？" + (biTree.IsEmpty()?"是":"否"));
        BiSeachTree.TreeNode minTreeNode = biTree.Tree_Minimum(biTree.getRoot());
        System.out.println("最小关键字："+minTreeNode.getKey());
        BiSeachTree.TreeNode maxTreeNode = biTree.Tree_Maximum(biTree.getRoot()); 
        System.out.println("最大关键字："+maxTreeNode.getKey());
        test(biTree, maxTreeNode);
        System.out.println("根结点的关键字："+biTree.getRoot().getKey());
        TestTraverse(biTree);
        }catch(Exception e)
        {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }
    public static void TestTraverse(BiSeachTree biTree)
    {
        System.out.println("遍历二叉树：" + biTree );
        System.out.println("二叉树转化为有序链表："+ biTree.toStringofOrderList());
    }
    public static  void test(BiSeachTree BiTree,BiSeachTree.TreeNode pNode) throws Exception
    {
        System.out.println("本结点: " + pNode);  
        System.out.println("前趋结点: " + BiTree.Tree_precessor(pNode));  
        System.out.println("后继结点: " + BiTree.Tree_Successor(pNode));  
    }
    
}