代码随想录算法训练营DAY03|链表Part01|LeetCode:203.移除链表元素 、707.设计链表、206.反转链表

目录

LeetCode:203.移除链表元素 

基本思路

C++代码

LeetCode:707.设计链表

定义链表结构体

初始化链表并设置类成员变量

int get(int index)

void addAtHead(int val)

void addAtTail(int val)

void addAtIndex(int index, int val)

void deleteAtIndex(int index)

LeetCode:206.反转链表

基本思路

双指针法

C++代码

递归法

C++代码

总结

       在做链表题目之前首先应该先了解什么是链表？

LeetCode:203.移除链表元素 

力扣代码链接

文字讲解：LeetCode:203.移除链表元素 

视频讲解：链表1：移除链表元素

基本思路

        删除节点实际上就是让删除节点的上一个节点的next指针所指向的下一个节点变为删除节点的下一个节点，即如上图所示，如果要删除D节点，只要将C节点的next指针，指向E节点就可以了。但是对于C++来说，并没有如python等语言所具有的内存回收机制，因此还要需要手动对这块内存进行释放。

        而对于本题来讲，结构显然为单链表，因此如果是删除中间节点还好，但是如果是头结点怎么办呢？这个时候我们就需要引入虚拟头节点，此时如果需要删除头结点，只需要让虚拟头结点的next指针指向头结点的下一个节点即可。

C++代码

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummynode = new ListNode(0);//设置虚拟头结点
        dummynode -> next = head;
        ListNode* cur = dummynode;
        while(cur->next != nullptr){ 
            if (cur->next->val == val ){
                ListNode* temp = cur->next;
                cur->next = cur->next->next;
                delete temp;
            }else{
                cur = cur->next; //如果不是需要删除的节点，则指针后移一位
            }
        }
        head = dummynode->next;
        delete dummynode;
        return head;
    }
};

        注意：这里的while循环条件为cur->next != nullptr 而不是cur  != nullptr,这是因为cur指针指向的是需要删除节点的上一个节点。

LeetCode:707.设计链表

力扣题目链接

文字讲解：LeetCode:707.设计链表

视频讲解：链表2：设计链表

定义链表结构体

    struct LinkedNode{
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val),next(nullptr){};//构造链表节点
    };

初始化链表并设置类成员变量

    //初始化链表
    MyLinkedList() {
        _dummyhead = new LinkedNode(0);
        _size = 0;
    }
    
    // 定义类成员变量
    private:
    LinkedNode* _dummyhead;
    int _size;

int get(int index)

        获取链表中下标为 index 的节点的值。

    //获取链表中下标为index的节点的值
    int get(int index) {
        LinkedNode* cur = _dummyhead;
        if (index > (_size - 1) || index < 0){
            return -1;
        }
        while(index--){
                cur = cur->next; // 循环结束时，cur指向获取的节点的上一个节点
        }
        return cur->next->val;
    }

void addAtHead(int val)

        将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。

    void addAtHead(int val) {
        LinkedNode* newnode = new LinkedNode(val);
        newnode->next = _dummyhead->next;
        _dummyhead->next = newnode;
        _size++;
    }

      注意：一定要先让新节点的下一个节点为之前的头结点，在让虚拟头结点的下一个节点为新节点。在完成后要记得让链表大小_size加1。

void addAtTail(int val)

        将一个值为 val 的节点追加到链表中作为链表的最后一个元素。

    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)

        将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。

    void addAtIndex(int index, int val) {
        LinkedNode* newnode = new LinkedNode(val);
        LinkedNode* cur = _dummyhead;
        if (index > _size) return ;
        if (index < 0){
            index = 0;;
        }
        while (index--){ //循环结束时，cur指向插入节点的上一个节点
            cur = cur->next;
        }
        newnode->next = cur->next;
        cur->next = newnode;
        _size++;
    }

        注意：一定要区分和int get(int index)函数中的if语句判别条件（为什么这里是index > _size 而不是index > _index - 1）。

void deleteAtIndex(int index)

        如果下标有效，则删除链表中下标为 index 的节点。

void deleteAtIndex(int index) {
        LinkedNode* cur = _dummyhead;
        if (index > _size-1) return ;
        if (index < 0){
            index = 0;
        }
        while (index--){
            cur = cur->next;
        }
        LinkedNode* temp = cur->next;
        cur->next = cur->next->next;
        delete temp; //记得结束后手动释放内存
        _size--;
    }

LeetCode:206.反转链表

力扣题目链接

文字讲解：LeetCode:206.反转链表

视频讲解：链表3：反转链表

基本思路

        最简单的想法肯定是再定义一个新链表，从而实现链表的反转，但这无疑是对内存的浪费。那么我们如果需要将两个节点的方向进行翻转应该怎么做呢？只需要改变指针所指的方向即可。

        此时我们可以通过双指针法实现，也可以通过递归的方法实现。

双指针法

        因为是进行链表的反转，实际上是不需要用到虚拟头结点的，可以分别定义两个指针pre和cur，分别指向空和当前头结点，通过while循环实现反转，并且当cur指向尾节点的下一个节点时，循环结束。

C++代码

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

递归法

        递归法应该怎么想呢，刚开始接触确实不容易想到这种方法。双指针法的本质还是一个不停交换指针指向的节点的过程，我们不妨试着模拟一下前几个的过程。

ListNode* revrse(ListNode* pre,ListNode* cur){
        if (cur == nullptr) return pre; //首先设置终止条件，cur指向尾节点时停止迭代
        ListNode* temp = cur->next; 
        cur->next = pre; 
        return revrse(cur,temp);//按pre = cur,cur = temp进行迭代，从而实现指针的移动
    }

C++代码

class Solution {
public:
    ListNode* revrse(ListNode* pre,ListNode* cur){
        if (cur == nullptr) return pre;
        ListNode* temp = cur->next;
        cur->next = pre;
        return revrse(cur,temp);
    }
    ListNode* reverseList(ListNode* head) {
        return revrse(nullptr,head);
    }
};

总结

        今天的题目前两个比较简单，最后一题没有想到，特别是递归的方法很简短，但是需要很强的逻辑能力，以后需要多在这方面进行锻炼。