算法-leetcode-树相关问题- 二叉树的四种遍历方式

30, 102. 二叉树的层序遍历

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

package com.shangguigu.dachang.algrithm.A09_basicTree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * @author : 不二
 * @date : 2022/4/20-下午8:43
 * @desc : 102. 二叉树的层序遍历
 * https://leetcode-cn.com/problems/binary-tree-level-order-traversal/
 *
 **/
public class A04_levelOrder {

    public static void main(String[] args) {
        TreeNode tn1 = new TreeNode(3);
        TreeNode tn2 = new TreeNode(9);
        TreeNode tn3 = new TreeNode(20);
        TreeNode tn4 = new TreeNode(15);
        TreeNode tn5 = new TreeNode(7);

        tn1.left = tn2;
        tn1.right = tn3;
        tn3.left = tn4;
        tn3.right = tn5;

        List<List<Integer>> results = levelOrder(tn1);
        System.out.println(results);
    }


    /**
     * 这里其实就是通过队列的方式进行处理的
     * 把根节点放入队列中
     * 出队的时候，根据当前size出对，把第二层子节点加入到队列中
     * 然后再次根据当前size出对的时候，再把第三层的子节点再加入进去
     * 依次下去的话，就可以层序遍历出二叉树了
     *
     */
    public static List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret = new ArrayList<List<Integer>>();
        if (root == null) {
            return ret;
        }

        // LinkedList本身继承了Deque，是一个双端队列
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);

        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<>();
            int currentLevelSize = queue.size();

            for (int i = 1; i <= currentLevelSize; ++i) {
                TreeNode node = queue.poll();
                level.add(node.val);
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if (node.right != null) {
                    queue.offer(node.right);
                }
            }
            ret.add(level);
        }

        return ret;
    }
}

29, 145. 二叉树的后序遍历

https://leetcode-cn.com/problems/binary-tree-postorder-traversal/

package com.shangguigu.dachang.algrithm.A09_basicTree;

import java.util.LinkedList;
import java.util.List;

/**
 * @author : 不二
 * @date : 2022/4/20-下午8:12
 * @desc : 145. 二叉树的后序遍历
 * https://leetcode-cn.com/problems/binary-tree-postorder-traversal/
 *
 **/
public class A03_postorderTraversal {

    public static void main(String[] args) {
        TreeNode tn1 = new TreeNode(1);
        // TreeNode tn_2 = new TreeNode(null);
        TreeNode tn2 = new TreeNode(2);
        TreeNode tn3 = new TreeNode(3);
        tn1.right = tn2;
        tn2.left = tn3;

        List<Integer> integers = postorderTraversal(tn1);
        System.out.println(integers);

        tn1.postorderTraversal();
    }

    public static List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> resultList = new LinkedList<>();
        if (root != null) {
            postorderTraversal(root, resultList);
        }
        return resultList;
    }

    public static void postorderTraversal(TreeNode root, List<Integer> resultList) {
        // 前序遍历就是先遍历根节点，再遍历左子节点，最后遍历右子节点
        // 首先把当前数据添加进去

        if (root.left != null) {
            postorderTraversal(root.left, resultList);
        }
        if (root.right != null) {
            postorderTraversal(root.right, resultList);
        }
        resultList.add(root.val);
    }
}

28, 94. 二叉树的中序遍历

https://leetcode-cn.com/problems/binary-tree-inorder-traversal/

package com.shangguigu.dachang.algrithm.A09_basicTree;

import java.util.LinkedList;
import java.util.List;

/**
 * @author : 不二
 * @date : 2022/4/20-下午8:08
 * @desc : 94. 二叉树的中序遍历
 * https://leetcode-cn.com/problems/binary-tree-inorder-traversal/
 **/
public class A02_inorderTraversal {
    public static void main(String[] args) {
        TreeNode tn1 = new TreeNode(1);
        // TreeNode tn_2 = new TreeNode(null);
        TreeNode tn2 = new TreeNode(2);
        TreeNode tn3 = new TreeNode(3);
        tn1.right = tn2;
        tn2.left = tn3;

        List<Integer> integers = inorderTraversal(tn1);
        System.out.println(integers);

        tn1.inorderTraversal();

    }

    public static List<Integer> inorderTraversal(TreeNode root) {
        LinkedList<Integer> resultList = new LinkedList<>();
        if (root != null) {
            inorderTraversal(root, resultList);
        }
        return resultList;
    }

    public static void inorderTraversal(TreeNode root, List<Integer> resultList) {
        // 前序遍历就是先遍历根节点，再遍历左子节点，最后遍历右子节点
        // 首先把当前数据添加进去

        if (root.left != null) {
            inorderTraversal(root.left, resultList);
        }
        resultList.add(root.val);
        if (root.right != null) {
            inorderTraversal(root.right, resultList);
        }
    }
}

27, 144. 二叉树的前序遍历

https://leetcode-cn.com/problems/binary-tree-preorder-traversal/

package com.shangguigu.dachang.algrithm.A09_basicTree;

import java.util.LinkedList;
import java.util.List;

/**
 * @author : 不二
 * @date : 2022/4/20-下午4:01
 * @desc : 144. 二叉树的前序遍历
 * https://leetcode-cn.com/problems/binary-tree-preorder-traversal/
 **/
public class A01_preorderTraversal {

    public static void main(String[] args) {
        TreeNode tn1 = new TreeNode(1);
        // TreeNode tn_2 = new TreeNode(null);
        TreeNode tn2 = new TreeNode(2);
        TreeNode tn3 = new TreeNode(3);
        tn1.right = tn2;
        tn2.left = tn3;

        List<Integer> integers = preorderTraversal(tn1);
        System.out.println(integers);

        // 对象方法
        tn1.preorderTraversal();
    }

    public static List<Integer> preorderTraversal(TreeNode root) {
        LinkedList<Integer> resultList = new LinkedList<>();
        if (root != null) {
            preorderTraversal(root, resultList);
        }
        return resultList;
    }

    public static void preorderTraversal(TreeNode root, List<Integer> resultList) {
        // 前序遍历就是先遍历根节点，再遍历左子节点，最后遍历右子节点
        // 首先把当前数据添加进去
        resultList.add(root.val);

        if (root.left != null) {
            preorderTraversal(root.left, resultList);
        }
        if (root.right != null) {
            preorderTraversal(root.right, resultList);
        }
    }
}