代码随想录算法训练营第3天 | 203.移除链表元素、707.设计链表、206.反转链表

代码随想录算法训练营第3天 | 203.移除链表元素、707.设计链表、206.反转链表

203.移除链表元素

题目链接：203.移除链表元素

解题思路

该题主要需要考虑的是要删除节点的位置，即要删除的节点是否是头节点，为了统一删除操作，可以采用虚拟头节点的方式，需要注意的是使用C++时需要手动清理内存。

代码实现

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) {
                ListNode* tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            } else {
                cur = cur->next;
            }
        }
        head = dummyHead->next;
        delete dummyHead;
        return head;
    }
};

题目总结

给链表添加虚拟头节点并将其设为新的头节点，此时删除旧头节点的方式便和删除链表中的其它节点方式一样，可以很好的简化链表问题。

707.设计链表

题目链接：707设计链表

解题思路

在单双链表的选择上，使用了单链表，整个链表的属性包含链表的长度 size，默认值为0，以及虚拟头节点 dummyHead，方便后续的操作。

MyLinkedList() {
        dummyHead = new LinkedNode(0);
        size = 0;
    }
private:
    LinkedNode* dummyHead;
    int size;

代码实现

获取链表第 index 个节点的值，索引无效，返回-1。注意这里的index从0开始。

int get(int index) {
        if (index < 0 || index > (size - 1)) {
            return -1;
        }
        LinkedNode* cur = dummyHead->next;
        while (index--) {
            cur = cur->next;
        }
        return cur->val;
    }

在链表最前面插入节点，这里直接让新插入的节点指向头节点，虚拟头节点指向新插入的节点即可，注意 size 的变化。

void addAtHead(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        newNode->next = dummyHead->next;
        dummyHead->next = newNode;
        size++;
    }

在链表最后面插入节点，判断是否到达链表尾部：cur->next == NULL，注意插入后 size 变化

void addAtTail(int val) {
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = dummyHead;
        while (cur->next != nullptr) {
            cur = cur->next;
        }
        cur->next = newNode;
        size++;
    }

在链表第 index 个节点前插入一个节点，若 index 大于链表长度，返回空。这里 index 为0时，则插入的节点是链表新的头节点；index 等于链表长度时，说明插入节点是链表的尾节点，插入操作要注意 size 的变化。

void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = dummyHead;
        while (index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        size++;
    }

删除链表的第 index 个节点，这里 index 从0开始，大于等于链表长度则直接返回，删除操作 size 要减一，同时注意手动释放内存。

void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        LinkedNode* cur = dummyHead;
        while (index--) {
            cur = cur->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        size--;
    }

整体代码：

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 < 0 || index > (size - 1)) {
            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;
        }
        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) {
            return;
        }
        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;
};

题目总结

• 注意内存的释放
• 判断 index 的范围
• 采用虚拟头节点

206.反转链表

题目链接：206.反转链表

解题思路

• 双指针法

定义一个 cur 指针指向头节点，再定义一个 pre 指针，初始化为 NULL 。使用 tmp 指针保存 cur->next 节点，改变 cur->next 指向，将 cur->next 指向 pre。循环执行以上逻辑，移动 pre 和 cur 指针。

• 递归法

递归三部曲：

1.确定递归函数的参数和返回值，本题就是 pre 和 cur 指针；
2.确定终止条件：节点为空
3.确定单层递归的逻辑：将 cur 指向 pre

代码实现

双指针法

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

递归法

class Solution {
public:
    ListNode* reverse(ListNode* pre, ListNode* cur) {
        if (cur == nullptr)
            return pre;
        ListNode* tmp = cur->next;
        cur->next = pre;
        return reverse(cur, tmp);
    }

    ListNode* reverseList(ListNode* head) { return reverse(nullptr, head); }
};

题目总结

两种方法逻辑相同，主要还是对 cur 和 pre 指针的操作。