LeetCode刷题之二叉树前、中、后序遍历及层次遍历

圆师傅

已于 2024-04-10 15:25:49 修改

阅读量340

点赞数 2

分类专栏：数据结构与算法文章标签： leetcode

于 2024-04-09 16:51:08 首次发布

本文链接：https://blog.csdn.net/Apple_wolf/article/details/137552846

版权

数据结构与算法专栏收录该内容

26 篇文章 0 订阅

订阅专栏

0. 题目汇总

leetCode 94题二叉树中序遍历
 leetCode 144题二叉树前序遍历
 LeetCode 145题二叉树后序遍历
 LeetCode 102题二叉树层序遍历
 LeetCode题199 二叉树的右侧图
 LeetCode题230 二叉搜索树中第K小的元素

1. 描述

leetCode 94题二叉树中序遍历

给定一个二叉树的根节点 root ，返回它的中序遍历。

示例1：
请添加图片描述

输入：root = [1,null,2,3]
输出：[1,3,2]

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

2. 分析

2.1 递归方法

中序遍历就是左-根-右顺序遍历。然后每个子树都要进行递归调用。

2.2 迭代

递归调用是维护了一个隐式的栈的，迭代就是自己显式维护这个栈。

3. 解答

3.1 递归

/**
 * 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;
 *     }
 * }
 */
public class Soultion {
	
	public List<Integer> inorderTraversal(TreeNode root) {
		List<Integer> res = new ArrayList<>();
        inorder(root, res);
        return res;
	} 
	private void inorder(TreeNode root, List<Integer> res) {
		if (root == null) {
			return;
		}
		inorder(root.left, res);
		res.add(root.val);
		inorder(root.right, res);
		
	}
}

3.2 迭代

public List<Integer> inorderTraversal(TreeNode root) {
      
        //迭代方法
        List<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();

        while(root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            res.add(root.val);
            root = root.right;
        }

        return res;
    }

4. 二叉树的前序遍历

leetCode 144题二叉树前序遍历

与中序遍历相比，只是遍历顺序变成了根节点-左节点-右节点。

4.1 递归

/**
 * 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<>();
        preorder(root, res);
        return res;
    }

    private void preorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }

        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }
}

4.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<>();
        Stack<TreeNode> stack = new Stack<>();

        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                res.add(root.val);
                stack.push(root);
                root = root.left;
            }

            root = stack.pop();
            root = root.right;

        }
        return res;
    }
}

5.后序遍历

LeetCode 145题二叉树后序遍历
左节点-右节点-根节点

5.1 递归

/**
 * 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<>();
        postOrder(root, res);
        return res;
    }

    private void postOrder(TreeNode root, List res) {
        if (root == null) {
            return;
        }
        postOrder(root.left, res);
        postOrder(root.right, res);
        res.add(root.val);
    }
}

5.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> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode prev = null;

        while(root != null || !stack.isEmpty()) {
            while (root != null) {
                stack.push(root);
                root = root.left;
            }

            root = stack.pop();
            if (root.right == null || root.right == prev) {
                res.add(root.val);
                prev = root;
                root = null;
            } else {
                stack.push(root);
                root = root.right;
            }
            
        }

        return res;
    }
}

6. 二叉树的层序遍历

LeetCode 102题二叉树层序遍历

6.1 描述

给你二叉树的根节点 root ，返回其节点值的层序遍历。（即逐层地，从左到右访问所有节点）。

示例 1：
请添加图片描述

输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]

示例 2：

输入：root = [1]
输出：[[1]]

示例 3：

输入：root = []
输出：[]

6.2 分析

用一个队列来存放每一层的所有元素。

6.3解答

6.3.1 迭代

/**
 * 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) {
        Queue<TreeNode> queue = new LinkedList<>();
        List<List<Integer>> res = new ArrayList<>();

        if (root != null) queue.add(root);

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

6.3.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<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        helper(root, 0, res);
        return res;
    }

    private void helper(TreeNode root, int level, List<List<Integer>> res) {
        if (root == null) {
            return;
        }
        if (res.size() == level) {
            List<Integer> newList = new ArrayList<>();
            res.add(newList);
        } 
        List<Integer> tmp = res.get(level);
        tmp.add(root.val);
        
        helper(root.left, level + 1 , res);
        helper(root.right, level + 1, res);
    }
}

7.二叉树的右侧视图

LeetCode题199 二叉树的右侧图

7.1 描述

给定一个二叉树的根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:
请添加图片描述

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

7.2 分析

一看到这个题，很容易联想到我们二叉树的层次遍历这个题，在拿到层次遍历的结果之后，只要再取出每一层的最后一个元素，就是题目要求的右侧视图了。

另外，我们层序遍历二叉树，往List中放数据的时候，如果不是全部都放进去，而是不断用右子树数据区替换原来的List，那么一次遍历下来的结果，就是右侧视图。

7.3 解答

7.3.1 层序遍历后取数据

/**
 * 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> rightSideView(TreeNode root) {
        List<List<Integer>> tmp = new ArrayList<>();
        level(root, 0, tmp);

        List<Integer> res = new ArrayList<>();
        for (int i = 0; i < tmp.size(); i++) {
            List<Integer> list = tmp.get(i);
            res.add(list.get(list.size() - 1));
        }

        return res;
    }

    private void level(TreeNode root, int level, List<List<Integer>>res) {
        if (root == null) {
            return;
        }

        if (res.size() == level) {
            res.add(new ArrayList<Integer>());
        } 

        res.get(level).add(root.val);
        level(root.left, level + 1, res);
        level(root.right, level + 1, res);
        
    }
}

7.3.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> rightSideView(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        level(root, 0, res);
        return res;
    }

    private void level(TreeNode root, int level, List<Integer> res) {
        if (root == null) {
            return;
        }

        if (res.size() == level) {
            res.add(0);
        } 

        res.set(level, root.val);
        level(root.left, level + 1, res);
        level(root.right, level + 1, res);
        
    }
}

8. 二叉搜索树中第K小的元素

LeetCode题230 二叉搜索树中第K小的元素

8.1 描述

给定一个二叉搜索树的根节点 root ，和一个整数 k ，请你设计一个算法查找其中第 k 个最小元素（从 1 开始计数）。

示例 1：
请添加图片描述

输入：root = [3,1,4,null,2], k = 1
输出：1

示例 2：

请添加图片描述

输入：root = [5,3,6,2,4,null,null,1],k = 3
输出：3

8.2 分析

二叉搜索树的一个特点是：其中序排列是单调递增的。

那么我们可以写出去中序遍历的结果，然后再从中序遍历中找出第K个小的元素。

但是这里我们不需要完整的中序遍历，我们可以在遍历的时候，同时计数，当计数达到第k个时候，停止遍历即可。

8.3 解答

/**
 * 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 int kthSmallest(TreeNode root, int k) {
        Deque<TreeNode> queue = new ArrayDeque<>();
        while ( root != null || !queue.isEmpty()) {
            while (root != null) {
                queue.push(root);
                root = root.left;
            }

            root = queue.pop();
            --k;
            if (k == 0) {
                break;
            }
            root = root.right;
        }

        return root.val;
    }

}

圆师傅

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
LeetCode刷题之二叉树前、中、后序遍历及层次遍历

中序遍历就是左-根-右顺序遍历。然后每个子树都要进行递归调用。递归调用是维护了一个隐式的栈的，迭代就是自己显式维护这个栈。给定一个二叉树的根节点 root ，返回它的。输入：root = [1,null,2,3]输入：root = [1]输入：root = []输出：[1,3,2]
复制链接

扫一扫