今日任务
二叉树理论基础
二叉递归
迭代
统一迭代
层序遍历
二叉树理论基础
在我们解题过程中二叉树有两种主要的形式:满二叉树和完全二叉树。
二哈书遍历方式分为深度优先和广度优先,其中深度优先又分成前序,中序,后序遍历。
二叉树递归遍历
144.二叉树的前序遍历 . - 力扣(LeetCode)
145.二叉树的后序遍历 . - 力扣(LeetCode)
94.二叉树的中序遍历 . - 力扣(LeetCode)
/**
* 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> result = new ArrayList<Integer>();
preorder(root, result);
return result;
}
public void preorder(TreeNode root, List<Integer> result) {
if (root == null) {
return;
}
result.add(root.val);
preorder(root.left, result);
preorder(root.right, result);
}
}
/**
* 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> result = new ArrayList<>();
Stack<TreeNode> stack = new Stack<TreeNode>();
if (root == null) { return result; }
stack.push(root);
while (!stack.isEmpty()) {
TreeNode node = stack.pop();
result.add(node.val);
if (node.left != null) { stack.push(node.left); }
if (node.right != null) { stack.push(node.right); }
}
Collections.reverse(result);
return result;
}
// @Test
// public void test(){
// TreeNode node1 = new TreeNode(3, null, null);
// TreeNode node2 = new TreeNode(2, node1, null);
// TreeNode node3 = new TreeNode(1, null, node2);
// System.out.println("The result is " + postorderTraversal(node3).toString());
// }
}
/**
* 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> result = new ArrayList<>();
inOrder(root, result);
return result;
}
public void inOrder(TreeNode root, List<Integer> result){
if (root == null) {
return;
}
inOrder(root.left, result);
result.add(root.val);
inOrder(root.right, result);
return;
}
// @Test
// public void test() {
// TreeNode node1 = new TreeNode(3, null, null);
// TreeNode node2 = new TreeNode(2, node1, null);
// TreeNode node3 = new TreeNode(1, null, node2);
// System.out.println("The result is " + inorderTraversal(node3).toString());
// }
// 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;
// }
// }
}
二叉树迭代
迭代法主要是结合堆栈进行处理。
144.二叉树的前序遍历 . - 力扣(LeetCode)
145.二叉树的后序遍历 . - 力扣(LeetCode)
94.二叉树的中序遍历 . - 力扣(LeetCode)
二叉树统一迭代
是对迭代法的优化,提取了统一的模版。
二叉树层序遍历
题目链接:
102.二叉树的层序遍历 . - 力扣(LeetCode)
/**
* 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>> result = new ArrayList<List<Integer>>();
if (root == null) {return result;}
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> restList = new ArrayList<>();
int len = queue.size();
while (len > 0) {
TreeNode tempNode = queue.poll();
restList.add(tempNode.val);
if (tempNode.left != null) queue.offer(tempNode.left);
if (tempNode.right != null) queue.offer(tempNode.right);
len--;
}
result.add(restList);
}
return result;
}
}