LeetCode HOT 100 --- 2021/8/9

寻找两个正序数组的中位数

方法一：
  先按照合并两个有序链表的方式合并两个数组，然后再求中位数。
代码：

class Solution {
public:
    double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
        vector<int> res;
        int m = nums1.size(), n = nums2.size();
        int i = 0, j = 0;
        while(i < m && j < n) {
            if(nums1[i] < nums2[j]) {
                res.push_back(nums1[i]);
                i++;
            }else {
                res.push_back(nums2[j]);
                j++;
            }
        }
        if(i < m) {
            for(int k = i; k < m; k++) {
                res.push_back(nums1[k]);
            }
        }else if(j < n){
            for(int k = j; k < n; k++) {
                res.push_back(nums2[k]);
            }
        }
        int mid = (m + n) / 2;
        if((m + n) & 1) {     
            return 1.0 * res[mid];
        }else {
            return (res[mid - 1] + res[mid]) / 2.0;
        }
    }
};

方法二：
  可以不合并两个链表，只要找到相应的位置下标即可，思想同方法一。

合并K个升序链表

方法一：
  循环合并。
代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* merge(ListNode* head1, ListNode* head2) {
        ListNode* head = new ListNode();
        ListNode* ptr = head;
        while(head1 && head2) {
            if(head1->val < head2->val) {
                ptr->next = head1;
                head1 = head1->next;
            }else {
                ptr->next = head2;
                head2 = head2->next;
            }
            ptr = ptr->next;
        }
        ptr->next = head1 == nullptr ? head2 : head1;
        return head->next;
    }
    
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int n = lists.size();
        if(n == 0) {
            return nullptr;
        }
        if(n == 1) {
            return lists[0];
        }
        ListNode* res = lists[0];
        for(int i = 1; i < n; i++) {
            res = merge(res, lists[i]);
        }
        return res;
    }
};

方法二：
  归并合并。
代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* merge(ListNode* head1, ListNode* head2) {
        ListNode* head = new ListNode();
        ListNode* ptr = head;
        while(head1 && head2) {
            if(head1->val < head2->val) {
                ptr->next = head1;
                head1 = head1->next;
            }else {
                ptr->next = head2;
                head2 = head2->next;
            }
            ptr = ptr->next;
        }
        ptr->next = head1 == nullptr ? head2 : head1;
        return head->next;
    }
    
    ListNode* mergeSort(vector<ListNode*>& lists, int l, int r) {
        if(l > r) {
            return nullptr;
        }
        if(l == r) {
            return lists[r];
        }
        int mid = l + (r - l) / 2;
        return merge(mergeSort(lists, l, mid), mergeSort(lists, mid + 1, r));
    }
    
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        int n = lists.size();
        return mergeSort(lists, 0, n - 1);
    }
};

最长有效括号

分析：
  参考官方题解。
代码：

class Solution {
public:
    int longestValidParentheses(string s) {
        int maxans = 0;
        stack<int> stk;
        stk.push(-1);
        for (int i = 0; i < s.length(); i++) {
            if (s[i] == '(') {
                stk.push(i);
            } else {
                stk.pop();
                if (stk.empty()) {
                    stk.push(i);
                } else {
                    maxans = max(maxans, i - stk.top());
                }
            }
        }
        return maxans;
    }
};