代码随想录训练营第三天——移除链表元素，设计链表，反转链表

已于 2023-12-22 22:54:09 修改
阅读量163 收藏
点赞数
分类专栏： leetcode训练——代码随想录 文章标签： 链表
于 2022-09-24 17:21:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39088868/article/details/127016091
版权

链表基础理论

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，数据域和指针域（存放指向下一个节点的指针），最后一个节点的指针指向null(空指针)，链表的入口节点称为链表的头节点，即head。如图所示：
链表示意图

链表的类型

单链表

单链表中的指针域只能指向节点的下一个节点，上图即为单链表

双链表

双链表的每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。因此双链表可以向前查询也可以向后查询。双链表如下图所示：
双链表示意图

循环链表

循环链表就是链表首尾相连，如下图所示：
环形链表示意图

链表的存储方式

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

链表的定义

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

如果不定义构造函数，C++默认生成一个构造函数，但这个构造函数不会初始化任何成员变量。
如果通过自己定义构造函数，初始化节点：

ListNode* head =new ListNode(0);

使用默认构造函数初始化节点：

ListNode* head=new ListNode();
head->val = 0;

如果不定义构造函数使用默认构造函数的话，在初始化的时候就不能直接给变量赋值。

链表的操作

删除节点

删除节点
删除C节点只要把B节点的指针指向D结点就可以了。此时C节点依然留在内存中，在C++中需要手动释放C节点的内存

添加节点

添加节点
链表的增添和删除的时间复杂度都是O(1)，不会影响到其他节点。但如果删除第五节点，需要从头节点查找到第四个节点通过next指针进行删除操作，查找的时间复杂度是O(n)。

性能分析

链表与数组的性能分析

leetcode 203.移除链表元素

题目链接：移除链表元素
链表移除操作，就是让节点next指针直接指向下下一个节点，由于单链表的特殊性，只能指向下一个节点，需要考虑移除的是中间节点还是头节点，因此链表的操作就存在两种方式：
（1）直接使用原来的链表进行删除操作。
（2）设置一个虚拟头节点再进行删除操作
方法一：直接使用原来的链表进行移除
移除头节点和移除其他节点的方式不一样，因为链表的其他节点都是通过前一个节点来移除，而头节点没有前一个节点。头节点的移除只需要将头节点向后移动一位就可以。

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

方法二：设置一个虚拟头节点
设置一个虚拟头节点，指向原链表的头节点，这样原链表中的所有节点就可以通过统一的逻辑进行操作。注意最后需要删除虚拟头节点，返回删除虚拟头节点后的头节点

class Solution {
public:
    ListNode* removeElements(ListNode* head, int val) {
        ListNode* dummyhead=new ListNode(0);//设置一个虚拟头节点
        dummyhead->next=head;
        ListNode* cur=dummyhead;
        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;
            }
        }
        head=dummyhead->next;   //注意需要返回删除虚拟头节点后的头节点
        delete dummyhead;
        return head;
    }
};

leetcode 707.设计链表

题目链接：设计链表
本题采用虚拟节点法，需要注意cur指针是指向虚拟头节点dummyhead还是指向dummyhead->next

class MyLinkedList {
public:
    // 定义链表节点结构体
   struct LinkedNode {
        int val;
        LinkedNode* next;
        LinkedNode(int val):val(val), next(nullptr){}
    };

    // 初始化链表
    MyLinkedList() {
        dummyHead = new LinkedNode(0); // 这里定义的头结点 是一个虚拟头结点，而不是真正的链表头结点
        size = 0;
    }

    // 获取到第index个节点数值，如果index是非法数值直接返回-1， 注意index是从0开始的，第0个节点就是头结点
    int get(int index) {
        if (index > (size - 1) || index < 0) {
            return -1;
        }
        LinkedNode* cur = dummyHead->next;
        while(index--){ // 如果--index 就会陷入死循环
            cur = cur->next;
        }
        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++;
    }

    // 在第index个节点之前插入一个新节点，例如index为0，那么新插入的节点为链表的新头节点。
    // 如果index 等于链表的长度，则说明是新插入的节点为链表的尾结点
    // 如果index大于链表的长度，则返回空
    // 如果index小于0，则置为0，作为链表的新头节点。
    void addAtIndex(int index, int val) {
        if (index > size || index < 0) {
            return;
        }
        LinkedNode* newNode = new LinkedNode(val);
        LinkedNode* cur = dummyHead;
        while(index--) {
            cur = cur->next;
        }
        newNode->next = cur->next;
        cur->next = newNode;
        size++;
    }

    // 删除第index个节点，如果index 大于等于链表的长度，直接return，注意index是从0开始的
    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--;
    }
private:
    int size;
    LinkedNode* dummyHead;

};

leetcode 206.反转链表

题目链接：反转链表

双指针法

采用两个指针cur，pre，cur指向头节点，pre初始化为NULL，通过cur指针是否为空作为循环结束的判断。同时注意是先移动pre，后移动cur。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* temp; // 保存cur的下一个节点
        ListNode* cur = head;
        ListNode* pre = NULL;
        while(cur) {
            temp = cur->next;  // 保存一下 cur的下一个节点，因为接下来要改变cur->next
            cur->next = pre; // 翻转操作
            // 更新pre 和 cur指针
            pre = cur;     //先移动pre
            cur = temp;    //后移动cur
        }
        return pre;
    }
};

递归法

递归法和双指针法是一样的逻辑，同样是当cur为空的时候循环结束，不断将cur指向pre的过程
（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);
    }
};

（2）从后往前翻转指针指向

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        // 边缘条件判断
        if(head == NULL) return NULL;
        if (head->next == NULL) return head;
        
        // 递归调用，翻转第二个节点开始往后的链表
        ListNode *last = reverseList(head->next);
        // 翻转头节点与第二个节点的指向
        head->next->next = head;
        // 此时的 head 节点为尾节点，next 需要指向 NULL
        head->next = NULL;
        return last;
    }
};

今日收获：
1.进一步熟悉了链表的基本数据结构及相关基础理论
2.学习了利用虚拟节点完成链表的增删改查
3.反转链表的两种方法：双指针法，递归法。

荒野饮冰室
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值