Merge pull request #390 from SeanMrLi/master

BJ001-1904108-week02作业

Author: GeekUniversity

Week_01/id_108/LeetCode_153_108.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_02/id_108/LeetCode_242_108.java

@@ -0,0 +1,66 @@
+import java.util.HashMap;
+
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/28
+ */
+public class LeetCode_242_108 {
+    class Solution1 {
+        public boolean isAnagram(String s, String t) {
+            if(s == null || t == null || s.length() != t.length()){
+                return false;
+            }
+            HashMap<Character,Integer> source = new HashMap<Character,Integer>();
+            HashMap<Character,Integer> target = new HashMap<Character,Integer>();
+            Integer count = null;
+            Character c = null;
+            for(int i=0 ; i< s.length() ; i ++){
+                c = s.charAt(i);
+                if(source.containsKey(c)){
+                    count = source.get(c);
+                    source.put(c,count + 1);
+                }else{
+                    source.put(c,1);
+                }
+            }
+
+            for(int i=0 ; i< t.length() ; i ++){
+                c = t.charAt(i);
+                if(source.containsKey(c) && source.get(c) > 0){
+                    count = source.get(c);
+                    source.put(c,count - 1);
+                }else{
+                    target.put(c,1);
+                }
+            }
+
+            return target.keySet().size() == 0;
+        }
+    }
+
+    class Solution2 {
+        public boolean isAnagram(String s, String t) {
+            if(s == null || t == null || s.length() != t.length()){
+                return false;
+            }
+            if(s.equals("") && t.equals("")){
+                return true;
+            }
+            int[] arr = new int[26];
+            for(int i = 0; i<s.length() ; i++){
+                arr[s.charAt(i) - 'a'] ++;
+                arr[t.charAt(i) - 'a'] --;
+            }
+            for(int i = 0;i<arr.length; i++){
+                if(arr[i] != 0){
+                    return false;
+                }
+            }
+
+            return true;
+        }
+    }
+
+
+}

Week_02/id_108/LeetCode_609_108.java

@@ -0,0 +1,55 @@
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/28
+ */
+public class LeetCode_609_108 {
+    class Solution {
+        public  List<List<String>> findDuplicate(String[] paths) {
+            HashMap<String,List<String>> contextIndexMap = new HashMap<>();
+            List<List<String>> duplicatePaths = new LinkedList<>();
+            for (String path : paths) {
+                HashMap<String, List<String>> subContextIndexMap = contentIndex(path);
+                for (Map.Entry<String, List<String>> entry : subContextIndexMap.entrySet()) {
+                    String key = entry.getKey();
+                    List<String> value = entry.getValue();
+                    List<String> addrs = contextIndexMap.get(key);
+                    if(!contextIndexMap.keySet().contains(key)){
+                        addrs = new LinkedList<>();
+                    }
+                    addrs.addAll(value);
+                    contextIndexMap.put(key, addrs);
+                }
+            }
+
+            for (Map.Entry<String, List<String>> entry : contextIndexMap.entrySet()) {
+                if(entry.getValue().size()>1){
+                    duplicatePaths.add(entry.getValue());
+                }
+            }
+            return duplicatePaths;
+        }
+
+        private  HashMap<String,List<String>> contentIndex(String value){
+            HashMap<String,List<String>> map = new HashMap<>();
+            String[] fileDir = value.split("\\s");
+            for (int i = 1; i < fileDir.length; i++) {
+                String text = fileDir[i];
+                String content = text.substring(text.indexOf("(") + 1,text.indexOf(")"));
+                String fileAddr = fileDir[0] + "/" + text.substring(0,text.indexOf("("));
+                List<String> addrs = map.get(content);
+                if(!map.containsKey(content)){
+                    addrs = new LinkedList<>();
+                }
+                addrs.add(fileAddr);
+                map.put(content,addrs);
+            }
+            return map;
+        }
+    }
+}

Week_02/id_108/LeetCode_692_108.java

@@ -0,0 +1,40 @@
+import java.util.*;
+
+/**
+ * @author zhangruihao.zhang
+ * @version v1.0.0
+ * @since 2019/04/28
+ */
+public class LeetCode_692_108 {
+    class Solution {
+        public List<String> topKFrequent(String[] words, int k) {
+            if(words == null || words.length == 0 ){
+                return new ArrayList<>();
+            }
+            HashMap<String,Integer> map = new HashMap<String,Integer>();
+            Integer count = null;
+            for(int i=0; i<words.length; i++){
+                count = map.get(words[i]);
+                if(map.containsKey(words[i])){
+                    map.put(words[i],count + 1);
+                }else{
+                    map.put(words[i],1);
+                }
+            }
+            PriorityQueue<String> priorityQueue = new PriorityQueue(k,
+                    (Comparator<String>) (o1, o2) -> map.get(o1) == map.get(o2) ? o1.compareTo(o2) : - map.get(o1).compareTo(map.get(o2)));
+
+            map.keySet().forEach(priorityQueue::offer);
+
+            List<String> result = new LinkedList<>();
+
+            while ((k--)!=0){
+                String peek = priorityQueue.poll();
+                result.add(peek);
+            }
+            return result;
+        }
+
+
+    }
+}