【数据结构与算法】4、用java实现二分搜索树以及它的三种遍历方式

什么是二叉树？每个节点有两个指向其左右子节点的引用，节点组织特点是同一个根节点下的左孩子都比右孩子小。

一、用来java实现一个二叉树

public class MyBST<E extends Comparable<E>> {
    private class Node {
        public E e;
        public Node left, right;
        public Node(E e) {
            this.e = e;
            left = null;
            right = null;
        }
        public Node() {
            this.e = null;
            left = null;
            right = null;
        }
    }

    private Node root;
    private int size;
    public MyBST() {
        root = null;
        size = 0;
    }

    // 插入元素
    public void add(E e) {
        root = add(root, e);
    }
    // 私有方法，向以node为根节点的二叉树中插入元素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 {
            node.right = add(node.right, e);
        }
        return node;
    }

    public int getSize() {
        return size;
    }
}

二、二叉树的三种遍历方式

    // 前序 遍历以node为根的二叉树
    public void preOrder() {
        preOrder(root);
    }
    private void preOrder(Node node){
        if(node == null) {
            return;
        }
        System.out.println(node.e);
        preOrder(node.left);
        preOrder(node.right);
    }

    // 中序 遍历以node为根的二叉树
    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);
    }


    // 后序 遍历以node为根的二叉树
    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 class Test {
    public static void main(String[] args) {
        MyBST myBST = new MyBST();
        int[] ns = {23,14,6,17,43,54};
        for(int n : ns) {
            myBST.add(n);
        }
        /*         23
                14     43
              6   17       54
         */
        myBST.preOrder();  //前序遍历 23 14 6 17 43 54
        myBST.inOrder();   //中序遍历 6 14 17 23 43 54
        myBST.postOrder(); //后序遍历 6 17 14 54 43 23
    }
}