代码随想录第十三天|144 二叉树的前序遍历 145二叉树的后序遍历 94 二叉树的中序遍历

哒哒233333

已于 2024-08-15 15:41:49 修改

阅读量162

点赞数 1

文章标签： java

于 2024-08-14 23:01:19 首次发布

本文链接：https://blog.csdn.net/weixin_39394671/article/details/141202078

版权

144 二叉树的前序遍历

满二叉树：二叉树，左右孩子都是满的
完全二叉树：二叉树，叶子节点从左到右
二叉搜索树：左的值<中的值<右的值
平衡二叉搜索树：左右子树的高度差不超过1的二叉搜索树
二叉树存储方式：链式和顺序存储（数组存储，下标：2i+1，2i+2）
前序遍历：中左右
中序遍历：左中右
后续遍历：左右中

/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        traversal(root, res);
        return res;
    }

    public void traversal(TreeNode cur, List<Integer> res) {
        if (cur == null) {
            return;
        }
        res.add(cur.val);
        traversal(cur.left, res);
        traversal(cur.right, res);
    }
}

145 后续遍历

/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        traversal(root, res);
        return res;
    }

    public void traversal(TreeNode cur, List<Integer> res) {
        if (cur == null) {
            return;
        }
        traversal(cur.left, res);
        traversal(cur.right, res);
        res.add(cur.val);
    }
}

94 中序遍历

/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        traversal(root, res);
        return res;
    }

    public void traversal(TreeNode cur, List<Integer> res) {
        if (cur == null) {
            return;
        }
        traversal(cur.left, res);
        res.add(cur.val);
        traversal(cur.right, res);
    }
}

102 二叉树的层序遍历

层序遍历使用到了队列

/**
 * Definition for a binary tree node.
 * public 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;
 *     }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            TreeNode node;
            List<Integer> list = new ArrayList<>();
            for(int i = 0; i < size; i++) {
                node = queue.poll();
                list.add(node.val);
                if(node.left != null) queue.offer(node.left);
                if(node.right != null) queue.offer(node.right);
            }
            res.add(list);
        }
        return res;
    }
}