Merge pull request #3 from algorithm001/master

sync

Author: xuyunbo

2019.04.27线上答疑要点整理.pdf

@@ -17,6 +17,6 @@
 
 ## 注意事项
 
-1. **代码文件命名规则：**`LeetCode_题目序号_学号`，比如学号为 `0` 的学员完成 [LeetCode 的第 2 题](https://leetcode.com/problems/add-two-numbers/description/) 后，请将代码文件名保存为  `LeetCode_2_0.py` (假设你使用的是 Python 语言)。
+1. **代码文件命名规则：**`LeetCode_题目序号_学号`，比如学号为 `0` 的学员完成 [LeetCode_33_108 的第 2 题](https://leetcode.com/problems/add-two-numbers/description/) 后，请将代码文件名保存为  `LeetCode_2_0.py` (假设你使用的是 Python 语言)。
 2. **作业公布地址：** 我们会在置顶的 issue 中公布当周的算法练习题以及其他注意事项。
 3. 如果对 Git 和 GitHub 不太了解，请参考 [Git 官方文档](https://git-scm.com/book/zh/v2) 或者极客时间的[《玩转 Git 三剑客》](https://time.geekbang.org/course/intro/145)视频课程。

README.md

@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode mergeTwoLists(ListNode n1, ListNode n2) {
+        ListNode result = new ListNode(0);
+        ListNode n0 = result;
+        while (n1 != null && n1 != null) {
+            //System.out.println("n1-----" + n1.val + "--------n2-------" + n2.val
+             if (n1.val < n2.val) {
+                n0.next = new ListNode(n1.val);
+                n1 = n1.next;
+             } else {
+                n0.next = new ListNode(n2.val);
+                n2 = n2.next; 
+            }
+            
+            n0 = n0.next;
+        }
+        if(n1 != null) n0.next = n1;
+        else n0.next = n2;
+        return result.next;
+    }
+}

Week_01/id_100/LeetCode_21_100.java

@@ -0,0 +1,28 @@
+/**
+ * Definition for singly-linked list.
+ * public class ListNode {
+ *     int val;
+ *     ListNode next;
+ *     ListNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public ListNode deleteDuplicates(ListNode head) {
+        ListNode pre = head;
+        ListNode pre_next = pre.next;
+        if(pre == null || pre_next == null){
+            return head;
+        }
+        while(pre_next != null){
+            if(pre.val == pre_next.val){
+                pre_next = pre_next.next;
+                pre = pre_next;
+            }else{
+                pre = pre_next;
+                pre_next = pre_next.next;
+            }
+        }
+        return head;
+        
+    }
+}

Week_01/id_100/LeetCode_83_100.java

@@ -0,0 +1,77 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/24
+ */
+public class LeetCode_153_108 {
+
+    class Solution1 {
+        public int findMin(int[] nums) {
+            if(nums.length == 1){
+                return nums[0];
+            }
+            if(nums.length == 2){
+                return nums[0] > nums[1] ? nums[1] : nums[0];
+            }
+            if(nums[0] < nums[nums.length-1]){
+                return nums[0];
+            }
+            int min = 0;
+            int high = nums.length - 1;
+            int mid = 0;
+            while(min <= high){
+                //针对1、2、3这种情况
+                if(min == high){
+                    return nums[min];
+                }
+                mid = min + ((high-min) >> 1);
+                if(nums[mid] > nums[high]){
+                    if(nums[mid+1] < nums[mid]){
+                        return nums[mid+1];
+                    }
+                    min = mid + 1;
+                    continue;
+                }
+                if(nums[mid] < nums[min]){
+                    if(nums[mid-1] > nums[mid]){
+                        return nums[mid];
+                    }
+                    high = mid - 1;
+                }
+            }
+            return -1;
+        }
+
+        //二分查找
+        //分为两种情况
+        //mid比最后一个元素大，判断它右边的值是否小于它，如果小于的话就返回右边的值，否则的话，min取mid+1
+        //mid比第一个元素小，判断它左边的值是否比它大，如果大的话，直接返回它自己，否则的话high取mid-1
+    }
+
+    class Solution2 {
+        public int findMin(int[] nums) {
+            if(nums.length == 1){
+                return nums[0];
+            }
+            int min = 0;
+            int high = nums.length - 1;
+            int mid = 0;
+            while(min < high){
+                mid = min + ((high-min) >> 1);
+                if(nums[mid] > nums[high]){
+                    min = mid + 1;
+                } else {
+                    high = mid;
+                }
+            }
+            return nums[min];
+        }
+
+        //二分查找
+        //分为两种情况
+        //mid比最后一个元素大，判断它右边的值是否小于它，如果小于的话就返回右边的值，否则的话，min取mid+1
+        //mid比第一个元素小，判断它左边的值是否比它大，如果大的话，直接返回它自己，否则的话high取mid-1
+
+
+    }
+}

Week_01/id_108/LeetCode_153_108.java

@@ -0,0 +1,49 @@
+import org.junit.Test;
+
+import java.util.Stack;
+
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/29
+ */
+public class LeetCode_20_108 {
+        public static void main(String[] args) {
+            String str = "()[]{}";
+            System.out.println(isValid(str));
+        }
+        public  static boolean isValid(String s) {
+            Stack stack = new Stack();
+            for(int i=0;i<s.length();i++){
+                char c = s.charAt(i);
+                if(stack.peek().equals(anotherChar(c))){
+                    stack.pop();
+                }else{
+                    stack.push(c);
+                }
+            }
+            return stack.isEmpty();
+        }
+
+        private static char anotherChar(char c){
+            if(c == '('){
+                return ')';
+            }
+            if(c == ')'){
+                return '(';
+            }
+            if(c == '{'){
+                return '}';
+            }
+            if(c == '}'){
+                return '{';
+            }
+            if(c == '['){
+                return ']';
+            }
+            if(c == ']'){
+                return '[';
+            }
+            return '0';
+        }
+}

Week_01/id_108/LeetCode_20_108.java

@@ -0,0 +1,75 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/29
+ */
+public class LeetCode_33_108 {
+    class Solution {
+        public int search(int[] nums, int target) {
+            if(nums == null || nums.length == 0){
+                return -1;
+            }
+
+            if(nums[0] == target){
+                return 0;
+            }
+            if(nums[nums.length - 1] == target){
+                return nums.length - 1;
+            }
+
+            int end = nums.length - 1;
+            int min = min(nums);
+            //如果没有旋转，并且最大的数小于target
+            if(min == 0 && nums[end]<target){
+                return -1;
+            }
+
+            if(nums[end] > target){
+                //target处于旋转的后半段
+                return binarySerach(nums,min,end,target);
+            }else{
+                //target有可能处于旋转的前半段
+                return binarySerach(nums,0,min-1,target);
+            }
+        }
+
+        //查找旋转点
+        private int min(int[] nums){
+            int low = 0;
+            int high = nums.length - 1;
+            int mid;
+            while(low < high){
+                mid = low + ((high-low)>>1);
+                if(nums[mid]>nums[high]){
+                    low = mid + 1;
+                }else{
+                    high = mid;
+                }
+            }
+            return low;
+        }
+
+        //二分查找
+        private int binarySerach(int[] nums,int left,int right,int target){
+            int mid = 0;
+            while(left<right){
+                mid = left + ((right - left)>>1);
+                if(nums[mid]==target){
+                    return mid;
+                }
+                if(nums[mid]<target){
+                    left = mid + 1;
+                    continue;
+                }
+                if(nums[mid]>target){
+                    right = mid - 1;
+                    continue;
+                }
+            }
+            if(nums[left] == target){
+                return left;
+            }
+            return -1;
+        }
+    }
+}

Week_01/id_108/LeetCode_33_108.java

@@ -0,0 +1,33 @@
+import java.util.Stack;
+
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/29
+ */
+public class LeetCode_503_108 {
+    class Solution {
+        public int[] nextGreaterElements(int[] nums) {
+
+            Stack<Integer> stack = new Stack<>();
+            int index[] = new int[nums.length];
+            for (int i = 0; i < index.length; i++) {
+                index[i] = -1;
+            }
+            if (nums.length == 1) {
+                return index;
+            }
+            int count = 0;
+            while (count < 2) {
+                for (int i = 0; i < nums.length; i++) {
+                    while (!stack.isEmpty() && nums[i] > nums[stack.peek()]) {
+                        index[stack.pop()] = nums[i];
+                    }
+                    stack.push(i);
+                }
+                count++;
+            }
+            return index;
+        }
+    }
+}

Week_01/id_108/LeetCode_503_108.java

@@ -0,0 +1,50 @@
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/05/03
+ */
+public class LeetCode_687_108 {
+    /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        int maxLen = 0;
+        public int longestUnivaluePath(TreeNode root) {
+            if(root == null){
+                return 0;
+            }
+            longest(root);
+            return maxLen;
+        }
+
+        private int longest(TreeNode root){
+            if(root == null){
+                return 0;
+            }
+            int leftLen=longest( root.left);
+            int rightLen=longest( root.right);
+            int leftUnivalueLen = 0;
+            int rightUnivalue = 0;
+            if(root.left != null && root.left.val == root.val){
+                leftUnivalueLen = leftLen + 1;
+            }
+
+            if(root.right != null && root.right.val == root.val){
+                rightUnivalue = rightLen + 1;
+            }
+
+            maxLen = max(maxLen , leftUnivalueLen + rightUnivalue );
+            return max(leftUnivalueLen,rightUnivalue);
+        }
+
+        private int max(int x,int y){
+            return x>y ? x : y;
+        }
+    }
+}