刷题计划_Day 6

最新推荐文章于 2026-01-05 22:36:07 发布

原创最新推荐文章于 2026-01-05 22:36:07 发布 · 1.6k 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #链表 #数据结构

本文介绍了如何使用双指针技巧计算整数数组子数组范围和，以及如何在链表中删除倒数第N个结点。算法涉及动态范围计算和链表操作的基本技巧。

Day 6

2104. 子数组范围和

给你一个整数数组 nums 。nums 中，子数组的范围是子数组中最大元素和最小元素的差值。

返回 nums 中所有子数组范围的和。

子数组是数组中一个连续非空的元素序列。

用 slow 指针来模拟子数组的左边界，用 quick 指针模拟右边界，对 slow 和 quick 之间的数据求最大值和最小值，结果相加得出 ans

class Solution {
public:
    long long subArrayRanges(vector<int>& nums) {
        long long ans = 0;
        int slow = 0;
        int quick = 1;
        int minV = INT_MAX;
        int maxV = INT_MIN;
        for(;slow < nums.size();slow++)
        {
            minV = INT_MAX;
            maxV = INT_MIN;
            for(quick = slow;quick < nums.size();quick++)
            {
                minV = min(minV,nums[quick]);
                maxV = max(maxV,nums[quick]);
                ans = ans + maxV - minV;
            }
        }
        return ans;
    }
};

19. 删除链表的倒数第 N 个结点

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

先写一个函数，求出链表的长度

定义一个哑巴结点，指向 head->next，遍历到第 length - n 个结点的时候

执行 cur->next = cur->next->next，最后用一个ans结点接住 d->next，在 delete d，返回 ans

/**
 * 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:
    int getLength(ListNode*head)
    {
        int cut = 0;
        while(head)
        {
            ++cut;
            head = head->next;
        }
        return cut;
    }
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        int length = getLength(head);
        ListNode* d = new ListNode(0,head);
        ListNode* cur = d;
        for(int i = 1;i < length - n + 1;++i)
        {
            cur = cur->next;
        }
        cur->next = cur->next->next;
        ListNode* ans = d->next;
        delete d;
        return ans;
    }
};

876. 链表的中间结点

给定一个头结点为 head 的非空单链表，返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

遍历求出链表的长度，length/2+1就是 ans需要指向的结点

在循环到这个结点，用一个 ans 接住 cur，最后返回 ans 就行

/**
 * 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:
    int getlength(ListNode*head)
    {
        int length = 0;
        while(head)
        {
            ++length;
            head = head->next;
        }
        return length;
    }
    ListNode* middleNode(ListNode* head) {
        int length = getlength(head);
        int n = length/2+1;
        ListNode* d = new ListNode(0,head);
        ListNode* cur = d;
        for(int i = 0;i < n;++i)
        {
            cur = cur->next;
        }
        ListNode* ans = cur;
        return ans;
    }
};