数据结构 -- 二叉树（Binary Search Tree）

一、简介

        在计算机科学中，二叉树是每个结点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。

        一棵深度为k，且有2^k-1个结点的二叉树，称为满二叉树。这种树的特点是每一层上的结点数都是最大结点数。而在一棵二叉树中，除最后一层外，若其余层都是满的，并且或者最后一层是满的，或者是在右边缺少连续若干结点，则此二叉树为完全二叉树。具有n个结点的完全二叉树的深度为floor(log2n)+1。深度为k的完全二叉树，至少有（2的k-1次方）个叶子结点，至多有2^k-1个结点。

       节点特性：1. 每个节点的值都大于其左子树的所有节点的值。

　　　　　　   2. 每个节点的值都小于其右子树的所有节点的值。

二、代码

 1.定义 ：一个支持泛型的节点类, 用于存储二分搜索树每个节点的信息, 这个类作为二分搜索树的一个内部类, 二分搜索树的类声明以及Node节点类

public class BinaryTree<E extends Comparable<E>> {
    // 根节点
    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;
    }
    // 二分搜索树节点类
    private class Node {
        public E e ;
        // 左右子树
        public Node left , right ;
        public Node(E e) {
            this.e = e ;
            this.left = null ;
            this.right = null ;
        }
    }
}

2. 添加操作：二分搜索树本身的递归特性, 可以很方便的使用递归实现向二分搜索树中添加元素。

 //添加元素
    public void add(E e){
        root = add(root, e);
    }
    //插入元素，递归算法。 返回插入新节点后二叉树的根
    private Node add(Node node, E e){
        //如果当前根节点为空，则直接创建该节点为根节点
        if(node == null){
            size ++;
            return new Node(e);
        }
        if(e.compareTo(node.e) < 0){ //添加元素e 小于 节点元素e，则从左边添加
            node.left = add(node.left,e);
        }else if (e.compareTo(node.e) > 0){ //添加元素e 大于 节点元素e，则从右边添加
            node.right = add(node.right,e);
        }
        return node;
    }

3. 查找操作：二分搜索树没有下标, 针对二分搜索树的查找, 定义一个contains方法, 是否包含某个元素, 返回布尔型变量, 这个操作是递归的过程。

 //查询是否包含e元素
    public boolean contains(E e){
        return contains(root, e);
    }
    // 看以node为根的二分搜索树中是否包含元素e, 递归算法
    private boolean contains(Node node, E e){
        if (node == null){
            return false;
        }
        if (node == e){
            return true;
        }else if (e.compareTo(node.e) > 0){ //如果大于根节点元素，则向右子树递归遍历
            return contains(node.right, e);
        }else{ //如果小于根节点元素，则向左子树递归遍历
            return contains(node.left, e);
        }
    }
　　//找出二叉树的最小元素
　　public E minimum(){
   　　 if (size == 0){
        　　throw new IllegalArgumentException("BinaryTree is empty!");
    　　}
    　　return minimum(root).e;
　　}
　　private Node minimum(Node node){
    　　if ( node.left == null){
        　　return node;
    　　}
    　　return minimum(node.left);
　　}
　　//找出二叉树的最大元素
　　public E maximum(){
    　　if (size == 0){
      　　  throw new IllegalArgumentException("BinaryTree is empty!");
    　　}
    　　return maximum(root).e;
　　}
　　private Node maximum(Node node){
   　　 if ( node.right == null){
       　　 return node;
    　　}
    　　return maximum(node.right);
　　}

4. 遍历操作

遍历分类：
深度优先遍历 :
    1. 前序遍历 : 对当前节点的遍历在对左右孩子节点的遍历之前, 遍历顺序 : 当前节点->左孩子->右孩子 
    2. 中序遍历 : 对当前节点的遍历在对左右孩子节点的遍历中间, 遍历顺序 : 左孩子->当前节点->右孩子 
    3. 后序遍历 : 对当前节点的遍历在对左右孩子节点的遍历之后, 遍历顺序 : 左孩子->右孩子->当前节点 广度优先遍历 : 
    1. 层序遍历 : 按层从左到右进行遍历

 前序遍历：最常用/自然的遍历方式：

（一）、递归写法　　

//二叉树的前序遍历
    public void preOrder(){
        preOrder(root);
    }
    // 前序遍历以node为根的二分搜索树, 递归算法
    private void preOrder(Node node){
        if (node == null){
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }
（二）、非递归写法：通过栈实现二叉树遍历　
// 二分搜索树的非递归前序遍历
public void preOrderNR(){
    Stack<Node> stack = new Stack<>();
    stack.push(root);
    while (!stack.isEmpty()){
        Node node = stack.pop();
        System.out.println(node.e);

        if(node.right != null){
            stack.push(node.right);
        }
        if(node.left != null) {
            stack.push(node.left);
        }
    }
}

 中序遍历：

//二叉树的中序遍历
    public void inOrder(){
        inOrder(root);
    }
    // 中序遍历以node为根的二分搜索树, 递归算法
    private void inOrder(Node node){
        if (node == null){
            return;
        }
        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }

后序遍历：

//二叉树的后序遍历
    public void postOrder(){
        postOrder(root);
    }
    // 中序遍历以node为根的二分搜索树, 递归算法
    private void postOrder(Node node){
        if (node == null){
            return;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.println(node.e);
    }

层序遍历： 

//二叉树的层序遍历
    public void levelOrder(){
        Queue<Node> queue = new LinkedList<>();
        queue.add(root); //先将最上层的根节点加入队列中
        while (!queue.isEmpty()){
            Node node = queue.remove(); //删除队列中的最低端的元素
            System.out.println(node.e); //打印输出

            //输出根节点后，将对应的左/右子树的元素添加到队列中。 队列是先进先出，所以先放左子树再放右子树
            if (node.left != null){
                queue.add(node.left);
            }
            if (node.right != null){
                queue.add(node.right);
            }
        }
    }

前,中,后序遍历总结

        可以认为在遍历的时候每个节点要访问三次, 对当前节点进行遍历操作时一次, 访问当前节点左子树时一次, 访问当前节点右子树时一次, 可以认为前序遍历就是在第一次访问当前节点时进行操作, 以方便我们理解遍历结果, 下面几张图演示前中后序遍历的访问顺序, 蓝色的点表示在这次访问时对当前节点进行遍历操作

前序递归遍历示意图:　蓝点便是绿色道路经过时，输出当前节点内容

中序递归遍历示意图：同理蓝色为输出点，路径如前序

后续递归遍历示意图：同理蓝色为输出点，路径如前序

前序非递归遍历图示：

层序遍历示例图：

　5. 删除操作

（1）删除最大最小节点：

　　删除最小值：找到左子树的最左节点（最小值节点，node.left == null），然后让其上一个节点的左节点指向当前最小值节点的右子树，同时删除最小值节点（node.right = null）；

　　删除最大值：找到右子树的最右节点（最大值节点，node.right == null），然后让其上一个节点的右节点指向当前最大值节点的左子树，同时删除最大值节点（node.left = null）。

删除最小值代码：

 // 从二分搜索树中删除最小值所在节点, 返回最小值
    public E removeMin(){
        E ret = minimum(); //查找二叉树的最小值
        root = removeMin(root);
        return ret;
    }
    // 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMin(Node node){
    　　 //当递归循环到node.left节点为空时，即当前node节点便是要删除的最小元素，将其与二叉树分离
        if (node.left == null){
            Node rightNode = node.right;
            node.right = null;//与二叉树脱离
            size --; //数量减一
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }

删除最大值代码：

// 从二分搜索树中删除最大值所在节点
    public EremoveMax(){
        E ret = maximum(); //查找二叉树的最大值
        root = removeMax(root);
        return ret;
    }
    // 删除掉以node为根的二分搜索树中的最大节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMax(Node node) {
        if (node.right == null){
            Node leftNode = node.left;
            node.left = null;//与二叉树脱离
            size --;
            return leftNode;
        }
        node.right = removeMax(node.right);
        return node;
    }

（2）删除任意节点元素

　删除任意节点可以分为以下几种情况 :

　　　　* 删除叶子节点, 直接删除即可

　　　　* 删除只有右子树的节点, 逻辑同删除最小值, 虽然这个节点不一定是最小值, 但是删除逻辑是一样的

　　　　* 删除只有左子树的节点, 逻辑同删除最大值

　　　　* 删除同时具有左右子树的节点, 此时删除节点的步骤稍微复杂一些

* 首先找到要删除的节点
* 然后找到对应节点的前驱或者后继节点, 前驱就是指当前节点的左子树中最大的元素节点, 
  后继就是指当前节点右子树中最小的元素节点, 下图就是基于后继节点的删除演示
* 使用后继节点替换当前节点, 然后再删除要删除的节点

删除任意节点代码：

// 从二分搜索树中删除元素为e的节点
    public void remove(E e){
        root = remove(root, e);
    }
    // 删除掉以node为根的二分搜索树中值为e的节点, 递归算法
    // 返回删除节点后新的二分搜索树的根
    private Node remove(Node node, E e){
        if ( node == null){
            return null;
        }
        if (e.compareTo(node.e) < 0){
            node.left = remove(node.left, e);
            return node;
        }else if(e.compareTo(node.e) > 0){
            node.right = remove(node.right, e);
            return node;
        }else{ //  e.compareTo(node.e) == 0 即找到当前元素

            // 待删除节点左子树为空的情况
            if(node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size --;
                return rightNode;
            }
            // 待删除节点右子树为空的情况
            if(node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size --;
                return leftNode;
            }

            // 待删除节点左右子树均不为空的情况
            // 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
            // 用这个节点顶替待删除节点的位置
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            node.left = node.right = null;

            return successor;
        }
    }

全部代码：

package com.wj.BinaryTree;

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * 实现二叉树
 */
public class BinaryTree<E extends Comparable> {

    private class Node{
        public E e;
        public Node left, right;
        public Node(E e){
            this.e = e;
            left = null;
            right = null;
        }
    }
    private Node root;
    private int size;

    public BinaryTree(){
        root = null;
        size = 0;
    }
    public int size(){
        return size;
    }
    public boolean isEmpty(){
        return size == 0;
    }

    //二叉树的增操作

    //添加元素
    public void add(E e){
        root = add(root, e);
    }
    //插入元素，递归算法。 返回插入新节点后二叉树的根
    private Node add(Node node, E e){
        //如果当前根节点为空，则直接创建该节点为根节点
        if(node == null){
            size ++;
            return new Node(e);
        }
        if(e.compareTo(node.e) < 0){
            node.left = add(node.left,e);
        }else if (e.compareTo(node.e) > 0){
            node.right = add(node.right,e);
        }
        return node;
    }

    //二叉树的查询操作

    //二叉树的前序遍历
    public void preOrder(){
        preOrder(root);
    }
    // 前序遍历以node为根的二分搜索树, 递归算法
    private void preOrder(Node node){
        if (node == null){
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }
    // 二分搜索树的非递归前序遍历
    public void preOrderNR(){
        Stack<Node> stack = new Stack<>();
        stack.push(root);
        while (stack !=null){
            Node node = stack.pop();
            System.out.println(node.e);

            if(node.right != null){
                stack.push(node.right);
            }
            if(node.left != null) {
                stack.push(node.left);
            }
        }
    }

    //二叉树的中序遍历
    public void inOrder(){
        inOrder(root);
    }
    // 中序遍历以node为根的二分搜索树, 递归算法
    private void inOrder(Node node){
        if (node == null){
            return;
        }
        inOrder(node.left);
        System.out.println(node.e);
        inOrder(node.right);
    }
    //二叉树的后序遍历
    public void postOrder(){
        postOrder(root);
    }
    // 中序遍历以node为根的二分搜索树, 递归算法
    private void postOrder(Node node){
        if (node == null){
            return;
        }
        postOrder(node.left);
        postOrder(node.right);
        System.out.println(node.e);
    }

    //二叉树的层序遍历
    public void levelOrder(){
        Queue<Node> queue = new LinkedList<>();
        queue.add(root); //先将最上层的根节点加入队列中
        while (!queue.isEmpty()){
            Node node = queue.remove(); //删除队列中的最低端的元素
            System.out.println(node.e); //打印输出

            //输出根节点后，将对应的左/右子树的元素添加到队列中
            if (node.left != null){
                queue.add(node.left);
            }
            if (node.right != null){
                queue.add(node.right);
            }
        }
    }

    //查询是否包含e元素
    public boolean contains(E e){
        return contains(root, e);
    }
    // 看以node为根的二分搜索树中是否包含元素e, 递归算法
    private boolean contains(Node node, E e){
        if (node == null){
            return false;
        }
        if (node == e){
            return true;
        }else if (e.compareTo(node.e) > 0){ //如果大于根节点元素，则向右子树递归遍历
            return contains(node.right, e);
        }else{ //如果小于根节点元素，则向左子树递归遍历
            return contains(node.left, e);
        }
    }
    //找出二叉树的最小元素
    public Node minimum(){
        if (size == 0){
            throw new IllegalArgumentException("BinaryTree is empty!");
        }
        return minimum(root);
    }
    private Node minimum(Node node){
        if ( node.left == null){
            return node;
        }
        return minimum(node.left);
    }
    //找出二叉树的最大元素
    public Node maximum(){
        if (size == 0){
            throw new IllegalArgumentException("BinaryTree is empty!");
        }
        return maximum(root);
    }
    private Node maximum(Node node){
        if ( node.right == null){
            return node;
        }
        return maximum(node.right);
    }

    // 从二分搜索树中删除最小值所在节点, 返回最小值
    public Node removeMin(){
        Node ret = minimum();
        root = removeMin(root);
        return ret;
    }
    // 删除掉以node为根的二分搜索树中的最小节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMin(Node node){
        if (node.left == null){
            Node rightNode = node.right;
            node.right = null;
            size --;
            return rightNode;
        }
        node.left = removeMin(node.left);
        return node;
    }
    // 从二分搜索树中删除最大值所在节点
    public Node removeMax(){
        Node ret = maximum();
        root = removeMax(root);
        return ret;
    }
    // 删除掉以node为根的二分搜索树中的最大节点
    // 返回删除节点后新的二分搜索树的根
    private Node removeMax(Node node) {
        if (node.right == null){
            Node leftNode = node.left;
            node.left = null;
            size --;
            return leftNode;
        }
        node.right = removeMin(node.right);
        return node;
    }

    // 从二分搜索树中删除元素为e的节点
    public void remove(E e){
        root = remove(root, e);
    }
    // 删除掉以node为根的二分搜索树中值为e的节点, 递归算法
    // 返回删除节点后新的二分搜索树的根
    private Node remove(Node node, E e){
        if ( node == null){
            return null;
        }
        if (e.compareTo(node.e) < 0){
            node.left = remove(node.left, e);
            return node;
        }else if(e.compareTo(node.e) > 0){
            node.right = remove(node.right, e);
            return node;
        }else{ //  e.compareTo(node.e) == 0 即找到当前元素

            // 待删除节点左子树为空的情况
            if(node.left == null){
                Node rightNode = node.right;
                node.right = null;
                size --;
                return rightNode;
            }
            // 待删除节点右子树为空的情况
            if(node.right == null){
                Node leftNode = node.left;
                node.left = null;
                size --;
                return leftNode;
            }

            // 待删除节点左右子树均不为空的情况
            // 找到比待删除节点大的最小节点, 即待删除节点右子树的最小节点
            // 用这个节点顶替待删除节点的位置
            Node successor = minimum(node.right);
            successor.right = removeMin(node.right);
            successor.left = node.left;
            node.left = node.right = null;

            return successor;
        }
    }
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        generateBSTString(root,0,res);
        return res.toString();
    }

    private void generateBSTString(Node node, int depth, StringBuilder res){
        if (node == null){
            res.append(generateDepthString(depth) + "null\n");
            return;
        }
        res.append(generateDepthString(depth) + node.e + "\n");
        generateBSTString(node.left,depth + 1,res);
        generateBSTString(node.right,depth + 1,res);
    }

    private String generateDepthString(int depth){
        StringBuilder res = new StringBuilder();
        for (int i=0; i< depth; i++){
            res.append("--");
        }
        return res.toString();
    }
}

测试类：

package com.wj.BinaryTree;

import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        int[] nums = {80,50,90,30,60,65,70,100,68,75,101,20,25};
        for (int i : nums){
            binaryTree.add(i);
        }
        System.out.println("=====增后的二叉树=====");
        System.out.println(binaryTree.toString());

        System.out.println("=====二叉树的前序遍历=====");
        // 二叉树的前序遍历
        binaryTree.preOrder();

        System.out.println("=====二叉树的非递归前序遍历=====");
        //二叉树的非递归前序遍历
        binaryTree.preOrderNR();

        System.out.println("=====二叉树的中序遍历=====");
        //二叉树的中序遍历
        binaryTree.inOrder();

        System.out.println("=====二叉树的后序遍历=====");
        //二叉树的后序遍历
        binaryTree.postOrder();

        System.out.println("二叉树的最小节点值："+binaryTree.minimum());
        System.out.println("二叉树的最大节点值："+binaryTree.maximum());
        System.out.println("20是否存在二叉树中："+binaryTree.contains(20));
        System.out.println("200是否存在二叉树中："+binaryTree.contains(200));

        System.out.println("=====删除操作=====");

        Object removeMin = binaryTree.removeMin();
        System.out.println("删除最小的值："+removeMin);
        System.out.println(removeMin+"是否存在二叉树中："+binaryTree.contains((Comparable) removeMin));

        Object removeMax = binaryTree.removeMax();
        System.out.println("删除最大的值："+removeMax);
        System.out.println(removeMax+"是否存在二叉树中："+binaryTree.contains((Comparable) removeMax));


        binaryTree.remove(100);
        System.out.println("100是否存在二叉树中："+binaryTree.contains(100));
    }
}

测试结果：

=====增后的二叉树=====
--50
----30
------20
--------null
--------25
----------null
----------null
------null
----60
------null
------65
--------null
--------70
----------68
------------null
------------null
----------75
------------null
------------null
--90
----null
----100
------null
------101
--------null
--------null

=====二叉树的前序遍历=====
50
20
60
70
75
100
=====二叉树的非递归前序遍历=====
50
20
60
70
75
100
=====二叉树的中序遍历=====
25
50
65
70
80
100
=====二叉树的后序遍历=====
20
68
70
60
101
90
二叉树的最小节点值：20
二叉树的最大节点值：101
20是否存在二叉树中：true
200是否存在二叉树中：false
=====删除操作=====
删除最小的值：20
20是否存在二叉树中：false
删除最大的值：101
101是否存在二叉树中：false
100是否存在二叉树中：false

结束