20190706

code/lc144.java

@@ -5,7 +5,7 @@ package code;
  * 难度：Medium
  * 分类：Stack, Tree
  * 思路：左节点依次入栈
- * Tips：和lc94中序,lc145后序一起看
+ * Tips：和lc94中序,lc145后序一起看, lc102
  */
 import java.util.ArrayList;
 import java.util.List;

code/lc145.java

@@ -35,4 +35,5 @@ public class lc145 {
         Collections.reverse(res);   //反转链表
         return res;
     }
+
 }

code/lc199.java

+package code;
+/*
+ * 199. Binary Tree Right Side View
+ * 题意：二叉树的右视图
+ * 难度：Medium
+ * 分类：Tree, Depth-first Search, Breadth-first Search
+ * 思路：1.记录当前递归最大深度，每次把第一次出现深度的节点值输出即可
+ *      2.层次遍历
+ * Tips：
+ */
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class lc199 {
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+
+    int max_depth = 0;
+    List<Integer> res = new ArrayList();
+    public List<Integer> rightSideView(TreeNode root) {
+        dfs(root, 1);
+        return res;
+    }
+
+    public void dfs(TreeNode root, int depth){
+        if(root==null) return;  //别忘了null
+        if(depth>max_depth) {
+            max_depth = depth;
+            res.add(root.val);
+        }
+        dfs(root.right, depth+1);
+        dfs(root.left, depth+1);
+    }
+
+    public List<Integer> rightSideView2(TreeNode root) {
+        List<Integer> res = new ArrayList();
+        Queue<TreeNode> qu = new LinkedList();  //是一个队列，用LinkedList
+        if(root!=null) qu.add(root);
+        while(!qu.isEmpty()){
+            int size = qu.size();
+            while(size>0){
+                TreeNode tn = qu.remove();
+                if(size==1) res.add(tn.val);    //==1的时候添加
+                if(tn.left!=null) qu.add(tn.left);
+                if(tn.right!=null) qu.add(tn.right);
+                size--;
+            }
+        }
+        return res;
+    }
+}

code/lc206.java

@@ -15,24 +15,24 @@ public class lc206 {
     }
 
     public ListNode reverseList(ListNode head) {
-        ListNode newHead = null;    //头节点变成尾节点，最后要指向null
-        while (head != null) {
+        ListNode pre = null;    //头结点变尾节点，指向null
+        while(head!=null){
             ListNode next = head.next;
-            head.next = newHead;
-            newHead = head;
+            head.next = pre;
+            pre = head;
             head = next;
         }
-        return newHead;
+        return pre;
     }
 
     public ListNode reverseList2(ListNode head) {   //递归
         return reverseListInt(head, null);
     }
-    private ListNode reverseListInt(ListNode head, ListNode newHead) {
+    private ListNode reverseListInt(ListNode head, ListNode pre) {
         if (head == null)
-            return newHead;
+            return pre;
         ListNode next = head.next;
-        head.next = newHead;
+        head.next = pre;
         return reverseListInt(next, head);  //尾递归，操作已经完成，最后返回最后结果罢了
     }
 }

code/lc493.java

+package code;
+
+import java.util.Arrays;
+
+/*
+ * 493. Reverse Pairs
+ * 题意：逆序对
+ * 难度：Hard
+ * 分类：
+ * 思路：归并排序的思路 或者 树相关的数据结构
+ *      排序前先count
+ *      负数怎么解决？ 不用考虑，因为排序前先count
+ * Tips：
+ */
+public class lc493 {
+    public static void main(String[] args) {
+        reversePairs(new int[]{1,3,2,3,1});
+        System.out.println(res);
+    }
+
+    static int res = 0;
+    public static int reversePairs(int[] nums) {
+        mergeSort(nums, 0, nums.length-1);
+        return res;
+    }
+
+    public static void mergeSort(int[] nums, int left, int right){
+        if(left<right){
+            int mid = (left + right)/2;
+            mergeSort(nums, left, mid);
+            mergeSort(nums, mid+1, right);
+            merge(nums, left, mid, right);
+        }
+    }
+
+    public static void merge(int[] nums, int left, int mid, int right){
+        //count elements
+        int pos1 = left;
+        int pos2 = mid+1;
+        int count = 0;
+        while(pos1<=mid){       //双指针 统计逆序对
+            if(pos2>right||nums[pos1]<=(double)nums[pos2]*2) {
+                pos1++;
+                res+=count;
+            }
+            else{
+                pos2++;
+                count++;
+            }
+        }
+
+        Arrays.sort(nums, left, right + 1);
+
+//        int[] nums_copy = nums.clone();     //耗时，大样例过不了
+//        pos1 = left;    //注意pos1, pos2重新赋值
+//        pos2 = mid+1;
+//        int cur = left;
+//        while( pos1<=mid && pos2<=right ){
+//            if(nums_copy[pos1]<=nums_copy[pos2]){
+//                nums[cur] = nums_copy[pos1];
+//                pos1++;
+//                cur++;
+//            } else {
+//                nums[cur] = nums_copy[pos2];
+//                pos2++;
+//                cur++;
+//            }
+//        }
+//        while(pos1<=mid){
+//            nums[cur] = nums_copy[pos1];
+//            cur++;
+//            pos1++;
+//        }
+//        while(pos2<=right){
+//            nums[cur] = nums_copy[pos2];
+//            cur++;
+//            pos2++;
+//        }
+    }
+
+
+}

code/lc94.java

@@ -34,4 +34,16 @@ public class lc94 {
         }
         return res;
     }
+
+    List<Integer> res = new ArrayList();
+    public List<Integer> inorderTraversal2(TreeNode root) { //递归
+        helper(root);
+        return res;
+    }
+    public void helper(TreeNode root){
+        if(root==null) return;
+        helper(root.left);
+        res.add(root.val);
+        helper(root.right);
+    }
 }