程序博客网 > 知达常青藤中学校简介

二叉查找树 (转载)

来源：互联网 发布：知达常青藤中学校简介 编辑：程序博客网 时间：2024/06/02 03:23
二叉查找树

                 二叉查找树（Binary Search Tree），或者是一颗空树，或者是具有下列性质的二叉树：

                       1、若它的左子树不空，则其左子树上的所有结点的值均小于它根结点的值；

                       2、若它的右子树不空，则其右子树上的所有结点的值均大于它根结点的值；

                       3、它的左、右子树也分别为二叉查找树。

                                                  

                 二叉查找树是基于二叉树的，其结点数据结构定义为如下：

[java] view plaincopyprint?
  1. /**结点数据结构*/  
  2. static class BinaryNode<T>  
  3. {  
  4.     T data;  
  5.     BinaryNode<T> left;  
  6.     BinaryNode<T> right;  
  7.     public BinaryNode(T data) {  
  8.         this(data,null,null);  
  9.     }  
  10.     public BinaryNode( T data, BinaryNode<T> left, BinaryNode<T> right) {  
  11.         this.data =data;  
  12.         this.left = left;  
  13.         this.right =right;  
  14.     }  
  15.     public BinaryNode()  
  16.     {  
  17.         data =null;  
  18.         this.left = left;  
  19.         this.right =right;  
  20.     }  
  21. }  

                 现在明白了什么是二叉查找树，那么二叉查找书的基本操作又是如何来实现的呢？                

          查找操作

                       在二叉查找树中查找x的过程如下：

                             1、若二叉树是空树，则查找失败。

                             2、若x等于根结点的数据，则查找成功，否则。

                             3、若x小于根结点的数据，则递归查找其左子树，否则。

                             4、递归查找其右子树。

                     根据上述的步骤，写出其查找操作的代码：

[java] view plaincopyprint?
  1. /**查找指定的元素,默认从 
  2.     * 根结点出开始查询*/  
  3.    public boolean contains(T t)  
  4.    {  
  5.       return contains(t, rootTree);  
  6.          
  7.    }  
  8.  /**从某个结点出开始查找元素*/  
  9.    public boolean contains(T t, BinaryNode<T> node)  
  10.    {  
  11.       if(node==null)  
  12.         return false;//结点为空，查找失败  
  13.       int result = t.compareTo(node.data);  
  14.        if(result>0)  
  15.           return contains(t,node.right);//递归查询右子树  
  16.       else if(result<0)  
  17.           return contains(t, node.left);//递归查询左子树    
  18.       else  
  19.           return true;  
  20.    }  
  21.     /** 
  22.        这里我提供一个对二叉树最大值 
  23.        最小值的搜索*/  
  24.    
  25.   
  26.  /**找到二叉查找树中的最小值*/  
  27.    public T findMin()  
  28.    {  
  29.       if(isEmpty())  
  30.       {  
  31.           System.out.println("二叉树为空");  
  32.           return null;  
  33.       }else  
  34.        return findMin(rootTree).data;  
  35.          
  36.    }  
  37.    /**找到二叉查找树中的最大值*/  
  38.    public T findMax()  
  39.    {  
  40.        if(isEmpty())  
  41.           {  
  42.               System.out.println("二叉树为空");  
  43.               return null;  
  44.           }else  
  45.            return findMax(rootTree).data;  
  46.    }  
  47.   
  48. /**查询出最小元素所在的结点*/  
  49.    public BinaryNode<T> findMin(BinaryNode<T> node)  
  50.    {  
  51.        if(node==null)  
  52.            return null;  
  53.        else if(node.left==null)  
  54.            return node;  
  55.        return findMin(node.left);//递归查找  
  56.    }  
  57.    /**查询出最大元素所在的结点*/  
  58.    public BinaryNode<T> findMax(BinaryNode<T> node)  
  59.    {  
  60.        if(node!=null)  
  61.        {  
  62.            while(node.right!=null)  
  63.                node=node.right;  
  64.        }  
  65.        return node;         
  66.    }  

           插入操作

                     二叉树查找树b插入操作x的过程如下：

                        1、若b是空树，则直接将插入的结点作为根结点插入。

                        2、x等于b的根结点的数据的值，则直接返回，否则。

                        3、若x小于b的根结点的数据的值，则将x要插入的结点的位置改变为b的左子树，否则。

                        4、将x要出入的结点的位置改变为b的右子树。

               代码实现如下：

[java] view plaincopyprint?
  1. /**插入元素*/  
  2.    public void insert(T t)  
  3.    {  
  4.        rootTree = insert(t, rootTree);  
  5.    }  
  6. /**在某个位置开始判断插入元素*/  
  7.    public BinaryNode<T> insert(T t,BinaryNode<T> node)  
  8.    {  
  9.        if(node==null)  
  10.        {  
  11.            //新构造一个二叉查找树   
  12.            return new BinaryNode<T>(t, null, null);  
  13.        }  
  14.        int result = t.compareTo(node.data);  
  15.        if(result<0)  
  16.           node.left= insert(t,node.left);  
  17.        else if(result>0)  
  18.           node.right= insert(t,node.right);  
  19.        else  
  20.            ;//doNothing   
  21.        return node;  
  22.    }  

          删除操作

                         对于二叉查找树的删除操作（这里根据值删除，而非结点）分三种情况：

                   不过在此之前，我们应该确保根据给定的值找到了要删除的结点，如若没找到该结点

                   不会执行删除操作！

                      下面三种情况假设已经找到了要删除的结点。

                        1、如果结点为叶子结点（没有左、右子树），此时删除该结点不会玻化树的结构

                             直接删除即可，并修改其父结点指向它的引用为null.如下图:

               

                       2、如果其结点只包含左子树，或者右子树的话，此时直接删除该结点，并将其左子树

                              或者右子树设置为其父结点的左子树或者右子树即可，此操作不会破坏树结构。
                
                          

                       3、 当结点的左右子树都不空的时候，一般的删除策略是用其右子树的最小数据

                            （容易找到）代替要删除的结点数据并递归删除该结点（此时为null），因为

                              右子树的最小结点不可能有左孩子，所以第二次删除较为容易。

                               z的左子树和右子树均不空。找到z的后继y，因为y一定没有左子树，所以可以删除y，

                              并让y的父亲节点成为y的右子树的父亲节点，并用y的值代替z的值.如图：

                   

                  删除操作源码：

[java] view plaincopyprint?
  1. /**删除元素*/  
  2.    public void remove(T t)  
  3.    {  
  4.        rootTree = remove(t,rootTree);  
  5.    } /**在某个位置开始判断删除某个结点*/  
  6.    public BinaryNode<T> remove(T t,BinaryNode<T> node)  
  7.    {  
  8.        if(node == null)  
  9.            return node;//没有找到,doNothing  
  10.        int result = t.compareTo(node.data);  
  11.        if(result>0)  
  12.            node.right = remove(t,node.right);  
  13.        else if(result<0)  
  14.            node.left = remove(t,node.left);  
  15.        else if(node.left!=null&&node.right!=null)  
  16.        {  
  17.            node.data = findMin(node.right).data;  
  18.            node.right = remove(node.data,node.right);  
  19.        }  
  20.        else  
  21.            node = (node.left!=null)?node.left:node.right;  
  22.        return node;  
  23.              
  24.    }  

             完整源码

[java] view plaincopyprint?
  1. <P></P><PRE class=java name="code">package com.kiritor;  
  2. /** 
  3.  * Java实现二叉查找树 
  4.  * @author Kiritor 
  5.  * @param <T>*/  
  6. public class BinarySearchTree<T extends Comparable<? super T>> {  
  7.     
  8.  /**结点数据结构*/  
  9.  static class BinaryNode<T>  
  10.     {  
  11.         T data;  
  12.         BinaryNode<T> left;  
  13.         BinaryNode<T> right;  
  14.         public BinaryNode(T data) {  
  15.             this(data,null,null);  
  16.         }  
  17.         public BinaryNode( T data, BinaryNode<T> left, BinaryNode<T> right) {  
  18.             this.data =data;  
  19.             this.left = left;  
  20.             this.right =right;  
  21.         }  
  22.         public BinaryNode()  
  23.         {  
  24.             data =null;  
  25.             this.left = left;  
  26.             this.right =right;  
  27.         }  
  28.     }  
  29.      
  30.    private BinaryNode<T> rootTree;  
  31.    /**构造一颗空的二叉查找树*/  
  32.    public BinarySearchTree()  
  33.    {  
  34.        rootTree = null;  
  35.    }  
  36.    /**清空二叉查找树*/  
  37.    public void clear()  
  38.    {  
  39.        rootTree = null;  
  40.    }  
  41.    /**判断是否为空*/  
  42.    public boolean isEmpty()  
  43.    {  
  44.        return rootTree == null;  
  45.    }  
  46.    /**查找指定的元素,默认从 
  47.     * 根结点出开始查询*/  
  48.    public boolean contains(T t)  
  49.    {  
  50.       return contains(t, rootTree);  
  51.          
  52.    }  
  53.    /**找到二叉查找树中的最小值*/  
  54.    public T findMin()  
  55.    {  
  56.       if(isEmpty())  
  57.       {  
  58.           System.out.println("二叉树为空");  
  59.           return null;  
  60.       }else  
  61.        return findMin(rootTree).data;  
  62.          
  63.    }  
  64.    /**找到二叉查找树中的最大值*/  
  65.    public T findMax()  
  66.    {  
  67.        if(isEmpty())  
  68.           {  
  69.               System.out.println("二叉树为空");  
  70.               return null;  
  71.           }else  
  72.            return findMax(rootTree).data;  
  73.    }  
  74.    /**插入元素*/  
  75.    public void insert(T t)  
  76.    {  
  77.        rootTree = insert(t, rootTree);  
  78.    }  
  79.    /**删除元素*/  
  80.    public void remove(T t)  
  81.    {  
  82.        rootTree = remove(t,rootTree);  
  83.    }  
  84.    /**打印二叉查找树*/  
  85.    public void printTree()  
  86.    {  
  87.         
  88.    }  
  89.    /**从某个结点出开始查找元素*/  
  90.    public boolean contains(T t, BinaryNode<T> node)  
  91.    {  
  92.       if(node==null)  
  93.         return false;  
  94.       int result = t.compareTo(node.data);  
  95.       if(result>0)  
  96.           return contains(t,node.right);  
  97.       else if(result<0)  
  98.           return contains(t, node.left);  
  99.       else  
  100.           return true;  
  101.    }  
  102.    /**查询出最小元素所在的结点*/  
  103.    public BinaryNode<T> findMin(BinaryNode<T> node)  
  104.    {  
  105.        if(node==null)  
  106.            return null;  
  107.        else if(node.left==null)  
  108.            return node;  
  109.        return findMin(node.left);//递归查找  
  110.    }  
  111.    /**查询出最大元素所在的结点*/  
  112.    public BinaryNode<T> findMax(BinaryNode<T> node)  
  113.    {  
  114.        if(node!=null)  
  115.        {  
  116.            while(node.right!=null)  
  117.                node=node.right;  
  118.        }  
  119.        return node;      
  120.    }  
  121.    /**在某个位置开始判断插入元素*/  
  122.    public BinaryNode<T> insert(T t,BinaryNode<T> node)  
  123.    {  
  124.        if(node==null)  
  125.        {  
  126.            //新构造一个二叉查找树   
  127.            return new BinaryNode<T>(t, null, null);  
  128.        }  
  129.        int result = t.compareTo(node.data);  
  130.        if(result<0)  
  131.           node.left= insert(t,node.left);  
  132.        else if(result>0)  
  133.           node.right= insert(t,node.right);  
  134.        else  
  135.            ;//doNothing   
  136.        return node;  
  137.    }  
  138.    /**在某个位置开始判断删除某个结点*/  
  139.    public BinaryNode<T> remove(T t,BinaryNode<T> node)  
  140.    {  
  141.        if(node == null)  
  142.            return node;//没有找到,doNothing  
  143.        int result = t.compareTo(node.data);  
  144.        if(result>0)  
  145.            node.right = remove(t,node.right);  
  146.        else if(result<0)  
  147.            node.left = remove(t,node.left);  
  148.        else if(node.left!=null&&node.right!=null)  
  149.        {  
  150.            node.data = findMin(node.right).data;  
  151.            node.right = remove(node.data,node.right);  
  152.        }  
  153.        else  
  154.            node = (node.left!=null)?node.left:node.right;  
  155.        return node;  
  156.              
  157.    }  
  158.    public BinaryNode<Integer> init()  
  159.    {  
  160.        BinaryNode<Integer> node3 = new BinaryNode<Integer>(3);  
  161.        BinaryNode<Integer> node1 = new BinaryNode<Integer>(1);  
  162.        BinaryNode<Integer> node4 = new BinaryNode<Integer>(4,node3,null);  
  163.        BinaryNode<Integer> node2 = new BinaryNode<Integer>(2,node1,node4);  
  164.        BinaryNode<Integer> node8 = new BinaryNode<Integer>(8);  
  165.        BinaryNode<Integer> root = new BinaryNode<Integer>(6,node2,node8);  
  166.        return root;  
  167.    }  
  168.     public void preOrder(BinaryNode node) {  
  169.         if (node != null) {  
  170.             System.out.print(node.data);  
  171.             preOrder(node.left);  
  172.             preOrder(node.right);  
  173.         }  
  174.     }  
  175.       /*简单测试*/   
  176.       public static void main(String[] args) {  
  177.         BinarySearchTree  searchTree = new BinarySearchTree<>();  
  178.         BinaryNode<Integer> node= searchTree.init();  
  179.         searchTree.rootTree=node;  
  180.         searchTree.preOrder(searchTree.rootTree);  
  181.         searchTree.remove(4);  
  182.         searchTree.preOrder(searchTree.rootTree);  
  183.     }  
  184.      
  185. }      </PRE>  
  186. <PRE></PRE>  
  187. <PRE></PRE>  
  188. <PRE></PRE>  
  189. <PRE></PRE>  
知达常青藤中学校简介 知达常青藤中学校简介
原创粉丝点击
热门IT博客
制导的主要算法制导的主要算法
网络上mc是什么意思啊网络上mc是什么意思啊
红蜘蛛多媒体教学软件
outlook是什么软件
易语言窗口同步器源码
潘多拉 网络共享
elk优化
传热计算软件
天猫和淘宝哪个正品多
yum命令安装
淘宝分期免息怎么设置
mac os显示桌面快捷键
年度总结数据分析
正版ps软件多少钱
电脑网络机柜
淘宝激光炮的原理
淘宝充值劲舞团未到账
北京四达时代 知乎
电脑怎么修改游戏数据
豆瓣知乎都是什么人
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 个税核定征收 个税纳税筹划 个税的计算方法 个税可以补缴吗 个税缴纳方法 个税申报系统下载 年终奖个税筹划 个税手续费返还 个税优惠政策 个税起征点调整时间 个税可以补交吗 劳务派遣个税 外籍人员个税起征点 个税计算器下载 个税倒算计算器 交个税的会计分录 个税怎样计算 个税征收标准 如何补交个税 劳务个税计算器 房产交易个税 年收入12万个税申报 个税起征点的调整 个税申报日期 个税起征点4800 劳务费个税计算器 个税申报软件 个税报税流程 房产个税怎么算 个税申报期限 个税免税项目 如何计算个税 个税缴纳标准 二手房个税营业税 提高个税起征点 可以补交个税吗 房屋个税怎么算 个税计算方式 个税的会计分录 个税扣除项目 个税手续费返还政策

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里