LeetCode 18-20

Problem 18 4Sum

这道题不知道有没有更好地方法，简单粗暴的当成是先选择一个数，再选择一个数，剩下两个数就用3Sum的方法来解就好了。

vector<vector<int>> fourSum(vector<int>& nums, int target) {
    sort(nums.begin(), nums.end());
    int size = nums.size();
    vector<vector<int>> result;
    for (int i = 0; i < size; i++) {
        for (int j = i + 1; j < size - 2; j++) {
            int left = j + 1, right = size - 1;
            while (left < right) {
                int sum = nums[i] + nums[j] + nums[left] + nums[right];
                if (sum == target) {
                    vector<int> temp = { nums[i], nums[j], nums[left],nums[right] };
                    result.push_back(temp);
                    while (left < right && nums[left + 1] == nums[left])
                        left++;
                    while (left < right && nums[right - 1] == nums[right])
                        right--;
                    left++;
                    right--;
                }
                if (sum < target) {
                    while (left < right && nums[left + 1] == nums[left])
                        left++;
                    left++;
                }
                else if (sum > target) {
                    while (left < right && nums[right - 1] == nums[right])
                        right--;
                    right--;
                }
            }
            while (j + 1 < size - 2 && nums[j + 1] == nums[j])
                j++;
        }
        while (i + 1 < size && nums[i + 1] == nums[i])
            i++;
    }
    return result;
}

Problem 19 Remove Nth Node From End of List

这道题要求只能遍历一遍，我能想到最容易实现的方法可能就是用一个数组存下所有的节点，然后用下标去寻找需要删除的节点并进行删除。这里分以下几种情况处理：

n == 0	return head
n == size	return head->next
n > 0 && n < size	delete nth

ListNode* removeNthFromEnd(ListNode* &head, int n) {
    if (n == 0)
        return head;
    vector<ListNode*> node_vec;
    ListNode* current = head;
    while (current != NULL) {
        node_vec.push_back(current);
        current = current->next;
    }
    int size = node_vec.size();
    if (n == size)
        return head->next;
    else {
        ListNode* to_delete = node_vec[size - n], *front = node_vec[size - n - 1];
        front->next = to_delete->next;
        delete to_delete;
        return head;
    }
}

Problem 20 Valid Parentheses

这是一道典型的使用栈来处理的问题，先进后出。先将读到的字符压栈，如果是括号的开始，那么继续读取；如果是括号的结束，查询栈顶的元素是否能匹配，如果不能匹配直接返回false，如果可以匹配那么pop，继续读取下一个字符。当字符全都读取完之后，需要判断栈中是否还有元素，如果没有元素返回true，有元素返回false（说明还有括号没有被匹配）

bool isValid(string s) {
    stack<char> Parentheses;
    int size = s.length();
    for(int i = 0; i < size; i++) {
        switch (s[i]) {
        case '(':
        case '[':
        case '{':
            Parentheses.push(s[i]);
            break;
        case ')':
            if (Parentheses.size() > 0 && Parentheses.top() == '(')
                Parentheses.pop();
            else
                return false;
            break;
        case ']':
            if (Parentheses.size() > 0 && Parentheses.top() == '[')
                Parentheses.pop();
            else
                return false;
            break;
        case '}':
            if (Parentheses.size() > 0 && Parentheses.top() == '{')
                Parentheses.pop();
            else
                return false;
            break;
        }
    }
    if (Parentheses.size() == 0)
        return true;
    else
        return false;
}