144. 二叉树的前序遍历
题目描述：
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
示例 1：
输入：root = [1,null,2,3]
输出：[1,2,3]
示例 2：
输入：root = []
输出：[]
示例 3：
输入：root = [1]
输出：[1]
图示：
迭代代码：
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import javax.swing.tree.TreeNode;
/*
* @lc app=leetcode.cn id=144 lang=java
*
* [144] 二叉树的前序遍历
*/
// @lc code=start
/**
* 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<>();
LinkedList<TreeNode> stack = new LinkedList<>();//栈
TreeNode cur = root;
while (!stack.isEmpty() || cur != null) {
if (cur != null) {
res.add(cur.val);
stack.addLast(cur);
cur = cur.left;
}else{
cur = stack.removeLast().right;
}
}
return res;
}
}
// @lc code=end
94.二叉树中序遍历
题目描述：
给定一个二叉树的根节点 root ，返回它的 中序 遍历。
示例：
输入：root = [1,null,2,3]
输出：[1,3,2]
输入：root = []
输出：[]
输入：root = [1]
输出：[1]
输入：root = [1,2]
输出：[2,1]
输入：root = [1,null,2]
输出：[1,2]
迭代代码：
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import javax.swing.tree.TreeNode;
/*
* @lc app=leetcode.cn id=94 lang=java
*
* [94] 二叉树的中序遍历
*/
// @lc code=start
/**
* 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<>();
LinkedList<TreeNode> stack = new LinkedList<>();
TreeNode cur = root;
TreeNode pre = null;
while (!stack.isEmpty() || cur != null) {
if(cur != null){
stack.addLast(cur);
cur = cur.left;
}else{
pre = stack.removeLast();
res.add(pre.val);
cur = pre.right;
}
}
return res;
}
}
// @lc code=end
后序遍历
题目描述：
给定一个二叉树，返回它的 后序 遍历。
示例:
输入: [1,null,2,3]
1
\
2
/
3
输出: [3,2,1]
迭代代码：
import java.util.*;
/*
* @lc app=leetcode.cn id=145 lang=java
*
* [145] 二叉树的后序遍历
*/
import javax.swing.tree.TreeNode;
// @lc code=start
/**
* 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) {
// 如果根节点为空，则直接返回空列表
if (root == null){
return new ArrayList<>();
}
//声明列表
ArrayList<Integer> list = new ArrayList<>();
//声明栈A
LinkedList<TreeNode> stackA = new LinkedList<>();
//声明栈B
LinkedList<TreeNode> stackB = new LinkedList<>();
//将次元素压入栈A
stackA.addLast(root);
//当栈A不为空时
while (!stackA.isEmpty()){
//取出其中压入的元素
TreeNode node = stackA.removeLast();
//压入栈B中
stackB.addLast(node);
//当此节点左子节点不为空时
if (node.left != null){
//压入栈A
stackA.addLast(node.left);
}
//当此节点右子节点不为空时
if (node.right != null){
//压入栈A
stackA.addLast(node.right);
}
}
//当栈B不为空时
while (!stackB.isEmpty()){
//取出其元素并且添加至列表中
TreeNode node = stackB.removeLast();
list.add(node.val);
}
//最后返回列表
return list;
}
}
// @lc code=end
二叉树的层序遍历
题目描述：
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
示例：
二叉树：[3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其层序遍历结果：
[
[3],
[9,20],
[15,7]
]
图示：
代码：
/*
* @lc app=leetcode.cn id=102 lang=java
*
* [102] 二叉树的层序遍历
*/
// @lc code=start
/**
* 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) {
if (root == null) {
return new ArrayList<List<Integer>>();
}
// 声明一个列表存储每一行的数据
List<List<Integer>> result = new ArrayList<>();
//声明一个队列
LinkedList<TreeNode> queue = new LinkedList<>();
//如果根节点不为空，将其入队
queue.offer(root);
//当队列不为空时，代表队列里有数据
while (!queue.isEmpty()) {
//存储每一行的数据line
List<Integer> line = new ArrayList<Integer>();
//保存队列中现有数据的个数，这些就是要添加至每一行列表的值
int size = queue.size();
for (int i=0;i<size;i++){
//取出队列的节点 （FIFO 先进先出）
TreeNode node = queue.poll();
line.add(node.val);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
result.add(line);
}
return result;
}
}
// @lc code=end
