一个数组中 连续的最大和

Author: wb-hjk570755

src/com/blankj/myself/GetKthFromEnd.java

@@ -0,0 +1,67 @@
+package com.blankj.myself;
+
+import com.blankj.myself.HasCycle_fast_slow_point.ListNode;
+
+/**
+ * Description:
+ * Copyright: Copyright (c) 2012
+ * Company: keruyun Technology(Beijing) Chengdu Co. Ltd.
+ *
+ * @author huangjk
+ * @version 1.0 2020/10/3
+ */
+public class GetKthFromEnd {
+    public static void main(String[] args) {
+        ListNode head = new ListNode(1);
+        ListNode tail = null;
+
+        //head.next=new ListNode(2);
+        //head.next.next=new ListNode(3);
+        //head.next.next.next=new ListNode(4);
+        //head.next.next.next.next=new ListNode(5);
+
+        for (int i=1;i<5;i++){
+            if(tail==null){
+                tail = new ListNode(i+1);
+                head.next = tail;
+            }else {
+                tail.next = new ListNode(i+1);
+                tail = tail.next;
+            }
+
+        }
+
+        GetKthFromEnd getKthFromEnd = new GetKthFromEnd();
+        getKthFromEnd.getKthFromEnd(head,2);
+
+
+    }
+
+    public ListNode getKthFromEnd(ListNode head, int k) {
+        int size = 0;
+        ListNode headSecond = head;
+        while(head!=null){
+            head = head.next;
+            size = size + 1;
+        }
+        ListNode res = null;
+        ListNode temp = null;
+        int index = 0;
+        while(headSecond!=null){
+
+            index = index + 1;
+            if(size-k<index){
+                if(res==null){
+                    temp = new ListNode(headSecond.val);
+                    res = temp;
+                }else{
+                    temp.next = headSecond;
+                    temp=temp.next;
+                }
+            }
+            headSecond = headSecond.next;
+        }
+        return res;
+    }
+
+}

src/com/blankj/myself/MaxSubArray.java

@@ -0,0 +1,21 @@
+package com.blankj.myself;
+
+/**
+ * Description:
+ * Copyright: Copyright (c) 2012
+ * Company: keruyun Technology(Beijing) Chengdu Co. Ltd.
+ *
+ * @author huangjk
+ * @version 1.0 2020/10/3
+ */
+public class MaxSubArray {
+
+    public int maxSubArray(int[] nums) {
+        int res = nums[0];
+        for(int i=1;i<nums.length;i++){
+            nums[i] = Math.max(nums[i-1],0) + nums[i];
+            res = Math.max(res,nums[i]);
+        }
+        return res;
+    }
+}

src/com/blankj/myself/MergeTwoLists.java

@@ -0,0 +1,36 @@
+package com.blankj.myself;
+
+import com.blankj.myself.HasCycle_fast_slow_point.ListNode;
+
+/**
+ * Description:
+ * Copyright: Copyright (c) 2012
+ * Company: keruyun Technology(Beijing) Chengdu Co. Ltd.
+ *
+ * @author huangjk
+ * @version 1.0 2020/10/3
+ */
+public class MergeTwoLists {
+
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+        if(l1==null&&l2==null){
+            return l2;
+        }
+        if(l1==null&&l2!=null){
+            return l2;
+        }
+        if(l2==null&&l1!=null){
+            return l1;
+        }
+        ListNode res ;
+        if(l1.val<=l2.val){
+            res = new ListNode(l1.val);
+            res.next = mergeTwoLists(l1.next,l2);
+        }else {
+            res = new ListNode(l2.val);
+            res.next = mergeTwoLists(l1,l2.next);
+        }
+        return res;
+
+    }
+}

src/com/blankj/myself/TreeBFS.java

@@ -0,0 +1,46 @@
+package com.blankj.myself;
+
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+
+import com.blankj.myself.InorderTraversal.TreeNode;
+
+/**
+ * Description:
+ * Copyright: Copyright (c) 2012
+ * Company: keruyun Technology(Beijing) Chengdu Co. Ltd.
+ *
+ * @author huangjk
+ * @version 1.0 2020/10/3
+ */
+public class TreeBFS {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> res = new ArrayList<>();
+        if(root==null){
+            return res;
+        }
+        ArrayDeque<TreeNode> queue = new ArrayDeque<TreeNode>();
+        queue.add(root);
+
+        while (queue.peek()!=null){
+            List<Integer> temp = new ArrayList<>();
+            int size = queue.size();
+            for (int i=0;i<size;i++){
+                TreeNode treeNode = queue.removeFirst();
+
+                if(treeNode.left != null){
+                    queue.add(treeNode.left);
+                }
+                if(treeNode.right != null){
+                    queue.add(treeNode.right);
+                }
+
+                temp.add(treeNode.val);
+            }
+
+            res.add(temp);
+        }
+        return res;
+    }
+}