483-82（23、239、450、113）

最新推荐文章于 2024-06-13 23:56:26 发布

liufeng2023

最新推荐文章于 2024-06-13 23:56:26 发布

阅读量155

点赞数 1

分类专栏：剑指offer 文章标签：链表数据结构算法

本文链接：https://blog.csdn.net/Edward_LF/article/details/126101805

版权

剑指offer 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

23. 合并K个升序链表

在这里插入图片描述

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        if (lists.size() == 0)   return nullptr;

        ListNode* dummy_node = new ListNode(-1);
        ListNode* cur = dummy_node;

        auto cmp = [](ListNode* a, ListNode* b)->bool {return a->val > b->val; };
        priority_queue<ListNode*, vector<ListNode*>, function<bool(ListNode* a, ListNode* b)>> q(cmp);

        for (ListNode* list : lists)
        {
            if (list == nullptr) continue;
            q.push(list);
        }

        while (!q.empty())
        {
            ListNode* temp = q.top();
            q.pop();
            cur->next = temp;
            cur = cur->next;
            if (temp->next != nullptr)
            {
                q.push(temp->next);
            }
        }
        return dummy_node->next;
    }
};

在这里插入图片描述

239. 滑动窗口最大值

在这里插入图片描述

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();

        priority_queue<pair<int, int>> q;

        for (int i = 0; i < k; i++)
        {
            q.push({ nums[i], i });
        }

        vector<int> ans;
        ans.push_back(q.top().first);

        for (int i = k; i < n; i++)
        {
            q.push({ nums[i], i });

            while (q.top().second <= i - k)
            {
                q.pop();
            }
            ans.push_back(q.top().first);
        }
        return ans;
    }
};

450. 删除二叉搜索树中的节点

在这里插入图片描述

class Solution {
public:
    TreeNode* deleteNode(TreeNode* root, int key) {
        if (root == nullptr) return root;

        if (root->val == key)
        {
            if (root->left == nullptr && root->right == nullptr)
            {
                delete root;
                return nullptr;
            }
            else if (root->left == nullptr)
            {
                TreeNode* right_node = root->right;
                delete root;
                return right_node;
            }
            else if (root->right == nullptr)
            {
                TreeNode* left_node = root->left;
                delete root;
                return left_node;
            }
            else
            {
                TreeNode* cur = root->right;
                while (cur->left != nullptr)
                {
                    cur = cur->left;
                }
                cur->left = root->left;
                TreeNode* temp = root->right;
                delete root;
                return temp;
            }
        }
        if (root->val > key) root->left = deleteNode(root->left, key);
        if (root->val < key) root->right = deleteNode(root->right, key);
        return root;
    }
};

113. 路径总和 II

在这里插入图片描述

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;
public:
    void traversal(TreeNode* cur, int count)
    {
        if (cur->left == nullptr && cur->right == nullptr && count == 0)
        {
            res.push_back(path);
            return;
        }

        if (cur->left)
        {
            path.push_back(cur->left->val);
            count -= cur->left->val;
            traversal(cur->left, count);
            count += cur->left->val;
            path.pop_back();
        }
        
        if (cur->right)
        {
            path.push_back(cur->right->val);
            count -= cur->right->val;
            traversal(cur->right, count);
            count += cur->right->val;
            path.pop_back();
        }
        return;
    }

public:
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        res.clear();
        path.clear();

        if (root == nullptr) return res;

        path.push_back(root->val);

        traversal(root, targetSum - root->val);
        return res;
    }
};