二叉搜索树(Binary Search Tree)

最新推荐文章于 2021-04-09 14:27:21 发布

zjtMeng

最新推荐文章于 2021-04-09 14:27:21 发布

阅读量186

点赞数

分类专栏：算法文章标签：二叉树二叉搜索树前序遍历中序遍历后序遍历

本文链接：https://blog.csdn.net/zjt980452483/article/details/104135175

版权

算法专栏收录该内容

10 篇文章 0 订阅

订阅专栏

一、基本概念

1. 二叉树

和链表一样，具有动态的数据结构；
具有唯一的根节点；
每个节点最多有两个子节点，最多有一个父节点；
每个节点的左子树也是二叉树，每个节点的右子树也是二叉树；
一个节点或者空也是二叉树；

2.二分搜索树

二分搜索树属于二叉树的一种；
每个节点的值
- 大于其左子树的所有节点；
- 小于其右子树的所有节点；
每个子树也是二分搜索树；
每个节点所存储的元素必须有可比较性；

二、二分搜索树的代码实现

1. 基础代码

此处限制了二叉搜索树所支持的泛型，需要继承Comparable类，即该类需要满足可比较性

//此处限制了二叉搜索树所支持的泛型，需要继承Comparable类，即该类需要满足可比较性
public class BSTree<E extends Comparable<E>>{

    //使用内部类定义节点的概念；
    private class Node{
        public E e;

        public Node left, right;

        public Node(E e){
            this.e = e;
            this.left = null;
            this.right = null;
        }
    }

    //根节点
    private Node root;

    //记录二叉树存储元素的个数
    private int size;

    //无参构造方法
    public BSTree(){
        this.root = null;
        this.size = 0;
    }

    //判断二叉树是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    //获取二叉树的元素数量
    public int getSize(){
        return size;
    }

}

2. 添加元素的方法

二分搜索树为空时，添加的元素放在根节点root的位置上；
二分搜索树不为空时，利用递归循环方法，存放元素

其中编写递归循环代码的步骤：
第一步：先写出递归终止条件：
第二步：然后写递归组成的逻辑；

//向二叉树添加元素
    public void add(E e){
        //如果二分搜索树为空的时候，添加的元素存放在根节点的位置上
        if (root == null){
            root = new Node(e);
            size++;
        }

        else
            add(root ,e);
    }

    //以node为根节点的二分搜索树中插入元素E
    private void add(Node node , E e){
        /**
         * 第一步：先写出递归终止条件：
         * 1.待插入节点与叶节点的值一样大；
         * 2.待插入节点插入到叶节点的左侧；
         * 3.待插入节点插入到叶节点的右侧；
         */
        if ((e.equals(node.e)))
            return ;
        else if (e.compareTo(node.e) < 0 && node.left == null){
            node.left = new Node(e);
            size++;
        }else if (e.compareTo(node.e) > 0 && node.right == null){
            node.right = new Node(e);
            size++;
        }

        /**
         * 第二步：递归调用
         */
        if (e.compareTo(node.e) < 0 && node.left != null)
            add(node.left, e);
        else
            add(node.right, e);
    }

3. 添加元素的方法(优化)

上述的add()递归方法中，将节点为空区别对待了。其实节点为空也为二叉树的一种形式，基于此情况，将上述add()方法优化改进一下。

//向二叉搜索树添加元素（暴露给用户使用）
    public void addPro(E e){
        root = addPro(root , e);
    }

    //返回插入新节点后二分搜索树的根
    private Node addPro(Node node, E e){
        if (node == null){
            size++;
            return new Node(e);
        }
        if (e.compareTo(node.e)<0)
            node.left = addPro(node.left, e);
        if (e.compareTo(node.e)>0)
            node.right = addPro(node.right, e);
        //返回当前节点
        return node;
    }

4. 查询操作

二叉搜索树查询，与添加元素的方法相似，且查询的递归逻辑较为简单，可以借鉴添加元素的逻辑

//查询二叉搜索树是否包含元素e
    public boolean contains(E e){
        return contains(root, e);
    }

    private boolean contains(Node node, E e){
        //递归终止条件
        if (node == null)
            return false;

        if (e.compareTo(node.e) == 0)
            return true;
        else if (e.compareTo(node.e) < 0)
            return contains(node.left, e);
        else
            return contains(node.right, e);
    }

5. 前序遍历

根节点最前遍历：先访问根节点，然后前序遍历左子树，然后前序遍历右子树；

    //二分搜索树的前序遍历
    public void preOrder(){
        preOrder(root);
    }

    //前序遍历以Node为根的二分搜索树，递归算法
    private void preOrder(Node node){
    	//第一步：递归终止条件
        if (node == null)
            return;
        //第二步：递归组成逻辑
        System.out.print(node.e+" ");
        preOrder(node.left);
        preOrder(node.right);
    }

对上述前序遍历的递归代码优化：

由于改进后的前序遍历代码，没有严格遵守递归算法编写步骤，降低了代码可读性，因此此处不推荐使用

    //二分搜索树的前序遍历
    public void preOrder(){
        preOrder(root);
    }
    
    private void preOrder1(Node node){
        if (node != null){
            System.out.print(node.e+" ");
            preOrder(node.left);
            preOrder(node.right);
        }
    }

6. 中序遍历

根节点中间遍历：先前序遍历左子树，然后访问根节点，最后前序遍历右子树；

    //二分搜索树的中序遍历
    public void inOrder(){
        inOrder(root);
    }

    //二分搜索树的中序遍历，递归算法
    private void inOrder(Node node){
        if (node == null)
            return;
        preOrder(node.left);
        System.out.print(node.e+" ");
        preOrder(node.right);
    }

7. 后序遍历

根节点最后遍历：先前序遍历左子树，然后前序遍历右子树，最后访问根节点；

    //二分搜索树的后序遍历
    public void postOrder(){
        postOrder(root);
    }

    //二分搜索树的后序遍历，递归算法
    private void postOrder(Node node){
        if (node == null)
            return;
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.e+" ");
    }

三、二分搜索树的遍历

1. 前、中、后三种遍历的作用

前序遍历：前序遍历结果即为所有元素插入的顺序，若只想二叉树所有元素时，可选择前序遍历；
中序遍历：中序遍历可以得到从小到大（从大到小）的排列顺序，故要输出排序好的二叉树时，选择中序遍历；
后续遍历：后续遍历的特点是执行操作时，肯定已经遍历过该节点的左右子节点，故适用于要进行破坏性操作的情况，比如删除所有节点；【为二叉搜索树释放内存】

2.二叉树前、中、后序遍历详解

遍历详解引用地址

本节完整代码

package binarySearchTree;

/**
 * @auther zjtMeng
 * @date 2020-1-21 
 */

//此处限制了二叉搜索树所支持的泛型，需要继承Comparable类，即该类需要满足可比较性
public class BSTree<E extends Comparable<E>>{

    //使用内部类定义节点的概念；
    private class Node{
        public E e;

        public Node left, right;

        public Node(E e){
            this.e = e;
            this.left = null;
            this.right = null;
        }
    }

    //根节点
    private Node root;

    //记录二叉树存储元素的个数
    private int size;

    //无参构造方法
    public BSTree(){
        this.root = null;
        this.size = 0;
    }

    //判断二叉树是否为空
    public boolean isEmpty(){
        return size == 0;
    }

    //获取二叉树的元素数量
    public int getSize(){
        return size;
    }

    //向二叉树添加元素
    public void add(E e){
        //如果二分搜索树为空的时候，添加的元素存放在根节点的位置上
        if (root == null){
            root = new Node(e);
            size++;
        }

        else
            add(root ,e);
    }

    //以node为根节点的二分搜索树中插入元素E
    private void add(Node node , E e){
        /**
         * 第一步：先写出递归终止条件：
         * 1.待插入节点与叶节点的值一样大；
         * 2.待插入节点插入到叶节点的左侧；
         * 3.待插入节点插入到叶节点的右侧；
         */
        if ((e.equals(node.e)))
            return ;
        else if (e.compareTo(node.e) < 0 && node.left == null){
        node.left = new Node(e);
        size++;
    }else if (e.compareTo(node.e) > 0 && node.right == null){
        node.right = new Node(e);
        size++;
    }

        /**
         * 第二步：递归调用
         */
        if (e.compareTo(node.e) < 0 && node.left != null)
        add(node.left, e);
            else
        add(node.right, e);
    }

    //向二叉搜索树添加元素（暴露给用户使用）
    public void addPro(E e){
        root = addPro(root , e);
    }

    //返回插入新节点后二分搜索树的根
    private Node addPro(Node node, E e){
        if (node == null){
            size++;
            return new Node(e);
        }
        if (e.compareTo(node.e)<0)
            node.left = addPro(node.left, e);
        if (e.compareTo(node.e)>0)
            node.right = addPro(node.right, e);
        return node;
    }

    //查询二叉搜索树是否包含元素e
    public boolean contains(E e){
        return contains(root, e);
    }

    private boolean contains(Node node, E e){
        //递归终止条件
        if (node == null)
            return false;

        if (e.compareTo(node.e) == 0)
            return true;
        else if (e.compareTo(node.e) < 0)
            return contains(node.left, e);
        else
            return contains(node.right, e);
    }

    //二分搜索树的前序遍历
    public void preOrder(){
        preOrder(root);
    }

    //前序遍历以Node为根的二分搜索树，递归算法
    private void preOrder1(Node node){
        if (node == null)
            return;
        System.out.print(node.e+" ");
        preOrder(node.left);
        preOrder(node.right);
    }

    private void preOrder(Node node){
        if (node != null){
            System.out.print(node.e+" ");
            preOrder(node.left);
            preOrder(node.right);
        }
    }

    //二分搜索树的中序遍历
    public void inOrder(){
        inOrder(root);
    }

    //二分搜索树的中序遍历，递归算法
    private void inOrder(Node node){
        if (node == null)
            return;
        inOrder(node.left);
        System.out.print(node.e+" ");
        inOrder(node.right);
    }

    //二分搜索树的后序遍历
    public void postOrder(){
        postOrder(root);
    }

    //二分搜索树的后序遍历，递归算法
    private void postOrder(Node node){
        if (node == null)
            return;
        postOrder(node.left);
        postOrder(node.right);
        System.out.print(node.e+" ");
    }
    
}

zjtMeng

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
二叉搜索树(Binary Search Tree)

一、基本概念1. 二叉树和链表一样，具有动态的数据结构；具有唯一的根节点；每个节点最多有两个子节点，最多有一个父节点；每个节点的左子树也是二叉树，每个节点的右子树也是二叉树；一个节点或者空也是二叉树；2.二分搜索树二分搜索树属于二叉树的一种；每个节点的值大于其左子树的所有节点；小于其右子树的所有节点；每个子树也是二分搜索树；每个节点所存储的元素必须有可比较性；...
复制链接

扫一扫