CodeTop day2

class Solution {
    public ListNode reverseKGroup(ListNode head, int k) {
        ListNode dummy = new ListNode(0);//设置虚拟头节点
        dummy.next = head;
        ListNode pre = dummy;//让起始和结束的k个节点从类似虚拟节点的头节点出发
        ListNode end = dummy;
        while(end.next!=null){
            for (int i=0;i<k&&end!=null;i++) end = end.next;//找到k个节点的最后一个节点
            if (end==null) break;//当最后一个节点为null，也就代表存在不能整除k的最后一部分，这是就保持原样
            ListNode start = pre.next;//开始节点：即pre【起虚拟头节点的作用】的next节点
            ListNode next = end.next;//保存下一个循环开始的start节点
            end.next = null;//隔断k个节点之后的节点
            pre.next = revers(start);//反转start-end的k个节点
            start.next = next;//反转之后的节点start的下一个节点，就是保存的下一个k组节点的start
            pre = start;//将这个start节点对于下一组起虚拟头节点的作用
            end = pre;//下一组的end从虚拟头节点开始出发
        }
        return dummy.next;
    }
    private ListNode revers(ListNode head){
        ListNode pre = null;
        ListNode cur = head;
        while(cur!=null){
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }
}

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> result = new ArrayList<>();
        if (nums[0]>0) return result;
        for (int i=0;i<nums.length-1;i++){
            if (i>0 && nums[i]==nums[i-1]) continue;
            int left = i+1;
            int right = nums.length-1;
            while(left<right){
                int sum = nums[i] + nums[left] + nums[right];
                List<Integer> path = new ArrayList<>();
                if (sum>0){
                    right--;
                } else if (sum<0) {
                    left++;
                }else{
                    path.add(nums[i]);
                    path.add(nums[left]);
                    path.add(nums[right]);
                    result.add(path);
                    while(left<right && nums[left+1]==nums[left]) left++;
                    while(left<right && nums[right-1]==nums[right]) right--;
                    left++;
                    right--;
                }
            }
        }
        return result;
    }
}

class Solution {
    public int maxSubArray(int[] nums) {
        int result = Integer.MIN_VALUE;
        int sum = 0;
        for (int i=0;i<nums.length;i++){
            sum += nums[i];
            result = Math.max(result,sum);
            if (sum<0) sum = 0;
        }
        return result;
    }
}