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

Day3 记录代码随想录

0 关于链表

链表是一种通过指针串联在一起的线性结构，通常，链表的每个节点由一个结构体实现，每一个节点由两部分组成：值和指向下一节点的指针，也被称作数据域和指针域。链表在内存中的存储是不连续的，每一个节点的地址和其他节点的地址可能离得很远，因此需要借助指针来指向下一个节点。

链表的第一个节点（head）被称作头节点或者入口节点，头节点的地址需要在定义的时候就保存住，丢失了头节点的地址整个链表都将找不到。

链表的最后一个节点的指针指向空NULL。

上面介绍的是单链表（我觉得称为单向链表更合适）顾名思义，链路方向是单向的。另外还有双链表和循环链表，不多说了，反正用的也不多，用到再说。

生成一个链表需要先定义一个结构体，然后在结构体中定义数据变量和指向节点的指针变量，由于节点也是这种结构体，因此指针的类型就是结构体的类型。除此之外还需要定义一个构造函数以进行初始化，下面是一个链表结构体定义的例子：

//定义一个链表结构体
struct Listnode {
    int val;          //定义节点的值变量
    Listnode* next;   //定义指向下一个节点的指针
    Listnode(int x) : val(x), next(NULL) {}    //构造函数，初始化，将val初始化为x，next=NULL
};

//定义一个节点
Listnode* head = new Listnode(100); //定义一个节点，并初始化值为100，head->next默认为NULL

Listnode* prehead = new Listnode(10);
prehead->next = head;    //将节点prehead链接到head前面

第一题 力扣203 移除链表元素

题意：删除链表中等于给定值 val 的所有节点。

示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]

示例 2： 输入：head = [], val = 1 输出：[]

示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]

题目链接：力扣题目链接

解题思路：对于一个链表来说，如果想要移除一个节点B，只需要将上一节点A的指针变量指向下一节点C，就会自动把节点B从这个链表中断开。

在C++中，移除的节点需要用delete指令将内存释放，否则该节点会持续保存在内存里，浪费空间。

在本题中，需要注意一个特殊情况是，如果要删除的节点是头节点的话，因为头节点是没有上一节点的，只需要将头节点往后移一位，然后返回新的头节点地址就可以了。

从原链表删除元素

代码如下：

/**本题自带结构体定义
 * 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) {
        // 删除非头结点
        ListNode* cur = head;        //先定义一个指针，指向当前节点
        while (cur != NULL && cur->next != NULL) {    
//判断遍历循环条件，当当前节点cur的下一节点地址为空时，说明已到达最后一个节点，遍历结束。当head为空或者所有节点的值都是val时就会出现cur==NULL，此时需要跳出循环。
            if (cur->next->val == val) {    //判断cur的下一节点的值是否为val
                ListNode* tem = cur->next;    //定义一个临时指针来存储cur下一节点的地址
                cur->next = cur->next->next;    //将cur的下一节点设置为原来的下下节点
                delete tem;         //将本来的下一节点内存释放掉
            } else
                cur = cur->next;    //当前节点不符合条件时，cur遍历到下一个节点
        }
        // 删除头结点
        while (head != NULL && head->val == val) {
            ListNode* tem = head;
            head = head->next;
            delete tem;
        }
        return head;        //返回头节点
    }
};

在这个代码中，需要判断要删除的节点是不是头节点，比较麻烦。

虚拟头节点

更通用简洁一点的做法是定义一个虚拟头节点vhead，指向头节点，由此只需要从vhead开始遍历，遇到符合条件的就删除即可，最后返回值为vhead->next。

代码如下：

/**
 * 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) {
        ListNode* vhead = new ListNode(0);  //设置一个虚拟头结点
        vhead->next = head; //虚拟头结点的下一个设置为头结点
        ListNode* cur = vhead;
        while ( cur != NULL && cur->next != NULL ) {
            if ( cur->next->val == val ) {
                ListNode* tem = cur->next;
                cur->next = cur->next->next;
                delete tem;
            }
            else 
                cur = cur->next;
        }
        head = vhead->next;
        delete vhead;
        return head;
    }
};

第二题 力扣 707. 设计链表

在链表类中实现这些功能：

• get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
• addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
• addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
• addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val  的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
• deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。

题目链接：力扣题目链接

题解：

本题就是实现链表的基本功能，包括，定义链表结构体，链表初始化，查询节点，删除特定节点，在特定位置增加节点。

定义和删除上题已经说过了，下面简单说一下其他部分。

初始化链表

初始化链表：主要是需要初始化虚拟头结点vhead，以便后续将其链接到头节点并不丢失链表，还需要初始化链表长度length。

有必要说明的是，vhead和length需要在类中定义。

//初始化
MyLinkedlist() {
    vhead = new Linknode(0);
    length = 0;
}

private:
    Linknode* vhead;
    int length;

 查询节点

查询节点需要做的是依据给出的Index值，将cur移动到对应的节点，再返回节点的值即可。

代码如下：

//查询节点
int get ( int Index) {
    Linknode* cur;
    cur = vhead->next;

    if( Index > length -1 || Index < 0) {    //判断Index是否在链表范围内
        return -1;
    }
    
    while( Index-- ) {    //每次cur后移一位，Index减一，当Index减到0时，一共减了Index次，循环了Index次，在最后一次判定时，cur从第0节点（vhead）移动到第Index节点，刚好符合题意
        cur = cur->next;    
    }
    return cur->val;    //直接返回当前节点的值
}

一定注意Index与cur的关系，Index是第几节点，cur是下标，在有虚拟头节点的时，cur==Index，在没有虚拟头节点时，cur ==Index-1，尤其是在添加节点时，十分容易弄错。

全部代码如下：

class MyLinkedList {
public:
    //定义一个链表节点结构体
    struct Linknode {
        int val;    //定义节点的值
        Linknode* next;
        Linknode( int val ): val( val ), next(NULL){}
    };

    MyLinkedList() {
        vhead = new Linknode(0);    //虚拟头节点
        length = 0;   //链表的长度
    }
    //获取下标index节点的值
    int get(int index) {
        if ( index > (length - 1) || index < 0 ) {  //如果index不在范围内则返回-1
            return -1;
        }
        Linknode* cur = vhead->next;    //将当前节点设置为虚拟头节点的下一个，即头节点
        while ( index-- ) {             //如果没到第index个节点，cur移向下一个
            cur = cur->next;
        }
        return cur->val;
    }
    //添加头结点
    void addAtHead(int val) {
        Linknode* Newnode = new Linknode(val);
        Newnode->next = vhead->next;
        vhead->next = Newnode;
        length++;
    }
    //添加尾节点
    void addAtTail(int val) {
        Linknode* Newnode = new Linknode(val);
        Linknode* cur = vhead;
        while ( cur->next != NULL ) {
            cur = cur->next;
        }
        cur->next = Newnode;
        length++;
    }
    //在下标Index前添加节点
    void addAtIndex(int index, int val) {
        if ( index > length  || index < 0 )
            return;
        Linknode* Newnode =new Linknode(val);

        if ( index == 0 ) {
            Newnode->next = vhead->next;
            vhead->next = Newnode;
            length++;
        }
        else {
            Linknode* cur = vhead;
            while ( index-- ) {
                cur = cur->next;
            }
            Newnode->next = cur->next;
            cur->next = Newnode;
            length++;
        }
    }
    //删除第index下标节点
    void deleteAtIndex(int index) {
        if( index < 0 || index > (length - 1) )
            return;
        else if( index == 0 ) {
            Linknode* tem = vhead->next;
            vhead->next = vhead->next->next;
            delete tem;
            tem = NULL;
            length--;
        }
        else {
            Linknode* cur = vhead;
            while ( index-- ) {
                cur = cur->next;
            }
            Linknode* tem = cur->next;
            cur->next = cur->next->next;
            delete tem;
            tem = NULL;
            length--;
        }

    }
private:
    Linknode* vhead;
    int length;

};

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList* obj = new MyLinkedList();
 * int param_1 = obj->get(index);
 * obj->addAtHead(val);
 * obj->addAtTail(val);
 * obj->addAtIndex(index,val);
 * obj->deleteAtIndex(index);
 */

第三题 力扣206. 反转链表

反转一个单链表。

示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL

题目链接：力扣题目链接

对于这个题，第一时间想到的是生成一个新的链表，从旧链表的第一个开始，依次作为新链表的头部，就是一个循环添加头节点的过程，工作量相对来说也不算多，但是因为要用到两个链表，会很浪费储存空间。

双指针

一种办法是使用双指针，pre 和 cur ，其中cur用来指向当前节点，并依次向后移动，pre用来存储改变后应该指向的节点。同时需要定义一个临时指针tem，用来在转换过程中存储地址，防止地址丢失。

代码如下：

/**
 * 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* reverseList(ListNode* head) {
        ListNode* pre = NULL;
        ListNode* cur = head;
        ListNode* tem;
        while (cur) {
            tem = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tem;
        }
        return pre;
    }
};

递归

对于双指针的思想，可以转化为递归的思想，主要是使用递归函数替换了pre=cur；cur=tem；

实现代码如下：

/**
 * 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* reverseone(ListNode* pre, ListNode* cur) {
        if (cur == NULL)
            return pre;
        ListNode* tem = cur->next;
        cur->next = pre;

        //这一步实际上就是替换了pre=cur；cur=tem；
        return reverseone(cur, tem);
    }

    ListNode* reverseList(ListNode* head) { 
        return reverseone(NULL, head); 
    }
};

递归的思想相当考验逻辑能力，递归和循环可以相互实现，使用递归可使代码更简洁，构造递归函数时，对应循环，需要首先考虑循环的初始值，对应递归函数的参数，然后需要考虑循环结束的条件，对应递归的返回值，然后就是一层循环结束以后，第二层循环各个量的关系，对应二次调用递归函数的参数。

今日心得：链表相对来说好理解，相关代码也不算难，对于基础比较差的我来说，今天碰到的困难主要集中在C++语法不熟练，比如结构体的定义，结构体中构造函数的定义以及初始化内容； struct->next 用法是用在指向结构体的指针中，而struct.next用在结构体变量中；类中的构造函数用法、概念和功能不清晰，需要多练习加深印象；递归思想很重要，需要多多思考。