算法学习(寒假打卡)——06二叉树的前中后以及层序遍历

一、复习二叉树的遍历

前序遍历(根左右)

中序遍历(左根右)

后序遍历(左右根)

层序遍历(从根到叶，从左到右，按照层级一层一层排)

大家应该也看出来啦这个可以简记的规律，那我们根据图示来复习对照一下

二、代码实现

1、实现

我们可以就前序遍历先来说说怎么实现，然后再根据算法题的要求进行修改，这里采用的是递归

public class Tree {
    //定义一个树
    public static class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;
        TreeNode() {}
        TreeNode(int val) { this.val = val; }
        TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
    //前序遍历方法
    public static void touch(TreeNode node){
        //输出节点的值
        System.out.println(node.val);
        //左孩子
        if(node.left != null){
            touch(node.left);
        }
        //右孩子
        if(node.right != null){
            touch(node.right);
        }
    }
	//测试！！
    public static void main(String[] args) {
        //定义一个树，按照上面图示的树定义
        TreeNode treeNode1 = new TreeNode(1);
        TreeNode treeNode2 = new TreeNode(2);
        TreeNode treeNode3 = new TreeNode(3);
        TreeNode treeNode4 = new TreeNode(4);
        TreeNode treeNode5 = new TreeNode(5);
        TreeNode treeNode6 = new TreeNode(6);
        TreeNode treeNode7 = new TreeNode(7);
        treeNode1.left = treeNode2;
        treeNode1.right = treeNode5;
        treeNode2.left = treeNode3;
        treeNode2.right = treeNode4;
        treeNode5.left = treeNode6;
        treeNode6.left = treeNode7;
        touch(treeNode1);
    }
}
//结果1 2 3 4 5 6 7

如果不是很清楚递归是怎么实现的，我们可以采用Debug的方式对方法进行调试，这样就可以详细的看到当前正在比较的节点以及判断左孩子右孩子的过程。

2、算法题

144. 二叉树的前序遍历

给你二叉树的根节点 root ，返回它节点值的 前序 遍历。

class Solution {
    public void touch(TreeNode node,List<Integer> list){
        if(node == null) return;
        //前序遍历(根左右)
        list.add(node.val);
        //左孩子
        if(node.left != null){
            touch(node.left,list);
        }
        //右孩子
        if(node.right != null){
            touch(node.right,list);
        }
    }
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        touch(root,list);
        return list;
    }
}

94. 二叉树的中序遍历

class Solution {
    public void touch(TreeNode node,List<Integer> list){
        if(node == null) return;
        //左孩子
        if(node.left != null){
            touch(node.left,list);
        }
        //中序遍历(左根右)
        list.add(node.val);
        //右孩子
        if(node.right != null){
            touch(node.right,list);
        }
    }
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        touch(root,list);
        return list;
    }
}

145. 二叉树的后序遍历

class Solution {
    public void touch(TreeNode node,List<Integer> list){
        if(node == null) return;
        //左孩子
        if(node.left != null){
            touch(node.left,list);
        }
        //右孩子
        if(node.right != null){
            touch(node.right,list);
        }
        //后序遍历(左右根)
        list.add(node.val);
    }
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> list = new ArrayList<Integer>();
        touch(root,list);
        return list;
    }
}

102. 二叉树的层序遍历

这里使用的是队列！！！

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
    List<List<Integer>> res = new ArrayList<>();

    Queue<TreeNode> queue = new ArrayDeque<>();
    if (root != null) {
        queue.add(root);
    }
    while (!queue.isEmpty()) {
        int n = queue.size();
        List<Integer> level = new ArrayList<>();
        for (int i = 0; i < n; i++) { 
            TreeNode node = queue.poll();
            level.add(node.val);
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
        res.add(level);
    }
    return res;
    }
}