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

一、203.移除链表元素

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

文章讲解：代码随想录

两种操作方式：

• 直接使用原来的链表来进行删除操作。
• 设置一个虚拟头结点在进行删除操作。

 1.1原链表移除节点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) 
    {
        // 删除头结点
        while (head != NULL && head->val == val) // 注意这里不是if
        { 
            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;
    }
};

 1.2设置虚拟头结点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyHead = new ListNode(0);
        dummyHead->next = 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;
    }
};

• 时间复杂度: O(n)
• 空间复杂度: O(1)

 

二、707.设计链表

LeetCode题目链接：707.设计链表

文章讲解：代码随想录

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;
            index--;
        }
        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;
        if(index < 0) index = 0; 
        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;
        tmp=nullptr;
        _size--;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

时间复杂度: 涉及 index 的相关操作为 O(index), 其余为 O(1)
空间复杂度: O(n) 

三、206.反转链表

LeetCode题目链接：206.反转链表

文章讲解：代码随想录

 3.1双指针法

 思考：通过cur指针、pre指针和临时的tmp指针可以实现链表的反转

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

• 时间复杂度: O(n)
• 空间复杂度: O(1)

3.2递归法

思考： 递归法和双指针法是一样的逻辑，不过在比较关键的初始化的写法变了。

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

• 时间复杂度: O(n), 要递归处理链表的每个节点
• 空间复杂度: O(n), 递归调用了 n 层栈空间