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

力扣203.移除链表元素

题目链接/文章讲解/视频讲解：：代码随想录

思路：分两种情况处理：头结点和非头结点。对于删除头结点可以将下一个结点设为头结点或者设置一个虚拟头结点。删除非头结点则将前一个结点指向下一个结点的指针指向下下个结点。

/**
 * 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:
    ListNode* removeElements(ListNode* head, int val) {
        while(head != NULL and head->val == val){
            ListNode *tmp = head;
            head = head->next;
            delete tmp;
        }

        ListNode *cur = head;
        while(cur != NULL && cur->next != NULL)
        {
            if(cur->next->val == val)
            {
                ListNode*tmp = cur->next;
                cur->next = cur->next->next;
                delete tmp;
            }
            else{
                cur = cur->next;
            }
        }
        return head;
    }
};

力扣707设计链表

题目链接/文章讲解/视频讲解：代码随想录

思路：

1. get(index):

   • 检查索引是否在合法范围内（0 ≤ index < 链表长度）。
   • 若索引无效，返回 -1。
   • 否则，从头结点开始遍历链表，直到到达第 index 个节点，返回该节点的值。

2. addAtHead(val):

   • 创建一个新节点，其值为 val。
   • 将新节点的 next 指针指向当前的头节点。
   • 更新头节点为新节点。

3. addAtTail(val):

   • 创建一个新节点，其值为 val，且 next 指针指向 NULL。
   • 如果链表为空，则新节点直接成为头节点。
   • 否则，从头结点开始遍历链表，直到到达链表的最后一个节点。
   • 将最后一个节点的 next 指针指向新节点。

4. addAtIndex(index, val):

   • 如果 index 小于等于 0，调用 addAtHead(val)。
   • 如果 index 等于链表长度，调用 addAtTail(val)。
   • 如果 index 大于链表长度，操作无效，不插入节点。
   • 否则，从头节点开始遍历链表，找到第 index-1 个节点。
   • 创建一个新节点，其值为 val，将其插入到第 index-1 个节点和第 index 个节点之间。

5. deleteAtIndex(index):

   • 检查索引是否在合法范围内（0 ≤ index < 链表长度）。
   • 若索引无效，不执行删除操作。
   • 若索引有效，从头结点开始遍历链表，找到第 index-1 个节点，将其 next 指针指向第 index+1 个节点。
   • 若删除头节点，更新头节点为当前头节点的下一个节点。

class MyLinkedList {
public:
    struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };
    MyLinkedList() {
        _dummyHead = new LinkedNode(0);
        _size = 0;
    }

    ~MyLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur) {
            LinkedNode* tmp = cur;
            cur = cur->next;
            delete tmp;
        }
    }

    void deleteAtIndex(int index) {
        if (index < 0 || index >= _size) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        for (int i = 0; i < index; i++) {
            cur = cur->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }

private:
    LinkedNode* _dummyHead;
    int _size;
};

力扣206 反转链表

题目链接/文章讲解/视频讲解：代码随想录

思路：第一想法是获取头结点的值，插入链表末尾，然后删除头结点，对新的头结点进行相同的操作，直到链表反转。看题解用了双指针法，比我的思路简单，使用两个指针 pre 和 cur，其中 cur 指向当前节点，pre 初始化为 null。在循环中，首先保存 cur->next 节点到临时指针 tmp，然后将 cur->next 指向 pre，完成当前节点的反转，接着将 pre 移动到 cur，将 cur 移动到 tmp，直至 cur 为 null。最终返回 pre，即新的头节点。

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

指针部分基础较差，写链表题的代码有些吃力。