diff --git a/Week_02/id_35/LeetCode_03_35.java b/Week_02/id_35/LeetCode_03_35.java
new file mode 100644
index 00000000..9187802a
--- /dev/null
+++ b/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;
+    }*/
+}
diff --git a/Week_02/id_35/LeetCode_242_35.java b/Week_02/id_35/LeetCode_242_35.java
new file mode 100644
index 00000000..ff02a35a
--- /dev/null
+++ b/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);
+     *     }
+     */
+}
diff --git a/Week_02/id_35/Leetcode_01_35.java b/Week_02/id_35/Leetcode_01_35.java
new file mode 100644
index 00000000..9f67edbf
--- /dev/null
+++ b/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};
+    }
+}
diff --git a/Week_03/id_35/Leetcode_102_35.java b/Week_03/id_35/Leetcode_102_35.java
new file mode 100644
index 00000000..2738113d
--- /dev/null
+++ b/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;
+    }
+
+
+}
diff --git a/Week_03/id_35/Leetcode_103_35.java b/Week_03/id_35/Leetcode_103_35.java
new file mode 100644
index 00000000..f27db157
--- /dev/null
+++ b/Week_03/id_35/Leetcode_103_35.java
@@ -0,0 +1,83 @@
+package com.leecode.week03;
+
+import com.leecode.TreeNode;
+
+import java.util.*;
+
+/**
+ * 103. Binary Tree Zigzag Level Order Traversal
+ */
+public class Leetcode_103_35 {
+
+    public static void main(String[] args) {
+        Leetcode_103_35 lc=new Leetcode_103_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.zigzagLevelOrder(treeNode);
+        System.out.println(list);
+
+    }
+
+    /**
+     * 思考过程，我是做了多叉树按层次遍历的题目之后来做这道题目的
+     * ，同样在上面基础上面进行改进,要从左到右，然后从右到做，只要把每层加入的时候顺序往后或者往前就好了
+     * 需要注意的是，出队列是有顺序的，所以只能是在写入list中元素的下标进行控制了
+     *
+     * @param root
+     * @return
+     */
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+
+
+        List<List<Integer>> list=new ArrayList<>();
+        if(root==null){
+            return list;
+        }
+
+        Queue<TreeNode> queue=new ArrayDeque<>();
+        queue.offer(root);
+        boolean needReverse=false;//false ->从左到右    true->从右到左
+
+        while (!queue.isEmpty()){
+            int queueSize=queue.size();
+            Integer[] arr=new Integer[queueSize];
+
+            for(int i=0;i<queueSize;i++){
+                TreeNode node =queue.poll();
+
+
+                if(needReverse){
+                    System.out.println("queueSize:"+queueSize);
+                    System.out.println("index:"+(queueSize-i-1));
+                    arr[queueSize-i-1]=node.val;
+
+
+                }else{
+                    arr[i]=node.val;
+
+                }
+
+                if(node.left!=null){
+                    queue.offer(node.left);
+
+                }
+
+                if(node.right!=null){
+                    queue.offer(node.right);
+
+                }
+
+            }
+
+
+            list.add(Arrays.asList(arr));
+            needReverse=!needReverse;
+        }
+
+        return list;
+    }
+}
diff --git a/Week_03/id_35/Leetcode_104_35.java b/Week_03/id_35/Leetcode_104_35.java
new file mode 100644
index 00000000..6bc8b00b
--- /dev/null
+++ b/Week_03/id_35/Leetcode_104_35.java
@@ -0,0 +1,32 @@
+package com.leecode.week03;
+
+import com.leecode.TreeNode;
+
+/**
+ * https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
+ * 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
+ */
+public class Leetcode_104_35 {
+    public static void main(String[] args) {
+        Leetcode_104_35 lc=new Leetcode_104_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);
+       int maxDept= lc.maxDepth(treeNode);
+       System.out.println("maxDept->"+maxDept);
+    }
+
+
+    /**
+     * 递归
+     * @param root
+     * @return
+     */
+    public int maxDepth(TreeNode root) {
+        return root == null ? 0 : (1 + Math.max(maxDepth(root.left), maxDepth(root.right)));
+    }
+
+
+}
diff --git a/Week_03/id_35/Leetcode_107_35.java b/Week_03/id_35/Leetcode_107_35.java
new file mode 100644
index 00000000..fc397789
--- /dev/null
+++ b/Week_03/id_35/Leetcode_107_35.java
@@ -0,0 +1,77 @@
+package com.leecode.week03;
+
+import com.leecode.TreeNode;
+
+import java.util.*;
+
+/**
+ * 107. Binary Tree Level Order Traversal II
+ */
+
+public class Leetcode_107_35 {
+
+    public static void main(String[] args) {
+        Leetcode_107_35 lc=new Leetcode_107_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.levelOrderBottom(treeNode);
+        System.out.println(list);
+
+    }
+
+    /**
+     * 思考过程，我是做了多叉树按层次遍历的题目之后来做这道题目的
+     * ,直接想法就是把结果反着输出就好了,要反着输出，就把结果压到栈上面
+     *
+     * @param root
+     * @return
+     */
+    public List<List<Integer>> levelOrderBottom(TreeNode root) {
+
+        List<List<Integer>> list=new ArrayList<>();
+        if(root==null){
+            return list;
+        }
+
+        Stack<List<Integer>> stack=new Stack<>();
+
+        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);
+
+                }
+
+            }
+
+            stack.push(ls);//结果压栈
+
+        }
+
+
+        //把结果挨个出栈
+        while (!stack.empty()){
+            List<Integer> ls =stack.pop();
+            list.add(ls);
+        }
+
+        return list;
+    }
+}
diff --git a/Week_03/id_35/Leetcode_111_35.java b/Week_03/id_35/Leetcode_111_35.java
new file mode 100644
index 00000000..74c34269
--- /dev/null
+++ b/Week_03/id_35/Leetcode_111_35.java
@@ -0,0 +1,54 @@
+package com.leecode.week03;
+
+import com.geekbang.BinaryTree;
+import com.leecode.TreeNode;
+
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+/**
+ * https://leetcode-cn.com/problems/minimum-depth-of-binary-tree/
+ * 给定一个二叉树，找出其最小深度
+ */
+public class Leetcode_111_35 {
+    public static void main(String[] args) {
+        Leetcode_111_35 lc=new Leetcode_111_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);
+       int minDept= lc.minDepth(treeNode);
+       System.out.println("minDepth->"+minDept);
+    }
+
+
+    /**
+     * 思考过程:
+     * 凡是要了解深度，都是要遍历到叶子节点，直接的想法就是遍历到所有的叶子节点，找到深度最小的那波即可
+     *
+     * @param root
+     * @return
+     */
+    public int minDepth(TreeNode root) {
+
+        if(root==null){
+            return 0;
+        }
+        //当前的叶子节点的条件，左右都是null的
+        if(root.left==null&&root.right==null){
+            return 1;
+        }
+        int minDept=Integer.MAX_VALUE;
+        if(root.left!=null){
+            minDept=Math.min(minDepth(root.left),minDept);
+        }
+
+        if(root.right!=null){
+            minDept=Math.min(minDepth(root.right),minDept);
+        }
+
+        //左右节点中不为空的情况，会往下递推一层，深度+1
+        return minDept+1;
+    }
+}
diff --git a/Week_03/id_35/Leetcode_429_35.java b/Week_03/id_35/Leetcode_429_35.java
new file mode 100644
index 00000000..af36d198
--- /dev/null
+++ b/Week_03/id_35/Leetcode_429_35.java
@@ -0,0 +1,128 @@
+package com.leecode.week03;
+
+import com.leecode.TreeNode;
+
+import java.util.*;
+
+/**
+ *
+ * N叉树的层序遍历
+ */
+public class Leetcode_429_35 {
+
+     class Node {
+        public int val;
+        public List<Node> children;
+
+        public Node() {}
+
+        public Node(int _val,List<Node> _children) {
+            val = _val;
+            children = _children;
+        }
+    };
+
+
+    public static void main(String[] args) {
+        Leetcode_429_35 lc=new Leetcode_429_35();
+
+        Node root=lc.createTree();
+
+
+
+        List<List<Integer>>  list=  lc.levelOrder(root);
+        System.out.println(list);
+
+    }
+
+
+    public Node createTree(){
+        List<Node> _children56=new ArrayList<>();
+        Node n5=new Node(5,null);
+        Node n6=new Node(6,null);
+
+        _children56.add(n5);
+        _children56.add(n6);
+
+
+        List<Node> _children324=new ArrayList<>();
+        Node n3=new Node(3,_children56);
+        Node n2=new Node(2,null);
+
+        List<Node> _children78=new ArrayList<>();
+
+        Node n7=new Node(7,null);
+        Node n8=new Node(8,null);
+
+        _children78.add(n7);
+        _children78.add(n8);
+
+        Node n4=new Node(4,_children78);
+
+
+
+        _children324.add(n3);
+        _children324.add(n2);
+        _children324.add(n4);
+
+        Node root=new Node(1,_children324);
+
+        return root;
+
+
+
+
+    }
+
+
+    /**
+     * 思考过程，按照层次遍历只是可以打印顺序，一开始是直接输出
+     * 但是碰到有个问题的就是层次没注意，
+     * 第一把提交未通过，再寻找原因
+     *后面发现每次入队列的时候队列上面的元素其实就是当前层的顺序，但是这次需要每次取元素的时候把
+     * 队列里面的元素都拿出来
+     * 拿出来之后队列必然是空的，接下来就把下一层元素全部放进队列里面
+     * 每个元素会被访问到两次，入队列一次，出队列一次
+     * @param root
+     * @return
+     */
+    public List<List<Integer>> levelOrder(Node root) {
+
+        List<List<Integer>> list=new ArrayList<>();
+        if(root==null){
+            return list;
+        }
+
+        Queue<Node> queue=new ArrayDeque<>();
+        queue.offer(root);
+
+
+        while (!queue.isEmpty()){
+            int curQueueSize=queue.size();
+            List<Integer> ls=new ArrayList<>(curQueueSize);
+            for (int i=0;i<curQueueSize;i++){
+                Node node=queue.poll();
+                ls.add(node.val);
+                //孩子全部入队列
+                if(node.children!=null&&node.children.size()!=0){
+                    for(Node n:node.children){
+                        queue.offer(n);
+                    }
+                }
+            }
+
+            list.add(ls);
+
+        }
+
+
+        return list;
+    }
+
+
+
+
+
+
+
+}