Merge pull request #1 from algorithm001/master

pull

Author: yanlingli3799

.gitignore

@@ -0,0 +1,4 @@
+*.DS_Store
+.idea
+.vscode
+.vs

Leetcode_262_115_java.java

@@ -0,0 +1,73 @@
+package data.leetcode.hash;
+
+import java.util.HashMap;
+
+public class Leetcode262 {
+    /**
+     * 执行时间过长
+     * 执行用时 : 57 ms, 在Valid Anagram的Java提交中击败了15.39% 的用户
+     * 内存消耗 : 41.9 MB, 在Valid Anagram的Java提交中击败了25.98% 的用户
+     *
+     * @param s
+     * @param t
+     * @return
+     */
+    public static boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) return false;
+        HashMap<Character, Integer> sMap = new HashMap<Character, Integer>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            Integer integer = sMap.get(c);
+            if (integer == null) {
+                integer = 0;
+            }
+            sMap.put(c, ++integer);
+        }
+        for (int i = 0; i < t.length(); i++) {
+            if (sMap.containsKey(t.charAt(i))) {
+                Integer integer = sMap.get(t.charAt(i));
+                integer--;
+                if (integer == 0) {
+                    sMap.remove(t.charAt(i));
+                } else {
+                    sMap.put(t.charAt(i), integer);
+                }
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 第二种解法，是将数据进行一个因射到26位字母
+     * <p>
+     * 执行用时 : 4 ms, 在Valid Anagram的Java提交中击败了96.25% 的用户
+     * 内存消耗 : 38.1 MB, 在Valid Anagram的Java提交中击败了95.44% 的用户
+     * 进行下一个挑战：
+     */
+    public static boolean isAnagram2(String s, String t) {
+        if (s.length() != t.length())
+            return false;
+        int[] freq1 = new int[26];
+        int[] freq2 = new int[26];
+        for (int i = 0; i < s.length(); i++)
+            freq1[s.charAt(i) - 'a']++;
+        for (int i = 0; i < t.length(); i++)
+            freq2[t.charAt(i) - 'a']++;
+        for (int i = 0; i < 26; i++) {
+            if (freq1[i] != freq2[i])
+                return false;
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+
+
+        isAnagram2("aacc", "ccac");//false
+
+        isAnagram2("aacc", "caac");//true
+
+    }
+}

Leetcode_609_115_java.java

@@ -0,0 +1,75 @@
+package data.leetcode.hash;
+
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Leetcode609 {
+    /**
+     * 给定一个目录信息列表，包括目录路径，以及该目录中的所有包含内容的文件，您需要找到文件系统中的所有重复文件组的路径。
+     * 一组重复的文件至少包括二个具有完全相同内容的文件。
+     * <p>
+     * 输入列表中的单个目录信息字符串的格式如下：
+     * <p>
+     * "root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"
+     * <p>
+     * 这意味着有 n 个文件（f1.txt, f2.txt ... fn.txt 的内容分别是 f1_content, f2_content ... fn_content）在目录 root/d1/d2/.../dm 下。注意：n>=1 且 m>=0。如果 m=0，则表示该目录是根目录。
+     * <p>
+     * 该输出是重复文件路径组的列表。对于每个组，它包含具有相同内容的文件的所有文件路径。文件路径是具有下列格式的字符串：
+     * <p>
+     * "directory_path/file_name.txt"
+     * <p>
+     * 示例 1：
+     * <p>
+     * 输入：
+     * ["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"]
+     * 输出：
+     * [["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]]
+     *
+     * @param paths
+     * @return 最终输出不需要顺序。
+     * 您可以假设目录名、文件名和文件内容只有字母和数字，并且文件内容的长度在 [1，50] 的范围内。
+     * 给定的文件数量在 [1，20000] 个范围内。
+     * 您可以假设在同一目录中没有任何文件或目录共享相同的名称。
+     * 您可以假设每个给定的目录信息代表一个唯一的目录。目录路径和文件信息用一个空格分隔。
+     */
+
+    /**
+     * 执行用时 : 61 ms, 在Find Duplicate File in System的Java提交中击败了73.58% 的用户
+     * 内存消耗 : 75 MB, 在Find Duplicate File in System的Java提交中击败了6.90% 的用户
+     * @param paths
+     * @return
+     */
+    public static List<List<String>> findDuplicate(String[] paths) {
+
+        HashMap<String, List<String>> contentMap = new HashMap<>();
+        for (int i = 0; i < paths.length; i++) {
+            String[] split = paths[i].split(" ");
+            for (int j = 1; j < split.length; j++) {
+                int contentStartSplit = split[j].indexOf("(");
+                String newPath = split[0]+"/" +split[j].substring(0,contentStartSplit).trim();
+                String content = split[j].substring(contentStartSplit+1, split[j].length()-1);
+                List<String> contentList = contentMap.get(content);
+                if (contentList == null) {
+                    contentList = new ArrayList<>();
+                    contentMap.put(content, contentList);
+                }
+                contentList.add(newPath);
+            }
+        }
+        List<List<String>> result = new ArrayList<>();
+        for (Map.Entry<String, List<String>> entry : contentMap.entrySet()) {
+            if(entry.getValue().size()>1){
+                result.add(entry.getValue());
+            }
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        String[] path = {"root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"};
+        List<List<String>> duplicate = findDuplicate(path);
+    }
+}

Leetcode_692_115_java.java

@@ -0,0 +1,62 @@
+package data.leetcode.hash;
+
+import java.util.*;
+
+public class Leetcode692 {
+    /**
+     * 给一非空的单词列表，返回前 k 个出现次数最多的单词。
+     * <p>
+     * 返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率，按字母顺序排序。
+     * <p>
+     * 示例 1：
+     * <p>
+     * 输入: ["i", "love", "leetcode", "i", "love", "coding"], k = 2
+     * 输出: ["i", "love"]
+     * 解析: "i" 和 "love" 为出现次数最多的两个单词，均为2次。
+     * 注意，按字母顺序 "i" 在 "love" 之前。
+     */
+
+    /**
+     * 执行用时 : 17 ms, 在Top K Frequent Words的Java提交中击败了83.42% 的用户
+     * 内存消耗 : 41.2 MB, 在Top K Frequent Words的Java提交中击败了74.16% 的用户
+     * @param words
+     * @param k
+     * @return
+     */
+
+    public static List<String> topKFrequent(String[] words, int k) {
+        HashMap<String, Integer> wordMap = new HashMap<String, Integer>();
+        List<String> wordList = new ArrayList<>();
+        for (int i = 0; i < words.length; i++) {
+            Integer node = wordMap.get(words[i]);
+            if (node == null) node = 0;
+            node += 1;
+            wordMap.put(words[i], node);
+        }
+        List<Map.Entry<String, Integer>> list = new ArrayList<Map.Entry<String, Integer>>(wordMap.entrySet());
+        Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {
+            @Override
+            public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
+                int code = o1.getValue() - o2.getValue();
+                if (code != 0) {
+                    return -code;
+                } else {
+                    return o1.getKey().compareTo(o2.getKey());
+                }
+            }
+        });
+        List<Map.Entry<String, Integer>> entries = list.subList(0, k);
+        for (Map.Entry<String, Integer> entry : entries) {
+            wordList.add(entry.getKey());
+        }
+        return wordList;
+    }
+
+
+    public static void main(String[] args) {
+
+        String words[] = {"i", "love", "leetcode", "i", "love", "coding"};
+        topKFrequent(words, 3);
+    }
+
+}

Week_01/.DS_Store

@@ -0,0 +1,5 @@
+public class TestPush {
+	public static void main(String[] args) {
+		System.out.println("Hello Geekbang~~");
+	}
+}

Week_01/id_0/TestPush.java

@@ -0,0 +1,35 @@
+class Solution {
+     public int findMin(int[] nums) {
+        int len = nums.length;
+        if (len == 1) {
+            return nums[0];
+        }
+
+        int min = 0;
+        int max = len - 1;
+         
+        if (nums[min] < nums[max]) {
+            return nums[min];
+        }
+
+        int mid = (min + max) / 2;
+        while (min <= max) {
+            if (nums[min] <  nums[mid]) {
+                min = mid;
+                mid = (min + max) / 2;
+            }else if (nums[min] > nums[mid]){
+                max = mid;
+                mid = (min + max) / 2;
+            }else {
+                break;
+            }
+        }
+        
+        if (min < len -1) {
+            if (nums[min] > nums[min + 1]) {
+                return nums[min + 1];
+            }
+        }
+        return nums[min];
+    }
+}

Week_01/id_1/LeetCode_153_1.java

@@ -0,0 +1,44 @@
+class Solution {
+
+    ListNode prePairTail = null;
+
+    public ListNode swapPairs(ListNode head) {
+
+        if (head == null) {
+            return null;
+        }
+
+        if (head.next == null) {
+            return head;
+        }
+
+        ListNode result = head.next;
+        
+        ListNode node = head;
+        ListNode next = head.next;
+        while (node != null && next != null) {
+
+            node = swap(node, next);
+
+            if (node == null) {
+                break;
+            }
+            next = node.next;
+        }
+        return result;
+
+    }
+
+    private ListNode swap(ListNode node, ListNode next) {
+
+        ListNode tmpNext = next.next;
+        next.next = node;
+        node.next = tmpNext;
+        if (prePairTail != null) {
+            prePairTail.next = next;
+        }
+        prePairTail = node;
+        return tmpNext;
+    }
+
+}

Week_01/id_1/LeetCode_24_1.java

@@ -0,0 +1,75 @@
+
+class Solution {
+
+    ListNode preGroupTail = null;
+    ListNode result = null;
+
+    public ListNode reverseKGroup(ListNode head, int k) {
+
+        if (head == null || head.next == null || k == 1) {
+            return head;
+        }
+
+        int index = 1;
+        ListNode groupHead = head;
+        ListNode groupTail = head;
+
+        while (true) {
+
+            if (index != k) { // 查找 k 个节点中的 head 和 tail 节点
+                groupTail = groupTail.next;
+                if (groupTail != null) {
+                    index ++;
+                    continue;
+                }else {
+                    // 链表长度小于 K 的情况
+                    if (this.preGroupTail != null) {
+                        this.preGroupTail.next = groupHead;
+                        break;
+                    }else {
+                        return head;
+                    }
+                }
+            }else { 
+                // 个数达到 k 时执行交换，返回下一组的 head 节点
+                ListNode node = this.swap(groupHead, groupTail);
+                if (node == null) {
+                    break;
+                }
+                groupHead = node;
+                groupTail = node;
+                index = 1;
+            }
+        }
+        return result;
+    }
+
+    private ListNode swap(ListNode head, ListNode tail) {
+
+        // 反转链表
+        ListNode preNode = null;
+        ListNode currentNode = head;
+        while (currentNode != tail) {
+            ListNode next = currentNode.next;
+            currentNode.next = preNode;
+            preNode = currentNode;
+            currentNode = next;
+        }
+
+        // 当前组的 tail 节点执行 swap
+        ListNode node= currentNode.next;
+        currentNode.next = preNode;
+
+        // 反转完成，将上一组的 tail 节点指向当前组的 head 节点
+        // 第一次反转时上一组 tail 为 null，因此要执行判空操作
+        if (this.preGroupTail != null) {
+            this.preGroupTail.next = currentNode;
+        }else {
+            // 上一组的 tail 为空说明是第一组执行交换
+            // 结果一定是第一组交换后的 head 节点
+            result = currentNode;
+        }
+        this.preGroupTail = head;
+        return node;
+    }
+}