二叉树遍历-函数自调用实现遍历（递归）

前序遍历：根左右

中序遍历：左根右

后序遍历：左右根

层序遍历：从上往下，从左往右。

节点类：

//二叉树节点类
public class TreeNode {
    public int val;
    public TreeNode left;
    public TreeNode right;
    public int deep;

    public TreeNode() {
    }

    public TreeNode(int val) {
        this.val = val;
    }

    public TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

前序遍历

对栈顶节点先判断是否为空，为空就出栈。否则就打印（进行操作），同时顺序入栈左，右子节点。最后栈顶节出栈。结合递归实现。

上代码：

//19遍历二叉树
public class BinaryTree19 {
    public static void main(String[] args) {
        TreeNode node7 = new TreeNode(7,null,null);
        TreeNode node6 = new TreeNode(6,null,null);
        TreeNode node5 = new TreeNode(5,node6,node7);
        TreeNode node4 = new TreeNode(4,null,null);
        TreeNode node3 = new TreeNode(3,null,null);
        TreeNode node2 = new TreeNode(2,node4,node5);
        TreeNode node1 = new TreeNode(1,node2,node3);
        preorder(node1);
    }

    //前序遍历
    public static void preorder(TreeNode root){
        if (root==null){
            return;
        }
        System.out.println(root.val);
        preorder(root.left);
        preorder(root.right);
    }
}

结果：1245673

中序遍历：

在遍历完左节点打印根节点信息即可，仿照前序遍历即可。

上代码：

//19遍历二叉树
public class BinaryTree19 {
    public static void main(String[] args) {
        TreeNode node7 = new TreeNode(7,null,null);
        TreeNode node6 = new TreeNode(6,null,null);
        TreeNode node5 = new TreeNode(5,node6,node7);
        TreeNode node4 = new TreeNode(4,null,null);
        TreeNode node3 = new TreeNode(3,null,null);
        TreeNode node2 = new TreeNode(2,node4,node5);
        TreeNode node1 = new TreeNode(1,node2,node3);
        midOrder(node1);
    }

    //中序遍历
    public static void midOrder(TreeNode root){
        if (root==null){
            return;
        }
        midOrder(root.left);
        System.out.println(root.val);
        midOrder(root.right);
    }
}

结果：4265713

后序遍历

在左右子节点都遍历结束后再打印根节点的信息。参考前面两种。

上代码：

//19遍历二叉树
public class BinaryTree19 {
    public static void main(String[] args) {
        TreeNode node7 = new TreeNode(7,null,null);
        TreeNode node6 = new TreeNode(6,null,null);
        TreeNode node5 = new TreeNode(5,node6,node7);
        TreeNode node4 = new TreeNode(4,null,null);
        TreeNode node3 = new TreeNode(3,null,null);
        TreeNode node2 = new TreeNode(2,node4,node5);
        TreeNode node1 = new TreeNode(1,node2,node3);
        lastOrder(node1);
    }
    //后序遍历
    public static void lastOrder(TreeNode root){
        if (root==null){
            return;
        }
        lastOrder(root.left);
        lastOrder(root.right);
        System.out.println(root.val);
    }
}

结果：4675231

层序遍历

二叉树里面，我们知道，假设是满二叉树，那么每一层节点数都是上一层两倍。这个时候就可以把二叉树转化成一个数组。假设第一个节点存在下标为1位置处，那么第二个节点就在1*2位置处，第三个节点就在1*2+1位置处。归纳发现，每一个左子节点都是根下标*2处，每一个右子节点都是在根下标*2+1处。

上代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

//19遍历二叉树
public class BinaryTree19 {
    public static void main(String[] args) {
        TreeNode node7 = new TreeNode(7,null,null);
        TreeNode node6 = new TreeNode(6,null,null);
        TreeNode node5 = new TreeNode(5,node6,node7);
        TreeNode node4 = new TreeNode(4,null,null);
        TreeNode node3 = new TreeNode(3,null,null);
        TreeNode node2 = new TreeNode(2,node4,node5);
        TreeNode node1 = new TreeNode(1,node2,node3);
        ArrayList list = new ArrayList<>();
        levelOrder(node1,1,list);
        list.forEach(System.out::println)
    }
    //层序遍历
    public static void levelOrder(TreeNode root,int i,ArrayList list){
        if (root==null){
            return;
        }
        int length = list.size();
        if (length<=i){
            for (int j=0;j<=i-length;j++){
                list.add(length+j,null);
            }
        }
        list.set(i,root.val);
        levelOrder(root.left,i*2,list);
        levelOrder(root.right,i*2+1,list);
    }
}

结果：1234567