【面试算法题总结05】树数据结构

置顶 已于 2022-06-13 12:14:57 修改
阅读量208 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 算法 面试
于 2022-03-10 21:17:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TickTick123/article/details/123379863
版权

树数据结构：

 

例题1：把二叉搜索树转换为累加树

让我们逆中序遍历一下

/**
 * 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 {
    int pre=0;
    public TreeNode convertBST(TreeNode root) {
        dfs(root);
        return root;
    }
    //这里我们逆中序遍历一下
    void dfs(TreeNode root){
        if(root==null){
            return;
        }
        dfs(root.right);
        root.val+=pre;
        pre=root.val;
        dfs(root.left);
    }
}

 

例题2：重建二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    Map<Integer,Integer> map=new HashMap<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        int n=preorder.length;
        for(int i=0;i<n;++i){
            map.put(inorder[i],i);
        }
        return dfs(preorder,inorder,0,n-1,0,n-1);
    }
    public TreeNode dfs(int[] preorder, int[] inorder,int preorderStart,int preorderEnd,int inorderStart,int inorderEnd){
        if(preorderStart>preorderEnd||inorderStart>inorderEnd){
            return null;
        }
        int val=preorder[preorderStart];
        TreeNode node =new TreeNode(val);
        int index=map.get(val);
        node.left=dfs(preorder,inorder,preorderStart+1,preorderStart+index-inorderStart,inorderStart,index-1);
        node.right=dfs(preorder,inorder,preorderStart+index-inorderStart+1,preorderEnd,index+1,inorderEnd);
        return node;
    }
}

 

例题3：树的子结构

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSubStructure(TreeNode A, TreeNode B) {
        if(A==null||B==null){
            return false;
        }
        return isSame(A,B)||isSubStructure(A.left,B)||isSubStructure(A.right,B);    //先遍历A
    }
    public boolean isSame(TreeNode A, TreeNode B){
        if(B==null){    //把B遍历完，则为有子结构了
            return true;
        }
        if(A==null||A.val!=B.val){
            return false;
        }
        //如果节点值相同，则在同时遍历A的当前节点和B
        return isSame(A.left,B.left)&&isSame(A.right,B.right);
    }
}

 

例题4：二叉树的镜像

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode mirrorTree(TreeNode root) {
        if(root==null){
            return null;
        }
        TreeNode temp=root.left;
        root.left=root.right;
        root.right=temp;
        mirrorTree(root.left);
        mirrorTree(root.right);
        return root;
    }
}

 

例题5：对称的二叉树

解法1：递归

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        return same(root,root);
    }
    public boolean same(TreeNode root1,TreeNode root2){
        if(root1==null&&root2==null){
            return true;
        }
        if(root1==null||root2==null){
            return false;
        }
        if(root1.val!=root2.val){
            return false;
        }
        return same(root1.left,root2.right)&&same(root1.right,root2.left);
    }
}

解法2：迭代

队列实现

/**
 * 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);
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode p=queue.poll();
            TreeNode q=queue.poll();
            if(p==null&&q==null){
                continue;
            }
            if(p==null||q==null||p.val!=q.val){
                return  false;
            }
            queue.offer(p.left);
            queue.offer(q.right);

            queue.offer(p.right);
            queue.offer(q.left);
        }
        return true;
    }
}

 

例题6：二叉搜索树的后序遍历序列

class Solution {
    public boolean verifyPostorder(int[] postorder) {
        return verify(postorder,0,postorder.length-1);
    }
    public boolean verify(int[] postorder,int start,int end){
        if(start>=end){
            return true;
        }
        int mid=postorder[end];
        int i=start;
        for(;i<end;++i){
            if(postorder[i]>mid){
                break;
            }
        }
        int j=i;
        for(;j<end;++j){
            if(postorder[j]<mid){
                return false;
            }
        }
        return verify(postorder,start,i-1)&&verify(postorder,i,end-1);
    }
}

 

例题7：二叉树中和为某一值的路径

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

 

例题8：二叉搜索树与双向链表

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val,Node _left,Node _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/
class Solution {
    Node result=null;
    Node pre=null;
    public Node treeToDoublyList(Node root) {
        if(root==null){
            return null;
        }
        dfs(root);
        pre.right=result;
        result.left=pre;
        return result;
    }
    public void dfs(Node root){
        if(root==null){
            return;
        }
        dfs(root.left);
        if(pre==null){
            result=root;
        }else{
            pre.right=root;
            root.left=pre;
        }
        pre=root;
        dfs(root.right);
    }
}

 

例题9：序列化二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Codec {

    // Encodes a tree to a single string.
    public String serialize(TreeNode root) {
        return dfs(root,"");
    }
    public String dfs(TreeNode root,String result){
        if(root==null){
            result+="$,";
            return result;     
        }
        result+=root.val+",";
        result=dfs(root.left,result);
        result=dfs(root.right,result);
        return result;
    }

    // Decodes your encoded data to tree.
    public TreeNode deserialize(String data) {
        String[] strs=data.split(",");
        List<String> list=new ArrayList<>(Arrays.asList(strs));
        return dfs2(list);
    }
    public TreeNode dfs2(List<String> list){
        if(list.get(0).equals("$")){
            list.remove(0);
            return null;
        }
        TreeNode root=new TreeNode(Integer.valueOf(list.get(0)));
        list.remove(0);
        root.left=dfs2(list);
        root.right=dfs2(list);
        return root;
    }
}

 

例题10：二叉树的中序遍历

解法1：递归

/**
 * 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 {
    List<Integer> result =new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
        dfs(root);
        return result;
    }
    public void dfs(TreeNode root){
        if(root==null){
            return;
        }
        dfs(root.left);
        result.add(root.val);
        dfs(root.right);
    }
}

解法2：迭代

/**
 * 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<>();
        
        Stack<TreeNode> stack=new Stack<>();
        TreeNode p=root;
        while(p!=null||!stack.isEmpty()){
            while(p!=null){
                stack.push(p);
                p=p.left;
            }
            p=stack.pop();
            result.add(p.val);
            p=p.right;
        }
        return result;
    }
}

 

例题11：验证二叉搜索树

解法1：二叉搜索树中序遍历的性质

中序遍历也可以使用迭代方法

/**
 * 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 {
    List<Integer> arr=new ArrayList<>();
    public boolean isValidBST(TreeNode root) {
        dfs(root);
        for(int i=1;i<arr.size();++i){
            if(arr.get(i)<=arr.get(i-1)){
                return false;
            }
        }
        return true;
    }
    public void dfs(TreeNode root){
        if(root==null){
            return;
        }
        dfs(root.left);
        arr.add(root.val);
        dfs(root.right);
    }
}

解法2：二叉搜索树的性质

class Solution {
    public boolean isValidBST(TreeNode root) {
        return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
    }

    public boolean isValidBST(TreeNode node, long lower, long upper) {
        if (node == null) {
            return true;
        }
        if (node.val <= lower || node.val >= upper) {
            return false;
        }
        return isValidBST(node.left, lower, node.val) && isValidBST(node.right, node.val, upper);
    }
}

 

例题12：不同的二叉搜索树

解法1：动态规划

class Solution {
    public int numTrees(int n) {
        int[] G=new int[n+1];
        G[0]=1;
        G[1]=1;
        for(int i=2;i<=n;++i){
            for(int j=1;j<=i;++j){
                G[i]=G[i]+G[j-1]*G[i-j];
            }
        }
        return G[n];
    }
}

解法2：数学（卡塔兰数 ）

背不下来就算了

class Solution {
    public int numTrees(int n) {
        long result=1;
        for(int i=0;i<n;++i){
        	//不能是result*=2*(2*i+1)/(i+2); 
        	//因为这样2*(2*i+1)/(i+2)会舍去小数部分
            result=result*2*(2*i+1)/(i+2);
        }
        return (int)result;
    }
}

 

例题12：二叉树展开为链表

/**
 * 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 {
    TreeNode preNode=null;
    public void flatten(TreeNode root) {
        dfs(root);
        return;
    }
    public void dfs(TreeNode root){
        if(root==null){
            return;
        }
        TreeNode leftNode=root.left;
        TreeNode rightNode=root.right;
        if(preNode!=null){
            preNode.right=root;
            preNode.left=null;
        }
        preNode=root;
        dfs(leftNode);
        dfs(rightNode);
    }
}

 

例题13：二叉树中的最大路径和

/**
 * 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 {
    int result=Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        getScore(root);
        return result;
    }
    public int getScore(TreeNode root){
        if(root==null){
            return 0;
        }
        int maxLeft=Math.max(getScore(root.left),0);
        int maxRight=Math.max(getScore(root.right),0);
        int newResult=root.val+maxLeft+maxRight;
        if(newResult>result){
            result=newResult;
        }
        return root.val+Math.max(maxLeft,maxRight);
    }
}
TickTick123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构算法题——树
linjiayina的博客
07-09 385
给定一个二叉树的根节点 root ，返回 它的遍历。：O(n)，其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。：O(n)。空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。
二叉查找树的中序后继 - LintCode
kane的博客
07-01 2645
描述 给定一个二叉查找树(什么是二叉查找树)，以及一个节点，求该节点在中序遍历的后继，如果没有返回null 保证p是给定二叉树中的一个节点。(您可以直接通过内存地址找到p) 样例 给出 tree = [2,1] node = 1: 2 / 1 返回 node 2. 给出 tree = [2,1,3] node = 2: 2 / \ 1 3 返回 node ...
哈夫曼编码与解码-二叉树的应用
Galaxy
05-09 915
哈夫曼编码与解码 【问题描述】读入n个字符所对应的权值，自底向上构造一棵哈夫曼树，自顶向下生成每一个字符对应的哈夫曼编码，并依次输出。另，求解某字符串的哈夫曼编码，求解某01序列的译码。 【输入形式】输入的第一行包含一个正整数n，表示共有n个字符需要编码。其中n不超过100。第二行中有n个用空格隔开的正整数，分别表示n个字符的权值，依次按照abcd…的默认顺序给出。然后是某字符串和某01序列。 【输出形式】前n行，每行一个字符串，表示对应字符的哈夫曼编码。然后是某字符串的哈夫曼编码，某01序列的译码。 【注
数据结构 - 二叉树 - 面试中常见的二叉树算法题
从零开始
01-17 2万+
数据结构 - 二叉树 - 面试中常见的二叉树算法题 数据结构是面试中必定考查的知识点，面试者需要掌握几种经典的数据结构：线性表（数组、链表）、栈与队列、树（二叉树、二叉查找树、平衡二叉树、红黑树）、图。 本文主要介绍树中的常见的二叉树数据结构。包括 概念简介 二叉树中树节点的数据结构（Java） 二叉树的遍历（Java） 常见的二叉树算法题（Java） 概念简介 如果对二叉
数据结构和算法分析2
weixin_35720385的博客
12-17 599
@TOC Tree Heap 堆 Hash BFS DFS String Manipulation 字符串 Trie Union Find 并查集 Dynamic Programming 动态规划
2021数据结构与算法面试题
08-14
数据结构与算法是计算机科学的基础，对于...以上知识点是数据结构与算法面试题中常见的部分，每个主题下都可能有深入的理论讲解和实践题目，对于准备面试的开发者来说，全面掌握这些内容将大大提升在面试中的竞争力。
2023数据结构与算法面试题手册
12-17
面试必备：数据结构与算法面试题 最新2023整理版
文档面试题数据结构算法大全
最新发布
04-16
文档面试题数据结构算法大全提取方式是百度网盘分享地址
面试常见基础算法题总结
04-29
面试中的算法题是每个IT求职者都需要准备的重要环节，涵盖了数据结构、算法设计与分析等多个领域。以下是对一些常见算法题目的详细解析： 1. **红黑树**：红黑树是一种自平衡二叉查找树，它保持了二叉搜索树的特性...
常见数据结构与算法笔试面试题大集合
09-12
这份“常见数据结构与算法笔试面试题大集合”涵盖了这一领域的核心概念，旨在帮助求职者更好地准备相关考试和面试。 1. **数组**：数组是最基础的数据结构，它提供了一种在内存中存储和访问固定数量元素的方式。...
【数据结构】二叉树常见面试题
如风逝去
08-07 6059
1、创建二叉树 树的结构如下： 这里我们创建二叉树用的是静态创建即不是每次从标准输入读入数据然后插入树中，而是将定义好的一个序列，也就是一个数组构建一棵树，这里采用的是递归创建，首先来看一下参数，首先传进来的就是根结点，然后是要构建树的序列然后是数组下标索引，负责遍历整个数组，然后是数组的大小，然后是无效值，遇到无效值表示当前结点为空，就返回上一层函数调用，递归程序的出口是index...
剑指offer编程题--求二叉树最大深度与最小深度
fxjzzyo的博客
07-12 507
题目描述 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 思路 递归思想，分别递归求解左右子树深度，总深度=左右子树中较深的那个深度+1 Java代码 /** public class TreeNode { int val = 0; TreeNode left = null; TreeN...
数据结构 --- 二叉树的相关面试题
y6_xiamo的博客
05-21 306
这里只介绍二叉树的以下几个面试题： 1.用非递归版本实现先序、中序和后序遍历 2.求二叉树的镜像 3.判断一棵树是否是完全二叉树 4.给一个前序遍历和中序遍历的结果重建二叉树 上一篇博客中我们详解了用非递归实现二叉树的先序、中序和后序遍历，在此不再赘述，有需要的参考。。。。，下面我们直接来看后面这三个问题。 1.求二叉树的镜像 镜像类似于我们生活中照镜子一样，除过左右发生了交换以外，...
数据结构
chuojuedeng3068的博客
12-30 1130
国外 IT 教育学院 Educative.io 创始人 Fahim ul Haq 写过一篇过万赞的文章，总结了程序员面试中需要掌握的 8 种数据结构知识。Fahim ul Haq 曾在 Facebook 和微软任职，面试过不少程序员，所以这篇文章还是值得参考的。以下内容编译自他的这篇《准备下次...
关于树的一些算法题---持续更新
qq_22158743的博客
03-22 2293
树的定义为： public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 1、求一棵树的高度： public int height(TreeNode root) { if(root == null)...
【HBU】数据结构树练习题
热门推荐
韩旭051的博客
10-15 4万+
4-1 某二叉树的前序和后序遍历序列正好相反，则该二叉树一定是(4分) 空或只有一个结点 高度等于其结点数 任一结点无左孩子 任一结点无右孩子 作者: DS课程组 单位: 浙江大学 4-2 已知一棵二叉树的先序遍历结果是ABC，则以下哪个序列是不可能的中序遍历结果：(4分) ABC BAC CBA CAB 作者: DS课程组 单位: 浙江大学 4-3 ...
/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * ...
weixin_30339969的博客
03-23 555
/** * Definition for binary tree * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */ c...
笔记整理之数据结构（树）
weixin_40149887的博客
04-09 718
二叉排序树 性质：若左子树不为空，左子树上所有节点的值小于它根节点的值；若右子树不为空，右子树上所有节点的值小于它根节点的值。 查找：根据二叉树性质，递归，若找得到返回该节点，若找不到，则返回遍历的最后一个节点。 插入：根据查找返回的结果判断是否存在等值节点，若不存在，则插入，若存在则判断该节点的值和插入值的大小从而决定插在左子树或右子树处。 删除：遍历查找到该节点， 若该节点是叶节点，直接...
【数据结构】二叉树经典入门算法题集锦（下）
林慢慢的博客
10-16 1928
前言：本章将通过五道来自LeetCode/牛客网中的二叉树相关算法题来介绍数据结构中二叉树在算法题中的应用，题目难度不大，大家就当放松放松。 文章目录1.二叉树的最大深度思路分析：题解：2.平衡二叉树思路分析：题解：3.二叉树的后序遍历思路分析：题解：4.二叉树的中序遍历思路分析：题解：5.翻转二叉树思路分析：题解： 1.二叉树的最大深度 OJ链接 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 思路分析： 二叉树的最大深度等价于：左右子树的最大深度
微软面试100题答案全集：数据结构与算法精华分享
面试题目的范围可能包括但不限于数组、链表、树、图、排序算法（如快速排序、归并排序）、搜索算法（如二分查找）、动态规划、递归、设计数据结构等核心概念。 博主强调，答案仅供参考，不应过度依赖，并指出先前...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值