二叉树的递归遍历和迭代遍历实现

二叉树

所谓遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题(比如：打印节点内容、节点内容加1)。 遍历是二叉树上最重要的操作之一，是二叉树上进
行其它运算之基础。

在遍历二叉树时，如果没有进行某种约定，每个人都按照自己的方式遍历，得出的结果就比较混乱，如果按照某种规则进行约定，则每个人对于同一棵树的遍历结果肯定是相同的。如果N代表根节点，L代表根节点的左子树，R代表根节点的右子树，则根据遍历根节点的先后次序有以下遍历方式：

1. NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。
2. LNR：中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。
3. LRN：后序遍历(Postorder Traversal)——根的左子树--->根的右子树--->根节点。

由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

递归实现

递归遍历实现代码比较简单

前序遍历，中序遍历，后序遍历

/**
     *递归遍历
     */
    // 前序遍历
    void preOrderTraversal(Node root){
        if (root == null) return;
        System.out.print(root.val+" ");
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);

    }
    // 中序遍历
    void inOrderTraversal(Node root){
        if (root == null) return;
        inOrderTraversal(root.left);
        System.out.print(root.val+" ");
        inOrderTraversal(root.right);
    }
    // 后序遍历
    void postOrderTraversal(Node root){
        if (root == null) return;
        postOrderTraversal(root.left);
        postOrderTraversal(root.right);
        System.out.print(root.val+" ");
    }

迭代实现

迭代实现利用栈模拟遍历的过程，依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问题(比如：打印节点内容）

前序遍历，中序遍历，后序遍历

/**
     * 非递归遍历
     */
    // 前序遍历
    void preOrderTraversalNor(Node root) {
        if (root == null) {
            return;
        }
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                System.out.print(cur.val+" ");
                cur = cur.left;
            }
            Node top = stack.pop();
            cur = top.right;
        }
    }
    // 中序遍历
    void inOrderTraversalNor(Node root) {
        if (root == null) {
            return;
        }
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        while (cur !=null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            Node top = stack.pop();//取栈顶
            System.out.print(top.val+" ");
            cur = top.right;
        }
    }

    // 后序遍历
    void postOrderTraversalNor(Node root) {
        if (root == null) return;
        Stack<Node> stack = new Stack<>();
        Node cur = root;
        Node prev = null;
        while (cur != null || !stack.isEmpty()) {
            while (cur != null) {
                stack.push(cur);
                cur = cur.left;
            }
            cur = stack.peek();//
            if (cur.right == null || cur.right == prev) {//如果发现cur.right等于打印的值，进出循环pop()出栈并打印栈顶元素
                stack.pop();
                System.out.print(cur.val+" ");
                prev = cur;//记录cur打印的值
                cur = null;//cur置为空，目的是不进入内部while循环，防止再次把打印的元素放入栈

            } else {
                cur = cur.right;
            }
        }
    }

层序遍历（使用队列）

设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从
左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是
层序遍历。

// 层序遍历
    void levelOrderTraversal(Node root){
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            //访问元素
            System.out.print(cur.val+" ");
            //左右子树入队列
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
    }

平衡二叉树

判断一颗二叉树是否是一个二叉树平衡二叉树

每个节点的左右两个子树的高度差的绝对值不超过 1

 public boolean isBalanced(Node root) {
        if (root == null) return true;
        if (root.left == null && root.right == null) return true;
        //看当前节点对应的子树是否平衡
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        if (leftHeight-rightHeight > 1 || leftHeight-rightHeight < -1) {
            return false;
        }
        return isBalanced(root.left) && isBalanced(root.right);
    }

完全二叉树

判断一颗二叉树是否是完全二叉树

大概意思就是中间没有空隙

 boolean isCompleteTree(Node root){
        if (root == null) return true;
        //1.队列
        Queue<Node> queue = new LinkedList<>();
        //2.往队列里扔元素 ，出队列(==null)
        queue.offer(root);
        while (!queue.isEmpty()) {
             Node cur = queue.poll();
             if (cur != null) {
                 queue.offer(cur.left);
                 queue.offer(cur.right);
             } else {
                 break;
             }
        }
        //代码走到这里，说明上面while循环是break跳出，poll的cur节点一定为空
        //3，继续判断队列，如果全部为null，为true,否则为false(因为如果是完全二叉树，一单弹出的元素为null了，后面必须全文空)
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            if (cur != null) {
                return false;
            }
        }
        return  true;
    }