Java实现二叉搜索树的遍历

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

在遍历前先定义一个二叉搜索树：

public class BinarySearchTree<E> implements BinaryTreeInfo{
    private int size; //二叉树节点个数
    private Node<E> root; //根节点

    private void elementNotNullCheck(E element) {
        if (element == null) {
            throw new IllegalArgumentException("element must not be null");
        }
    }

    /**
     * 往二叉树中添加元素
     * @param element
     */
    public void add(E element){
        elementNotNullCheck(element);

        //添加第一个节点
        if (root == null) {
            root = new Node<E>(element, null);
            size++; //java默认将没有赋值的int置为0
            return;
        }

        //添加的不是第一个节点
        //找到父节点
        Node<E> parent = root;
        Node<E> node = root;
        int cmp = 0;
        do {
            cmp = compare(element, node.element);
            parent = node;
            if (cmp > 0) {
                node = node.right;
            } else if (cmp < 0) {
                node = node.left;
            } else {
                node.element = element;
                return;
            }
        } while (node != null);

        //查看插入到父节点的位置
        Node<E> newNode = new Node<>(element, parent);
        if (cmp > 0) {
            parent.right = newNode;
        } else {
            parent.left = newNode;
        }
        size++;
    }
    
    /**
    * 内部类
    */
    private  static class Node<E> {
        E element; //节点元素
        Node<E> left; //维护一个左节点
        Node<E> right; //维护一个右节点
        Node<E> parent; //维护一个父节点

        public Node(E element, Node<E> parent) {
            this.element = element;
            this.parent = parent;
        }

        public boolean isLeaf(){
            return left == null && right == null;
        }

        public boolean hasTwoChildren() {
            return left != null && right != null;
        }
    }
}

1、前序遍历

public void preorderTraversal() {
    preorderTraversal(root);
}
private void preorderTraversal(Node<E> node) {
    if (node == null) return;
    System.out.println(node.element);
    preorderTraversal(node.left);
    preorderTraversal(node.right);
}

2、中序遍历

public void inorderTraversal(){
    inorderTraversal(root);
}
private void inorderTraversal(Node<E> node) {
    if (node == null) return;
    inorderTraversal(node.left);
    System.out.println(node.element);
    inorderTraversal(node.right);
}

3、后序遍历

public void postorderTraversal() {
    postorderTraversal(root);
}
private void postorderTraversal(Node<E> node) {
    if (node == null) return;
    postorderTraversal(node.left);
    postorderTraversal(node.right);
    System.out.println(node.element);
}

4、层序遍历

public void levelOrderTraversal() {
    if (root == null) return;
    Queue<Node<E>> queue = new LinkedList<>();
    queue.offer(root);
    while (!queue.isEmpty()) {
        Node<E> node = queue.poll();
        System.out.println(node.element);
        if (node.left != null) {
            queue.offer(node.left);
        }
        if (node.right != null) {
            queue.offer(node.right);
        }
    }
}