代码随想录Day 3 | 链表Part 1

文章目录

  • Day 1 习题
    • 二分法
      • 34. 在排序数组中查找元素的第一个和最后一个位置
    • 双指针
      • 283. 移动零
  • Day 2 习题
    • 滑动窗口
      • 904. 水果成篮
  • Day 3 链表Part 1
    • 链表理论基础
    • 203. 移除链表元素
    • 707. 设计链表
    • 206. 反转链表
    • C++语法
  • 总结


Day 1 习题

二分法

34. 在排序数组中查找元素的第一个和最后一个位置

本题进一步练习二分法区间收窄时的细节控制,及分别使用两个函数(或一个函数两个判断条件)寻找左右位置的整体思路。

class Solution {
public:
    int binarySearchLeft(vector<int>& nums, int target){
        // 搜索第一个和目标值相等的元素的位置,如果没有,则会返回第一个比目标值大的元素的位置
        int left = 0;
        int right = nums.size();
        int leftBoundary = -2;
        while (left < right){
            int middle = left + (right - left) / 2;
            if (nums[middle] >= target){
                right = middle;
                leftBoundary = right;
            }
            else
                left = middle + 1;
        }
        return leftBoundary;
    }
    int binarySearchRight(vector<int>& nums, int target){
        // 搜索第一个比目标值大的元素的位置
        int left = 0;
        int right = nums.size();
        int rightBoundary = -2;
        while (left < right){
            int middle = left + (right - left) / 2;
            if (nums[middle] > target)
                right = middle;
            else{
                left = middle + 1;
                rightBoundary = left;
            } 
        }
        return rightBoundary;
    }
    
    vector<int> searchRange(vector<int>& nums, int target) {
        int leftBoundary = binarySearchLeft(nums, target);
        int rightBoundary = binarySearchRight(nums, target);
        if (leftBoundary == -2 || rightBoundary == -2)
            return {-1, -1};
        else if (leftBoundary == rightBoundary)
            return {-1, -1};
        else
            return {leftBoundary, rightBoundary - 1};
        
    }
};

双指针

283. 移动零

比较经典的一道题目,之前做过。

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow = 0;
        for (int fast = 0; fast < nums.size(); fast++){
            if (nums[fast] == 0){
                continue;
            }
            int temp = nums[fast];
            nums[fast] = nums[slow];
            nums[slow] = temp;
            slow++;
        }
    }
};

Day 2 习题

滑动窗口

904. 水果成篮

思路类似标准题。

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        if (fruits.size() == 1)
            return 1;
        int maxLength = 0;
        int currentLength = 1;
        int left = 0;
        int right = 1;
        int firstType = fruits[0];
        //找到第二种果子的起始位置并记录
        while (right < fruits.size() && fruits[right] == firstType){
            right++;
            currentLength++;
        }
        if (right == fruits.size())
            return currentLength;
        int secondType = fruits[right];
        for (; right < fruits.size(); right++){
            //符合两种果子的要求时,不断增加长度
            if (fruits[right] == firstType || fruits[right] == secondType){
                currentLength += 1;
                continue;
            }
            //遇到第三种果子,记录本次采摘总数,并和最长历史纪录作比较
            maxLength = max(currentLength, maxLength);
            //重置总长度,更新果子种类,并由后向前地对新第一种果子的数目进行统计,以作为新长度的一部分
            int newLeft = right - 1;
            firstType = fruits[newLeft];
            secondType = fruits[right]; 
            currentLength = 1;
            while(fruits[newLeft--] == firstType)
                currentLength += 1;   
        }
        return max(maxLength, currentLength);
    }
};

Day 3 链表Part 1

链表理论基础

注意释放内存:

ListNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;

203. 移除链表元素

不使用虚拟头节点时,头指针需要和后面的循环分开判断。
使用虚拟头节点:

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0, head);

        ListNode* cur = dummyHead;
        while (cur->next != NULL)
        {
            if (cur->next->val == val)
            {
                ListNode* tmp = cur->next;   
                cur->next = cur->next->next;
                delete tmp;
            }
            else
                cur = cur->next;
        }
        //注意删除虚拟头
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }

707. 设计链表

照着网站上的答案敲了一遍,涉及到index与size判断的地方,有时思路不够清晰,容易马虎。对于一个链表结构所包含的节点结构体、哑头、链表大小及常规操作需要再熟悉。


206. 反转链表

首先比较简单直接的想法是,想要反转某一个节点,则必须同时记录其前面一个节点和后面一个节点,算上它自己,共三个节点。对于链表长度不足三个节点的情况,分情况讨论:

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre;
        ListNode* cur;
        ListNode* nxt;
        //在反转时,一定同时需要储存三个节点。首先考虑节点数小于三个的情况
        if (head == NULL)
            return NULL;
        if (head->next == NULL)
            return head;
        if (head->next->next == NULL){
            cur = head->next;
            cur->next = head;
            head->next = NULL;
            return cur;
        }
        //节点数大于三个时,逐步遍历,停止条件为下一个端点为空。
        pre = head;
        cur = head->next;
        nxt = cur->next;
        head->next = NULL;
        while (nxt){
            cur->next = pre;
            pre = cur;
            cur = nxt;
            nxt = nxt->next;
        }
        //当下一个端点为空时退出循环。此时最后一个节点仍未反转,因此要单独处理一步。
        cur->next = pre;
        return cur;
    }
};

上面的方法显然很不简练,下面考虑对不同情况进行归并。

  1. 当整个链表只有两个节点时,下一个节点为空,这种情况就是循环退出时的情况,所以并不需要对这种情况单独讨论,可以直接删掉。
  2. 链表为空或只有一个节点的情况,都可以直接返回head,因此前两个if判断可以合并为一个;
  3. 在最开始定义三个节点时就可以直接给它们赋值。

整理后的代码如下:

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL || head->next == NULL)
            return head;
        ListNode* pre = head;
        ListNode* cur = head->next;
        ListNode* nxt = cur->next;
        head->next = NULL;
        while (nxt){
            cur->next = pre;
            pre = cur;
            cur = nxt;
            nxt = nxt->next;
        }
        cur->next = pre;
        return cur;
    }
};

代码简洁了不少,但是循环结束还要额外进行一步处理,不太漂亮。考虑循环的终止条件,造成最后要额外处理一步的原因是:当指向下一个节点的指针为NULL时,就需要停止,否则下一次循环再寻找节点时NULL->next无意义会报错,而这时最后一个节点还没处理。
因此考虑怎么让最后一个当前节点先处理完再做终止判断。此时想到:循环终止条件可以为当前节点而不是下一个节点,换句话说,不是将三个节点同时向后移,而是先移动当前节点,等确认了当前节点存在后,再访问其下一个节点
按照这个思路的代码修改如下,可以发现此时nxt节点的定义并没有一开始给出,而是移到了循环判断中。另外,发现单节点链表的情况同样可以归并到循环内。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == NULL)
            return head;
        ListNode* pre = head;
        ListNode* cur = head->next;
        ListNode* nxt;
        head->next = NULL;
        while (cur){
            nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }
};

反思:为什么一开始没有想到用cur做循环判断而是用了nxt呢?原因是当我最开始想到必须用三个变量来储存节点时,我就把它们三个的地位平等地看待,脑海中的画面也一直是三个指针向后推进直到链表尾部,自然就会想到用nxt节点做终止判断。而实际上nxt指针只是一个附属性的存在,它只负责存储节点,而并不进行实际的操作。这也是为什么标准答案中将其取名为tmp。进一步地,同样prev也只负责存储节点而不进行实际操作,为什么给人感觉它的地位比nxt高?是因为在链表开头下意识地让它指向了head,cur没办法作为一个独立的指针对每一个节点都做处理。因此考虑让cur直接指在head的位置,prev置于NULL,这样连最开始的判断都省去了,得到最终版本:

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = NULL;
        ListNode* cur = head;
        ListNode* nxt;
        while (cur){
            nxt = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nxt;
        }
        return pre;
    }
};

反思:将当前节点作为中心,让它遍历整个链表的每一个节点,以这种思路去切入,可能会得到更通用和精简的解答。


C++语法

数组用花括号表示,如 {-1, 2, 3}。


总结

还没上道儿。

你可能感兴趣的:(链表,数据结构,算法)