Merge pull request gzc426#149 from Syuan-Cheng/master

gzc426 · web-flow · commit 6be6b6855734 · 2018-11-29T16:33:46.000+08:00
syuan
diff --git a/2018.11.24-leetcode28/syuan.md b/2018.11.24-leetcode28/syuan.md
@@ -0,0 +1,30 @@
+```
+class Solution {
+    public int strStr(String haystack, String needle) {
+        if(needle.length() == 0)
+            return 0;
+        char [] charArrayhaystack = haystack.toCharArray();
+        char [] charArrayneedle = needle.toCharArray();
+        for(int i =0;i<charArrayhaystack.length;i++)
+        {
+            if(charArrayhaystack[i] == charArrayneedle[0])
+            {
+                int j = i + 1;
+                int k = 1;
+                for(k=1;k<charArrayneedle.length && j < charArrayhaystack.length;k++)
+                {
+                    if(charArrayhaystack[j] == charArrayneedle[k])
+                    {
+                        j++;
+                    }else{
+                        break;
+                    }
+                }
+                if(k == charArrayneedle.length)
+                    return i;
+            }
+        }
+        return -1;
+    }
+}
+```
diff --git a/2018.11.25-leetcode80/syuan.md b/2018.11.25-leetcode80/syuan.md
@@ -0,0 +1,83 @@
+##### 题目
+
+```
+给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素最多出现两次，返回移除后数组的新长度。
+
+不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
+
+示例 1:
+
+给定 nums = [1,1,1,2,2,3],
+
+函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3 。
+
+你不需要考虑数组中超出新长度后面的元素。
+
+示例 2:
+
+给定 nums = [0,0,1,1,1,1,2,3,3],
+
+函数应返回新长度 length = 7, 并且原数组的前五个元素被修改为 0, 0, 1, 1, 2, 3, 3 。
+
+你不需要考虑数组中超出新长度后面的元素。
+
+说明:
+
+为什么返回数值是整数，但输出的答案是数组呢?
+
+请注意，输入数组是以“引用”方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。
+
+你可以想象内部操作如下:
+
+// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
+int len = removeDuplicates(nums);
+
+// 在函数里修改输入数组对于调用者是可见的。
+// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
+for (int i = 0; i < len; i++) {
+    print(nums[i]);
+}
+```
+##### 代码
+
+```
+class Solution {
+    public int removeDuplicates(int[] nums) {
+        int count=0;
+        if (nums.length==1) {
+            return 1;
+        }
+        if (nums.length==0) {
+            return 0;
+        }
+        if (nums.length==2) {
+            return 2;
+        } 
+        int i=0;
+        int j=i;
+        int tempCount=0;
+        while(i<nums.length)
+        {
+            if (j<nums.length && nums[j]==nums[i]) {
+                j++;
+                tempCount++;
+            }else{
+                if (tempCount>=2) {
+                    count+=2;
+                    nums[i+1]=nums[i];
+                    i=i+2;
+                }else{
+                    count++;
+                    i++;
+                }
+                if (j>=nums.length) {
+                    break;
+                }
+                nums[i]=nums[j];
+                tempCount=0;
+            }
+        }
+        return count;
+    }
+}
+```
diff --git a/2018.11.26-leetcode11/syuan.md b/2018.11.26-leetcode11/syuan.md
@@ -0,0 +1,39 @@
+##### 题目
+
+```
+给定 n 个非负整数 a1，a2，...，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0)。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
+
+说明：你不能倾斜容器，且 n 的值至少为 2。
+```
+![微信截图_20181127122321](2DF0C29B574D4A30BFAB06ABDF185FA9)
+```
+图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
+示例:
+
+输入: [1,8,6,2,5,4,8,3,7]
+输出: 49
+```
+##### 思路
+双指针
+
+##### 代码
+
+```
+class Solution {
+    public int maxArea(int[] height){
+        int maxarea=0;
+        int i=0;
+        int j=height.length-1;
+        
+        while(i<j){
+            maxarea=Math.max(maxarea,Math.min(height[i],height[j])*(j-i));
+            if(height[i]<height[j]){
+                i++;
+            }else{
+                j--;
+            }
+        }
+        return maxarea;
+    }
+}
+```
diff --git a/2018.11.28-leetcode151/syuan.md b/2018.11.28-leetcode151/syuan.md
@@ -0,0 +1,127 @@
+##### 题目
+```
+给定一个字符串，逐个翻转字符串中的每个单词。
+
+示例:  
+
+输入: "the sky is blue",
+输出: "blue is sky the".
+
+说明:
+
+    无空格字符构成一个单词。
+    输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
+    如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
+
+进阶: 请选用C语言的用户尝试使用 O(1) 空间复杂度的原地解法。
+```
+##### 思路
+- 先将整个字符串反转
+- 按照空格分成String数组
+- 每个单词反转
+##### 代码
+
+```
+public class Solution {
+    public String reverseWords(String s) {
+        int length=s.length();
+        //当字符串为空
+        if(s == null){ return null;}
+        //当字符串为"    "时 直接返回null
+        if(s.trim().equals("")){
+            return s.trim();   
+        }
+
+        //1.反转整个字符串
+        String allRevStr=ReverseWord(s);
+        //2.获得每个单词
+        String[] strChar=allRevStr.split(" ");
+
+        //3.反转每个字符串
+        String reverse="";
+        for (int i=0; i<strChar.length; ++i) { 
+            String temp=ReverseWord(strChar[i]);
+            if (temp.equals("")) {
+                continue;
+            }
+            
+            if (i==strChar.length-1) {
+                reverse=reverse+temp;
+            }else{
+                reverse=reverse+temp+" ";
+            }
+        }
+        return reverse;
+    }
+
+    String ReverseWord(String s){
+        //删除字符串前序和后继中的空格
+        String str=s.trim();
+        if (str.length()==1) {
+            return str;
+        }else if (str.equals("")) {
+            return "";
+        }else{
+            StringBuilder sb=new StringBuilder(str);
+            String revStr=sb.reverse().toString();
+            return revStr;
+        }
+    }
+    
+}
+```
+
+##### 改进方法
+
+```
+public class Solution {
+    public String reverseWords(String s) {
+        int length=s.length();
+        //当字符串为空
+        if(s == null){ return null;}
+        //当字符串为"    "时 直接返回null
+        if(s.trim().equals("")){
+            return s.trim();   
+        }
+        /**
+         * 先将字符串按照空格分裂为字符串数组
+         * 然后收尾两个指针来交换即可
+         */
+        //0.掐头去尾
+        String allRevStr=s.trim();
+        //1.将字符串按照空格分裂为字符串数组
+        String[] strChar=allRevStr.split(" ");
+
+        //2.使用首尾两个指针来交换
+        int left=0;
+        int right=strChar.length-1;
+        String temStr=null;
+        while(left<right){
+            //交换
+            temStr=strChar[left];
+            strChar[left]=strChar[right];
+            strChar[right]=temStr;
+            //移动指针
+            left++;
+            right--;
+        }
+        //3.拼接好新的字符串
+        String reverse="";
+        for (int i=0; i<strChar.length; ++i) { 
+            //对每一个单词掐头去尾
+            String temp=strChar[i].trim();
+            
+            if (temp.equals("")) {
+                continue;
+            }
+
+            if (i==strChar.length-1) {
+                reverse=reverse+temp;
+            }else{
+                reverse=reverse+temp+" ";
+            }
+        }
+        return reverse;
+    }
+}
+```
diff --git a/2018.11.29-leetcode443/syuan.md b/2018.11.29-leetcode443/syuan.md
@@ -0,0 +1,79 @@
+##### 题目
+```
+给定一组字符，使用原地算法将其压缩。
+
+压缩后的长度必须始终小于或等于原数组长度。
+
+数组的每个元素应该是长度为1 的字符（不是 int 整数类型）。
+
+在完成原地修改输入数组后，返回数组的新长度。
+```
+##### 思路
+设置两个指针i  和  j
+i是赋值指针
+j用来统计每次字符出现的次数
+
+**难点**
+当次数为两位数时的写入
+
+```
+char[] temArray=String.valueOf(count).toCharArray();
+int k=0;
+while (k<temArray.length) {
+    chars[i++]=temArray[k++];
+}
+```
+一位数时的int和char转换
+
+```
+chars[i++]=(char) (count + '0');
+```
+
+##### 代码
+```
+class Solution {
+    public int compress(char[] chars) {
+        /**
+         * 思路：
+         * 遍历数组  统计每个字符出现的次数
+         */
+        int length=chars.length;//数组长度
+        if (length<=1) {
+            return length;
+        }
+
+        
+        int i=0,j=i,count=0;
+        char temChar=chars[j];
+        //i是赋值指针
+        //j是计数指针  
+        while(j<length){
+            temChar=chars[j];
+            //个数和temChar相等的字符的个数
+            while(j<length && chars[j]==temChar){
+                j++;
+                count++;
+            }
+            //当个数为1时  直接把temChar赋给数组chars
+            if (count==1) {
+                chars[i++]=temChar;
+            }else {
+                chars[i++]=temChar;
+                //当个数为一位数
+                if (count<10) {
+                    chars[i++]=(char) (count + '0');
+                }else{//当个数大于一位数  借助字符数组
+                    char[] temArray=String.valueOf(count).toCharArray();
+                    int k=0;
+                    while (k<temArray.length) {
+                        chars[i++]=temArray[k++];
+                    }
+                }
+            }
+            count=0;
+        }
+        return i;
+    }
+}
+```
+
diff --git a/2019.11.24/syuan.md b/2019.11.24/syuan.md
