suv1234的博客

思路：先求最大最小叶子节点，再求两节点的LCA（最近公共祖先），求两节点到LCA距离。import java.util.*;/*public class TreeNode { int val = 0; TreeNode left = null; TreeNode right = null; public TreeNode(int val) {

public ArrayList inorderTraversal(TreeNode root) { Stack stack = new Stack(); ArrayList result = new ArrayList(); TreeNode curt = root; while (curt != null || !stack.em

给定一个字符串source和一个目标字符串target，在字符串source中找到包括所有目标字符串字母的子串。在答案的子串中的字母在目标字符串中不需要具有相同的顺序给出source = "ADOBECODEBANC"，target = "ABC" 满足要求的解 "BANC"要求时间复杂度为O(n)public class Solution { publ

给出一个整数数组 nums 和一个整数 k。划分数组（即移动数组 nums 中的元素），使得：所有小于k的元素移到左边所有大于等于k的元素移到右边返回数组划分的位置，即数组中第一个位置 i，满足 nums[i] 大于等于 k。public int partitionArray(int[] nums, int k) { //write your code here

给出三个字符串:s1、s2、s3，判断s3是否由s1和s2交叉构成。public boolean isInterleave(String s1, String s2, String s3) { if (s1.length() + s2.length() != s3.length()) { return false; }

给定一个含不同整数的集合，返回其所有的子集子集中的元素排列必须是非降序的，解集必须不包含重复的子集class Solution { /* @param S: A set of numbers. * @return: A list of lists. All valid subsets. */ public ArrayList> subsets(

// 给出一个测试数据样例， 二叉树{3,9,20,#,#,15,7}，表示如下的树结构：// 3// / \// 9 20// / \// 15 7

给出数组 [9,3,2,4,8]，第三大的元素是 4给出数组 [1,2,3,4,5]，第一大的元素是 5，第二大的元素是 4，第三大的元素是 3，以此类推要求时间复杂度为O(n)，空间复杂度为O(1)public static int kthLargestElement(int k, int[] nums) { // write your code here

/** * 比较当前运算符和栈顶运算符的优先级 * @param stackPeek 栈顶元素 * @param current 当前元素 * @return */ public static boolean getPriority(String stackPeek,String current) { if(stac

求逆波兰表达式的值。在逆波兰表达法中，其有效的运算符号包括 +, -, *, / 。每个运算对象可以是整数，也可以是另一个逆波兰计数表达。哪家公司问你的这个题？AirbnbAlibabaAmazonAppleBaiduBloombergCiscoDropboxEbayFacebookGoogleHuluIntelLinkedinMicrosoftNetEaseNvidiaOracl

public class Solution { /** * @param m: An integer m denotes the size of a backpack * @param A & V: Given n items with size A[i] and value V[i] * @return: The maximum value * 背

带重复元素的排列public List> permuteUnique(int[] nums) { ArrayList> results = new ArrayList>(); if (nums == null) { return results; } if(nums.lengt

两个排序的数组A和B分别含有m和n个数，找到两个排序数组的中位数，要求时间复杂度应为O(log (m+n))。     给出数组A = [1,2,3,4,5,6] B = [2,3,4,5]，中位数3.5 给出数组A = [1,2,3] B = [4,5]，中位数 3public double findMedianSortedArrays(int A[], int B[])

/**02 * int的key按照降序排列03 *04 * @author zhangdonghao05 *06 */07public class IntKeyAscComparator extends WritableComparator {08 09protected IntKeyAscComparator() {10    super(IntWritable.class, true);11

可能是没吃饭就去面试了，一塌糊涂，好尴尬，生成器竟然卡壳了···，问的随机数生成器生成1、2、3的概率相等，都为1/3，问如何设计生成器，使得生成1、2、3的概率为0.5、0.3、0.2.先整体总结一下之前的生成器的问题1给定一个随机生成器fun()，生成0和1的概率分别为0.5，那么如何构造一个生成0和1的概率分别是0.3和0.7的随机生成器？可以考虑将其生成的数字0,1进行组合

面试到这个很尴尬的题，刚开始问的很简单，就是求用币值为1元，5元,10元,20元,50元,100元的最少张数表示一个数a=m/100; b=(m%100)/50; c=(m%100%50)/20; d=(m%100%50%20)/10; e=(m%100%50%20%10)/5; f=m%100%50%20%10%5; 接下来面试官问了，如果可以找零呢？比如你要换99，你可以给他

我之前写了一个全排列，在递归的过程中，如果不满足result中的元素个数等于要排列的元素数（递归的终止条件），就继续递归，而在判断元素是否应该加入到result中时，采用了是每次都遍历一遍要排列的数组，如果元素在result中，则continue，否则就加入result。面试官让我看看可不可以改进，按人的思维思考，比如123，先固定1，有23,32两种，采用的是交换的思想，把两个元素交换pub

public ArrayList postorderTraversal(TreeNode root){ Stack stack = new Stack<>(); ArrayList result = new ArrayList<>(); if(root== null){ return result;

public class Solution { public ArrayList> levelOrder(TreeNode root) { ArrayList result = new ArrayList(); if (root == null) { return result; } Queue q

public class Solution { /**weizuo * @param head: The first node of linked list. * @return: a tree node * 排序列表转换为二分查找树 * 给出一个所有元素以升序排序的单链表，将它转换成一棵高度平衡的二分查找树 */ private

给出n个物品的体积A[i]和其价值V[i]，将他们装入一个大小为m的背包，最多能装入的总价值有多大？n个物品，背包为m，体积a[1..n]，价值v[1..n]state: f[i][j]表示前i个物品中，取出“若干”物品后，体积“正好”为j的最大价值。function: f[i][j] = max{f[i-1][j], f[i-1][j - a[i]] +v[i]}inti

在n个物品中挑选若干物品装入背包，最多能装多满？假设背包的大小为m，每个物品的大小为A[i]n个整数a[1..n]，装m的背包state: f[i][j] “前i”个数，取出一些能否组成和为jfunction: f[i][j] = f[i-1][j - a[i]] or f[i-1][j]intialize: f[X][0] = true; f[0][1..m] = f

今天面到的算法题挺有意思，是要我写一个randomSplit（）函数，传入的变量有待分的正整数m，要分的份数n，最小值min_val,最大值max_val;将m分成最大值和最小值之间的n个随机数这其实就是一个随机分红包的问题，这个思路就是要注意这n部分要一份一分的分开生成，我们需要确定的就是每一份的上下限是什么。上限：math.min{max-val,m - (n -  ni)*min_v

给定一棵具有不同节点值的二叉查找树，删除树中与给定值相同的节点。如果树中没有相同值的节点，就不做任何处理。你应该保证处理之后的树仍是二叉查找树。Steps:1. Find the node2. Find the maximum node in the left subtree3. Replace the node with the maximum node in the left

给定一个字符串s，将s分割成一些子串，使每个子串都是回文。返回s符合要求的的最少分割次数。样例 比如，给出字符串s = "aab"，返回 1， 因为进行一次分割可以将字符串s分割成["aa","b"]这样两个回文子串state: f[i]”前i”个字符组成的子字符串需要最少几次cut(最少能被分割为多少个字符串-1)function: f[i] = MIN{

给一个整数数组，调整每个数的大小，使得相邻的两个数的差小于一个给定的整数target，调整每个数的代价为调整前后的差的绝对值，求调整代价之和最小是多少。你可以假设数组中每个整数都是正整数，且小于等于100。state: f[i][v] 前i个数，第i个数调整为v，满足相邻两数function: f[i][v] = min(f[i-1][v’] + |A[i]-v|, |vv’|

数字是不断进入数组的，在每次添加一个新的数进入数组的同时返回当前新数组的中位数。中位数的定义：中位数是排序后数组的中间值，如果有数组中有n个数，则中位数为A[(n-1)/2]。比如：数组A=[1,2,3]的中位数是2，数组A=[1,19]的中位数是1。样例持续进入数组的数的列表为：[1, 2, 3, 4, 5]，则返回[1, 1, 2, 2, 3]时间复杂度为O(nlogn

给出一个链表，每个节点包含一个额外增加的随机指针可以指向链表中的任何节点或空的节点。返回一个深拷贝的链表。public RandomListNode copyRandomList(RandomListNode head) { if (head == null) { return null; } HashMap m

如果可以允许出现两次重复将如何处理？public int removeDuplicates(int[] nums) { // write your code here if(nums == null) return 0; int cur = 0; int i ,j; for(i = 0; i

给出3*n + 1 个的数字，除其中一个数字之外其他每个数字均出现三次，找到这个数字。给出 [1,1,2,3,3,3,2,2,4,1] ，返回 4 public int singleNumberII(int[] A) { int result = 0 ; int [] a = new int[32]; for(int i = 0;

public class Solution { // you need treat n as an unsigned value public int reverseBits(int n) { int reversed = 0; for (int i = 0; i < 32; i++) { reversed = (revers

如果要从一个有序数组中选择一个元素作为根结点，应该选择哪个元素呢？我们应该选择有序数组的中间元素作为根结点。选择了中间元素作为根结点并创建后，剩下的元素分为两部分，可以看作是两个数组。这样剩下的元素在根结点左边的作为左子树，右边的作为右子树。解法由上面的思路，我们可以在O（N）的时间内从有序数组创建一棵平衡的BST，使用分治算法，代码如下：struct node* sorted

给定一个二叉树,确定它是高度平衡的。对于这个问题,一棵高度平衡的二叉树的定义是：一棵二叉树中每个节点的两个子树的深度相差不会超过1。class ResultType{ public int maxpath; public boolean isbalanced; public ResultType(int maxpath, boolean isbalanced){

给出一个字符串s和一个词典，判断字符串s是否可以被空格切分成一个或多个出现在字典中的单词。 样例 s = "lintcode"dict = ["lint","code"]返回 true 因为"lintcode"可以被空格切分成"lint code"private int getMaxLength(Set dict) { int maxLength = 0;

今天面了小米，一面的程序题是一个乱序的数组，用o（n）的时间将它重新排序成一升一降的形式比如【1,2,4,6,9】---【1，6，4，9，2】因为只是一个元素的左右进行比较，所以不满足条件调换左右即可public class Main { public static void main(String[] args){ int [] Number = {9,3,2,4,8,12}

// version 1: Merge Sortpublic class Solution { private ListNode findMiddle(ListNode head) { ListNode slow = head, fast = head.next; while (fast != null && fast.next !

private class ResultType { // singlePath: 从root往下走到任意点的最大路径，这条路径可以不包含任何点 // maxPath: 从树中任意到任意点的最大路径，这条路径至少包含一个点 int signlePath, maxPath; ResultType(int signlePath, int

从数据流中等概率的采样k个数字。怎么做呢？先拿到最开始的k个数字，然后以后的每个数字等概率的和这k个数字交换。那么就可以达到每个数字被抽取的概率是等概率的。怎么证明呢？类似题目：给定一个数据流，其中包含无穷尽的搜索关键字（比如，人们在谷歌搜索时不断输入的关键字）。如何才能从这个无穷尽的流中随机的选取1000个关键字？