代码随想录 day03

203.移除链表元素

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;
            }
        }
        // 此处一定要返回 dummyHead->next
        // 因为如果只有一个节点，即头节点，被删除，却以返回 head
        // 则这种情况下，相当于没有删除头节点
        return dummyHead->next;
    }
};

707.设计链表

// 单链表
class MyLinkedList {
public:
    // 定义链表结构体
    struct LinkedNode {
        int val;
        LinkedNode* next;

        // 构造函数，新节点的指针域默认为空
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        _dummyHead = new LinkedNode(0); // 使用虚拟头节点进行操作
        _size = 0;
    }

    // 获取指定位置节点的数值
    // 注意：index 从 0 开始，第 0 个节点就是头节点
    int get(int index) {
        // index 从 0 开始，因此 index > (_size - 1)
        if (index < 0 || index > (_size - 1)) {
            return -1;
        }

        LinkedNode* cur = _dummyHead->next; // 此处体现的第 0 个节点就是头节点
        while (index > 0) { // 如果 --index 将会陷入死循环
            index--;
            cur = cur->next;
        }
        return cur->val;
    }

    // 在链表头部添加节点
    void addAtHead(int val) {
        LinkedNode* newHead = new LinkedNode(val); // 创建新节点

        // 以下两步不能颠倒
        newHead->next = _dummyHead->next;
        _dummyHead->next = newHead;

        _size++; // 增大链表的大小
    }

    // 在链表尾部添加节点
    void addAtTail(int val) {

        // 不用再为 newTail 的指针域赋值为 nullptr 因为有参构造中已经默认节点的指针域为空
        LinkedNode* newTail = new LinkedNode(val); // 不用再为 newTail 的指针域赋值为 nullptr 因为有参构造中已经默认节点的指针域为空
        LinkedNode* cur = _dummyHead;

        // 找到链表的最后一个节点
        while (cur->next != nullptr) {
            cur = cur->next;
        }

        cur->next = newTail;
        _size++;
    }

    // 在链表指定位置插入节点
    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则置为0，作为链表的新头节点。
    void addAtIndex(int index, int val) {
        // 此处由于 leetcode 对 index 的范围有限制 > 0 && < 1000
        // 因此不会出现 index < 0 的情况
        if (index < 0 || index > _size) {
            return;
        }

        // 注意：newNode 的插入位置 cur 与 cur->next 之间
        // 因此要使第 0 个节点为 _dummyHead
        LinkedNode* cur = _dummyHead;
        while (index > 0) {
            index--;
            cur = cur->next;
        }

        LinkedNode* newNode = new LinkedNode(val);

        // 以下两步不能颠倒
        newNode->next = cur->next;
        cur->next = newNode;

        _size++;
    }

    // 删除链表的指定节点
    void deleteAtIndex(int index) {
        if (index < 0 || index > (_size - 1)) {
            return;
        }

        // 注意：需要删除的节点是 cur->next
        // 因此需要找到 cur 即应该使第 0 个节点为 _dummyHead
        LinkedNode* cur = _dummyHead;
        while (index > 0) {
            index--;
            cur = cur->next;
        }

        LinkedNode* temp = cur->next;
        cur->next = cur->next->next;
        delete temp;
        _size--;
    }

    // 打印链表
    void printfLinkedNode() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size; // 当前链表元素个数
    LinkedNode* _dummyHead;
};

206.反转链表

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;       // 当前节点的位置
        ListNode* pre = nullptr;    // 新链表的真正头节点
        ListNode* temp = nullptr;   // 临时保存原始链表的下一个节点

        // 注意：
        // 如果循环条件为 cur->next != nullptr
        // 则 pre 可以移动到原始链表的最后一个节点，但不可以直接改变其指针域

        // 如果循环条件为 cur != nullptr
        // 则 pre 直接到达原始链表的最后一个节点的指针域，可以直接修改其指针
        while (cur != nullptr) {
            // 注意：以下四个步骤不可以颠倒
            // 画图比较容易理解
            temp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = temp;
        }
        // 注意：此时 pre 才是真正的头节点
        // 而原始链表的 head 已经成为新链表的最后一个节点
        return pre;
    }
};

小结：

1. 节点的位置 即 index 从 0 开始，明确要使哪个节点为第 0 个节点
   删除指定位置的节点时，应该使 dummyHead 为第 0 个节点，方便查找到被删除节点的前一个节点
2. 清楚什么时候使用 cur = dummyHead->next，什么时候使用 cur = dummyHead
cur = dummyHead->next 表明第 0 个节点为头节点
   cur = dummyHead 表明第 0 个节点为dummyHead
   与小结 1 配合使用
3. 在循环中什么时候使用cur != nullptr，什么时候使用cur->next != nullptr
   使用cur != nullptr 则 cur 可以到达最后一个节点的指针域
   使用cur->next != nullptr 则 cur 只可以到达最后一个节点，而无法到达其指针域