Day15
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>> ans = new ArrayList();
public List<List<Integer>> levelOrder(TreeNode root) {
checkFun(root, 0);
return ans;
}
public void checkFun (TreeNode node, int deep) {
if (node == null) return;
deep++;
if (ans.size() < deep) {
List<Integer> list = new ArrayList();
ans.add(list);
}
ans.get(deep - 1).add(node.val);
checkFun(node.left, deep);
checkFun(node.right, deep);
}
}
迭代法
/**
* 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>> ans = new ArrayList();
if (root == null) return ans;
Queue<TreeNode> queue = new LinkedList();
queue.offer(root);
while (!queue.isEmpty()) {
int len = queue.size();
List<Integer> list = new ArrayList();
while (len > 0) {
TreeNode node = queue.poll();
len--;
list.add(node.val);
if (node.left != null) queue.offer(node.left);
if (node.right != null) queue.offer(node.right);
}
ans.add(list);
}
return ans;
}
}
226.翻转二叉树
递归法
/**
* 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 TreeNode invertTree(TreeNode root) {
if (root == null) return root;
invert(root);
return root;
}
public void invert (TreeNode node) {
if (node.left == null && node.right == null) return;
TreeNode tmp = node.left;
node.left = node.right;
node.right = tmp;
if (node.left != null) invert(node.left);
if (node.right != null) invert(node.right);
}
}
迭代法
/**
* 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 TreeNode invertTree(TreeNode root) {
if (root == null) return root;
Stack<TreeNode> st = new Stack();
st.push(root);
while (!st.isEmpty()) {
TreeNode node = st.pop();
if (node.left != null) st.push(node.left);
if (node.right != null) st.push(node.right);
TreeNode tmp = node.left;
node.left = node.right;
node.right = tmp;
}
return root;
}
}
101.对称二叉树
迭代法
/**
* 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 boolean isSymmetric(TreeNode root) {
Queue<TreeNode> queue = new LinkedList();
queue.offer(root);
while (!queue.isEmpty()) {
int len = queue.size();
List<Integer> list = new ArrayList();
while (len -- > 0) {
TreeNode node = queue.poll();
if (node != null) {
list.add(node.val);
queue.offer(node.left);
queue.offer(node.right);
}
else list.add(null);
}
if (!isSym(list)) return false;
}
return true;
}
public boolean isSym(List<Integer> list) {
int len = list.size();
for (int i = 0; i < len / 2; i++) {
if (list.get(i) != list.get(len - 1 - i)) return false;
}
return true;
}
}
递归法
/**
* 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 boolean isSymmetric(TreeNode root) {
if (root == null) return true;
return compare(root.left, root.right);
}
public boolean compare(TreeNode left, TreeNode right) {
if (left == null && right == null) return true;
else if (left == null && right != null) return false;
else if (left != null && right == null) return false;
else if (left.val != right.val) return false;
boolean outside = compare(left.left, right.right);
boolean inside = compare(left.right, right.left);
return outside && inside;
}
}