第三周作业#35

Week_02/id_35/LeetCode_03_35.java

@@ -0,0 +1,131 @@
+package com.leecode.week02;
+
+import com.sun.org.apache.xpath.internal.operations.Bool;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/
+ * 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
+ */
+public class LeetCode_03_35 {
+    public void printAllSubstring(String s){
+        char[] chs=s.toCharArray();
+        for(int i=0;i<s.length();i++){
+            for(int j=i+1;j<s.length();j++){
+                System.out.println(s.substring(i,j));
+            }
+        }
+    }
+    public static void main(String[] args) {
+        LeetCode_03_35 lc=new LeetCode_03_35();
+        System.out.println(lc.lengthOfLongestSubstring("abcabcbb"));
+        System.out.println(lc.lengthOfLongestSubstring("abc         abcbb"));
+        System.out.println(lc.lengthOfLongestSubstring("bb  bbb"));
+        System.out.println(lc.lengthOfLongestSubstring(" "));
+        System.out.println(lc.lengthOfLongestSubstring("au"));
+        System.out.println(lc.lengthOfLongestSubstring("abcabcbb"));
+        System.out.println(lc.lengthOfLongestSubstring("abbbcd"));
+
+        //1.给定一个字符串，先输出看子串都有哪些
+        //暴力枚举
+        lc.printAllSubstring("abcabcbb");
+
+
+    }
+
+
+    public int lengthOfLongestSubstring(String s){
+        if(s.isEmpty()){
+            return 0;
+        }
+
+        if(s.length()==1){
+            return 1;
+        }
+
+        int longest=0;
+
+        char[] chs=s.toCharArray();
+        Set<Character> set=new HashSet<>();
+        for(int i=0;i<s.length();i++){
+            set.add(chs[i]);
+            int subLen=1;
+            for(int j=i+1;j<s.length();j++){
+
+                if(set.contains(chs[j])){ //有重复字符,则循环终止
+                    set.clear();
+                    break;
+                }else{
+                    set.add(chs[j]);
+                }
+                subLen++;
+            }
+            longest=Math.max(longest,subLen);
+
+            set.clear();
+
+        }
+        return longest;
+    }
+
+
+    public int lengthOfLongestSubstring_v1(String s) {
+        if(s.isEmpty()){
+            return 0;
+        }
+
+        if(s.length()==1){
+            return 1;
+        }
+
+        int longest=0;
+
+        char[] chs=s.toCharArray();
+        Set<Character> set=new HashSet<>();
+        for(int i=0;i<s.length();i++){
+            set.add(chs[i]);
+            int subLen=1;
+            for(int j=i+1;j<s.length();j++){
+
+                if(set.contains(chs[j])){ //有重复字符,则循环终止
+                    set.clear();
+                    break;
+                }else{
+                    set.add(chs[j]);
+                }
+                subLen++;
+            }
+            longest=Math.max(longest,subLen);
+
+            set.clear();
+
+        }
+        return longest;
+    }
+
+    /*Map<String, Boolean> cache=new HashMap<>();
+    public boolean hasRepeatingChar(String s){
+
+        if(cache.containsKey(s)){
+            return cache.get(s);
+        }
+
+        char[] chs=s.toCharArray();
+        Set<Character>  characters=new HashSet<>();
+        for (char ch:chs) {
+            if(characters.contains(ch)){
+                cache.put(s,true);
+                return true;
+            }else {
+                characters.add(ch);
+            }
+
+        }
+        cache.put(s,false);
+        return false;
+    }*/
+}

Week_02/id_35/LeetCode_242_35.java

@@ -0,0 +1,73 @@
+package com.leecode.week02;
+
+import java.util.Arrays;
+
+/**
+ * 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
+ * 输入: s = "anagram", t = "nagaram"
+ * 输出: true
+ */
+public class LeetCode_242_35 {
+    public static void main(String[] args) {
+        LeetCode_242_35 lc=new LeetCode_242_35();
+        System.out.println(lc.isAnagram("anagram","nagaram"));
+
+        System.out.println(lc.isAnagram("rat","art"));
+        System.out.println(lc.isAnagram("rat"," car"));
+        //Arrays.equals("anagram".toCharArray(),"nagaram".toCharArray());
+    }
+
+    public boolean isAnagram(String s, String t)
+    {
+        if(s==null||t==null||s.length()!=t.length()){
+            return  false;
+        }
+        int[]  sArr=new int[128];
+        int[]  tArr=new int[128];
+        char[] sChs=s.toCharArray();
+        char[] tChs=t.toCharArray();
+
+        for(int i=0;i<sChs.length;i++){
+            sArr[sChs[i]]++;
+            tArr[tChs[i]]++;
+        }
+
+
+        return Arrays.equals(sArr,tArr);
+    }
+
+    public boolean isAnagram_v0(String s, String t) {
+        if(s.length()!=t.length()){
+            return  false;
+        }
+        char[] bys= s.toCharArray();
+        Arrays.sort(bys);
+
+        char[] byt= t.toCharArray();
+        Arrays.sort(byt);
+
+        int i = 0;
+        int n = byt.length;
+        while (n-- != 0) {
+            if (bys[i] != byt[i])
+                return false;
+            i++;
+        }
+
+        return true;
+    }
+
+    /**
+     *大神的做法
+     *
+     * public boolean isAnagram(String s, String t) {
+     *         if(s == null || t == null || s.length() != t.length()) return false;
+     *         int[]one = new int[128];
+     *         int[]two = new int[128];
+     *         for(char c: s.toCharArray()) one[c]++;
+     *         for(char c: t.toCharArray()) two[c]++;
+     *
+     *         return Arrays.equals(one,two);
+     *     }
+     */
+}

Week_02/id_35/Leetcode_01_35.java

@@ -0,0 +1,74 @@
+package com.leecode.week02;
+
+import java.util.*;
+
+/**
+ * https://leetcode.com/problems/two-sum/
+ * Given an array of integers, return indices of the two numbers such that they add up to a specific target.
+ *
+ * You may assume that each input would have exactly one solution, and you may not use the same element twice.
+ */
+public class Leetcode_01_35 {
+    public static void main(String[] args) {
+        Leetcode_01_35 lc=new Leetcode_01_35();
+        int[] nums={2, 7, 11, 15};
+        int target=9;
+        System.out.println(Arrays.toString(lc.twoSum(nums,target)));
+        System.out.println(Arrays.toString(lc.twoSum_v1(nums,target)));
+
+    }
+
+
+    /**
+     * 确定了一个元素之后另一个元素其实也确定了,一次遍历过程中因为要通过下标访问，所以提取不到另一个元素
+     * 思路:遍历之后把元素的位置缓存起来
+     * @param nums
+     * @param target
+     * @return
+     */
+    public  int[] twoSum(int[] nums, int target){
+
+        Map<Integer,Integer> cache=new HashMap<>();
+
+        for (int i=0;i<nums.length;i++){
+            int num=nums[i];
+            int other=target-num;
+            if(cache.keySet().contains(other)){
+                return new int[]{cache.get(other),i};
+            }else {
+                cache.put(num,i);
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     *两次遍历，先找到第一个元素，剩下的元素再接着找，时间复杂度是O(n^2)
+     * @param nums
+     * @param target
+     * @return
+     */
+    public  int[] twoSum_v1(int[] nums, int target) {
+        int r1=-1,r2=-1;
+
+        for(int i=0;i<nums.length;i++){
+            r1=i;
+            int other=target-nums[r1];
+
+            for (int j=i+1;j<nums.length;j++){
+                if(other==nums[j]){
+                    r2=j;
+                    break;
+                }
+            }
+
+            if(r2!=-1){
+                break;
+            }
+
+        }
+
+        return  new int[]{r1,r2};
+    }
+}

Week_03/id_35/Leetcode_102_35.java

@@ -0,0 +1,70 @@
+package com.leecode.week03;
+
+import com.leecode.TreeNode;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+
+/**
+ * https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
+ * 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
+ */
+public class Leetcode_102_35 {
+    public static void main(String[] args) {
+        Leetcode_102_35 lc=new Leetcode_102_35();
+        //int[] arr={3,2,9,-1,-1,10,-1,-1,8,-1,11,-1};
+        //[3,9,20,null,null,15,7]
+        int[] arr={3,9,20,-1,-1,-1,15,7};
+       // int[] arr={3,2};
+        TreeNode treeNode=TreeNode.createBinaryV1(arr,arr.length);
+
+        List<List<Integer>>  list=  lc.levelOrder(treeNode);
+        System.out.println(list);
+
+    }
+
+    /**
+     * 思考过程，我是做了多叉树按层次遍历的题目之后来做这道题目的
+     *
+     * @param root
+     * @return
+     */
+    public List<List<Integer>> levelOrder(TreeNode root) {
+
+        List<List<Integer>> list=new ArrayList<>();
+        if(root==null){
+            return list;
+        }
+
+        Queue<TreeNode> queue=new ArrayDeque<>();
+       queue.offer(root);
+
+       while (!queue.isEmpty()){
+           int queueSize=queue.size();
+           List<Integer> ls =new ArrayList<>(queueSize);
+
+           for(int i=0;i<queueSize;i++){
+               TreeNode node =queue.poll();
+               ls.add(node.val);
+               if(node.left!=null){
+                   queue.offer(node.left);
+
+               }
+
+               if(node.right!=null){
+                   queue.offer(node.right);
+
+               }
+
+           }
+
+           list.add(ls);
+       }
+
+        return list;
+    }
+
+
+}