为了克服对树结构编程的恐惧感,决心自己实现一遍二叉查找树,以便掌握关于树结构编程的一些技巧和方法。以下是基本思路:

[1] 关于容器与封装。封装,是一种非常重要的系统设计思想;无论是面向过程的函数,还是面向对象的对象,都是实现抽象和封装的技术手段。要使系统更加安全更具可维护性,就应当将封装思想谨记心中。容器是封装思想的绝好示例。用户对容器的印象应该简洁地表达为:A. 可以存入指定的东西; B. 可以取出所期望的东西。 而至于这容器中究竟有什么机关,藏的是毒蛇还是黄金,都是对用户不可见的。二叉查找树就是这样一个容器。面向对象编程中,为实现树结构,自然要对树结点对象进行建模。这里采用了内部类;外部类对二叉查找树进行建模,而树结点作为内部类实现。

[2] 本程序尽量实现一个比较实用的二叉查找树,其中包括动态的插入、删除操作;查询给定关键字、最小关键字、最大关键字;获取二叉树的有序列表(用于排序)等。因为我希望以后还能用到这个容器的,而不仅仅是编程练习。二叉查找树操作的大部分算法参考了《算法导论2》第12章内容,删除操作略显笨拙。程序中有错误之处,欢迎指出。

[3]  程序如下:

/**
 * @author shuqin1984  2011-3-13
 *
 * 此程序实现一个二叉查找树的功能,可以进行动态插入、删除关键字;
 * 查询给定关键字、最小关键字、最大关键字;转换为有序列表(用于排序)
 *
 *
 */
package datastructure.tree;
import java.util.ArrayList;
import java.util.List;

public class BinarySearchTree {

    // 树的根结点
    private TreeNode root = null;

    // 遍历结点列表
    private List<TreeNode> nodelist = new ArrayList<TreeNode>();

    private class TreeNode {

        private int key;
        private TreeNode leftChild;
        private TreeNode rightChild;
        private TreeNode parent;

        public TreeNode(int key, TreeNode leftChild, TreeNode rightChild, TreeNode parent) {
            this.key = key;
            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 + ")";
        }

    }

    /**
     * isEmpty: 判断二叉查找树是否为空;若为空,返回 true ,否则返回 false .
     *
     */
    public boolean isEmpty()
    {
        if (root == null) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * TreeEmpty: 对于某些二叉查找树操作(比如删除关键字)来说,若树为空,则抛出异常。
     */
    public void TreeEmpty() throws Exception
    {
        if (isEmpty()) {
            throw new Exception("树为空!");
        }
    }

    /**
     * search: 在二叉查找树中查询给定关键字
     * @param key 给定关键字
     * @return 匹配给定关键字的树结点
     */
    public TreeNode search(int key)
    {
        TreeNode pNode = root;
        while (pNode != null && pNode.key != key) {
            if (key < pNode.key) {
                pNode = pNode.leftChild;
            }
            else {
                pNode = pNode.rightChild;
            }
        }
        return pNode;
    }

    /**
     * minElemNode: 获取二叉查找树中的最小关键字结点
     * @return 二叉查找树的最小关键字结点
     * @throws Exception 若树为空,则抛出异常
     */
    public TreeNode minElemNode(TreeNode node) throws Exception
    {
        if (node == null) {
            throw new Exception("树为空!");
        }
        TreeNode pNode = node;
        while (pNode.leftChild != null) {
            pNode = pNode.leftChild;
        }
        return pNode;
    }

    /**
     * maxElemNode: 获取二叉查找树中的最大关键字结点
     * @return 二叉查找树的最大关键字结点
     * @throws Exception 若树为空,则抛出异常
     */
    public TreeNode maxElemNode(TreeNode node) throws Exception
    {
        if (node == null) {
            throw new Exception("树为空!");
        }
        TreeNode pNode = node;
        while (pNode.rightChild != null) {
            pNode = pNode.rightChild;
        }
        return pNode;
    }

    /**
     * successor: 获取给定结点在中序遍历顺序下的后继结点
     * @param node 给定树中的结点
     * @return 若该结点存在中序遍历顺序下的后继结点,则返回其后继结点;否则返回 null
     * @throws Exception
     */
    public TreeNode successor(TreeNode node) throws Exception
    {
        if (node == null) {
            return null;
        }

        // 若该结点的右子树不为空,则其后继结点就是右子树中的最小关键字结点
        if (node.rightChild != null) {
            return minElemNode(node.rightChild);
        }
        // 若该结点右子树为空
        TreeNode parentNode = node.parent;
        while (parentNode != null && node == parentNode.rightChild) {
            node = parentNode;
            parentNode = parentNode.parent;
        }
        return parentNode;
    }

    /**
     * precessor: 获取给定结点在中序遍历顺序下的前趋结点
     * @param node 给定树中的结点
     * @return 若该结点存在中序遍历顺序下的前趋结点,则返回其前趋结点;否则返回 null
     * @throws Exception
     */
    public TreeNode precessor(TreeNode node) throws Exception
    {
        if (node == null) {
            return null;
        }

        // 若该结点的左子树不为空,则其前趋结点就是左子树中的最大关键字结点
        if (node.leftChild != null) {
            return maxElemNode(node.leftChild);
        }
        // 若该结点左子树为空
        TreeNode parentNode = node.parent;
        while (parentNode != null && node == parentNode.leftChild) {
            node = parentNode;
            parentNode = parentNode.parent;
        }
        return parentNode;
    }

    /**
     * insert: 将给定关键字插入到二叉查找树中
     * @param key 给定关键字
     */
    public void insert(int key)
    {
        TreeNode parentNode = null;
        TreeNode newNode = new TreeNode(key, 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 ;
            }
        }
        if (key < parentNode.key) {
            parentNode.leftChild = newNode;
            newNode.parent = parentNode;
        }
        else {
            parentNode.rightChild = newNode;
            newNode.parent = parentNode;
        }        

    }

    /**
     * insert: 从二叉查找树中删除匹配给定关键字相应的树结点
     * @param key 给定关键字
     */
    public void delete(int key) throws Exception
    {
        TreeNode pNode = search(key);
        if (pNode == null) {
            throw new Exception("树中不存在要删除的关键字!");
        }
        delete(pNode);
    }

    /**
     * delete: 从二叉查找树中删除给定的结点.
     * @param pNode 要删除的结点
     *
     * 前置条件: 给定结点在二叉查找树中已经存在
     * @throws Exception
     */
    private void delete(TreeNode pNode) throws Exception
    {
          if (pNode == null) {
              return ;
          }
          if (pNode.leftChild == null && pNode.rightChild == null) { // 该结点既无左孩子结点,也无右孩子结点
              TreeNode parentNode = pNode.parent;
              if (pNode == parentNode.leftChild) {
                  parentNode.leftChild = null;
              } else {
                  parentNode.rightChild = null;
              }
              return ;
          }
          if (pNode.leftChild == null && pNode.rightChild != null) { // 该结点左孩子结点为空,右孩子结点非空
              TreeNode parentNode = pNode.parent;
              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) { // 该结点左孩子结点非空,右孩子结点为空
              TreeNode parentNode = pNode.parent;
              if (pNode == parentNode.leftChild) {
                  parentNode.leftChild = pNode.leftChild;
                  pNode.rightChild.parent = parentNode;
              }
              else {
                  parentNode.rightChild = pNode.leftChild;
                  pNode.rightChild.parent = parentNode;
              }
              return ;
          }
          // 该结点左右孩子结点均非空,则删除该结点的后继结点,并用该后继结点取代该结点
          TreeNode successorNode = successor(pNode);
          delete(successorNode);
          pNode.key = successorNode.key;
    }

    /**
     * inOrderTraverseList: 获得二叉查找树的中序遍历结点列表
     * @return 二叉查找树的中序遍历结点列表
     */
    public List<TreeNode> inOrderTraverseList()
    {
        if (nodelist != null) {
           nodelist.clear();
        }
        inOrderTraverse(root);
        return nodelist;
    }

    /**
     * inOrderTraverse: 对给定二叉查找树进行中序遍历
     * @param root 给定二叉查找树的根结点
     */
    private void inOrderTraverse(TreeNode root)
    {
        if (root != null) {
            inOrderTraverse(root.leftChild);
            nodelist.add(root);
            inOrderTraverse(root.rightChild);
        }
    }

    /**
     * toStringOfOrderList: 获取二叉查找树中关键字的有序列表
     * @return 二叉查找树中关键字的有序列表
     */
    public String toStringOfOrderList()
    {
        StringBuilder sbBuilder = new StringBuilder(" [ ");
        for (TreeNode p: inOrderTraverseList()) {
            sbBuilder.append(p.key);
            sbBuilder.append(" ");
        }
        sbBuilder.append("]");
        return sbBuilder.toString();
    }

    /**
     * 获取该二叉查找树的字符串表示
     */
    public String toString()
    {
        StringBuilder sbBuilder = new StringBuilder(" [ ");
        for (TreeNode p: inOrderTraverseList()) {
            sbBuilder.append(p);
            sbBuilder.append(" ");
        }
        sbBuilder.append("]");
        return sbBuilder.toString();
    }
    public TreeNode getRoot() {
        return root;
    }

    public static void testNode(BinarySearchTree bst, TreeNode pNode) throws Exception {
        System.out.println("本结点: " + pNode);
        System.out.println("前趋结点: " + bst.precessor(pNode));
        System.out.println("后继结点: " + bst.successor(pNode));
    }

    public static void testTraverse(BinarySearchTree bst) {
        System.out.println("二叉树遍历:" + bst);
        System.out.println("二叉查找树转换为有序列表: " + bst.toStringOfOrderList());
    }

    public static void main(String[] args)
    {
        try {
            BinarySearchTree bst = new BinarySearchTree();
            System.out.println("查找树是否为空? " + (bst.isEmpty() ? "是" : "否"));
            int[] keys = new int[] {15, 6, 18, 3, 7, 13, 20, 2, 9, 4};
            for (int key: keys) {
                bst.insert(key);
            }
            System.out.println("查找树是否为空? " + (bst.isEmpty() ? "是" : "否"));

            TreeNode minkeyNode = bst.minElemNode(bst.getRoot());
            System.out.println("最小关键字: " + minkeyNode.getKey());
            testNode(bst, minkeyNode);

            TreeNode maxKeyNode = bst.maxElemNode(bst.getRoot());
            System.out.println("最大关键字: " + maxKeyNode.getKey());
            testNode(bst, maxKeyNode);

            System.out.println("根结点关键字: " + bst.getRoot().getKey());
            testNode(bst, bst.getRoot());
            testTraverse(bst);

            System.out.println("****************************** ");

            System.out.println("查找 7 : " + (bst.search(7) != null ? "查找成功!" : "查找失败,不存在该关键字!"));
            bst.delete(7);
            System.out.println("查找 7 : " + (bst.search(7) != null ? "查找成功!" : "查找失败,不存在该关键字!"));
            System.out.println("查找 12 : " + (bst.search(12) != null ? "查找成功!" : "查找失败,不存在该关键字!"));
            bst.insert(12);
            System.out.println("查找 12 : " + (bst.search(12) != null ? "查找成功!" : "查找失败,不存在该关键字!"));

            testTraverse(bst);

            System.out.println("****************************** ");

            bst.insert(16);
            bst.delete(6);
            bst.delete(4);

            testTraverse(bst);

        } catch (Exception e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }

} 

  

二叉查找树的Java实现的更多相关文章

  1. 二叉查找树之 Java的实现

    参考:http://www.cnblogs.com/skywang12345/p/3576452.html 二叉查找树简介 二叉查找树(Binary Search Tree),又被称为二叉搜索树.它是 ...

  2. 数据结构--二叉查找树的java实现

    上代码: package com.itany.erchachazhaoshu; public class BinarySearchTree<T extends Comparable<? s ...

  3. 算法笔记_053:最优二叉查找树(Java)

    目录 1 问题描述 2 解决方案   1 问题描述 在了解最优二叉查找树之前,我们必须先了解何为二叉查找树? 引用自百度百科一段讲解: 二叉排序树(Binary Sort Tree)又称二叉查找树(B ...

  4. 数据结构笔记--二叉查找树概述以及java代码实现

    一些概念: 二叉查找树的重要性质:对于树中的每一个节点X,它的左子树任一节点的值均小于X,右子树上任意节点的值均大于X. 二叉查找树是java的TreeSet和TreeMap类实现的基础. 由于树的递 ...

  5. 二叉查找树(三)之 Java的实现

    概要 在前面分别介绍了"二叉查找树的相关理论知识,然后给出了二叉查找树的C和C++实现版本".这一章写一写二叉查找树的Java实现版本. 目录 1. 二叉树查找树2. 二叉查找树的 ...

  6. Java实现二叉查找树

    摘要:一个二叉查找树的Java实现.可以学习二叉树处理的递归及非递归技巧. 难度:初级. 为了克服对树结构编程的恐惧感,决心自己实现一遍二叉查找树,以便掌握关于树结构编程的一些技巧和方法.以下是基本思 ...

  7. 伸展树(三)之 Java的实现

    概要 前面分别通过C和C++实现了伸展树,本章给出伸展树的Java版本.基本算法和原理都与前两章一样.1. 伸展树的介绍2. 伸展树的Java实现(完整源码)3. 伸展树的Java测试程序 转载请注明 ...

  8. 16.检查是否为BST

    题目描述 请实现一个函数,检查一棵二叉树是否为二叉查找树. 给定树的根结点指针TreeNode* root,请返回一个bool,代表该树是否为二叉查找树 import java.util.*; /* ...

  9. Spark案例分析

    一.需求:计算网页访问量前三名 import org.apache.spark.rdd.RDD import org.apache.spark.{SparkConf, SparkContext} /* ...

随机推荐

  1. java J2EE与DiscuzX3.2的UCenter实现单点登录

    最近笔者在实现Java项目对discuz的整合.在此过程中,查了很多这方面的资料,发现网上并没有说得比较全面的文章.笔者博取众长以及自己在此过程中遇到的问题,写下来供大家参考,希望大家可以在这过程中少 ...

  2. Angular系列----AngularJS入门教程00:引导程序(转载)

    我们现在开始准备编写AngularJS应用——phonecat.这一步骤(步骤0),您将会熟悉重要的源代码文件,学习启动包含AngularJS种子项目的开发环境,并在浏览器端运行应用. 进入angul ...

  3. SQLServer异常捕获

    在SQLserver数据库中,如果有很多存储过程的时候,我们会使用动态SQL进行存储过程调用存储过程,这时候,很可能在某个环节就出错了,但是出错了我们很难去跟踪到出错的存储过程,此时我们就可以使用异常 ...

  4. CodeIgniter框架——介绍

    CodeIgniter 是一个应用程序框架 CodeIgniter 是一个为用 PHP 编写网络应用程序的人员提供的工具包.它的目标是实现让你比从零开始编写代码更快速地开发项目,为此,CI 提供了一套 ...

  5. hdu 1011 Starship Troopers (树形背包dp)

    本文出自   http://blog.csdn.net/shuangde800 题目链接 : hdu-1011   题意 有n个洞穴编号为1-n,洞穴间有通道,形成了一个n-1条边的树, 洞穴的入口即 ...

  6. [转]Have a query in Blue prism coding stage and collection stage.

    本文转自:https://www.rpaforum.net/threads/have-a-query-in-blueprism-coding-stage-and-collection-stage.48 ...

  7. 07_ for 练习 _ sumOfOdd

    <!DOCTYPE html> <html> <head> <meta charset="utf-8" /> <title&g ...

  8. 微信小程序从零开始开发步骤-引入框架WeUI

    首先来看下WeUI的官方介绍: WeUI 是一套同微信原生视觉体验一致的基础样式库,由微信官方设计团队为微信内网页和微信小程序量身设计,令用户的使用感知更加统一.在微信小程序的开发过程中,涉及到的前端 ...

  9. [Memcached]分布式缓存系统Memcached在Asp.net下的应用

    Memcached 是一个高性能的分布式内存对象缓存系统,用于动态Web应用以减轻数据库负载.它通过在内存中缓存数据和对象来减少读取数据库的次数,从而提高动态.数据库驱动网站的速度.Memcached ...

  10. The &#39;INFORMATION_SCHEMA.GLOBAL_STATUS&#39; feature is disabled; see the documentation for &#39;show_compatibility_56&#39;

    --从mysql5.7.6开始information_schema.global_status已经开始被舍弃,为了兼容性,此时需要打开 show_compatibility_56 mysql> ...