【Java算法题】剑指offer_数据结构之02树

已于 2023-06-13 21:53:03 修改
阅读量412 收藏
点赞数
分类专栏： Java 文章标签： 算法 java 数据结构
于 2023-05-29 22:23:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43800119/article/details/130937714
版权

前言

刷题链接：
https://www.nowcoder.com/exam/oj/ta?page=2&tpId=13&type=265

原定于5.27写完树部分的算法，但是未能如愿写完。现已经5.31，另外 “JZ37 序列化二叉树” HARD题目，暂时没写出来，后续再刷的时候会再写。

2. 树

JZ55 二叉树的深度

在这里插入图片描述

思路：dep = max_deepth(left,right)+1，二叉树的深度为根节点到叶子节点，使用递归访问根节点的左孩子和右孩子，取最大值。

看图了解递归更新步骤：大致是这样，返回某一结点左边然后再右边（叶子节点的访问应该是两步，此处写成了一步）
[图片]

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

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

    }

}
*/

public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        return Math.max(TreeDepth(root.left),TreeDepth(root.right))+1;
    }
}

还可以用层次遍历，当前结点的左右孩子节点入队。记录队列大小，访问完的节点出队，访问完一层的时候深度+1。队列为空的时候，退出遍历。

JZ77 按之字形顺序打印二叉树

在这里插入图片描述

思路：使用队列进行层次遍历的应用，但是需要按照之字形访问，添加一个flag来操作。

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 {
    public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
        TreeNode head = pRoot;

        if(head==null){
            return res;
        }

        // 队列存储,层次遍历
        Queue<TreeNode> temp = new LinkedList<TreeNode>();
        temp.offer(head); //根节点入队
        TreeNode p;
        boolean flag = true; //决定是否反转
        while(!temp.isEmpty()){
            ArrayList<Integer> row = new ArrayList<Integer>(); //记录二叉树的某一行
            int n = temp.size();
            flag = !flag;
            for(int i=0;i<n;i++){
                p = temp.poll(); //返回当前队列的节点
                row.add(p.val);
                if(p.left != null) // 当前节点的左右孩子不为空则添加到队列
                    temp.offer(p.left);
                if(p.right != null)
                    temp.offer(p.right);
            }
            if(flag){ //奇数行不反转，偶数行反转
                Collections.reverse(row);
            }
            res.add(row);
        }

        return res;
    }

}

JZ54 二叉搜索树的第k个节点

在这里插入图片描述

思路：二叉搜索树的特点就是左节点<中间节点<右节点，利用中序遍历就可以生成一个升序的数组，那么利用一个count标记已访问的节点数，当count等于k的时候返回当前节点就行。

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 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param proot TreeNode类 
     * @param k int整型 
     * @return int整型
     */
    private int count = 0;
    private int res = -1;
    public int KthNode (TreeNode proot, int k) {
        // write code here
        if(proot == null)
            return -1;
        // 中序遍历
        midOrder(proot,k);
        return res;
    }
    public void midOrder(TreeNode p,int k ){
        if(p == null || count > k){
            return ; 
        }
        midOrder(p.left,k);
        count++;
        if(count==k){
            res = p.val; //记录第k个访问到的节点
        }
        midOrder(p.right,k);
    }
}

JZ7 重建二叉树

在这里插入图片描述

思考：

  1. 利用前序遍历pre[0]确定根节点；
  2. 在中序遍历搜索根节点位置vin[i]，确认左右子树；
  3. 递归：左子树传入pre[1:i+1]和vin[0,i] ，右子树传入pre[i+1,pre.length]和vin[i+1,vin.length]

Arrays.copyOfRange(int[] nums,int from,int to) 左开右闭复制数组

import java.util.*;
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode reConstructBinaryTree(int [] pre,int [] vin) {
        int n = pre.length;
        int m = vin.length;
        if(n==0||m==0){
            return null;
        }
        TreeNode root = new TreeNode(pre[0]);
        for(int i = 0;i<m;i++){
            if(vin[i] == pre[0]){ //找到中序遍历的根节点
                root.left=reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(vin,0,i));
                root.right=reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,n),Arrays.copyOfRange(vin,i+1,m));
                break;
            }
        }
        return root;
    }
}

JZ26 树的子结构

在这里插入图片描述

思路：考察的是二叉树先序遍历（仔细斟酌一下）

  1. 因为空树不是任何树的子树，先判断B树是否为空
  2. 当A树为空节点，但是B树不为空的时候，B树不是A的子树
  3. 当A树为空节点，B树为空，则B树为A的子树
  4. 每次递归从比较A树当前节点开始，判断是否与B树一致，同步先序遍历
  5. A树自己再前序遍历进入子节点，当作子树起点再与B树同步遍历。
    以上任意一种情况满足即可。
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        if(root1==null || root2 == null){ //空树不是任何树的子树
            return false;
        }
        if(isSame(root1,root2)){ //判断是否相等
            return true;
        }else{
            return HasSubtree(root1.left,root2) ||  HasSubtree(root1.right,root2);
        }
        
    }
    public boolean isSame(TreeNode head1, TreeNode head2){
        if(head2 == null){ //遍历树B完成
            return true; //B为A的子树
        }else if(head1 == null){
            return false; //遍历树A完成,B不是子树
        }

        if(head1.val != head2.val){ //当前节点不相等
            return false;
        }
        // 当前节点相等，进入下一节点比较，所有节点相等返回true
        boolean flag1 = isSame(head1.left,head2.left);
        boolean flag2 = isSame(head1.right,head2.right);

        return flag1&&flag2;
    }
}

JZ27 二叉树的镜像

[图片]

思路：考察后序遍历
访问当前节点的左右节点，将两个值交换

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 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    public ArrayList<Integer> nums = new ArrayList<>();
    public TreeNode Mirror (TreeNode pRoot) {
        //空树返回
       if(pRoot == null){
        return null;
       }
       //递归子树
       TreeNode left = Mirror(pRoot.left);
       TreeNode right = Mirror(pRoot.right);
       //交换
       pRoot.left = right;
       pRoot.right = left;
       return pRoot;
    }

}

JZ32 从上往下打印二叉树

在这里插入图片描述

思路：广度遍历（层次遍历），使用队列保存当前层的节点信息，访问一个节点则存入数组中。

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 {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        //层次遍历

        ArrayList<Integer> nums = new ArrayList<>();
        if(root == null){ //空则返回空
            return nums;
        }

        //创建队列存储节点
        Queue<TreeNode> t = new LinkedList<TreeNode>();
        TreeNode p;
        t.offer(root); //根节点入队
        while(!t.isEmpty()){
            int n = t.size();
            for(int i=0;i<n;i++){
                p = t.poll(); //删除并返回队头元素
                nums.add(p.val);
                if(p.left != null){
                    t.offer(p.left);
                }
                if(p.right != null){
                    t.offer(p.right);
                }   
            }     
        }
        return nums;
    }
}

JZ33 二叉搜索树的后序遍历序列

在这里插入图片描述

在这里插入图片描述

思路：
二叉搜索树的特点就是左子树<中间节点<右子树

  1. 找到左右子树分界点，记录索引值mid
  2. 如果mid==-1，说明没有右子树，直接判定为true
  3. 若有右子树，判断右子树合不合法，即看数值是不是都小于root
  4. 递归检查左右子树
public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence.length==0){
            return false;
        }
        return order(sequence,0,sequence.length-1);
    }
    public boolean order(int[] sequence,int left, int right){
        if(left >= right) return true;
        int root = sequence[right]; //根节点为最后一个元素
        
        // 找到左右子树的分界点，第一个大于根节点的元素位置
        int mid = -1;
        for(int i=left;i<right;i++){
            if(sequence[i]>root){
                mid = i;
                break;
            }
        }
        if(mid == -1) return true; //只有左子树，直接判定true

        // 判断右子树合不合法
        for(int i=mid;i<right;i++){
            if(sequence[i]<root){ //右子树存在小于root的元素则为false
                return false;
            }
        }

        return order(sequence,left,mid-1) && order(sequence,mid,right-1);
    }
}

一个待解决的BUG：

小白发问，这个代码面对{4,6,7,5}时运行错误，应该如何修正呢？出错的点在于处理右子树{6,7}时，order(seq,1,2)=>mid=0 没有该子树没有右子树，但是因为mid=0，还是会运行下面的右子树合法判断。
我将mid初始化为-1，额外添加了if(mid==-1) return true; 还有别的方法改进吗？

    
public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
        if(sequence.length==0){
            return false;
        }
        return order(sequence,0,sequence.length-1);
    }
    public boolean order(int[] sequence,int left, int right){
        if(left >= right) return true;
        int root = sequence[right]; //根节点为最后一个元素
        
        // 找到左右子树的分界点，第一个大于根节点的元素位置
        int mid = 0;
        for(int i=left;i<right;i++){
            if(sequence[i]>root){
                mid = i;
                break;
            }
        }

        // 判断右子树合不合法
        for(int i=mid;i<right;i++){
            if(sequence[i]<root){ //右子树存在小于root的元素则为false
                return false;
            }
        }

        return order(sequence,left,mid-1) && order(sequence,mid,right-1);
    }
}

JZ82 二叉树中和为某一值的路径(一)

在这里插入图片描述

在这里插入图片描述

思路：检查根节点到叶子节点是否有满足条件的路径，那么就需要从根节点遍历。采用先序遍历的思想，每遍历一个就将sum减去该节点值。首先判断该节点是否为空，空则不是路径；其次检查该节点是否为叶子节点，且sum减去该节点值为0，那么该条路径满足要求。递归检查左右子树是否有满足要求的路径，任意一条满足即可。

import java.util.*;

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

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @param sum int整型 
     * @return bool布尔型
     */
    public boolean hasPathSum (TreeNode root, int sum) {
        // write code here
        if(root == null) //检查该节点是否为空，空则不是路径
            return false;
        if(root.left == null && root.right == null && sum-root.val==0){ 
            //检查是不是为叶子节点，且sum-该节点值是否等于0
            return true;
        }
        //检查左子树或右子树
        return hasPathSum(root.left,sum-root.val) || hasPathSum(root.right,sum-root.val);
    }
}

可以用深度优先搜索(dfs)

JZ34 二叉树中和为某一值的路径(二)

在这里插入图片描述

[图片]

思路：从根节点开始遍历，当前路径path记录路径，当前的目标值减去该节点值，如果满足叶子节点和值==0的要求则满足路径要求，加入到输出数组res中。递归左右子树，找寻是否存在满足要求的路径。

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 {
    private ArrayList<ArrayList<Integer>> res = new ArrayList<>();
    private Stack<Integer> path = new Stack<>();
    public ArrayList<ArrayList<Integer>> FindPath(TreeNode root,int expectNumber) {
        
        if(root==null){ //该节点为空，直接输出来所有路径
            return res;
        }
        path.push(root.val);//加入该节点到路径数组中
        expectNumber -= root.val;

        if(root.left==null && root.right==null && expectNumber==0){
            res.add(new ArrayList<Integer>(path)); //找到一条满足的路径，加入到res中
        }
        FindPath(root.left,expectNumber); //左子树、右子树查找
        FindPath(root.right,expectNumber);
        path.pop();//清空当前路径数组

        return res;
    }
}

JZ36 二叉搜索树与双向链表

在这里插入图片描述
在这里插入图片描述

思路：

  • 想到了中序遍历，创建两个指针（head指向双链表表头，pre指向当前遍历的前一个节点）；
  • 首先，递归到最左找到叶子节点（递归出口就是节点为空则返回），也就可以初始化(if pre==null)双链表表头head和pre；
  • 然后，pRootOfTree指向最左子树的中间节点，双向连接pre和pRootOfTree（pre.right=pRootOfTree; pRootOfTree.left=pre;），更新pre节点到当前遍历的pRootOfTree(pre=pRootOfTree)；
  • 最后，递归进入右子树，重复操作。
/**
public class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

    }

}
*/
public class Solution {
    public TreeNode head = null; //头节点
    public TreeNode pre = null; // 当前节点的前一节点
    public TreeNode Convert(TreeNode pRootOfTree) {
        if(pRootOfTree == null){
            return null; //中序递归，叶子节点为空则返回
        }
        //左边最小值
        Convert(pRootOfTree.left);
        if(pre == null){
            head = pRootOfTree; //双向链表的头节点
            pre = pRootOfTree;
        }else{ //建立连接，当前节点与上一个节点
            pre.right = pRootOfTree;
            pRootOfTree.left = pre;
            pre = pRootOfTree; //当前节点变为前一节点
        }
        Convert(pRootOfTree.right);
        

        return head;
    }
}

JZ79 判断是不是平衡二叉树

在这里插入图片描述
在这里插入图片描述

思路：DFS方法

  • 递归左子树和右子树，如果为null则返回true，证明该子树为平衡树。
  • 计算左右子树高度差（递归实现，参考JZ55 二叉树的深度），如果高度差小于2则为true
import java.util.*;

public class Solution {
    public boolean IsBalanced_Solution(TreeNode root) {
        if(root == null){ //空树是平衡二叉树
            return true;
        }
        boolean left = IsBalanced_Solution(root.left);
        
        boolean right = IsBalanced_Solution(root.right);

        return left && right && Math.abs(deepth(root.left)-deepth(root.right))<2;
    }
    public int deepth(TreeNode root){
        if (root==null){
            return 0;
        }
        return Math.max(deepth(root.left),deepth(root.right))+1;
    }
}

JZ8 二叉树的下一个结点

[图片]

[图片]

[图片]

思路：

  • 当前节点有右子树: 下一节点为当前节点的右子树的最左下节点
  • 当前节点无右子树:
    • 当前节点是其父亲节点的左孩子：下一节点为父亲节点
    • 当前节点是其父亲节点的右孩子：向上找当前节点的父亲节点的父亲节点，直到当前节点为父亲节点的左子树，返回该父亲节点为当前节点的下一节点
  • 否则为NULL
/*
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) {
       
        //1.该节点有右孩子,下一节点为其右子树的最左下的节点
        if(pNode.right!=null){
            TreeLinkNode rchild = pNode.right;
            //找最左下的节点
            while(rchild.left != null){
                rchild = rchild.left;
            }
            return rchild;
        }

        //2.该节点无右孩子，当前节点是其父亲节点的左孩子，下一节点为其父亲节点
        if(pNode.next!=null && pNode.next.left == pNode){
           return pNode.next; 
        }
        //3.该节点无右孩子，当前节点是其父亲节点的右孩子，
        // 往上找父亲节点的父亲节点，直到当前节点为父亲节点的左子树，返回这个父亲节点
        if(pNode.next != null && pNode == pNode.next.right){
            TreeLinkNode father = pNode.next; //往上面找
            while(father.next!=null && father.next.right==father){
                father = father.next;
            }
            return father.next;
        }

        return null;
    }
}

JZ28 对称的二叉树

[图片]

[图片]

思路：比较外侧节点和内侧节点
https://www.programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E9%80%92%E5%BD%92%E6%B3%95
比较的是二叉树的左右节点，确定递归终止条件：

  • 左节点为空，右节点不为空，不对称
  • 左节点不为空，右节点为空，不对称
  • 左右节点都为空，对称
  • 左右节点不为空，数值不相等，不对称
    左右节点不为空，数值相等，进入递归：
  • 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子
  • 比较内侧是否对称，传入左节点的右孩子，右节点的左孩子
  • 如果左右都对称就返回true ，有一侧不对称就返回false
/*
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;
        return compare(pRoot.left,pRoot.right);
    }

    boolean compare(TreeNode left,TreeNode right){
        if(left==null && right!=null){
            return false;
        }else if(left!=null && right==null){
            return false;
        }else if(left==null && right==null){
            return true;
        }else if(left.val != right.val){
            return false;
        }
        return compare(left.right,right.left) && compare(left.left,right.right);
    }
}

JZ78 把二叉树打印成多行

在这里插入图片描述

[图片]

思路：层次遍历
使用队列，遍历一层的节点入队，出队输出到一维数组里面。

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> > Print(TreeNode pRoot) {
        ArrayList<ArrayList<Integer> > res = new ArrayList<ArrayList<Integer> >();
        if(pRoot==null){
            return res;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        TreeNode p;
        queue.offer(pRoot);

        while(!queue.isEmpty()){
            ArrayList<Integer> num = new ArrayList<Integer>(queue.size()); //创建行数组
            int n = queue.size();
            for(int i = 0;i<n;i++){
                p = queue.poll(); 
                num.add(p.val);
                if(p.left != null){
                    queue.offer(p.left);
                }
                if(p.right != null){
                    queue.offer(p.right);
                } 
            }
            
            res.add(num);
        }
        return res;
    }
}

JZ84 二叉树中和为某一值的路径(三)

在这里插入图片描述
在这里插入图片描述
思路：从任意节点出发寻找路径，因此需要遍历二叉树，使用前序遍历选取起始节点。查找路径也需要往下遍历，每遍历一个节点，sum减去该节点的值。

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 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param sum int整型 
     * @return int整型
     */
    public int res  = 0;

    //以某节点为根查询满足要求的路径数
    public void dfs(TreeNode root,int sum){
        if(root==null){
            return;
        }
        if(sum==root.val){ //符合目标值
            res++;
        }
        dfs(root.left,sum-root.val); //减去当前节点值，进入子节点继续寻找
        dfs(root.right,sum-root.val);
    }

    //以每个节点为根查询路径
    public int FindPath (TreeNode root, int sum) {
        // write code here
        if(root == null) return res;

        //以某节点为跟的路径数
        dfs(root,sum);
        //以某子节点为新根
        FindPath(root.left,sum);
        FindPath(root.right,sum);
        
        return res;
    }
}

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

在这里插入图片描述
在这里插入图片描述
思路：需要从下往上遍历所有的节点，用后序遍历可以满足从下往上找的要求。

  1. 确认递归函数返回值以及参数：

int lowestCommonAncestor (TreeNode root, int o1, int o2)

  1. 确认终止条件：此处为某节点的值等于o1或者o2时返回root.vall，或者root为null则返回-1；

if(root == null) return -1;
if(root.val == o1 || root.val == o2 ) return root.val;

  1. 确认单层递归逻辑：分为三种情况
    a. 两个值都在当前节点的左子树，公共祖先就在左子树；
    b. 两个值都在当前节点的右子树，公共祖先就在右子树；
    c. 在当前节点的一左一右，公共祖先为当前节点(root)。
import java.util.*;

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

public class Solution {
    /**
     * 
     * @param root TreeNode类 
     * @param o1 int整型 
     * @param o2 int整型 
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int o1, int o2) { //后序遍历
        if(root == null) return -1;
        if(root.val == o1 || root.val == o2 ) return root.val;

        int left = lowestCommonAncestor(root.left,o1,o2);
        int right = lowestCommonAncestor(root.right,o1,o2);

        if(left==-1){ //不在左子树，则在右子树
            return right;
        }
        if(right==-1){ //不在右子树，找左子树
            return left;
        }
        return root.val; //一个在左，一个在右，root就是公共祖先
        
    }
}

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

在这里插入图片描述
在这里插入图片描述

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 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param p int整型 
     * @param q int整型 
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        // write code here
        ArrayList<Integer> path1 = getPath(root,p);
        ArrayList<Integer> path2 = getPath(root,q);
        int res = 0;

        for(int i = 0;i<path1.size() && i<path2.size();i++){
            int x = path1.get(i); 
            int y = path2.get(i);
            if(x==y){
                res = path1.get(i);
            }else{
                break;
            }
        }

        return res;
       
    }

    public ArrayList<Integer> getPath(TreeNode root,int target){
        ArrayList<Integer> path = new ArrayList<Integer>();
        TreeNode node = root;
        while(node.val!= target){
            path.add(node.val);
            if(node.val<target){
                node=node.right;
            }else if(node.val>target){
                node=node.left;
            }
        }
        path.add(node.val); //加入相等的节点
        return path;
    }

}
  • 二叉树递归的方法和《JZ86》相同
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 {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @param p int整型 
     * @param q int整型 
     * @return int整型
     */
    public int lowestCommonAncestor (TreeNode root, int p, int q) {
        // write code here
        if(root==null) return -1;
        if(root.val == p || root.val == q) 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;
    }

}

3. 队列 & 栈

【Java算法题】剑指offer_数据结构之03队列&栈

zoetu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
《剑指Offer：数据结构与算法名企面试题精讲》.zip
06-16
大学生 C/C++/JAVA/Python数据结构学习笔记和资料大全
《剑指Offer》学习80题java版本.zip
03-10
《剑指Offer》学习80题，适合面试中提问数据结构和算法，应聘者必备
牛客网剑指offer——Java题解.pdf
09-07
本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：使用双指针，从右上角...
《剑指 Offer》 Python, Java, C++ 解题代码，LeetBook《图解算法数据结构》配套代码仓.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和...
Java版-剑指offer数据结构与算法 视频教程 下载 百度网盘链接4.zip
最新发布
06-19
Java版-剑指offer数据结构与算法 视频教程 下载 百度网盘链接4.zip
算法day28
2202_76101487的博客
06-13 1193
正值少年的日常打卡
卡尔曼滤波原理及应用（一）
qq_67958647的博客
06-13 697
卡尔曼滤波原理及推导
【算法专题--链表】反转链表II--高频面试题（图文详解，小白一看就会！！！）
weixin_45031801的博客
06-15 691
反转链表II这道题，可以说是--链表专题--，最经典的一道题，也是在面试中频率最高的一道题目，通常在面试中，面试官可能会从多个方面考察这道题目，所以大家需要对这道题目非常熟悉哦！！
代码随想录算法训练营第六天| 242.有效的字母异位词 | 349. 两个数组的交集 | 202. 快乐数 |1. 两数之和
weixin_45596561的博客
06-11 850
3. 不知道如何用javascript创建set类型，没有理解这个题用set的原因，利用了hash法在查找元素方面的优点，这里由于元素长度不固定，用数组就不太适合，利用set这个数据结构(底层实现是红黑树，可以用于这种查找元素范围不固定的情况)，将第一个数组转为set1，这样就自动完成了去重操作，然后遍历第二个数组，对每一个元素，在set1中执行查询操作，找到了就添加到结果set2中，利用set2完成去重操作，最后将set2转为数组返回。4，用了一个小时左右，利用set完成去重操作和提高查找效率。
算法训练营day06--242.有效的字母异位词+349. 两个数组的交集+202. 快乐数+1. 两数之和
qq_42029265的博客
06-12 529
242.有效的字母异位词+349. 两个数组的交集+202. 快乐数+1. 两数之和
【文献阅读】一种多波束阵列重构导航抗干扰算法
Sol-itude的博客
06-12 1208
针对导航信号在近地表的信号十分微弱、抗干扰能力差的问题，文章提出了自适应波束形成技术。自适应波束形成技术可以分为调零抗干扰算法和多波束抗干扰算法。主要应用功率倒置技术，充分利用导航信号功率低于环境噪声功率的特点，对强信号来向角度进行抑制。原理是通过对采样信号实时计算，由信号统计特征获得一组合适阵列配置参数，依此调整主波束指向期望信号方向，同时在空域上对干扰信号的来向进行抑制，实现对导航信号增益的同时抑制干扰信号。，优点是提高了输出信号与干噪加噪声比SINR，并且减少了计算量。
双指针练习：和为s的两个数字
2202_75331338的博客
06-13 390
购物车内的商品价格按照升序记录于数组 price。请在购物车中找到两个商品的价格总和刚好是 target。若存在多种情况，返回任一结果即可。输入：price = [3, 9, 12, 15], target = 18输出：[3,15] 或者 [15,3]输入：price = [8, 21, 27, 34, 52, 66], target = 61输出：[27,34] 或者 [34,27]两层for循环：·外层 for 循环依次枚举第一个数a；·内层 for 循环依次枚举第二个数b，让它与a匹配。
C++:十大排序
2301_80418172的博客
06-12 1031
十大排序CPP
ACM算法学习路线、清单
qq_45477639的博客
06-10 2052
算法与数据结构学习路线
基数排序详解
都市隸人的博客
06-11 708
本文详细解释了基数排序实现的思路，并附上了C语言源码
【LeetCode】LCR 124. 推理二叉树
时光、疏离了记忆づ童话的博客
06-16 258
思路：有前备知识我们很快能发现，先序主要作用是确定根，先序中的每个节点都会顺序的成为从上往下的子树的根节点；而通过先序中确定的根节点，在中序序列中，我们能够将二叉树进行初步划分左右子树，然后继续找先序中的根，继续划分左右子树，划分这个过程可以借助递归完成。这样，在找寻到一个根节点的时候，通过这个根节点所在中序中的位置确定下一次划分的区间。：某二叉树的先序遍历结果记录于整数数组 preorder，它的中序遍历结果记录于整数数组 inorder。
代码随想录算法训练营DAY37｜ 56. 合并区间、738.单调递增的数字、968.监控二叉树、总结
Greeneril_的博客
06-13 242
两个维度权衡问题在出现两个维度相互影响的情况时，两边一起考虑一定会顾此失彼，要先确定一个维度，再确定另一个一个维度。贪心算法：分发糖果贪心算法：根据身高重建队列贪心解决区间问题贪心算法：跳跃游戏贪心算法：跳跃游戏II贪心算法：用最少数量的箭引爆气球贪心算法：无重叠区间贪心算法：划分字母区间贪心算法：合并区间。
基于MATLAB仿真的BCC卷积码维特比译码算法
m0_73019469的博客
06-13 1307
BCC卷积码是一种非分组码，它在1955年被提出。卷积码在编码时是把k个比特的信息段编写成n个比特的码组，但其监督码元不仅与当前编码比特信息有关，还与前面(N-1)个比特有关，其中N为卷积码的编码约束度。卷积码通常记为(n, k, N)。根据卷积码的特性，它更适合用于前向纠错，并且在许多实际情况下其效果优于分组码。此外，卷积码运算简单，尤其适合用在被高斯白噪声所干扰的传输信道中。维特比译码算法是一种卷积码的解码算法，它在1967年被提出。
数组移除元素算法（以JS为例）
a3098448071的博客
06-16 275
需要注意的是，这种实现并不是最优的双指针技术，因为它没有使用两个指针来同时处理元素的移动和比较。在更复杂的场景中，双指针技术可能会涉及到两个或更多的指针来同时进行不同的操作，以实现更高效的数据处理。这种实现方式的优势在于它不需要额外的空间来存储新数组，而是在原数组上进行操作，节省了空间。但是，这种方法会改变原数组的内容，如果需要保留原数组不变，就需要在函数开始时创建一个原数组的副本。作为辅助指针，用来记录新数组（或原数组中未被覆盖部分）的当前位置。的值，即新数组中有效元素的数量。：如果当前元素不等于。
剑指offerjava版pdf
07-16
此外，这本Java版的剑指Offer PDF还提供了一些常见的算法和数据结构的实现，帮助程序员更好地理解和掌握这些基础知识。通过阅读和实践这些题目，程序员可以提高自己的编程能力和解决问题的能力，为日后的面试做好...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zoetu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值