手撕代码之“二叉树”

最新推荐文章于 2024-09-16 20:27:23 发布
原创 最新推荐文章于 2024-09-16 20:27:23 发布 · 983 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

文章目录

重构二叉树(中等难度)

题目描述: 输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。
解题思路分析： 前序遍历：从根节点开始，先访问根节点，然后左子树，再右子树；中序遍历：先左子树，再根节点，最后右子树；
算法思想：
（1）pre数组中的第一个节点则一定是root，并且root一定再in的中间位置，故在in中找到root所在的位置i，则in[0,i)为root的左子树，左子树的节点树为i，in[i+1,in.length)为root的右子树，右子树的长度为
（2）pre中的左子树为:pre[1,i+1),长度为i;右子树的范围为[i+1,pre.length]
（3）in中的左子树为：in[0,i);右子树为：in[i+1,in.length]
（4）递归遍历，直到pre和in数组为空才结束。
在这里插入图片描述

代码实现

import java.util.Arrays;
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        //特判，空树
        if(pre.length==0 || in.length==0){
            return null;
        }
        TreeNode root=new TreeNode(pre[0]);//创建一个根节点
        //在in中找到根节点
        for(int i=0;i<in.length;i++){
            if(in[i]==pre[0]){
                    //左子树,注意Arrys.copyOfRange为左闭又开空间
                root.left=reConstructBinaryTree(Arrays.copyOfRange(pre,1,1+i),Arrays.copyOfRange(in,0,i));
                root.right=reConstructBinaryTree(Arrays.copyOfRange(pre,1+i,pre.length),Arrays.copyOfRange(in,i+1,in.length));
                break;//下次递归进入for循环，因此找完左右子树后就要结束整个循环。
            }
            
        }
        return root;
    }
}

树的镜像（简单）

题目 操作给定的二叉树，将其变换为源二叉树的镜像。
在这里插入图片描述
思路分析：使用递归的思想，明确递归的结束条件，和调用自己的条件；
（1）当root为空时，直接结束当前函数
（2）当前root的左节点和右节点交换
（3）从左子树开始使用同样的逻辑开始递归；从右子树开始使用同样的逻辑递归.

public class Solution {
    public void Mirror(TreeNode root) {
        if(root==null){
            return ;
        }
        //交换左、右子节点
         TreeNode tmp=root.left;
         root.left=root.right;
         root.right=tmp;
         //递归左子树
        if(root.left!=null){
            Mirror(root.left);
        }
        //递归右子树
        if(root.right!=null){
            Mirror(root.right);
        }   
    }
}

求树的深度（简单）

原理 利用递归的方式，使用递归时，首先得出递归的条件，然后进入递归调用；

import java.lang.Math.*;
public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root==null){
            return 0;
        }
        //左子树和右子树以同样的逻辑判断，没向下走一层，结果应该加一，每一次递归，针对的树的根节点
        return (Math.max(TreeDepth(root.left),TreeDepth(root.right))+1);
    }
}

树的平衡性检测（简单）

题目描述 给定一颗树，判断其是否为平衡二叉树
思路分析 平衡二叉树的定义：左右子树的深度差不能超过1,当root为null时，该树必为平衡二叉树，我们需要做的是：检测该树的所有左右子树，判断其是否符合平衡二叉树的定义。
编程的关键
(1)getDepth(),给定根节点，求该节点的深度；
(2)判断一颗树，是否为符合平衡二叉树的定义；
(3)按照相同的判断逻辑，递归调用，判断这颗树的左子树、右子树是否均为平衡二叉树；

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        //特判
        if(root==null){
             return true;
         }
        //判断当前树是否为平衡二叉树
         if(Math.abs(getDepth(root.left)-getDepth(root.right))>1){
            return false;
        }
        //递归判断当前节点的左、右子树是否都是平衡树
        return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right);
    }
    
    //获取一颗树的深度
    public int getDepth(TreeNode root){
        if(root==null){
            return 0;
        }
        return Math.max(getDepth(root.left),getDepth(root.right))+1;
    }
}

树的层序遍历（中等）

题目描述 层序遍历，从上到下，从左到右遍历二叉树，每一层的节点存储在一个list中，最后将所有的list存储到结果集中。
思路分析 需要用到两个队列作为缓冲，第一个队列用来缓存当前层的节点，第二个队列用来缓存当前层的下一个节点；每次循环，应该保证队列1中的所有元素都入了队列2，然后依次取出队列二中的元素放入list中；
使用到的java库函数：
（1）队列，其实现的是java.util.Queue接口和java.util.List接口，所以应该导入这两个包，故：Queue q=new LinkedList();
（2）队列常见的方法：q.offer()入队，q.poll()出队，q.peek()查看队首元素，但是不出队列。

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

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

    }

}
*/
import java.util.*;
public class Solution {
    ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        //用于存储最后的结果集合
        ArrayList<ArrayList<Integer>> listOuter=new ArrayList<ArrayList<Integer>>();
        //队列1缓存每一层的值
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        //队列2缓存当前层的下一层的值
        Queue<TreeNode> queue2=new LinkedList<TreeNode>(); 
        if(pRoot==null){
            return listOuter;
        }
        //1.根节点先入队列1
        queue.offer(pRoot);
        while(!queue.isEmpty()){
            //一次性将队列1中的所有根节点都取出并放进队列2中
            while(!queue.isEmpty()){
                TreeNode curNode=queue.poll();
                queue2.offer(curNode);
            }
            ArrayList<Integer> listInner=new ArrayList<Integer>();
            //当前层的左右节点即为下一层的根节点
            //
            while(!queue2.isEmpty()){
                TreeNode curNode2=queue2.poll();
                listInner.add(curNode2.val);//缓存当前层的值
                if(curNode2.left!=null){
                    queue.offer(curNode2.left);//存储下一层的根节点
                }
                if(curNode2.right!=null){
                    queue.offer(curNode2.right);//存储下一层的根节点
                }
            }
            listOuter.add(listInner);
        }
        return listOuter;
    }
}

//使用一个队列即可
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
import java.util.*;
public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> res=new ArrayList<Integer>();
        if(root==null){
            return res;
        }
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            int size=queue.size();
            for(int i=0;i<size;i++){
                TreeNode curNode=queue.poll();
                if(curNode.left!=null){
                    queue.add(curNode.left);
                }
                if(curNode.right!=null){
                    queue.add(curNode.right);
                }
                res.add(curNode.val);
            }
        }
        return res;
        
    }
}

二叉树的下一个节点（中等）

题目描述 给定一个二叉树和其中的一个结点，请找出中序遍历顺序的下一个结点并且返回。注意，树中的结点不仅包含左右子结点，同时包含指向父结点的指针。
分析 根据输入节点是否含有右子树来判断;
(1)如果输入参数含有右子树，则：找到右子树的最左边的叶子节点
(2)如果输入参数没有右子树，则：找向上寻他的祖宗节点，直到满足如下条件：当前节点必须是祖宗的左子节点。

/*
public class TreeLinkNode {
    int val;
    TreeLinkNode left = null;
    TreeLinkNode right = null;
    TreeLinkNode next = null;

    TreeLinkNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public TreeLinkNode GetNext(TreeLinkNode pNode){
        //特判
        if(pNode==null){
            return null;
        }
        //如果存在右子树，则找到右子树最左边的节点；
        if(pNode.right!=null){
            //找右子树最深的左节点
            TreeLinkNode node=pNode.right;
            while(node.left!=null){
                node=node.left;
            }
            return node;
        }
        //如果右子树子树为空，则一直循环向上找其祖宗节点，
        //直到找到满足如下条件的祖宗节点为止：当前节点是该祖宗节点的左子节点
        while(pNode.next!=null){
            if(pNode.next.left==pNode){
                return pNode.next;
            }
            pNode=pNode.next;
        }
        return null;
    }
    
}

二叉排序树转换成双端链表（中等）

题目描述 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
例如二叉树为：
在这里插入图片描述
在这里插入图片描述

可以转化为:

思路分析：
先看下图，再解释：
在这里插入图片描述
关于二叉树的问题，基本上可以归纳为递归调用的问题，而递归调用的关键在于：让函数处理好当前节点 ，其他的就交给递归做就好了。这个问题可以这样分解：排序二叉树看成三个组成部分：根节点4，以2为根节点的左子树和以6为根节点的右子树。按照递归的思想，我们先处理好根节点，而至于另外两个子树则以相同的处理逻辑递归调用即可。同时，排序二叉树一定和中序遍历有关系，因此我们应该在中序遍历的过程中完成二叉树转化的过程，转换过程的另一个关键点在于：让左子树的最后一个节点lastNode的右指针指向当前节点，当前节点的左指针指向lastNode，当根节点4完成转化，后更新LastNode,即LastNode=Node;，由于这个lastNode依赖于左子树，所以应该先递归完成左子树，，此时再递归完成右子树（整体的框架为:中序遍历）


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

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

    }

}
*/
public class Solution {
    TreeNode lastNode=null;
    public TreeNode Convert(TreeNode pRootOfTree){
        if(pRootOfTree==null){
            return null;
        }
        inorder(pRootOfTree);
        //获取双端链表的头节点
        while(lastNode.left!=null){
            lastNode=lastNode.left;
        }
        return lastNode;
    }
    
    private void inorder(TreeNode node){
        if(node==null){
            return;
        }
        inorder(node.left);
        //初始化，lastNode为当前节点,要不然会报空指针异常
        if(lastNode==null){
            lastNode=node;
        }else{
            node.left=lastNode;
            lastNode.right=node;
            lastNode=node;
        }
        inorder(node.right);
    } 
}

子树问题（简单）

问题描述: 输入两棵二叉树A，B，判断B是不是A的子结构。
树问题的处理方式: 归根结底，大部分二叉树的问题都可以使用递归的方式求解，求解过程可见树分成以下三个部分:根节点形成的当前树、根节点的左子树，根节点的右子树。我们递归的核心逻辑是：只处理当前的节点！只处理当前节点！只处理当前节点，由于其他节点的逻辑均一样，所以可以使用递归调用，分别传入root.left和root.right;
问题分析: 按照上述的思维方式，判断一树B是否为树A的子结构，需要解决两个大问题：
（1）如何判断两个树完全相同

  • 特判：Bnull,则为true；B！=null && Anull 必为false;
  • 使用递归的方式判断，两树的所有节点均相等（先当前节点，再递归左节点最后递归右节点）
    （2）将树A分为三个部分：树A、左子树和右子树；接下来只要满足三个条件之一就能断定树B是树A的子树
  • 树B和树A相同
  • 树B和树A的左子树相同（递归）
  • 树B和树A的右子树相同（递归）
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    //判断root2是否为root1的子树
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        //特判
        if(root1==null || root2==null){
            return false;
        }
        return isSame(root1,root2) || HasSubtree(root1.left,root2) || HasSubtree(root1.right,root2);
    }
    //判断两棵树是否相同
    private boolean isSame(TreeNode root1,TreeNode root2){
        //特判,如果B树为空，两者返回true
        if(root2==null){
            return true;
        }
        //B!==null && A==null,则B比不可能是A的子树，返回false
        if(root1==null){
            return false;
        }
        boolean res=true;
        res=res && (root1.val==root2.val) && isSame(root1.left,root2.left) && isSame(root1.right,root2.right);
        return res;
    }
}

二叉搜索树的第k个节点

题目描述 给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
思路分析： 单凡是BST问题，必然和中序遍历有着极大的联系，因为BST的中序遍历刚好就是各个节点从小到大的序列，这道的思路很简单，将这课树的中序遍历序列加入队列中（该过程在中序遍历的过程中完成），然后，读取到第K个节点即可；

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

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

    }

}
*/
import java.util.*;
public class Solution {
    TreeNode KthNode(TreeNode pRoot, int k){
        if(k<1){
            return null;
        }
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        inorder(pRoot,queue);
        if(queue.size()<k){
            return null;
        }
        
        while(k>1){
            queue.poll();
            k--;
        }
        return queue.poll();
    }
    //中序遍历root树，并依次入队列
    private void inorder(TreeNode root,Queue queue){
        if(root==null){
            return;
        }
        inorder(root.left,queue);
        //将当前节点加入队列
        queue.offer(root);
        inorder(root.right,queue);
    }

}

二叉树的序列化与反序列化

题目描述： 请实现两个函数，分别用来序列化和反序列化二叉树
[注] 二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
题目分析： 可以使用前、中、后、层序等4中遍历方式来实现，注意在序列化和反序列化的过程中他们所使用的遍历方式保持一致即可，同时要遵循相同的约定
用到的java工具包： StringBuilder、字符串中的常用方法;

/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;
    public TreeNode(int val) {
        this.val = val;

    }

}
*/
public class Solution {
    private int index=-1;
    String Serialize(TreeNode root) {
        StringBuilder sb=new StringBuilder();
        serializeHelper(root,sb);
        return sb.toString();
    }
    //使用前序遍历进行序列化
    private void serializeHelper(TreeNode root,StringBuilder sb){
        //特判
        if(root==null){
            sb.append("#!");
            return;
        }
        sb.append(root.val).append("!");
        serializeHelper(root.left,sb);
        serializeHelper(root.right,sb);
    }
    TreeNode Deserialize(String str) {
       String[] strs=str.split("!");
       return deserializeHelper(strs);
    }
    private TreeNode deserializeHelper(String[] strs){
        index++;
        //第一个节点不能是空节点
        if(!strs[index].equals("#")){
            TreeNode curNode=new TreeNode(Integer.parseInt(strs[index]));
            curNode.left=deserializeHelper(strs);
            curNode.right=deserializeHelper(strs);
            return curNode;
        }
        return null;
    }
}

Z字形打印树

题意描述： 请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。
思路分析： 该题的思路就是层序遍历，通过观察发现：当偶数层时，顺序加入list,当奇数层时，逆序加入list中，因此可以引入层数变量level 来记录当前是第几层。关于层序遍历的思路很简单：用一个队列缓冲，初始化时，将根节点入队列，计算当前队列中的size，每次从队列中取出size个的节点，这些节点则为当前层的节点，如果需要逆序打印，则有两种方式：

  • list.add(0,node);每次从0索引开始加；
  • 利用栈的特性，先入栈，然后再出栈
/*
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
import java.util.*;
public class Solution {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer>> results=new ArrayList<ArrayList<Integer>>();
         //特判
        if(pRoot==null){
            return results;
        }
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        int level=0;
        queue.offer(pRoot);
        while(!queue.isEmpty()){
            int size=queue.size();
            ArrayList<Integer> list=new ArrayList<Integer>();
            Stack<TreeNode> stack=new Stack<TreeNode>();
            for(int i=0;i<size;i++){
                TreeNode curNode=queue.poll();
                if(level%2==0){
                    //偶数层，则顺序添加
                    list.add(curNode.val);
                }else{//逆序放入list中
                    list.add(0,curNode.val);
                    //stack.add(curNode);
                }
                if(curNode.left!=null){
                    queue.offer(curNode.left);
                }
                if(curNode.right!=null){
                    queue.offer(curNode.right);
                }
            }
            //while(!stack.isEmpty()){
                //list.add(stack.pop().val);
            //}
            level++;
            results.add(list);
        }
        return results;
    }
}

对称二叉树

题目描述： 判断一棵树是否为对称二叉树，左右两节点围绕中轴线对称
解题思路： 先实现这么一个函数：如何判断两颗树是否对称，用递归的方式就是：如果两个根节点都为空，则必为对称，如果只有一个为空，则必然不对称，如果两个都不为空，需要判断两个根节点是否相等,然后使用相同的逻辑框架去递归判断左右子树，即：左子树的右节点要等于右子树的左节点，同时，右子树的左节点要等与左子树的右节点；，递归问题都是负责当前节点的问题；如何判断两颗树是否对称知道了，那么一颗树的对称不就是这棵树的左子树和右子树要对称吗？当然一定要有个特判：空树必然对称，只有一个子树的树必然不对称，其他情况再用上述函数进行判断。

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

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

    }

}
*/
public class Solution {
    boolean isSymmetrical(TreeNode pRoot){
        if(pRoot==null){
            return true;
        }
        if(pRoot.left==null && pRoot.right==null){
            return true;
        }
        if(pRoot.left==null || pRoot.right==null){
            return false;
        }
        return sysmmetrical(pRoot.left,pRoot.right);
    }
    //判断两颗树是否为对称的
    private boolean sysmmetrical(TreeNode root1,TreeNode root2){
        //两颗空树比对称
        if(root1==null && root2==null){
            return true;
        }
        //只有一个为空必然不对称
        if(root1==null || root2==null){
            return false;
        }
        //两个根节点不为空，则要求两个节点的值要相等；
        return root1.val==root2.val && sysmmetrical(root1.left,root2.right) && sysmmetrical(root1.right,root2.left);
    }
}

根节点到叶子节点和为sum的问题总结

是否存在路径

题目描述： 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
思路分析： 使用递归的方式来求解，当前节点的值如果是叶子节点并且其值为目标值，结束递归，找到；否则的话，在判断左子树到叶子节点的值是否为sum-target,同理，右子树也一样，两者是 || 的关系

public boolean hasPathSum(TreeNode root, int sum) {
    if (root == null)
        return false;
    int val = root.val;
    if (root.left == null && root.right == null && val == sum)
        return true;
    return hasPathSum(root.left, sum - val) || hasPathSum(root.right, sum - val);
}

找到所有的路径

题目描述： 输入一颗二叉树的根节点和一个整数，按字典序打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
题目分析： 这道题和上一道题，核心思想是一样的，只是需要用一个list来存储当前找到的路径，由于java中的参数是值传递，所以每次进入递归调用的时候需要想复制上一段的list。

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

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

    }

}
*/
import java.util.ArrayList;
public class Solution {
    
    
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int target) {
        //记录总的路径
        ArrayList<ArrayList<Integer>> res=new ArrayList<ArrayList<Integer>>();
        //记录每一条路径
        ArrayList<Integer> list=new ArrayList<Integer>();
        findPath(root,target,list,res);
        return res;
    }
    private void findPath(TreeNode root,int target,ArrayList<Integer> list, ArrayList<ArrayList<Integer>> res){
        if(root==null){
            return;
        }
        if(root.left==null && root.right==null && root.val==target){
            list.add(root.val);
            res.add(list);
            return;
        }
        //想加入根节点的值，继续向下递归
        list.add(root.val);
        if(root.left!=null){
            //这是上一list的基础上进行，所以复制
            ArrayList<Integer> leftList=new ArrayList<Integer>(list);
            findPath(root.left,target-root.val,leftList,res);
        }
        if(root.right!=null){
            //复制
             ArrayList<Integer> rightList=new ArrayList<Integer>(list);
            findPath(root.right,target-root.val,rightList,res); 
        }
    }
}

使用到的一个list复制方法： new ArrayList(list);复制list；

计算路径的总条数

题目描述： 输入一颗二叉树的根节点和一个整数，按字典序打印出二叉树中结点值的和为输入整数的所有路径的总数目。
思路分析： 和上题一样，直接看代码

class Solution {
    public int pathSum(TreeNode root, int sum) {
        //特判
        if(root==null){
            return 0;
        }
        //从根路径开始找,利用递归的方式遍历每一个节点
        int rootSum=findPathFromNode(root,sum);
        int leftSum=pathSum(root.left,sum);
        int rightSum=pathSum(root.right,sum);
        return rootSum+leftSum+rightSum;
    }

    //从指点节点Node中向下寻找路径,满足路径和=sum
    private int findPathFromNode(TreeNode node,int sum){
        if(node==null){
            return 0;
        }
        //当前节点的值==sum，则路径为1
        int pathSum=node.val==sum?1:0;
        //向左递归查找左子树是否能找到路径
        int leftSum=findPathFromNode(node.left,sum-node.val);
        //向右递归查找是否能找到路径
        int rightSum=findPathFromNode(node.right,sum-node.val);
        return leftSum+rightSum+pathSum;
    }
}

BST后序遍历序列

题目描述： 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
思路分析： BST的后序序列有如下特点：最后一个元素为根节点，剩余元素中比根节点的小的在左半部分（左子树），比根节点大的在右半部分（右子树），关键点在于找到左右子树的分界点；两个fo循环就能解决；对于左右子树，同样用递归去求解，这里面要注意递归的结束条件：start>=root,为什么呢？当start==root时，只有根节点，必为true,当start>root时，只有左子树；

public class Solution {
    int index=0;
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence==null || sequence.length==0){
            return false;
        }
        return verifyHelper(sequence,0,sequence.length-1);
    }
    private boolean verifyHelper(int[] sequence,int start,int root){
        //只有根节点
        if(start>=root){
            return true;
        }
        int key=sequence[root];//数组最后一个值一定为根节点的值
        //找到左、右子树的分界点
        //i的左边全小于key，i的右边全大于key
        int i=0;
        for(i=start;i<root;i++){//[0,root)
            if(sequence[i]>key){
                break;
            }
        }
        for(int j=i;j<root;j++){
            if(sequence[j]<key){
                return false;
            }
        }
        //找到了i;左子树为[0,i-1],右子树为[i,root-1]
        //使用递归的方式
        return verifyHelper(sequence,start,i-1) && verifyHelper(sequence,i,root-1);
        
    }
}

总结

所有的二叉树问题几乎都可以归咎于递归，递归的思想就是，当前函数只关注本节点的处理逻辑，而对左子树和右子树的处理逻辑均调用自己，直到递归的结束条件为止，因此，递归必然要先考虑结束条件，否则为死归！！！！！

华为OD最新面试手撕代码：翻转二叉树
zf169_com的博客
06-27 715
翻转这棵二叉树，并返回其根节点。给你一棵二叉树的根节点。
2025华为OD面试手撕代码真题目录
热门推荐
MISAYAONE的博客
04-28 8万+
一般面试的时候每一轮技术面都会出一到两个手撕代码题，这些题的特点就是，非常短小，易于理解。不可能会再出阅读理解一样的机试题的。但是这些题目也非常注意基本功，很注意细节的处理，一般都是easy+medium题目。但是大家一定要注意，因为大部分面试官上面一开始就会让你做题，直接看你所有的做题过程（防止有人水平一般，机试就网上找的答案的蒙混过关），手撕代码题会给你后面的面试定一个基调。
LeetCode刷题 —— 手撕二叉树
qq_66314292的博客
06-10 3353
二叉树刷题
手撕代码之二叉树
青萍之末的博客
04-09 1086
文章目录一、根据排序数组构造二叉搜索树（leetcode 108）二、根据前序遍历和中序遍历构造二叉树（leetcode 105）三、二叉树的非递归遍历（leetcode 94、144、145）四、二叉树中和为某一值的路径（leetcode 112）五、二叉树的最大深度（leetcode 104）六、二叉树的层次遍历（leetcode 102）七、判断两个二叉树是否相同（leetcode 100）...
Java 手撕二叉树
xianyu9264的专栏
03-31 467
先定义一个结点类 /** * 二叉树的结点 * * @author Administrator * */ public class Node { Object value; Node leftChild; Node rightChild; public Node(Object value) { this.value = value; } public Node...
数据结构:手撕二叉树
m0_60388241的博客
05-21 388
二叉树的基础概念: 树:高效的查找与搜索 1.为什么会存在树结构? 企业中员工的分类就是一个"树"结构!!! 如果是一个线性结构,大家都在一个"目录"中: 比如当前企业一共有300号员工,要找到一个特定员工最坏情况下要找300次 如果是一个树结构: 按照员工的职级分类,300个员工一共分为5级,搜索一个特点员工只需要5次即可找到 OS系统中的文件就是基于树结构管理的 OS系统中的所有文件都放在一个目录下,若当前操作系统有1亿个文件,最坏情况遍历1亿次才能找到特定元..
面试过程中手撕代码之二叉树
renhui1993的博客
08-31 2428
二叉树的个人总结由于本人目前在找算法工程师方向的工作，在面试过程中，经常会被问到非递归方法遍历的二叉树，二叉搜索树，二叉树的高度等一系列方法，本人写了c++代码供自己复习使用，希望也能够帮到各位小伙伴们代码块// // tree.cpp // myTest // // Created by lixiaoxue on 2017/8/28. // Copyright © 2017年 lixiao
面试手撕代码整理
09-29
以上整理的知识点覆盖了算法面试中一些常见的手撕代码题目，包括数值计算、链表操作、二叉树处理以及排序算法等。了解和掌握这些知识点对于应聘者在IT行业的面试中快速准确地完成算法题目是非常有帮助的。
二叉树的手撕代码 ：二叉树的中序遍历方法，左子树，右子树，后续 确定遍历方法等等，可以找题自己练习，选择 python
最新发布
10-11
</think>### Python实现二叉树中序遍历的代码 二叉树的中序遍历顺序为：**左子树 → 根节点 → 右子树**。以下是三种实现方法： #### 1. 递归法（标准求解） ```python class TreeNode: def __init__(self, val=0...
十道题带你手撕二叉树
m0_57304511的博客
04-25 8949
十道题带你手撕二叉树
手撕初阶数据结构之二叉树
liu3290607528的博客
06-19 1103
上篇博客小L已经讲述了二叉树的基本性质目前初阶数据结构最难的一集-树+二叉树_堆-优快云博客，这期我将带领大家一起进行二叉树的具体实现，由于普通二叉树实在太复杂，于是我们这节要一步步从零开始，那么就让我们系好安全带，一起向二叉树前进吧！！！
终于手撕了二叉搜索树（代码可运行，带详细注释）
大吉的博客
12-05 1012
含操作二叉搜索树的常用方法，重点是二叉搜索树的删除，删除远比插入复杂，网上的案例多有情况考虑不周的情况，一怒之下本人手撕了一个带详细注释的Demo。
[C++ code]手撕二叉树的遍历
emmJane的博客
02-12 565
前序遍历 根-左-右，递归 class Solution{ public: vector<int> preorderTraversal(TreeNode* root) { vector<int> result; preorder(root, result); return result; } void preorder(TreeNode* cur, vector<int> &res)
手撕二叉搜索树
GG_Bruse的博客
11-17 1170
二叉搜索树(BST,Binary Search Tree),也称二叉排序树或二叉查找树
手撕二叉树（图解+代码）
小S的博客
04-22 1273
包含二叉树的基本操作，内附图解和程序设计源码
【Cpp】手撕搜索二叉树(K模型)
patrick的博客
04-19 713
/定义左子树 BSTreeNode < k > * right;//定义右子树 k _key;//存储关键码 BSTreeNode(const k & key) //构造函数 : _key(key) , _left(nullptr) , _right(nullptr) {} }上面我们已经把每个结点的结构定义出来了//将结点名字重新命名,方便后续写代码 public :这篇文章写的都是搜索二叉树的K模型.关于KV模型的代码手撕将在下一篇文章中,到时候查看我所写的博客即可.
C++进阶：二叉搜索树
QinMou
09-16 1304
另外，⼆分查找也可以实现O(logN) 级别的查找效率，但是⼆分查找有两⼤缺陷： 1. 需要存储在⽀持下标随机访问的结构中，并且有序。 2. 插⼊和删除数据效率很低，因为存储在下标随机访问的结构中，插⼊和删除数据⼀般需要挪动数 据。 这⾥也就体现出了平衡⼆叉搜索树的价值。
Java 手撕二叉树，用递归，栈，bfs，dfs 遍历二叉树
crushem的博客
03-05 673
手撕二叉树 java
二叉树进阶——手撕二叉搜索树
m0_73802195的博客
04-06 953
若它的左子树不为空，则左子树上的所有节点的值都小于根节点的值若它的右子树不为空，则右子树上的所有节点的值都大于根节点的值总的来说二叉搜索树，比较难的地方就是删除部分，多画图多思考。下篇我们就要深入二叉搜索树。
评论 2
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值