力扣爆刷第150天之TOP100五连刷6-10（几数之和、堆排、合并链表）

力扣爆刷第150天之TOP100五连刷6-10（几数之和、堆排、合并链表）

一、15. 三数之和

题目链接：https://leetcode.cn/problems/3sum/description/
思路：经典的两数之和、三数之和，两数之和使用map，三数之和需要考虑的是去重和早停。
三数之和，三个数，第一个数单独拿出来，然后剩下的两个数在一块，这就又形成了两数之和了。首先给整个数组排序，第一个数固定不动，看看剩下两个数加一块的三数之和，如果大于0说第三个数大了，要左移，如果小于0说明第二哥数小了，要右移。对于后两个数的去重，相同的数要抛弃。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(nums);
        for(int i = 0; i < nums.length-2; i++) {
            if(nums[i] > 0) break;
            if(i > 0 && nums[i] == nums[i-1]) continue;
            int j = i+1, k = nums.length-1;
            while(j < k) {
                int t = nums[i] + nums[j] + nums[k];
                if(t == 0) {
                    List<Integer> list = new ArrayList();
                    list.add(nums[i]);
                    list.add(nums[j]);
                    list.add(nums[k]);
                    result.add(list);
                    while(j < k && nums[j] == nums[j+1]) j++;
                    while(j < k && nums[k] == nums[k-1]) k--;
                    j++;
                    k--;
                }else if(t > 0) {
                    k--;
                }else{
                    j++;
                }
            }
        }
        return result;
    }
}

二、53. 最大子数组和

题目链接：https://leetcode.cn/problems/maximum-subarray/description/
思路：本题可以用贪心，也可以用动规，如果使用贪心的话，因为求的是最大连续子数组的和，所以只要子数组的和大于0我们就不停的记录最大值，如果子数组的和小于0了，那么就重新开始。

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

三、912. 排序数组

题目链接：https://leetcode.cn/problems/sort-an-array/description/
思路：排序算法嘛，经典题目，一般不是快排就是堆排、归并，如果测试用例有有序的存在，你还不太会写变体的快排的话，写堆排就可以。
思路就是先构建大顶堆，层于层之间有序，层内无序，然后每次把堆顶元素替换到尾部，由此即可排序。

class Solution {
    
    public int[] sortArray(int[] nums) {
        heapSort(nums);
        return nums;
    }

    void heapSort(int[] nums) {

        for(int i = nums.length/2-1; i >= 0; i--) {
            builHeap(nums, i, nums.length);
        }

        for(int i = nums.length-1; i > 0; i--) {
            int t = nums[0];
            nums[0] = nums[i];
            nums[i] = t;
            builHeap(nums, 0, i);
        } 
    }
    
    void builHeap(int[] nums, int start, int end) {
        int t = nums[start], k = start;
        for(int i = start * 2 + 1; i < end; i = i * 2 + 1) {
            if(i+1 < end && nums[i] < nums[i+1]) i++;
            if(nums[i] > t) {
                nums[k] = nums[i];
                k = i;
            }else break;
        }
        nums[k] = t;
    }
}

四、21. 合并两个有序链表

题目链接：https://leetcode.cn/problems/merge-two-sorted-lists/description/
思路：合并两个有序链表，经典归并排序，没啥好说的，比较然后合并即可。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode root = new ListNode(), p = root;
        while(list1 != null && list2 != null) {
            if(list1.val < list2.val) {
                p.next = list1;
                list1 = list1.next;
            }else{
                p.next = list2;
                list2 = list2.next;
            }
            p = p.next;
        }
        if(list1 != null) p.next = list1;
        if(list2 != null) p.next = list2;
        return root.next;
    }
}

五、1. 两数之和

题目链接：https://leetcode.cn/problems/two-sum/description/
思路：经典两数之和，使用map记录每一个数与target的差值，然后如果当前数出现在map中，就说明找到两数之和了。

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for(int i = 0; i < nums.length; i++) {
            if(map.containsKey(nums[i])) {
                return new int[] {map.get(nums[i]), i};
            }
            map.put(target - nums[i], i);
        }
        return new int[] {-1, -1};
    }
}