二叉树的前序遍历
-
我的解法：利用递归，自底向下逐步添加到list，返回最终的前序遍历list
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list=new ArrayList<>();
if (root==null) {
return list;
}
list.add(root.val);
if (root.left!=null) {
list.addAll(preorderTraversal(root.left));
}
if (root.right!=null) {
list.addAll(preorderTraversal(root.right));
}
return list;
}
}
-
参考解法：利用递归，但只在外部建一个list，更好理解！
class Solution {
public List<Integer> list=new LinkedList<>();
public List<Integer> preorderTraversal(TreeNode root) {
if (root==null)
return list;
list.add(root.val);
preorderTraversal(root.left);
preorderTraversal(root.right);
return list;
}
}
中序遍历二叉树，同样有两种方法
-
第一种
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> list=new ArrayList<>();
if (root==null) {
return list;
}
if (root.left!=null) {
list.addAll(inorderTraversal(root.left));
}
list.add(root.val);
if (root.right!=null) {
list.addAll(inorderTraversal(root.right));
}
return list;
}
}
-
第二种
class Solution {
List<Integer> list=new ArrayList<>();
public List<Integer> inorderTraversal(TreeNode root) {
if (root==null) {
return list;
}
inorderTraversal(root.left);
list.add(root.val);
inorderTraversal(root.right);
return list;
}
}
-
后序遍历二叉树：也有两种方法，和前面的差不多，所以只写简洁的
class Solution {
List<Integer> list=new ArrayList<>();
public List<Integer> postorderTraversal(TreeNode root) {
if (root==null) {
return list;
}
postorderTraversal(root.left);
postorderTraversal(root.right);
list.add(root.val);
return list;
}
}
层次遍历二叉树
-
队列解法：
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res=new ArrayList<>();
if (root==null) {
return res;
}
Queue<TreeNode> queue=new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
int count=queue.size();
List<Integer> list=new LinkedList<>();
while (count>0) {
TreeNode node=queue.poll();
list.add(node.val);
if (node.left!=null) {
queue.add(node.left);
}
if (node.right!=null) {
queue.add(node.right);
}
count--;
}
res.add(list);
}
return res;
}
}
-
递归解法：参考大神的代码！！！
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res=new ArrayList<>();
if (root==null) {
return res;
}
addList(res, 0, root);
return res;
}
private void addList(List<List<Integer>> res,int level,TreeNode head) {
if (head==null) {
return;
}
if (res.size()<=level) { //这里有个问题，如果不是等于的话
res.add(new ArrayList<>());
}
res.get(level).add(head.val);//这里的将会越界，因为level=res.size()取不到
addList(res, level+1, head.left);
addList(res, level+1, head.right);
}
}
二叉树的最大深度
-
递归
class Solution {
public int maxDepth(TreeNode root) {
if (root==null) {
return 0;
}
int leftH=maxDepth(root.left);
int rightH=maxDepth(root.right);
return Math.max(leftH, rightH)+1;
}
}
迭代
这个方法太难了，不优先考虑！！
class Solution {
public int maxDepth(TreeNode root) {
Queue<Pair<TreeNode,Integer>> queue=new LinkedList<>();
if (root!=null) {
queue.add(new Pair<TreeNode, Integer>(root, 1));
}
int depth=0;
while (!queue.isEmpty()) {
Pair<TreeNode,Integer> pair=queue.poll();
root=pair.getKey();
int pair_depth=pair.getValue();
if (root!=null) {
depth=Math.max(depth, pair_depth);
queue.add(new Pair<TreeNode, Integer>(root.left, pair_depth+1));
queue.add(new Pair<TreeNode, Integer>(root.right, pair_depth+1));
}
}
return depth;
}
}
对称二叉树
-
递归
class Solution {
public boolean isSymmetric(TreeNode root) {
return isMirror(root, root);
}
private boolean isMirror(TreeNode t1,TreeNode t2) {
if (t1==null&&t2==null) {
return true;
}
if (t1==null||t2==null) {
return false;
}
return (t1.val==t2.val)&&isMirror(t1.left, t2.right)
&&isMirror(t1.right,t2.left);
}
}
-
迭代
class Solution {
public boolean isSymmetric(TreeNode root) {
Queue<TreeNode> queue=new LinkedList<>();
if (root==null||(root.left==null&&root.right==null)) {
return true;
}
queue.add(root.left);
queue.add(root.right);
while (!queue.isEmpty()) {
TreeNode t1=queue.poll();
TreeNode t2=queue.poll();
if (t1==null&&t2==null) continue;
if(t1==null||t2==null) return false;
if(t1.val!=t2.val) return false;
queue.add(t1.left);
queue.add(t2.right);
queue.add(t1.right);
queue.add(t2.left);
}
return true;
}
}
-
路径总和：递归很简洁
class Solution {
public boolean hasPathSum(TreeNode root, int sum) {
if (root==null) {
return false;
}
if (root.left==null&&root.right==null) {
return sum-root.val==0;
}
return hasPathSum(root.right, sum-root.val)||
hasPathSum(root.left, sum-root.val);
}
}
验证二叉搜索树
-
利用中序遍历法：简单易懂
class Solution {
public boolean isValidBST(TreeNode root) {
if (root==null) {
return true;
}
List<Integer> list=new ArrayList<>();
inOrder(root, list);
for (int i = 0; i < list.size()-1; i++) {
if (list.get(i+1)<=list.get(i)) {
return false;
}
}
return true;
}
private void inOrder(TreeNode node,List<Integer> list) {
if (node==null) {
return;
}
inOrder(node.left, list);
list.add(node.val);
inOrder(node.right, list);
}
}
-
大神递归法：
class Solution {
double last=-Double.MAX_VALUE;
public boolean isValidBST(TreeNode root) {
if (root==null) {
return true;
}
if (isValidBST(root.left)) {
if (last<root.val) {
last=root.val;
return isValidBST(root.right);
}
}
return false;
}
}
-
堆桟法
public boolean isValidBST(TreeNode root) {
Stack<TreeNode> stack = new Stack();
TreeNode p = root;
Integer preVal = null ;
while( p != null || !stack.isEmpty() ){
if(p != null){
stack.push(p);
p = p.left;
}else{
p = stack.pop();
int val = p.val;
if(preVal == null){
preVal = val;
}else{
if(val <= preVal){
return false;
}
preVal = val;
}
p = p.right;
}
}
return true;
}
将有序数组转换为二叉搜索树
-
解法一
class Solution {
public TreeNode sortedArrayToBST(int[] nums) {
return buildBST(nums, 0, nums.length-1);
}
private TreeNode buildBST(int[] nums,int l,int r) {
if (l>r) {
return null;
}
if (l==r) {
return new TreeNode(nums[l]);
}
int mid=(r+l)/2;
TreeNode root=new TreeNode(nums[mid]);
root.left=buildBST(nums, l, mid-1);
root.right=buildBST(nums, mid+1, r);
return root;
}
}
总结：递归是万能的，但递归真的很恶心！！！