7、二分搜索树（上篇）

一、二分搜索树的简单概念。

什么是二分搜索树，顾明思议，我们这棵二叉树是左子树元素，小于根节点的元素，小于右子树的元素。

当我们进行插入或者查找元素的时候，我们首先通过在根元素，查找。如果当前元素比它大，就去右子树找。如果当前元素比它

小，我们就去左子树找。如果相等，就说明找到。并且如果相等元素，我们在进行二分搜索树，插入的时候，我们不进行插入。

然后，我们说一说二分搜索树的前序中序后序便利。

我们先说下简单的规则。

1、当为前序便利的时候，我们先便利根节点，然后左子树，最后右子树。

2、当为中序便利的时候，我们先便利左子树，然后根节点，最后右子树。

3、当为后序便利的时候，我们先便利左子树，然后右子树，最后根节点。

它的实现，我们可以用递归和非递归分别实现。

二、二分搜索树的实现。

package com.ipp.demo;

import java.util.Stack;

public class BST<T extends Comparable<T>> {

    private class Node {
        public T e;
        public Node left, right;

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

    private Node root;

    private int size;

    public BST() {
        root = null;
        size = 0;
    }

    public int getSize() {
        return size;
    }


    public boolean isEmpty() {
        return size == 0;
    }

    public Node getRoot() {
        return root;
    }

    /**
     * 1.向二分搜索树中去添加元素
     */
    public void add(T e) {
        root = add(root, e);
    }

    public void add3(T e) {
        if (root == null) {
            root = new Node(e);
            size++;
        } else {
            add3(root, e);
        }
    }

    //调用的可以直接
    private Node add(Node node, T e) {
        if (node == null) {  // 如果node=null  我们不能够进行参数传递
            node = new Node(e);
            size++;
        }
        if (node.e.compareTo(e) > 0) {  //如果当前元素较小
            node.left = add(node.left, e); //传递的是一个空值
        } else if (node.e.compareTo(e) < 0) {  //如果当前元素大的时候
            node.right = add(node.right, e);
        } else {  //如果两个元素相等，就放弃操作

        }
        return node;
    }

    /**
     * 这个是错误的。我们传递的时候，传递空过去，根本接收不了。我们传递的参数是值传递
     *
     * @param node
     * @param e
     */
/*
    private void add2(Node node, T e) {
        if (node == null) {  // 如果node=null  传递过来的是一个空 这个是值传递  我们根本就无法进行赋值。
            node = new Node(e);
            size++;
        }
        if (node.e.compareTo(e) > 0) {  //如果当前元素较小
            add2(node.left, e);
        } else if (node.e.compareTo(e) < 0) {  //如果当前元素大的时候
            add2(node.right, e);
        } else {  //如果两个元素相等，就放弃操作

        }
    }
*/
    private void add3(Node node, T e) {
        if (node.e.compareTo(e) > 0 && node.left == null) {  //这个是递归的终止条件
            node.left = new Node(e);
            size++;
            return;
        }
        if (node.e.compareTo(e) < 0 && node.right == null) {
            node.right = new Node(e);
            size++;
            return;
        }
        if (node.e.compareTo(e) > 0) {  //如果当前元素较小
            add3(node.left, e); //传递的一定不是空
        } else if (node.e.compareTo(e) < 0) {  //如果当前元素大的时候
            add3(node.right, e);
        } else {  //如果两个元素相等，就放弃操作

        }
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        preOrder(root);
    }

    public void preOrder(Node node) {  // 当前节点  左   右
        if (node == null) {
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }

    /**
     * 前序便利非递归实现
     */

    public void preOrderDq() {
        if (root == null) {
            return;
        }
        Stack<Node> stack = new Stack<Node>();
        stack.push(root);
        while (!stack.isEmpty()) {
            Node node = stack.pop();
            System.out.println(node.e);
            //如果右子树不为null 压人栈中。
            if (node.right != null) {
                stack.push(node.right);
            }
            if (node.left != null) {
                stack.push(node.left);
            }
        }
    }

    /**
     * 中序便利
     */
    public void inOrder() {
        inOrder(root);
    }

    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);
    }

    //左子树  右子树  当前节点
    private void postOrder(Node node) {
        if (node == null) return;
        postOrder(node.left);    //左 右 当前
        postOrder(node.right);
        System.out.println(node.e);
    }


    /**
     * 判断是不是包含某个元素
     */
    public boolean contain(T e) {
        return contain(root, e);
    }

    private boolean contain(Node root, T e) {
        if (root == null) {
            return false;
        }
        if (root.e.equals(e)) {
            return true;
        } else if (root.e.compareTo(e) > 0) {
            return contain(root.left, e);
        } else {
            return contain(root.right, e);
        }
    }

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

    // 生成以node为根节点，深度为depth的描述二叉树的字符串
    private void generateString(Node node, int depth, StringBuilder res) {

        if (node == null) {
            res.append(generateDepthString(depth) + "null\n");
            return;
        }

        res.append(generateDepthString(depth) + node.e + "\n");
        generateString(node.left, depth + 1, res);
        generateString(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();
    }

    public static void main(String[] args) {
        BST bst = new BST();
        bst.add(5);
        bst.add(3);
        bst.add(2);
        bst.add(6);
        bst.add(7);

        System.out.println(bst.toString());
        boolean flag = bst.contain(6);
        System.out.println(flag);
        bst.preOrder();
        System.out.println("---------------------------------");
        bst.inOrder();
        System.out.println("---------------------------------");
        bst.postOrder();
        System.out.println("---------------------------------");
        System.out.println(bst.getSize());
    }

}

三、总结

当我实现，二分搜索树实现插入的时候，我是使用的递归实现的。

递归实现是有一个终止条件的，和一个迭代的过程。

第一种实现是，我们把判断如果我们要插入的元素，小于当前的元素，并且当前的左孩子为null 为终止条件。

或者说是，把我们要插入的元素大于当前节点，并且当前节点的右孩子为null为终止条件。

然后不断的递归实现。

 private void add3(Node node, T e) {
        if (node.e.compareTo(e) > 0 && node.left == null) {  //这个是递归的终止条件
            node.left = new Node(e);
            size++;
            return;
        }
        if (node.e.compareTo(e) < 0 && node.right == null) { 这个是递归的终止条件
            node.right = new Node(e);
            size++;
            return;
        }
        if (node.e.compareTo(e) > 0) {  //如果当前元素较小
            add3(node.left, e); //传递的一定不是空
        } else if (node.e.compareTo(e) < 0) {  //如果当前元素大的时候
            add3(node.right, e);
        } else {  //如果两个元素相等，就放弃操作

        }
    }

第二种实现，我们是把当前节点为null 为递归终止条件，然后在这个地方进行插入元素操作。

因为不管是当前节点小于插入的元素，在右边插入，还是当前节点大于插入的元素，在左边插入。

我们都是最后插入的位置就是一个null 的位置。但是实现，这个我们必须考虑递归传递参数的时候，

不能够传递为null 的参数。这样我们无法实现树的递归添加元素。我们在进行插入的时候，我们采用的

是应该用返回值得形式，来获取当前添加的元素，而不是采用值传递。

  //调用的可以直接
    private Node add(Node node, T e) {
        if (node == null) {  // 如果node=null  我们不能够进行参数传递
            node = new Node(e);
            size++;
        }
        if (node.e.compareTo(e) > 0) {  //如果当前元素较小
            node.left = add(node.left, e); //传递的是一个空值
        } else if (node.e.compareTo(e) < 0) {  //如果当前元素大的时候
            node.right = add(node.right, e);
        } else {  //如果两个元素相等，就放弃操作

        }
        return node;
    }

    /**
     * 这个是错误的。我们传递的时候，传递空过去，根本接收不了。我们传递的参数是值传递
     *
     * @param node
     * @param e
     */
/*
    private void add2(Node node, T e) {
        if (node == null) {  // 如果node=null  传递过来的是一个空 这个是值传递  我们根本就无法进行赋值。
            node = new Node(e);
            size++;
        }
        if (node.e.compareTo(e) > 0) {  //如果当前元素较小
            add2(node.left, e);
        } else if (node.e.compareTo(e) < 0) {  //如果当前元素大的时候
            add2(node.right, e);
        } else {  //如果两个元素相等，就放弃操作

        }
    }
*/