树Tree相关面试题

已于 2022-03-28 22:18:10 修改
阅读量379 收藏 1
点赞数 1
分类专栏： LeetCode 剑指Offer 文章标签： 二叉树 leetcode
于 2021-04-23 23:21:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45661125/article/details/114981447
版权

Tree

二叉树的层序遍历

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

import java.util.ArrayList;
import java.util.*;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    ArrayList<ArrayList<Integer>> ret = new ArrayList<>();
    ArrayList<ArrayList<Integer> > Print(TreeNode root) {
      if(root == null) {
          return ret;
      }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            ArrayList<Integer> tmp = new ArrayList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
            }
            ret.add(tmp);
        }
        return ret;
        
    }
}

二叉树的层序遍历II(从下往上遍历）

https://leetcode-cn.com/problems/binary-tree-level-order-traversal-ii/

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> ret = new LinkedList<>();
        if (root == null)
            return ret;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (!queue.isEmpty()) {
            List<Integer> tmp = new ArrayList<>();
            // 每次都取出一层的所有数据
            for (int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if (node.left != null){
                    queue.add(node.left);
                }                
                if (node.right != null){
                    queue.add(node.right);
                }     
            }
            // 每次都往队头塞
            ret.add(0, tmp);
        }
        return ret;
    }
}

二叉树的前序遍历

  • 递归
/**
 * 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> ret = new ArrayList<>();
        if(root == null) {
            return ret;
        }
        pre(root, ret);
        return ret;
    }
    public void pre(TreeNode root, List<Integer> ret) {
        if(root == null) {
            return ;
        }
        ret.add(root.val);
        pre(root.left, ret);
        pre(root.right, ret);
    }
}
  • 迭代
/**
 * 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> ret = new ArrayList<>();
        if(root == null) {
            return ret;
        }
        pre(root, ret);
        return ret;
    }
    public void pre(TreeNode root, List<Integer> ret) {
        if(root == null) {
            return;
        }
        Stack<TreeNode> stack=new Stack<>();
        while (root != null || !stack.isEmpty()) {
            while (root != null) {
                ret.add(root.val);
                stack.add(root);
                root = root.left;
            }
            root = stack.pop().right;
        }
    }
}

二叉树的中序遍历

https://www.nowcoder.com/practice/0bf071c135e64ee2a027783b80bf781d?tpId=117&&tqId=38363&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

  • 递归
//dfs
import java.util.*;
public class Solution {
    public List<Integer> list = new ArrayList<Integer>();
    public int[] inorderTraversal (TreeNode root) {
        in_order(root);
        int[] ret = new int[list.size()];
        for(int i = 0; i < list.size(); i++) {
            ret[i] = list.get(i);
        }
        return ret;
    }
    public void in_order(TreeNode root){
        if(root == null){
            return ;
        }else{
            in_order(root.left);
            list.add(root.val);
            in_order(root.right);
        }
    }
}
  • 迭代版本
//栈
public class Solution {
    public int[] inorderTraversal (TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
                if (cur != null) {
                    stack.push(cur);
                    cur = cur.left;
                } else {
                    cur = stack.pop();
                    list.add(cur.val);
                    cur = cur.right;
                }
            }
        int[] ret = new int[list.size()];
        for(int i = 0; i < list.size(); i++) {
            ret[i] = list.get(i);
        }
        return ret;
    }
}

二叉树的后续遍历

  • 递归
/**
 * 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> ret = new ArrayList<>();
        if(root == null) {
            return ret;
        }
        post(root, ret);
        return ret;
    }
    public void post(TreeNode root, List<Integer> ret) {
        if(root == null) {
            return ;
        }
        post(root.left, ret);
        post(root.right, ret);
        ret.add(root.val);
    }
}

**

  • 迭代版本

**

/**
 * 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> ret = new ArrayList<Integer>();
        if(root == null) {
            return ret;
        }
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode node = stack.pop();
            if(node.left != null) {
                stack.push(node.left);//和传统先序遍历不一样，先将左结点入栈
            }
            if(node.right != null) {
                stack.push(node.right); //后将右结点入栈
            }
            ret.add(0, node.val);                        //逆序添加结点值
        }     
    return ret;
    }
}

实现二叉树先序，中序和后序遍历

https://www.nowcoder.com/practice/a9fec6c46a684ad5a3abd4e365a9d362?tpId=117&&tqId=37819&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    public int[][] threeOrders (TreeNode root) {
        // write code here
     // write code here
        List<Integer> preList = new ArrayList();
        List<Integer> midList = new ArrayList();
        List<Integer> afterList = new ArrayList();
         
        preOrder(root,preList);
        midOrder(root,midList);
        afterOrder(root,afterList);
         
        int len=preList.size();
        int [][]result=new int[3][len];
         
        for(int i=0;i<len;i++){
            result[0][i]=preList.get(i);
        }
        for(int i=0;i<len;i++){
            result[1][i]=midList.get(i);
        }
        for(int i=0;i<len;i++){
            result[2][i]=afterList.get(i);
        }
        return result;
    }
    //先序  中左右
    public void preOrder(TreeNode root,List<Integer> list){
        if(root==null){
            return;
        }
        list.add(root.val);
        preOrder(root.left,list);
        preOrder(root.right,list);
    }
    //中序  左中右
    public void midOrder(TreeNode root,List<Integer> list){
        if(root==null){
            return;
        }
        midOrder(root.left,list);
        list.add(root.val);
        midOrder(root.right,list);
    }
    //后序  左右中
    public void afterOrder(TreeNode root,List<Integer> list){
        if(root==null){
            return;
        }
         
        afterOrder(root.left,list);
        afterOrder(root.right,list);
        list.add(root.val);
    }
}

对称的二叉树

https://leetcode-cn.com/problems/dui-cheng-de-er-cha-shu-lcof/

class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root == null) {
            return true;
        }
        return dfs(root.left, root.right);
    }
    public boolean dfs(TreeNode p, TreeNode q) {
        if(p == null && q == null) {
            return true;
        }
        if(p == null || q == null) {
            return false;
        }
        return p.val == q.val && dfs(p.left, q.right) && dfs(p.right, q.left);
    }
}

二叉树的镜像

https://leetcode-cn.com/problems/er-cha-shu-de-jing-xiang-lcof/

import java.util.*;
public class Solution {
    public TreeNode Mirror (TreeNode root) {
        // write code here
        if(root == null) {
            return null;
        }
        TreeNode left = Mirror(root.left);
        TreeNode right = Mirror(root.right);
        root.left = right;
        root.right = left;
        return root;
    }
}

class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        Stack<TreeNode> stk = new Stack<TreeNode>();
        stk.push(root);
        while(!stk.isEmpty()) {
            TreeNode node = stk.pop();
            if(node.left != null) stk.push(node.left);
            if(node.right != null) stk.push(node.right);
            TreeNode tmp = node.left;
            node.left = node.right;
            node.right = tmp;
        }
        return root;
    }
}

合并二叉树

https://leetcode-cn.com/problems/merge-two-binary-trees/

import java.util.*;
public class Solution {
    public TreeNode mergeTrees (TreeNode t1, TreeNode t2) {
        // write code here
        if(t1 == null)  return t2;
        if(t2 == null)  return t1;
        t1.val += t2.val;
        t1.left = mergeTrees(t1.left, t2.left);
        t1.right = mergeTrees(t1.right, t2.right);
        return t1;
    }
}

之字形打印二叉树I（左->右,左->右）

https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-ii-lcof/

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret = new ArrayList<>();
        if(root == null) {
            return ret;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            ArrayList<Integer> tmp = new ArrayList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                tmp.add(node.val);
                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
            }
            ret.add(tmp);
        } 
        return ret;
    }
}

之字形打印二叉树II（左->右->左）

问题链接：(https://leetcode-cn.com/problems/cong-shang-dao-xia-da-yin-er-cha-shu-iii-lcof/

/**
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> ret = new ArrayList<>();
        if(root == null) {
            return ret;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            ArrayList<Integer> tmp = new ArrayList<>();
            for(int i = queue.size(); i > 0; i--) {
                TreeNode node = queue.poll();
                if(ret.size() % 2 == 0) {
                   tmp.add(node.val);
                }else {
                     tmp.add(0, node.val);
                }
                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
            }
            ret.add(tmp);
        }
        return ret;
    }
}

二叉树的最大深度

问题链接：https://leetcode-cn.com/problems/er-cha-shu-de-shen-du-lcof/

    //dfs
class Solution {
    public int maxDepth(TreeNode root) {
    if(root==null) return 0;
    int l=maxDepth(root.left);
    int r=maxDepth(root.right);
    return Math.max(l,r)+1;
    }
}
  //bfs
class Solution {
    public int maxDepth(TreeNode root) {
    if(root==null) return 0;
    Queue<TreeNode> queue=new LinkedList<>();
    queue.add(root);
    int ret=0;
    while(!queue.isEmpty())
    {
        ret++;
        for(int i=queue.size();i>0;i--)
        {
            TreeNode node=queue.poll();;
            if(node.left!=null) queue.add(node.left);
            if(node.right!=null) queue.add(node.right);
        }
    }
    return ret;
    }
}

平衡二叉树

问题链接：https://leetcode-cn.com/problems/ping-heng-er-cha-shu-lcof/

//自顶向下dfs
class Solution {
   public boolean isBalanced(TreeNode root) {
        if(null == root){
            return true;
        }
        if(Math.abs(maxDepth(root.right)-maxDepth(root.left)) > 1){
            return false;
        }
        return isBalanced(root.right) && isBalanced(root.left);
    }
    public int maxDepth(TreeNode root) {
        if(null == root){
            return 0;
        }
        int l=maxDepth(root.left);
        int r=maxDepth(root.right);
        return Math.max(l,r)+1;
    }
}

//自底向上
class Solution {
    public int high(TreeNode root){
        if(root==null) return 0;
        int l=high(root.left);
        int r=high(root.right);
        if(Math.abs(l-r)<=1&&l!=-1&&r!=-1) 
        {
           return Math.max(l,r)+1;
        }else{
            return -1;
        }
    }
    public boolean isBalanced(TreeNode root) {
        return high(root)>=0;
    }
}

翻转一棵二叉树

问题链接：https://leetcode-cn.com/problems/invert-binary-tree/

//先序遍历
class Solution {
    public TreeNode invertTree(TreeNode root) {
     if(root==null) return null;
     //保存左子树
     TreeNode left=root.left;
     root.left=invertTree(root.right);
     root.right=invertTree(left);
     return root;
    }
}
//层序遍历
class Solution {
    public TreeNode invertTree(TreeNode root) {
        // 层次遍历--直接左右交换即可
        if (root == null) return null;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()){
            TreeNode node = queue.poll();
            TreeNode rightTree = node.right;
            node.right = node.left;
            node.left = rightTree;
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
        return root;
    }
}

二叉搜索树的第k大节点

https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof/

class Solution {
    public int kthLargest(TreeNode root, int k) {
        if(root == null) {
            return -1;
        }
        List<Integer> list = new ArrayList<>();
        dfs(root, list);
        return list.get(list.size() - k);
    }
    public void dfs(TreeNode root, List<Integer> list) {
        if(root == null) {
            return ;
        }
        dfs(root.left, list);
        list.add(root.val);
        dfs(root.right, list);
    }
}


class Solution {
    private int ret = 0, count = 0;
    public int kthLargest(TreeNode root, int k) {
        if(root == null) {
            return -1;
        }
        dfs(root, k);
        return ret;
    }
    private void dfs(TreeNode root, int k) {
        if(root == null) return ;
        dfs(root.right, k);
        if(++count == k) {
            ret = root.val;
        }
        dfs(root.left, k);
    }
}

二叉搜索树的第k小元素

https://leetcode-cn.com/problems/kth-smallest-element-in-a-bst/

class Solution {
    public int kthSmallest(TreeNode root, int k) {
         if(root == null) {
            return -1;
        }
        List<Integer> list = new ArrayList<>();
        dfs(root, list);
        return list.get(k - 1);
    }
      public void dfs(TreeNode root, List<Integer> list) {
        if(root == null) {
            return ;
        }
        dfs(root.left, list);
        list.add(root.val);
        dfs(root.right, list);
    }
}


class Solution {
    private int ret = 0, count = 0;
    public int kthSmallest(TreeNode root, int k) {
        if(root == null) {
            return -1;
        }
        dfs(root, k);
        return ret;
    }
      private void dfs(TreeNode root, int k) {
        if(root == null) return ;
        dfs(root.left, k);
        if(++count == k) {
            ret = root.val;
        }
        dfs(root.right, k);
    }
}

二叉树根节点到叶子节点的所有路径和

https://www.nowcoder.com/practice/185a87cd29eb42049132aed873273e83?tpId=117&&tqId=37715&&companyId=898&rp=1&ru=/company/home/code/898&qru=/ta/job-code-high/question-ranking

public class Solution {

    public int sumNumbers (TreeNode root) {
        // write code here
        if(root == null) {
            return 0;
        }
        return func(root, 0);
    }
    public int func(TreeNode root, int sum) {
        if(root ==null){
            return 0;
        }
        sum = sum * 10 + root.val;
        if(root.left == null && root.right == null) {
            return sum;
        }
        return func(root.left, sum) + func(root.right, sum);
    }
}

二叉树中和为某一值的路径(一) Boolean类型

https://www.nowcoder.com/practice/508378c0823c423baa723ce448cbfd0c?tpId=117&&tqId=37719&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking
迭代求解

import java.util.*;
/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
      if (root == null) {
          return false;
      }
        sum -= root.val;
        if (sum == 0 && root.left == null && root.right == null) {
            return true;
        }
            
        return hasPathSum(root.left, sum) || hasPathSum(root.right, sum);
    }
}

二叉树中和为某一指的路径（二）（回溯）

问题链接：https://leetcode-cn.com/problems/er-cha-shu-zhong-he-wei-mou-yi-zhi-de-lu-jing-lcof/

/**
 * 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>> ret = new ArrayList<>();
    public List<Integer> path = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int target) {
        func(root, target);
        return ret;
    }
    public void func(TreeNode root, int target) {
        if(root == null) {
            return;
        }
        path.add(root.val);
        target -= root.val;
        if(target == 0 && root.left == null && root.right == null) {
            ret.add(new ArrayList(path));
        }
        func(root.left, target);
        func(root.right, target);
        path.remove(path.size() - 1);
    }
}

二叉搜索树和双向链表

问题链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-yu-shuang-xiang-lian-biao-lcof

  • 代码
class Solution {
    public Node prev=null;
    //中序遍历排序 并连接双向链表
    public  void inOrder(Node cur)
    {
        if(cur==null) return ;
            inOrder(cur.left);
            cur.left=prev;
            if(prev!=null)
            {
                prev.right=cur;
            }
            prev=cur;
            inOrder(cur.right);
        }
    
    public Node treeToDoublyList(Node root) {
        if(root==null) return null;
        inOrder(root);
        Node head=root;
        Node tail=root;
        //找头
        while(head.left!=null)
        {
            head=head.left;
        }
        //找尾
        while(tail.right!=null)
        {
            tail=tail.right;
        }
        //连接头和尾
        head.left=tail;
        tail.right=head;
        return head;
    }
}

二叉搜索树的最近公共祖先

https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-zui-jin-gong-gong-zu-xian-lcof/

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || root == p || root == q) {
            return root;
        }
        if(p.val < root.val && q.val < root.val) {
            return lowestCommonAncestor(root.left, p, q);
        }
        if(p.val > root.val && q.val > root.val) {
            return lowestCommonAncestor(root.right, p, q);
        }
        return root;
    }
}

二叉树的最近公共祖先

https://leetcode-cn.com/problems/er-cha-shu-de-zui-jin-gong-gong-zu-xian-lcof/

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null || root == p || root == q) return root;
        TreeNode left = lowestCommonAncestor(root.left, p, q);
        TreeNode right = lowestCommonAncestor(root.right, p, q);
        if(left == null) return right;
        if(right == null) return left;
        return root;
    }
}

在二叉树中找到两个节点的最近公共祖先

https://www.nowcoder.com/practice/e0cc33a83afe4530bcec46eba3325116?tpId=117&&tqId=37826&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 * }
 */

public class Solution {
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        // write code here
       if(root == null) {
           return -1;
       }
        if(p == root.val || q == root.val) {
            return root.val;
        }
        int left = lowestCommonAncestor(root.left, p, q);
        int right = lowestCommonAncestor(root.right, p, q);
        if(left == -1) {
            return right;
        }
        if(right == -1) {
            return left;
        }
        return root.val;
    }
}

相同的树

问题链接：https://leetcode-cn.com/problems/same-tree/

class Solution {
    public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p == null && q == null) return true;
        if((p == null && q != null) || (q == null && p != null)) return false;
        if(p.val != q.val) return false;
        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
    }
}

另一颗树的子树（判断t1树中是否有与t2树完全相同的子树）

问题链接：https://leetcode-cn.com/problems/subtree-of-another-tree/submissions/

class Solution {
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root == null || subRoot == null) return false;
       if(isSametree(root, subRoot)) return true;
       if(isSubtree(root.left, subRoot)) return true;
       if(isSubtree(root.right, subRoot)) return true;
         return false;
    }
    //判断两个树是否相同
    public boolean isSametree(TreeNode p, TreeNode q) {
        if(p == null && q == null) return true;
        if((p != null && q == null) || (p == null && q != null)) return false;
        if(p.val != q.val) return false;
        return isSametree(p.left, q.left) && isSametree(p.right, q.right);
    }
}

重建二叉树（前序中序构建二叉树）

public class Solution {
    public int preIndex;
    public TreeNode dfs(int[] pre, int[] in, int l, int r) {
        if(l > r) {
            return null;
        }
        TreeNode root = new TreeNode(pre[preIndex]);
        int index = findVal(in, pre[preIndex], l, r);
        preIndex++;
        root.left = dfs(pre, in, l, index - 1);
        root.right = dfs(pre, in, index + 1, r);
        return root;
        
    }
    public int findVal(int[] in, int key, int l, int r) {
        for(int i = l; i <= r; i++) {
            if(in[i] == key) {
                return i;
            }
        }
        return -1;
    }
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
           if(pre == null || in == null || pre.length == 0 || in.length == 0) {
               return null;
           } 
        return dfs(pre, in, 0, in.length - 1);
    }
}

中序后续遍历序列构建二叉树

https://leetcode-cn.com/problems/construct-binary-tree-from-inorder-and-postorder-traversal/

/**
 * 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 int posIndex = 0;
    public TreeNode buildTree(int[] ino, int[] pos) {
        if(ino == null || pos == null) return null;
        posIndex = pos.length-1;
        return dfs(ino, pos, 0, ino.length - 1);
    }
    public TreeNode dfs(int[] ino, int[] pos, int l, int r){
        if(l > r) return null;
        TreeNode root = new TreeNode(pos[posIndex]);
        int index = findVal(ino, pos[posIndex], l, r);
        posIndex--;
        root.right = dfs(ino, pos, index+1, r);
        root.left = dfs(ino, pos, l, index - 1);
        return root;
    }
    public int findVal(int[] ino, int key, int l, int r){
        for(int i = l; i <= r; i++)
        {
            if(ino[i] == key){
                return i;
            }
        }
         return -1;
    }
}

二叉树的右视图I

https://leetcode-cn.com/problems/binary-tree-right-side-view/

class Solution {
    List<Integer> ret = new ArrayList<>();
    public List<Integer> rightSideView(TreeNode root) {
        if(root == null) {
            return ret;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            for(int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
                if(size - 1 == i) {
                    ret.add(node.val);
                }
            }
        }
        return ret;
    }
}

输出二叉树的右视图II

给前序和中序先重建树再输出右视图

import java.util.*;


public class Solution {
    public int preIndex;
    public ArrayList<Integer> ret = new ArrayList<>();
    public TreeNode createTree(int[] pre, int[] in, int l, int r) {
        if(l > r) {
            return null;
        }
        TreeNode root = new TreeNode(pre[preIndex]);
        int index = findVal(in, pre[preIndex], l, r);
        preIndex++;
        root.left = createTree(pre, in, l, index - 1);
        root.right = createTree(pre, in, index + 1, r);
        return root;
    }
    public int findVal(int[] in, int key, int l, int r) {
        for(int i = l; i <= r; i++) {
            if(in[i] == key) {
                return i;
            }
        }
        return -1;
    }
    public int[] solve (int[] pre, int[] in) {
       //西安将二叉树重建出来
        if(pre == null || in == null || pre.length == 0 || in.length == 0) {
            return null;
        }
        TreeNode root = createTree(pre, in, 0, in.length - 1);
        //在输出二叉树的右视图
        func(root);
        int[] ans = new int[ret.size()];
        for(int i = 0; i < ret.size(); i++) {
            ans[i] = ret.get(i);
        }
        return ans;
    }
    
    public ArrayList<Integer> func(TreeNode root) {
        if(root == null) {
            return ret;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            int size = queue.size();
            for(int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                if(node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
                if(size - 1 == i) {
                    ret.add(node.val);
                }
            }
        }
        return ret;
    }
}

二叉树根节点到叶子节点的所有路径和

public class Solution {
    public int sumNumbers (TreeNode root) {
        // write code here
        if(root == null) {
            return 0;
        }
        return func(root, 0);
    }
    public int func(TreeNode root, int sum) {
        if(root ==null){
            return 0;
        }
        sum = sum * 10 + root.val;
        if(root.left == null &&root.right == null) {
            return sum;
        }
        return func(root.left, sum) + func(root.right, sum);
    }
}

判断一棵二叉树是否为搜索二叉树和完全二叉树

https://www.nowcoder.com/practice/f31fc6d3caf24e7f8b4deb5cd9b5fa97?tpId=117&&tqId=37822&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

import java.util.*;
public class Solution {
     public boolean[] judgeIt (TreeNode root) {
        boolean[] res = new boolean[2];
        res[0] = true; res[1] = true;
        if (root == null) return res;
        //res[0] = search(root, Long.MIN_VALUE, Long.MAX_VALUE);
        ArrayList<Integer> temp = new ArrayList<>();
        inorder(root, temp);
        for (int i = 0; i < temp.size() - 1; i++){
            if (temp.get(i) > temp.get(i + 1)) res[0] = false;
        }
        res[1] = all(root);        
        return res;
    }
    // 直接DFS返回钟中序遍历，再遍历temp判断
    void inorder(TreeNode root, ArrayList<Integer> temp){
        if (root == null) return;
        inorder(root.left, temp);
        temp.add(root.val);
        inorder(root.right, temp);    
    }
    //通过边界条件递归判断左右子树是否符合
//     boolean search(TreeNode root, long left, long right){
//         if (root == null) return true;
//         if (root.val > right || root.val < left) return false;
//         return search(root.left, left, root.val) && search(root.right, root.val, right);
//     } 
    boolean all(TreeNode root){
        if (root == null) return true;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        boolean flag = false;
        while(queue.size() != 0){            
            TreeNode newroot = queue.poll();
            TreeNode left = newroot.left;
            TreeNode right = newroot.right;
            if ( (left == null && right != null) || // 无左子树有右子树
                (flag && !(left == null && right == null)) ) //有残缺且非叶节点
                return false;
            if (left != null) queue.add(left);
            if (right != null) queue.add(right); 
            // 存在残缺节点
            if (left == null || right == null) flag = true;
        }
        return true;
    }
}

二叉树中的最大路径和

https://leetcode-cn.com/problems/binary-tree-maximum-path-sum/

import java.util.*;
public class Solution {
    private int ret = Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        /**
        对于任意一个节点, 如果最大和路径包含该节点, 那么只可能是两种情况:
        1. 其左右子树中所构成的和路径值较大的那个加上该节点的值后向父节点回溯构成最大路径
        2. 左右子树都在最大路径中, 加上该节点的值构成了最终的最大路径
        **/
        getMax(root);
        return ret;
    }
    
    private int getMax(TreeNode r) {
        if(r == null) {
            return 0;
        }
        int left = Math.max(0, getMax(r.left)); // 如果子树路径和为负则应当置0表示最大路径不包含子树
        int right = Math.max(0, getMax(r.right));
        ret = Math.max(ret, r.val + left + right); // 判断在该节点包含左右子树的路径和是否大于当前最大路径和
        return Math.max(left, right) + r.val;
    }
}

序列化二叉树

https://leetcode-cn.com/problems/xu-lie-hua-er-cha-shu-lcof/

public class Codec {
   public String serialize(TreeNode root) {
    if(root == null){
        return "null,";
    }
        String res = root.val + ",";
        res += serialize(root.left);
        res += serialize(root.right);
        return res;
    }

    public TreeNode deserialize(String data) {
        String[] str = data.split(",");
        Queue<String> queue = new LinkedList<String>();
        for(int i = 0; i < str.length; i++){
            queue.offer(str[i]);
        }
        return createTree(queue);
    }

    public TreeNode createTree(Queue<String> queue){
        String val = queue.poll();
        f(val.equals("null")){
            return null;
        }
        TreeNode root = new TreeNode(Integer.valueOf(val));
        root.left = createTree(queue);
        root.right = createTree(queue);
        return root;
    }
}

持续更新中。。。。。。。

赵jc
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常见的二叉树面试题大汇总（涵盖二叉搜索树）
mengni123321的专栏
09-04 3225
1，前序遍历建立二叉树 2，前序遍历 3，中序遍历 4，后序遍历 5，二叉树的销毁 6，从上至下分层遍历二叉树 7，从上至下分层遍历二叉树 且每一层打印一行 8，按照之字形上至下分层 打印二叉树 9，求二叉树深度 10，判断是否是平衡二叉树 11，判断是否是平衡二叉树 不允许重复遍历 12，求二叉树第K层的节点数 13，求二叉树第K层叶子节点数 14，比较两个二叉树结构是
JS面试题【算法】 - 树转数组
weixin_53170968的博客
02-14 342
实现前端大厂笔试题 树与数组之间的互相转换
前端面试题总结（5）
wuyxinu的博客
06-25 3808
一、问题 1、以下代码执行后，console 的输出是？ let x = 10; let foo = () => { console.log(x); let x = 20; x++; } foo(); ​ A、抛出 ReferenceError B、10 C、20 D、21 2、以下代码的执行后，str 的值是： var str = "Hellllo world"; str = str.replace(/(l)\1/g, '$1'); 3、以下哪个语句打印出来的结果时false？ A、ale
二叉树面试题汇总(一)
11-02 2844
title: 二叉树面试题汇总(一) categories: 数据结构 date: 2016-08-18 9:16:00版权声明：本站采用开放的[知识共享署名-非商业性使用-相同方式共享 许可协议]进行许可所有文章出现的代码，将会出现在我的github中，名字可以根据类全名来找，我在github中的文件夹也会加目录备注。计算二叉树的总结点数树的定义：public class BinaryTree
树的基本面试题
ss123mlk的博客
10-27 252
前中后遍历 二叉树 （递归） 不要想复杂 栈当中会帮助我们回溯 就顺序的递归就好了 层序遍历 记得深拷贝 BFS模板 List item
前端大厂最新面试题-tree.docx
06-06
前端大厂最新面试题-树 本文将详细介绍树形数据结构在计算机领域中的应用，包括树的定义、分类、遍历方法等。 一、树的定义和分类 树是一种非线性数据结构，可以表示数据之间的一对多关系。以树和二叉树最为常用...
程序员面试题精选100题.pdf
最新发布
01-26
这里我们重点讨论的是如何将一个二元查找树（Binary Search Tree, BST）转换成一个排序的双向链表，这是一个典型的面试题，考察了对数据结构的理解和递归算法的应用。 二元查找树是一种特殊的二叉树，每个节点的值...
java常见面试题总结
01-23
以下是对几个常见面试题的详细解答： 1. **Map在JDK1.7到JDK1.8的变化** 在JDK1.8中，HashMap的数据结构发生了显著变化。它引入了红黑树（Red-Black Tree）的概念。当链表长度超过8个节点时，链表会转换为红黑树，...
程序员面试题精选100题.docx
10-27
本文档概述了程序员面试题精选100题，涵盖了C++面试题和笔试题，其中有一道典型的题目是将二元查找树转换成排序的双向链表。 知识点一：二元查找树（Binary Search Tree） * 二元查找树是一种特殊的树数据结构，它...
前端大厂最新面试题-tree (1).docx
06-06
在这篇文章中，我们将对前端大厂最新面试题-tree进行总结和分析，并从树的角度来探讨这些问题的解决方案。 首先，让我们来看看树的定义和性质。树是一种数据结构，它是一种具有节点和边的图形结构。树的每个节点都...
二叉树中的那些常见的面试题
chen825919148的专栏
10-17 1090
转自：http://www.cnblogs.com/BeyondAnyTime/archive/2012/08/27/2659163.html 关于二叉树 二叉树作为树的一种，是一种重要的数据结构，也是面试官经常考的东西。昨天看了一下关于树中的面试题，发现二叉树中的面试题比较常见的题型大概有下面几个：创建一颗二叉树（先序，中序，后序）、遍历一颗二叉树（先序，中序，后序和层次遍历）、求二叉树
树-面试题
void
07-04 1950
树 面试题
决策树详解以及常见面试题
屏幕里的日与夜
06-02 1186
学习决策树的心得体会以及搜集的一些面试题决策树训练过程最优划分属性连续和缺失值剪枝操作预剪枝后剪枝多变量决策树CART树决策树回归过程CART剪枝相关面试题 决策树 决策树是最符合人类思考模式，最容易被理解和解释的模型之一，所以在一些需要可解释性的场景下经常使用，其训练过程相比其他机器学习算法也更加通俗易懂 训练过程 初始情况下生成一个根节点，所有的数据都在这一个节点之内。 寻找一个最能区分开不同类样本的最优划分属性，按照样本在该属性上取值的不同，分配到不同的下一级的子节点上。 如果某个节点上没有了样本或
算法系列之二叉树
Web分享
09-09 225
二叉树相关概念 由于本篇博文主要介绍二叉树的面试题，所以关于其相关概念只做简单的描述。 二叉树简介 数据结构中有一种结构是树，不过一般我们常见的是树中的一种特殊类型——二叉树。二叉树简单来说就是每个节点最多有两个子节点。 如果每个节点都有两个子节点，那么我们称这种二叉树为满二叉树。 还有一种二叉树，其叶子节点都在最底下两层，最后一层叶子节点都靠左排列，并且除了最后一层，其他层的叶子节点都要达到最大，这种二叉树叫作完全二叉树。 除了上面那些，这里还需要特别提到一种树，二叉搜索树。二叉搜索树要求，在树中的任意
数据结构 - 二叉树 - 面试中常见的二叉树算法题
热门推荐
从零开始
01-17 2万+
数据结构 - 二叉树 - 面试中常见的二叉树算法题 数据结构是面试中必定考查的知识点，面试者需要掌握几种经典的数据结构：线性表（数组、链表）、栈与队列、树（二叉树、二叉查找树、平衡二叉树、红黑树）、图。 本文主要介绍树中的常见的二叉树数据结构。包括 概念简介 二叉树中树节点的数据结构（Java） 二叉树的遍历（Java） 常见的二叉树算法题（Java） 概念简介 如果对二叉
二叉树相关面试题（上）
zjx624bjh的博客
03-02 939
一，将二叉搜索树转换为一个排序的双向链表。 提示：要求不能创建任何新的结点，只能调整树中节点的指向。 eg： 搜索二叉树：左节点的值小于父节点的值，右节点的值大于父节点的值。 思路：二叉树中每个节点有两个指向子节点的指针，双向链表中每个节点也有两个指针，两个节点结构相似，同时二叉搜索树也是一种排序的数据结构。因此理论上可能实现二叉搜索树和排序双向链表的转换。 步骤：在将二叉搜索树转换...
C++面试笔记--树
dingzhenzha7040的博客
06-09 226
树 　　树的题目基本都是二叉树，但是面试官还没有说是不是二叉树的时候千万不要先把答案说出来，要是面试官说是多叉树，而你做的是二叉树就直接挂了！ 　　 　　一. 树的三种遍历。前序、中序、后序，如果直接考遍历，就肯定是让你写非递归代码的（递归版太弱智了），具体写法，要不你记下来，要不参考“递归”部分的，怎么递归转非递归，另一个就是给个中序+前序（后序），让你还原二叉树，中序必须...
寻找下一个结点
xiyu2768的博客
03-22 97
请设计一个算法，寻找二叉树中指定结点的下一个结点（即中序遍历的后继）。 给定树的根结点指针TreeNode* root和结点的值int p，请返回值为p的结点的后继结点的值。保证结点的值大于等于零小于等于100000且没有重复值，若不存在后继返回-1 题目很简单：直接遍历中序遍历即可。 /* struct TreeNode { int val; stru
数据结构二叉树常见面试题
Nameseven的博客
10-03 980
题目： 1. 求二叉树中的节点个数 2. 求二叉树的深度 3. 求二叉树中叶子节点的个数 4. 求二叉树第K层的节点个数 5. 前序遍历，中序遍历，后序遍历(递归版本，非递归版本) 6. 分层遍历二叉树（按层次从上往下，从左往右） 7. 将二叉查找树变为有序的双向链表 8. 判断两棵二叉树是否结构相同 9. 判断二叉树是不是平衡二叉树(AVL树) 10. 求二叉树的镜像 11. 求二叉树中两个节...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值