20190316

code/lc105.java

@@ -34,7 +34,7 @@ public class lc105 {
         }
         tn.left = recursion(preorder, inorder, pre_index+1, start, in_index-1);
         tn.right = recursion(preorder, inorder, pre_index+in_index-start+1, in_index+1, end);   //注意右孩子节点index参数
-        return tn;
+        return tn;      //记住函数的返回值的设置，返回Node，递归的构造子树
     }
 
 }

code/lc108.java

 package code;
 /*
  * 108. Convert Sorted Array to Binary Search Tree
- * 题意：将有序数组转换为二叉平衡树
+ * 题意：将有序数组转换为二叉搜索树
  * 难度：Easy
  * 分类：Tree, Depth-first Search
  * 思路：类似二分查找，每次把数组劈成两半

code/lc32.java

@@ -4,7 +4,7 @@ import java.util.Stack;
 
 /*
  * 32. Longest Valid Parentheses
- * 题意：最长有效子串
+ * 题意：最长括号匹配
  * 难度：Hard
  * 分类：Dynamic Programming, String
  * 思路：两种常规方法，一是dp，每个位置记录以该位置结尾的最长长度。另一种是用栈，把位置索引入栈。

code/lc35.java

+package code;
+/*
+ * 35. Search Insert Position
+ * 题意：找到数组中 target 插入的位置
+ * 难度：
+ * 分类：Array, Binary Search
+ * 思路：二分查找
+ * Tips：
+ */
+public class lc35 {
+    public int searchInsert(int[] nums, int target) {
+        int left = 0, right = nums.length-1;
+        while(left<=right){
+            int mid = (left + right)/2;
+            if(nums[mid]==target) return mid;
+            else if(nums[mid]<target) left = mid+1;
+            else right = mid-1;
+        }
+        return left;
+    }
+}

code/lc43.java

+package code;
+/*
+ * 43. Multiply Strings
+ * 题意：大数相乘
+ * 难度：Medium
+ * 分类：Math, String
+ * 思路：每个位置上的数字都相乘，把位置排好，加起来
+ *      https://leetcode.com/problems/multiply-strings/discuss/17605/Easiest-JAVA-Solution-with-Graph-Explanation
+ * Tips：挺难的，好多细节
+ */
+public class lc43 {
+    public String multiply(String num1, String num2) {
+        int[] res = new int[num1.length()+num2.length()];   //最高位 index 是 0
+        for (int i = num1.length()-1; i>=0 ; i--) { //从后往前，解决重复进位
+            for (int j = num2.length()-1; j>=0 ; j--) {
+                int a = i+j;
+                int b = i+j+1;
+                int mul = (num1.charAt(i) -'0') * (num2.charAt(j) - '0');
+                mul += res[b];  //解决进位
+                res[b] = mul%10;    //右边的直接=，因为上一步已经+了
+                res[a] += mul/10;   //左边+=
+            }
+        }
+        StringBuilder sb = new StringBuilder();
+        for(int i:res) if(!(sb.length()==0&&i==0)) sb.append(i);
+        return sb.length() == 0 ? "0" : sb.toString();
+    }
+}

code/lc56.java

@@ -43,7 +43,7 @@ public class lc56 {
         }
         Arrays.sort(starts);
         Arrays.sort(ends);
-        for (int i = 1; i < starts.length ; i++) {
+        for (int i = 1; i < starts.length ; i++) {  //注意下这里的操作
             if(starts[i]<=ends[i-1]){
                 starts[i] = starts[i-1];
             }else{

code/lc63.java

@@ -5,8 +5,8 @@ package code;
  * 题意：路径数
  * 难度：Medium
  * 分类：Array, Dynamic Programming
- * 思路：和lc64, lc62思路一样, arr存储的内容由路径数换成了和
- * Tips：可以用一位数组减小空间复杂度
+ * 思路：和lc64, lc62思路一样
+ * Tips：可以用一维数组减小空间复杂度
  */
 public class lc63 {
     public static void main(String[] args) {

code/lc73.java

@@ -5,6 +5,7 @@ package code;
  * 难度：Medium
  * 分类：Array
  * 思路：用第一行和第一列作为标志位。注意赋值的时候从后往前，防止标志位被改变
+ *      两遍循环，先记录，再置位
  * Tips：注意赋值的顺序，防止标志位被改变
  *       思路是很简单，但有许多细节
  */

code/lc76.java

@@ -7,6 +7,7 @@ package code;
  * 思路：两个指针，移动右指针使得满足条件，移动左指针缩短距离。用hashmap存储进行判断是否满足条件。
  * Tips：很难的题，思路记一下。
  *      https://leetcode.com/problems/minimum-window-substring/discuss/26808/here-is-a-10-line-template-that-can-solve-most-substring-problems
+ *      和lc3也坐下对比
  */
 import java.util.HashMap;
 

code/lc79.java

@@ -6,6 +6,7 @@ package code;
  * 分类：Array, Backtracking
  * 思路：回溯法
  * Tips：访问过的格子要标记，不能重复访问。回溯法注意回来的时候要重置标志位。向下找的时候直接找4个方向的，回来的时候不用再找了，只需重置标志位。
+ *       不用mem，因为 ABC ABAD 这种情况，不能仅仅从A一个字符就断定为不为true
  */
 public class lc79 {
     public static void main(String[] args) {

code/lc84.java

@@ -9,6 +9,8 @@ import java.util.Stack;
  * 分类：Array, Stack
  * 思路：两种方法：1.用dp找到边界，再遍历一遍; 2.用栈，栈内存索引，保证栈内索引对应的高度是递增的，若减了即找到了右边界，出栈开始计算。因为栈内是递增的，左边界就是上个栈内的元素。若栈为空，左边界就是-1。
  * Tips：和lc42做比较，都可以用栈或者dp来做. 很难，栈的操作很难想到.
+ *       和lc42 dp作比较 和lc32栈做比较
+ *       lc85
  *
  */
 public class lc84 {

code/lc94.java

 package code;
 /*
  * 94. Binary Tree Inorder Traversal
- * 题意：二叉树中序遍历
+ * 题意：
  * 难度：Medium
  * 分类：HashTable, Stack, Tree
- * 思路：左节点依次入栈
+ * 思路：左节点依次入栈二叉树中序遍历
  * Tips：和lc144前序,lc145后序一起看
  */
 import java.util.ArrayList;

code/lc98.java

@@ -51,5 +51,4 @@ public class lc98 {
         }
         return true;
     }
-
 }