Coding Interview

1. The use of List of List in Java在声明时，List和ArrayList必须每一层对应，就是中的类型必须对应List> list = new Arraylist> () 是不对的

与1不同的是要在一个list中不断更新，每次在list头上插入一个1，然后除去head和tail的两个1不更新， 其他位置全更新为 list.set ( j, list.get ( j ) + list.get ( j + 1 )); 就是上一行这个位置和后面一个数的和。public class Solution {    public List getRow(int rowInd

错太多了，一开始找规律就找错了，想一行一行的取。后来想不用找规律了，直接每行开一个string，按曲线一个一个char赋值给对应的string。但是if else又写错了很多次。1. string数组声明之后要对每个string初始化，否则会出现怪东西。2.边界条件是nRows等于1的情况，以及s.length 小于nRows的情况。3.找规律的话省空间，就是要计算好每行每两个数之间的

两个有序array，A的空间足够大。这种从head开始填充需要移动every element的，都从tail开始，因为已知了大小，已知了结束位置。public class Solution {    public void merge(int A[], int m, int B[], int n) {        int inA = m - 1;        int inB =

For example, the following two linked lists:A: a1 → a2 ↘ c1 → c2 → c3 ↗ B: b1 → b2 → b3begin to intersect at

public class Solution { public boolean isPalindrome(String s) { if ( s == null || s.length() == 0) return true; s = s.replaceAll("[^a-zA-Z0-9 ]", "").toLowerCase();

1.最初新建了一个数组，顺序对了之后想直接让原数组等于新数组，但是不可以，因为java的指针问题，回去看书。2.将新数组一个一个assign给了原数组，时间虽然是n的 但是空间也是n。这个题时间只能是n 但是空间可以13.看了答案后，发现只要自己写一个reverse，整个数组reverse三次就可以了。 注意：k要先％length之后再用。要判断nums数组是否为空。public

string splitString string = "004-034556";String[] parts = string.split("-");String part1 = parts[0]; // 004String part2 = parts[1]; // 034556Note that this takes a regular expression, so re

从空集开始，每次取一个数加入每个已有的子集，保留原有子集的同时将新生成的子集加入所有子集的集合中。时间复杂度2^n，是np问题，所以每个步骤都要尽量省时间，否则超时。并且没注意那个size是变动的！死循环！1.List 和 ArrayList的声明还是搞混，        List> res = new ArrayList>();这里谁是外层谁是内层搞混了        Lis

动态规划[ [2], [3,4], [6,5,7], [4,1,8,3]]找到最小sum的一个路径，不要求记录路径，给出sum就行。1.并不是在每一层都是optimal，就是并不是在每层都sum最小2.记录到每个点的时候能得到的最小sum，然后下一层每个点根据上一层中和它相邻的两个点（或者一个）计算。3.为了省空间，只用一个list记录走到

DFS 想清楚停止条件 在本层判断所在的位置是否符合要匹配的字母，假如符合再递归进入四个方向。注意假如没找到 清空用来标记是否走过的那个矩阵。

是1的follow up，只是grid中会出现obstacle 用1表示[ [0,0,0], [0,1,0], [0,0,0]]注意：可以在原gird中修改数值，要判断是1还是0，因为每个格子只扫一遍，所以修改也不影响。但是对于第一个格子要单独判断，如果像上面那个题一样，首先在最外面将［0］［0］设置为1，在循环里面不加入位置判断（是否在扫第一个格子），就会把它当

比上题多一个条件是可能有重复数字，那每次新加入一个数字的时候假如和前面数字一样，就只需要更新上一次新加入的子集。最初想 需要记录上一次总共新加入了几个子集。后来发现每次size都是double。

Roman rules在这个网页里面，http://www.factmonster.com/ipka/A0769547.html只要判断清楚前后数字的大小关系就行，大的话就加 小就减，记得从后往前判断public class Solution { public int romanToInt(String s) { if ( s == null || s.length

没有反应过来用stack假如是左就push 是右就看看栈定是不是匹配的左 是就pop 不是就返回false。里面if else写的太乱下面是别人的代码 比较清晰

A -> 1 B -> 2 C -> 3 ... Z -> 26 AA -> 27 AB -> 28 实际就是26进制转10进制 进制转换太不熟了 每次循环先乘26还是先加一位，要想清楚。

进制转化 从10进制转26进制，但是注意并不是直接转换 因为A对应1 而不是零 Z对应26 所以余数是零的时候应该是z最开始将余数减一后加'A' 是错的， 应该在被除数上减一再除，再做％。

今天怎么状态这么不好，感觉这个题不简单啊，居然是easy。看了答案才写出来。两种，recursive代码很简单，只是想清楚不容易，感觉怎么写helper要想明白。 iterative 写了好久，总是出错，用stack实现，每次push一对对应位置上的node，即应该相等的node。push进去之前就判断这对的值是否相等，pop出来之后，对于这一对，要检查一下前提条件（是否都具有左右子，对应

和上一题几乎一模一样，只是不用左右交替了，更简单，把上个symmetric的helper function稍微改一下就是这个题了public class Solution { public boolean isSameTree(TreeNode p, TreeNode q) { if ( p == null || q == null ){ ret

这个题让设计data structure存储数据，实现add 和find函数，find只要返回结果就行。一开始想到用hashmap 后来觉得没有存value的必要，想改成set。仔细看题之后发现需要考虑有重复的情况，比如2+2=4也符合，所以还是用hashmap value存这个key的个数，每次遇到符合情况的，要检查一下如果这两个数是相等的 那value必须大于1.学到的一点就是

这个就是array已经有序 就可以用两个pointer的方法了。注意不要想成二分，这个是从两端逼近，每次只移动一个位置，整个array扫一遍。public class Solution { public int[] twoSum(int[] numbers, int target) { if ( numbers == null || numbers.length =

和前序几乎一模一样，递归里面就是add的时间在进入左右子之间非递归的就是把add那句话放进了else中，即当前node为null，pop stack返回上一层时加入这个node递归：public class Solution { public List inorderTraversal(TreeNode root) { List list = new Array

code ganker说这个的非递归很难，看了半天觉得好麻烦，看到discussion里面有个特别天才的解法！！preorder 是root－left－right， postorder是 left－right－root。那么稍微改一下preorder 变成 root－right－left 那个么就和postorder顺序完全相反了！！只要Collections.reverse就行！！代码：

动态规划 找sum最大的subarray的sum不光要维护一个全局的max还要维护一个使用了当前这个element的local 最大，local是比较(A[i], A[i] + local)就是说A[i]一定包含在当前的local最优解中，要判断是否还要保留之前的那些element。public class Solution { public int maxSubArray(int

DP问题第一遍做的时候是top－down 当前这层的数值从上一层得到，非常麻烦的地方在于需要判断这个元素是否在一层两端。bottom－up方法就比较直观，不需要考虑边界，因为对于地n－1行arr [ i ] = min(arr[ i ]，arr [ i + 1] )+ 当前bottom-up:public class Solution { public int minimu

设计数据结构，用一个内部的stack存所有小于root的节点，即push的顺序是从大到小的，实现一个pushall函数 就是push这个node一直往左走路径上的所有节点。public class BSTIterator { private Stack stack = new Stack(); public BSTIterator(TreeNode root) {

卡特兰数的应用之一，还有一个是让求有多少种方式配对括号。http://en.wikipedia.org/wiki/Catalan_number这个题发现对于每个数字n 解法数＝左子树0个结点的方法 ＊ 右子树n－1个节点的方法 ＋ 左1个节点＊右子n－2个.......要注意的是要多存一个arr[0] = 1 数组是n＋1大小的public class Solution {

因为是乘积，所以可能是一个很小的负数，再乘以一个负数，就会得到很大的乘积。所以除了localMax globalMax 还要记录一个localminlocalmin和localmax每次都是要三个数比较，localMax * A[ i ], localMin * A[ i ], A[ i ]， 同时假如先更新min 则要保存一下 否则max再更新的时候 用的就不是上个数得到的min了 而是更新

DFS 里面的if else写错了 第一段是正确代码，第二段是错误的。错误的写法就是因为多写了一个else，就不会再进right那边了。public class Solution { public int minDepth(TreeNode root) { if ( root == null ) return 0; int min

preorder,inorder, postorder都属于dfs“第一种是以图的深度优先搜索为原型的遍历， 可以是中序， 先序和后序三种方式， 不过结点遍历的方式是相同的， 只是访问的时间点不同而已， 对应于Binary Tree Inorder Traversal， Binary Tree Preorder Traversal和Binary Tree Postorder Tra

感觉这个题像前序遍历，但是其实完全按preorder的话 我只能想到用两个stack 太不好了看到用stack的iterative 发现入stack顺序和preorder不一样，才能保证出来的时候是这个顺序即先push right 再push left，pop之后的右子设置为当前stack top这个里面强调不要忘记将左子设置为null； public void flatten

递归方法非常简单 只要判断左右depth 取max＋1就行public class Solution { public int maxDepth(TreeNode root) { if ( root == null ) return 0; int left = maxDepth(root.left); int ri

典型dfs，但是dfs写的太少了＝＝base case想了很久，main函数里面怎么处理第一次调用也想了很久。把判断条件搞错了好几次。应该在每次走到这个节点时就判断左右子是否为空。/** * Definition for binary tree * public class TreeNode { * int val; * TreeNode left; *

这个请参照level order traversal 不同的就是需要看每次从左还是右输出，维持一个bool 每一层取反就行，然后根据这个bool判断是用add（e） 还是add（0，e）public class Solution { public List> zigzagLevelOrder(TreeNode root) { Queue que = new Linked

错误解法：以为遍历的时候每次查看是否left 递归解法就需要每次传入两个界，min max，是根据当前的parent已经parent的情况确定的。要注意test case就是MAX_VALUE MIN_VALUE, 因为定义中是严格大于小于 所以在判断非法树的时候 写的是root.val >= max || root.val 所以要用root.val > max || root.val

感觉一写递归就全是错。首先练熟递归，然后搞清楚dfs bfs与各种traversal关系，再写树这个题首先一开始递归写的有问题，既然每次已进入helper函数，首先判断了node是否为空，就不要再继续先判断是否有左右子再递归了，直接递归就行。正确的： public int countD ( TreeNode node){ if ( node == null)

这个题一开始一直想从叶子开始加，后来发现从root向下走比较方便。递归函数传一个记录到达当前节点的和。recursive：public class Solution { public int sumNumbers(TreeNode root) { return sum(root,0); } public int sum (TreeNode root,

扫数组到当前这一天的时候，局部最优就是要么今天卖出（昨天不卖了）（前提是之前已经买了，且已知最大profit是在昨天卖出），要么今天买入（局部profit为零）所以local的比较参数不是很好想明白。public class Solution { public int maxProfit(int[] prices) { if (prices == null|| pr

唯一和上一个题不同的就是要倒序输出层，从底层开始。只需要改一个小地方就是最后将每层list add到大list时候，用add（0，list），即add到第一位。public class Solution { public List> levelOrderBottom(TreeNode root) { Queue que = new LinkedList();

首先不知道java中bfs用什么数据结构，知道用queue之后，不知道queue怎么实现。java中一般使用Queue queueA = new LinkedList();Queue queueB = new PriorityQueue();来实现queue，常用linkedlist来实现没有优先级的，即单纯的fifo.记得看queue的讲解，里面有两套function，分别