LeetCode | 自我刷题记录

• LeetCode 21.Merge Two Sorted Lists

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.
Example:
Input: 1->2->4, 1->3->4
Output: 1->1->2->3->4->4
思路很简单，归并排序解决问题：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode result = new ListNode(0);//创建一个新链表用于保存合并后的结果
        ListNode curr = result;//创建一个指向结果链表头结点的指针，用于执行归并操作
        while(l1 != null && l2 != null){  //如果l1和l2都还有元素
            if(l1.val < l2.val){  //如果l1元素较小，插入结果链表，两个链表都进行后移
                curr.next = l1;
                curr = curr.next;
                l1 = l1.next;
            }else{
                curr.next = l2;
                curr = curr.next;
                l2 = l2.next;
            }
        }
        if(l1 == null){   
            curr.next = l2;  //如果l2已经无元素，则插入l1剩余元素
        }else{
            curr.next = l1;
        }
        return result.next;
    }
}

• LeetCode 121.Best Time To Buy and Sell Stock

Say you have an array for which the ith element is the price of a given stock on day i.
 If you were only permitted to complete at most one transaction (i.e., buy one and sell one share of the stock), design an algorithm to find the maximum profit.
Note that you cannot sell a stock before you buy one.
Example 1:
Input: [7,1,5,3,6,4]
Output: 5
Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5.
Not 7-1 = 6, as selling price needs to be larger than buying price.
Example 2:
Input: [7,6,4,3,1]
Output: 0
Explanation: In this case, no transaction is done, i.e. max profit = 0.
典型的动态规划题目，
dp[i]代表[0,i]内交易股票的最大收益
minPrice表示［0，i）之间价格的最小值
状态转移方程 dp[i] = max(dp[i-1],prices[i]-minPrice)

//d[i]代表[0,i]内交易股票的最大收益 minPrice表示［0，i）之间价格的最小值
//状态转移方程 dp[i] = max(dp[i-1],prices[i]-minPrice)

class Solution{
    public int maxProfit(int[] prices){
        if(prices.length < 1){
            return 0;
        }
        int[] dp = new int[prices.length];
        int minprice = prices[0];
        for(int i = 1; i < prices.length;i++){
            minprice = Math.min(minprice,prices[i]);
            dp[i] = Math.max(dp[i-1],prices[i] - minprice);
        }
        return dp[prices.length-1];
    }
}

• LeetCode 121.Best Time To Buy and Sell Stock II

我们有效地使用峰值和谷值，但我们不需要跟踪峰值和谷值对应的成本以及最大利润，但我们可以直接继续增加加数组的连续数字之间的差值，如果第二个数字大于第一个数字，我们获得的总和将是最大利润。 只需要通过简单的一次遍历，时间复杂度O(n)，空间复杂度O(1)。

class Solution {
    public int maxProfit(int[] prices) {
        int maxprofit = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1])
                maxprofit += prices[i] - prices[i - 1];
        }
        return maxprofit;
    }
}

• LeetCode 217.Contains Any Duplicates

Given an array of integers, find if the array contains any duplicates.
Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.
Example 1:
Input: [1,2,3,1]
Output: true
Example 2:
Input: [1,2,3,4]
Output: false
Example 3:
Input: [1,1,1,3,3,4,3,2,4,2]
Output: true

---

方法一：使用Sort实现

class Solution {
    public boolean containsDuplicate(int[] nums) {
        if(nums.length == 0){
            return false;
        }
        Arrays.sort(nums);
        for(int i = 0; i < nums.length-1;i++){
            if(nums[i] == nums[i+1]){
                return true;
            }
        }
        return false;
    }
}

方法2：使用Hashset实现

class Solution {
    public boolean containsDuplicate(int[] nums) {
        HashSet set = new HashSet<>();
        for(int i = 0; i < nums.length; i++){
            if(set.contains(nums[i])){
               return true; 
            }
            set.add(nums[i]);
        }
        return false;
    }
}

• LeetCode 78.Subsets

Given a set of distinct integers, nums, return all possible subsets (the power set).
Note:The solution set must not contain duplicate subsets.
Example:
Input: nums = [1,2,3]
Output:
[
[3],
[1],
[2],
[1,2,3],
[1,3],
[2,3],
[1,2],
[]
]

思路：求集合的所有子集问题。题目要求子集中元素非递减序排列，因此我们先要对原来的集合进行排序。原集合中每一个元素在子集中有两种状态：要么存在、要么不存在。这样构造子集的过程中每个元素就有两种选择方法：选择、不选择，因此可以构造一颗二叉树，例如对于例子中给的集合[1,2,3]，构造的二叉树如下（左子树表示选择该层处理的元素，右子树不选择），最后得到的叶子节点就是子集。

DFS思路

• LeetCode 237. Delete Node in a Linked List

Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.
非常巧的思路，直接将要删除节点后的数值复写至要删除节点，之后让该节点直接指向要删除节点的孙子节点，即完成。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public void deleteNode(ListNode node) {
        node.val = node.next.val;
        node.next = node.next.next;
    }
}