Day3|203.移除链表元素、707.设计链表、206.反转链表

LeetCode 203 移除链表元素

题目链接：203. 移除链表元素 - 力扣（LeetCode）

视频链接：手把手带你学会操作链表 | LeetCode：203.移除链表元素_哔哩哔哩_bilibili

思路

前提需要了解一些链表的基础，链表与数组的区别。链表分为单链表和双链表和循环链表。

单链表：是一种通过指针串联在一起的线性结构，每个节点由数据域和指针域组成。

如图所示：

 链表的入口节点称为链表的头节点（head），最后一个结点的指针域指向空指针（null） 

双链表：每个节点有两个指针域，一个指向上一个节点一个指向下一个节点，可以前后查询。

如图所示：

 循环链表：链表首尾相连。

如图所示：

 链表：适合数据量不固定，需要频繁删增元素的情况。

数组：适合数据量固定，较少删增元素的情况。

203. 移除链表元素 - 力扣（LeetCode） 这道题有两种解题方法，第一个方法是从原链表上进行删除的方法，但是这个方法需要单独写一段代码来处理头节点的移除情况，因为头节点没有前一个结点，所以这种方式的逻辑不统一。第二个方法是设置一个虚拟头节点的方法，如果设置一个虚拟头节点，那么链表中所有节点的移除方式都会相同，逻辑统一了。

第一种解题方法（原链表移除的方法）

代码实现：

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        while(head != NULL && 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;
    }
};

 记得手动释放内存。

·时间复杂度：O(n)

·空间复杂度：O(1)

第二种解题方法（虚拟头节点方法）

 代码实现：

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;
            }
        }
        return dummyHead->next;
    }
};

·时间复杂度：O(n)

·空间复杂度：O(1)

LeetCode 707 设计链表

题目链接：707. 设计链表 - 力扣（LeetCode）

视频链接：帮你把链表操作学个通透！LeetCode：707.设计链表_哔哩哔哩_bilibili

思路

本题用虚拟头结点的方式来写代码，这是一道覆盖了链表常见操作的题，需要注意的是节点从零开始，第零个节点就是链表的头节点。还需要注意一下顺序，如图所示。还有一个很重要的思路就是要保证第n个节点为cur->next。

代码实现

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 > (_size - 1) || index < 0) {
            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;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = _dummyHead;
        while(index) {
            cur = cur->next;
            index--;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if (index >= _size || index < 0) {
            return;
        }
        LinkedNode* cur = _dummyHead;
        while(index--) {
            cur = cur ->next;
        }
        LinkedNode* tmp = cur->next;
        cur->next = cur->next->next;
        delete tmp;
        _size--;
    }

        void printLinkedList() {
        LinkedNode* cur = _dummyHead;
        while (cur->next != nullptr) {
            cout << cur->next->val << " ";
            cur = cur->next;
        }
        cout << endl;
    }
private:
    int _size;
    LinkedNode* _dummyHead;

};

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

·空间复杂度： O(n)

LeetCode 206.反转链表

题目链接：206. 反转链表 - 力扣（LeetCode）

视频链接：帮你拿下反转链表 | LeetCode：206.反转链表 | 双指针法 | 递归法_哔哩哔哩_bilibili

思路

反转链表其实直接把链表反转就可以，不用定义一个新链表。如图所示：

代码实现：

一、双指针法

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;
    }
};

·时间复杂度：O(n)

·空间复杂度：O(1) 

二、递归法

class Solution {
public:
    ListNode* reverse(ListNode* pre,ListNode* cur){
        if(cur == NULL) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        // 可以和双指针法的代码进行对比，如下递归的写法，其实就是做了这两步
        // pre = cur;
        // cur = temp;
        return reverse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        // 和双指针法初始化是一样的逻辑
        // ListNode* cur = head;
        // ListNode* pre = NULL;
        return reverse(NULL, head);
    }

};

·时间复杂度：O（n)

·空间复杂度：O（n）