代码随想录算法训练营第三天 | 203. 移除链表元素、707. 设计链表、206. 反转链表、每日一题2389. 和有限的最长子序列

203. 移除链表元素

设置虚拟头结点，判断当前结点的下一个结点的值是否等于val，以便删除操作。

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = head;
        ListNode* cur = dummyHead;
        while (cur->next != nullptr) {
            if (cur->next->val == val) {
                cur->next = cur->next->next;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        return head;
    }
};

707. 设计链表

构造链表结点，设置虚拟头结点和链表大小两个属性，来控制增删改查。

class MyLinkedList {
public:
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val): val(val), next(nullptr) {}
    };

    MyLinkedList() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }
    
    int get(int index) {
        if (index > (_size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = _dummyHead->next;
        while (index--) {
            cur = cur->next;
        }
        return cur->val;        
    }
    
    void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = _dummyHead->next;
        _dummyHead->next = newNode;
        _size++;
    }
    
    void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cur = cur->next;
        }
        cur->next = newNode;
        _size++;
    }
    
    void addAtIndex(int index, int val) {
        if (index > _size) return;
        if (index < 0) index = 0;
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;        
        while (index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if (index >= 0 && index < _size) {
            LinkedNode* cur = _dummyHead;  
            while (index--) {
                cur = cur->next;
            }
            LinkedNode* tmp = cur->next;
            cur->next = cur->next->next;
            delete tmp;
            _size--;
        }
    }

private:
    LinkedNode* _dummyHead; 
    int _size;
};

206. 反转链表

双指针

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* prev = nullptr;
        ListNode* curr = head;
        while (curr) {
            ListNode* next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
};

递归

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head == nullptr || head->next == nullptr){
            return head;
        }
        ListNode* ret = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return ret;        
    }
};

2389. 和有限的最长子序列

暴力解法

class Solution {
public:
    vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {
        vector<int> answer(queries.size(), 0);
        sort(nums.begin(), nums.end());
        for (int i = 0; i < queries.size(); i++) {
            int sum = 0;
            for (int j = 0; j < nums.size(); j++) {
                sum += nums[j];
                if (sum > queries[i]) {
                    answer[i] = j;
                    break;
                }
                if (j == nums.size() - 1) {
                    answer[i] = nums.size();
                    break;
                }
            }
        }
        return answer;
    }
};

利用前缀和+二分查找

class Solution {
public:
    vector<int> answerQueries(vector<int>& nums, vector<int>& queries) {
        int n = nums.size(), m = queries.size();
        sort(nums.begin(), nums.end());
        vector<int> prefix(n + 1, 0);
        for (int i = 0; i < n; i++) {
            prefix[i + 1] = prefix[i] + nums[i];
        }
        vector<int> answer(m, 0);
        for (int i = 0; i < m; i++) {
            answer[i] = upper_bound(prefix.begin(), prefix.end(), queries[i]) - prefix.begin() - 1;
        }
        return answer;
    }
};