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

链表的基本概念

链表：一种通过指针串联在一起的线性结构

如图所示：

• 每一个节点由两部分组成，一个是数据域（存放数据），一个是指针域（存放指向下一个节点的指针）
• 链表的入口节点称为链表的头结点（head），最后一个节点的指针域指向null（空指针）

链表的类型

1.单链表

前文已介绍

2.双链表

• 每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点
• 可以向前查询也可以向后查询

3.循环链表

• 首尾相连的链表
• 循环链表可以用来解决约瑟夫环问题

链表的存储方式

链表在内存中不是连续分布的，参看下图：

• 链表通过指针域的指针链接在内存中各个节点
• 链表中的节点散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理

链表的定义

C/C++的定义链表节点方式：

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

链表的操作

1.删除节点

要删除A->C->D->E中的D节点，操作过程如下图：

1. 使用临时指针temp存储D节点
2. 将C节点的next指针指向E节点
3. 手动释放D节点的内存（delete）

2.添加节点

要在A->C->D->E中添加F节点，使链表变为A->C->F->D->E，操作过程如下图：

注意以下顺序不可调换：

1. 将F节点的next指向D节点（C->next）
2. 将C节点的next指针指向F节点

性能分析

将链表的特性和数组的特性进行一个对比，如下图所示：

203.移除链表元素

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

求解思路：

代码：

/**
 * 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* dummyHead = new ListNode(0); //虚拟头结点
        dummyHead->next = head; //虚拟头结点的next指向head
        ListNode* cur = dummyHead;//新建一个指针（表示当前位置）
        while (cur->next != NULL){
            if (cur->next->val == val){
                //新建一个temp，指向下一个元素（目标元素）
                ListNode* temp = cur->next; 
                //将cur指向下下个元素
                cur->next = temp->next;
                //使用temp将存储目标元素的内存释放
                delete temp;
            }
            else 
                cur = cur->next;//cur指针后移一位
        }
        return dummyHead->next; //实际的头结点是虚拟头结点的下一个
    }
};

707.设计链表

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

求解思路：

元素的删除在上文已介绍。

元素的插入见下图：

代码：

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;
        }
        return cur->val;
    }
    //在第一个元素之前插入节点
    void addAtHead(int val) {
        //新建一个节点，值为val
        LinkedNode* newNode = new LinkedNode(val); 
        //将新节点的next指向第一个元素
        newNode->next = _dummyHead->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; //必须先指定new的next
        cur->next = newNode; //再指定cur的next
        _size++;
    }
    
    void deleteAtIndex(int index) {
        if (index > (_size-1) || index < 0) //合法性
            return;
        LinkedNode* cur = _dummyHead;
        while(index--){
            cur = cur->next;
        }
        LinkedNode* temp = cur->next;
        cur->next = temp->next;
        delete temp;
        _size--;
    }
private:
    int _size;
    LinkedNode* _dummyHead;
};

/**
 * 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.反转链表

题目链接：力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

求解思路：

代码：

/**
 * 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 = nullptr; //初始化为null，最后为链表的结尾
        ListNode* cur = head;
        while (cur != nullptr){
            ListNode* temp = cur->next; //temp存储cur的下一个节点
            cur->next = pre; //翻转cur的next，使其指向pre
            pre = cur; //将pre后移一位
            cur = temp; //将cur后移一位
        }
        return pre;
    }
};