一、题目
94. 二叉树的中序遍历https://leetcode.cn/problems/binary-tree-inorder-traversal/
144. 二叉树的前序遍历https://leetcode.cn/problems/binary-tree-preorder-traversal/
145. 二叉树的后序遍历https://leetcode.cn/problems/binary-tree-postorder-traversal/
二、题解
方式一:递归
/**
* 二叉树前序遍历
* 方式一:递归之前序遍历
*
* @param root
* @return
*/
public List<Integer> preorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<>();
preorder(root, res);
return res;
}
public void preorder(TreeNode curr, List<Integer> list) {
if (curr == null) {
return;
}
list.add(curr.val);
preorder(curr.left, list);
preorder(curr.right, list);
}
/**
* 二叉树遍历方式
* 方式一:递归之中序
*
* @param root
* @return
*/
public List<Integer> inorderTraversal(TreeNode root) {
LinkedList<Integer> res = new LinkedList<>();
inorder(root, res);
return res;
}
public void inorder(TreeNode curr, List<Integer> list) {
if (curr == null) {
return;
}
inorder(curr.left, list);
list.add(curr.val);
inorder(curr.right, list);
}
/**
* 二叉树得遍历方式
* 方式一:递归之后续遍历
*
* @param root
* @return
*/
public List<Integer> postorderTraversal(TreeNode root) {
LinkedList<Integer> res = new LinkedList<>();
postorder(root, res);
return res;
}
public void postorder(TreeNode curr, List<Integer> list) {
if (curr == null) {
return;
}
postorder(curr.left, list);
postorder(curr.right, list);
list.add(curr.val);
}
方式二:迭代
这俩天期末考试,有点忙,所以这俩天可能会偷会懒(其实我主要是想偷懒~放假肯定不啦,相信我~哈哈)
然后今天在更新一下二叉树的遍历的迭代法;
前序遍历中左右,看懂前序遍历后,你会发现后续遍历就是把前序遍历稍微改了一下,有朋友到这可能看不懂了,为什么后续遍历只是在前序遍历的代码上,把左右节点加入栈的顺序换了一下,最后反转了一下结果集,就成为后续遍历了呢?哈哈哈,这里我当时想通的时候,也不得不大喊一声,妙!那么为什么秒呢?我解释一下
前序遍历的顺序是中左右嘛,后续遍历的顺序是左右中嘛;我们把前序遍历的左右顺序换一下,是不是就变成了中右左了?这个时候,我们再把整体结果反转一下,是不是就是左右中了?看到这,你忽然茅塞顿开,哇,左右中??!!可不就是后续遍历嘛哈哈哈,所以说算法真的是好奇妙,只有每天刷算法的人,才能在看到一个好的思路时,感到惊奇惊奇,发出赞叹,那种感觉真的是妙不可言呢~
只有中序遍历嘛,也没什么好讲的啦,实在看不懂,就debug一下,然后再在纸上画一下,相信你马上就懂了,不是什么难点~
那么今天就先更新前中后序的普通迭代,后面还有前中后序的通用迭代,以及层序遍历呢~拜拜
/**
* 二叉树前序遍历
* 方式二:迭代遍历
*
*
* 中,左,右
* @param root
* @return
*/
public List<Integer> preorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode curr = root;
stack.push(curr);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
res.add(node.val); //输出中间节点
if (node.right != null) { //右节点入栈
stack.push(node.right);
}
if (node.left != null) { //左节点入栈
stack.push(node.left);
}
}
return res;
}
/**
* 二叉树遍历方式
* 方式一:迭代中序遍历
*
* @param root
* @return
*/
public List<Integer> inorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode curr = root;
while (!stack.isEmpty() || curr != null) {
if (curr != null) {
//如果当前节点不等于空,那么一直向左走
stack.push(curr);
curr = curr.left;
} else {
//如果当前节点为空
//输出当前节点
curr = stack.pop();
res.add(curr.val);
//然后将当前节点移动到当前节点的右节点
curr = curr.right;
}
}
return res;
}
/**
* 二叉树得遍历方式
* 方式一:迭代后续遍历
*
* @param root
* @return
*/
public List<Integer> postorderTraversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<>();
if (root == null) {
return res;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode curr = root;
stack.push(curr);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
res.add(node.val); //输出中间节点
if (node.left != null) { //左节点入栈
stack.push(node.left);
}
if (node.right != null) { //右节点入栈
stack.push(node.right);
}
}
Collections.reverse(res);
return res;
}
方式三:通用迭代
/**
*
* 二叉树得遍历方式:通用迭代遍历
*
* @param root
* @return
*/
public List<Integer> traversal(TreeNode root) {
ArrayList<Integer> res = new ArrayList<>();
Stack<TreeNode> stack = new Stack<>();
if (root == null) {
return res;
}
stack.push(root);
while (!stack.isEmpty()) {
TreeNode top = stack.peek();
//前序遍历,中,左右
if (top != null) {
TreeNode temp = stack.pop();
//放入中间节点
stack.push(temp);
stack.push(null);
//先放入右节点
if (temp.right != null) {
stack.push(temp.right);
}
//放入左节点
if (temp.left != null) {
stack.push(temp.left);
}
} else { //等于空得情况下,说明要弹出那个被标记得节点
stack.pop(); //弹出空
res.add(stack.pop().val);
}
}
return res;
}
以上是二叉树前中后得通用迭代方式,只需要不断变换中间节点得位置就行,前序遍历,中左右,那么就先放入右节点,在放入左节点,最后放入中间节点并加入空做标记;中序遍历,左中右,那么就先放入右节点,再放入中间节点并加入标记,最后放入左节点;后续遍历,左右中,先放入中间节点并加入标记,然后放入右节点,最后放入左节点。(标记就是加入空,当我们弹出节点得时候,遇到null,那么就表明下一个节点就是我们要弹出得节点);如果时间充足得话,希望大家可以用debug得方式将前中后方式分别就运行一遍,我相信马上会了然于胸得;
方式四:层序遍历(从左到右)
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res = new ArrayList<>();
LinkedList<TreeNode> list = new LinkedList<>();
if (root == null) {
return res;
}
list.addLast(root);
while (!list.isEmpty()) {
int len = list.size();
ArrayList<Integer> temp = new ArrayList<>();
while (len > 0) {
len--;
TreeNode first = list.getFirst();
temp.add(first.val);
if (first.left != null) {
list.addLast(first.left);
}
if (first.right != null) {
list.addLast(first.right);
}
list.removeFirst();
}
res.add(temp);
}
return res;
}