力扣题（链表篇）

W起名有点难

已于 2023-09-22 08:17:41 修改

阅读量63

点赞数

分类专栏：力扣文章标签： leetcode 链表算法

于 2023-09-18 10:23:19 首次发布

本文链接：https://blog.csdn.net/qq_44807946/article/details/132879896

版权

力扣专栏收录该内容

5 篇文章 0 订阅

订阅专栏

链表

移除链表元素

力扣题目链接：203.移除链表元素

题目描述
题意：删除链表中等于给定值 val 的所有节点。
在这里插入图片描述
思路及讲解视频
链表基础操作| LeetCode：203.移除链表元素
 代码随想录：移除链表元素
C++代码

直接使用原来的链表来进行移除节点操作：

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->next != NULL){
            if(cur->next->val == val){
                cur->next = cur->next->next;
            }else cur = cur->next;
        }
        return dummyhead->next;
    }
};

707.设计链表

力扣题目链接
在链表类中实现这些功能：

get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。
addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。
addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。
addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。如果 index 大于链表长度，则不会插入节点。如果index小于0，则在头部插入节点。
deleteAtIndex(index)：如果索引 index 有效，则删除链表中的第 index 个节点。
讲解视频链接：
帮你把链表操作学个通透！LeetCode：707.设计链表
代码随想录题解思路：
思路
C++代码：

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，则在头部插入节点
   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;
       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;
       //delete命令指示释放了tmp指针原本所指的那部分内存，
       //被delete后的指针tmp的值（地址）并非就是NULL，而是随机值。也就是被delete后，
       //如果不再加上一句tmp=nullptr,tmp会成为乱指的野指针
       //如果之后的程序不小心使用了tmp，会指向难以预想的内存空间
       tmp=nullptr;
       _size--;
   }

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

};

206.反转链表

题目描述
题意：反转一个单链表。
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
题目链接
反转链表
C++代码
两种写法：
1、双指针
定义一个cur指针指向头结点，pre指针指向NULL，开始反转
cur->next用temp存一下，cur的next指向pre，pre指向cur的位置，cur指向temp，从左往右将链表反转。

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

2、递归
递归有点不太明白

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

};

24.两两交换链表中的节点

题目描述
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
在这里插入图片描述
看了一下代码随想录给出的讲解视频：帮你把链表细节学清楚！ | LeetCode：24. 两两交换链表中的节点
尝试自己写了一下伪代码：

//使用虚拟头结点
cur = dummyhead;
temp = cur->next;
cur->next = cur->next->next;
cur = temp;

看完后面的解答之后，发现自己忘了处理交换之后的操作，也没有遍历链表，链表的遍历条件也没考虑到，还需要再接再厉啊
思路
定义一个虚拟头结点，交换两个相邻的节点，看图比较直观：
在这里插入图片描述
根据思路写出的代码：
遍历链表的条件怎么得出的呢？主要考虑两种情况：（1）链表的节点数为奇数，cur->next->next=NULL的时候，遍历结束；（2）链表的节点数为偶数，cur->next=NULL的时候，遍历结束。（空链表包括在偶数节点这里了）

dummyhead->next = head;
cur = dummyhead;
while(cur->next != NULL && cur->next->next != NULL){
	temp = cur->next;
	temp1 = cur->next->next;
	cur->next = cur->next->next;
	cur->next->next = temp;
	temp->next = temp1;
	cur = cur->next->next;
}
return dummyhead->next;

C++代码

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* dummyhead = new ListNode();
        dummyhead->next = head;
        ListNode* cur = dummyhead;
        while(cur->next != NULL && cur->next->next != NULL){
            ListNode* temp1 = cur->next;
            ListNode* temp2 = cur->next->next->next;
            cur->next = cur->next->next;//开始交换了
            cur->next->next = temp1;//节点2指向节点1
            temp1->next = temp2;//节点1指向节点3
            cur = cur->next->next;//cur节点向后移两位
        }
        return dummyhead->next;
    }
};

19.删除链表的倒数第N个节点

题目描述
力扣题目链接
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
在这里插入图片描述
讲解视频及思路
链表遍历学清楚！ | LeetCode：19.删除链表倒数第N个节点
本题的关键在于找到倒数第n个节点，使用fast和slow指针进行操作，1）fast先移动n+1步，2）fast和slow同时移动，3）fast指向空节点时，slow指向的是待删除节点的前一节点，此时进行删除操作，C++要手动释放内存空间。
上图比较清晰，算了，直接上代码随想录的链接嘿嘿：
链接: 代码随想录：思路
C++代码

class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummyhead = new ListNode(0);//new一个虚拟头结点
        dummyhead->next = head;
        ListNode* fast = dummyhead;
        ListNode* slow = dummyhead;
        n++;
        while((n--) && (fast != NULL)){//fast指针移动n+1
            fast = fast->next;
        }
        while(fast != NULL){//fast指针和slow指针同时移动
            fast = fast->next;
            slow = slow->next;
        }
        //此时slow指针指向的是待删除节点的前一节点
        ListNode* temp = slow->next;
        slow->next = slow->next->next;
        delete temp;//释放内存空间
        return dummyhead->next;//返回头节点
    }
};

总结

链表的理论基础
链表的种类：单链表，双链表，循环链表
链表的存储方式：节点在内存中是分散存储的，通过指针连在一起
链表的增删改查
学会利用虚拟头结点解决问题

链表篇就到这儿啦~

W起名有点难

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
力扣题（链表篇）

主要考虑两种情况：（1）链表的节点数为奇数，cur->next->next=NULL的时候，遍历结束；给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。cur->next用temp存一下，cur的next指向pre，pre指向cur的位置，cur指向temp，从左往右将链表反转。看完后面的解答之后，发现自己忘了处理交换之后的操作，也没有遍历链表，链表的遍历条件也没考虑到，还需要再接再厉啊。示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL。
复制链接

扫一扫