递归前序遍历、递归中序遍历、递归后序遍历、层序遍历和判断一棵树是否为完全二叉树

前言

本文主要讲 递归前序遍历二叉树、递归中序遍历二叉树、递归后序遍历二叉树 以及 层序遍历的方法。

非递归方法请看 非递归前序遍历二叉树、非递归中序遍历二叉树、非递归后序遍历二叉树

递归前序遍历

	/*
    * 递归 前序遍历*/
    public void preorder(Visitor<E> visitor){
    
    
        preorder(root,visitor);
    }

    private void preorder(Node<E> node, Visitor<E> visitor){
    
    
        if (root == null || visitor == null) return;
        visitor.visit(node.element);
        preorder(node.left,visitor);
        preorder(node.right,visitor);
    }
    public static interface Visitor<E>{
    
    
        boolean visit(E element);
    }

递归中序遍历

	public void inorder(Visitor<E> visitor){
    
    
        inorder(root,visitor);
    }

    private void inorder(Node<E> node, Visitor<E> visitor){
    
    
        if (root == null || visitor == null) return;
        inorder(node.left,visitor);
        visitor.visit(node.element);
        inorder(node.right,visitor);
    }
     public static interface Visitor<E>{
    
    
        boolean visit(E element);
    }

递归后序遍历

	public void postorder(Visitor<E> visitor){
    
    
        postorder(root,visitor);
    }

    private void postorder(Node<E> node, Visitor<E> visitor){
    
    
        if (root == null || visitor == null) return;
        postorder(node.left,visitor);
        postorder(node.right,visitor);
        visitor.visit(node.element);
    }
    public static interface Visitor<E>{
    
    
        boolean visit(E element);
    }

层序遍历（很重要）

	public void levelOrder(Visitor<E> visitor){
    
    
        if (root == null || visitor == null) return;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()){
    
    
            Node<E> node = queue.poll();
            visitor.visit(node.element);

            if (node.left != null){
    
    
                queue.offer(node.left);
            }
            if (node.right != null){
    
    
                queue.offer(node.right);
            }
        }
    }
    public static interface Visitor<E>{
    
    
        boolean visit(E element);
    }

判断一棵树是否为完全二叉树

两种方法实现：

1. 使用层序遍历
2. 使用队列

	/*
     * 判断一棵树是否为完全二叉树
     * 使用层序遍历，使用队列
     * 两种写法
     * */
    public boolean isComplete(){
    
    
        if (root == null) return false;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);
        boolean leaf = false;

        while(!queue.isEmpty()){
    
    
            Node<E> node = queue.poll();
            if (leaf && !node.isLeaf()){
    
    
                return false;
            }

            if (node.hasTwoChildren()){
    
    
                queue.offer(node.left);
                queue.offer(node.right);
            }else if (node.left == null && node.right != null){
    
    
                return false;
            }else {
    
      //后面遍历的节点都必须是叶子节点
                leaf = true;
                if (node.left != null){
    
    
                    queue.offer(node.left);
                }
            }
        }
        return true;
    }

    public boolean isComplete2(){
    
    
        //这种写法更好，判断更少
        if (root == null) return false;
        Queue<Node<E>> queue = new LinkedList<>();
        queue.offer(root);

        boolean leaf = false;
        while(!queue.isEmpty()){
    
    
            Node<E> node = queue.poll();
            if (leaf && !node.isLeaf()) return false;

            if (node.left != null){
    
    
                queue.offer(node.left);
            }else if (node.right != null){
    
    
                //node.left == null && node.right != null
                return false;
            }

            if (node.right != null){
    
    
                queue.offer(node.right);
            }else {
    
    
                //node.right == null
                leaf = true;
            }
        }
        return true;
    }
    protected 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;
        }
    }