链表篇习题：移除链表元素、翻转链表、两两交换链表中的节点、删除链表中倒数第N个节点、链表相交、环形链表||

已于 2023-07-28 21:27:44 修改
阅读量144 收藏
点赞数
分类专栏： #代码随想录学习打卡 文章标签： 链表 数据结构
于 2023-03-30 22:09:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/evildoerxmf/article/details/129824804
版权

2.2移除链表元素

例题1（题目203）给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点
示例

/**
 * 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) {
			if (head == NULL)
	{
		return NULL;
	}
	struct ListNode* dummy=new ListNode(0);//创建头节点前的虚节点
	dummy->next = head;//指向头节点
	ListNode* cur = dummy;
	while (cur->next!= NULL)
	{
		if (cur->next->val == val)
		{
			ListNode* temp = cur->next;
			cur->next = cur->next->next;
			free(temp);//释放内存
		}
		else
		{
			cur = cur->next;
		}
	}
	return dummy->next;
};

删除节点涉及两种方式：
①直接使用原链表进行删除
删除头节点元素1，与中间节点不同，需要单独列一种情况，将头节点后移移位，再将原头节点从内存中删掉
删除头节点
移除头节点
删除头节点
②设置一个虚拟头节点进行删除
新建一个虚节点为新的头节点，头节点与其他节点删除方式统一了，return dummy node->next为新链表的头节点
移除头节点

2.3 设计链表

例题1（707题）你可以选择使用单链表或者双链表，设计并实现自己的链表。
单链表中的节点应该具备两个属性：val 和 next 。val 是当前节点的值，next 是指向下一个节点的指针/引用。
如果是双向链表，则还需要属性 prev 以指示链表中的上一个节点。假设链表中的所有节点下标从 0 开始。
实现 MyLinkedList 类：
MyLinkedList() 初始化 MyLinkedList 对象。
int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。
采用虚节点方式会比直接在链表上操作更简单

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

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

2.4翻转链表

例题1（206题）给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
翻转链表
可以迭代和递归解决链表的翻转问题（学习递归思想）

//① 双指针法
ListNode* Solution1::reverseList(ListNode* head) {
	if (head == NULL)
	{
		return NULL;
	}
	//用一个节点存储前一个，一个节点存储后一个
	ListNode* cur = head;//当前节点
	ListNode* pre = nullptr;//前一节点
	ListNode* behind ;//当前后一个节点
	while (cur != nullptr)
	{
		behind = cur->next;
		cur->next = pre;
		pre = cur;
		cur = behind;
	}
	return pre;
}

//② 递归法
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);
	}

//③ 新建虚头结点使用头插法
public class ListNode reverseList1(ListNode* head)
{
	ListNode* dummyHead = new ListNode(-1);
dummyHead->next = nullptr;
ListNode* cur = head;
while (cur != nullptr)
{
	ListNode* temp = cur->next;
	//头插法
	cur->next = dummyHead->next;
	dummyHead->next = cur;
	cur = temp;
}
return dummyHead->next;
}

//使用栈解决链表翻转：栈后进先出，依次加入头节点后

public ListNode reverseList(ListNode* head) {
	Stack<ListNode> stack = new Stack<>();//新建栈
	ListNode* cur = head;
	while (cur != nullptr)//将链表节点入栈
	{
		stack.push(cur);
		cur = cur->next;
	}
	ListNode* dummyHead = new ListNode(0);
	dummyHead->next = nullptr;
	ListNode* cur = dummyHead;
	while (!stack.isempty())//将栈中元素推出依次添加在链表后
	{
		ListNode* node = stack.pop();
		cur->next = node;
		cur = cur->next;
	}
	cur->next = nullptr;//最后一个元素的next赋值为空
	return dummyHead->next;
}

2.5 两两交换链表中的节点

例题1（24题）给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即，只能进行节点交换）。
示例

/**
 * 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* swapPairs(ListNode* head) {
if (head == nullptr || head->next == nullptr)
	{
		return head;
	}
	//建立虚头结点，用双指针两两将节点添加在头节点后
	ListNode* dummyHead = new ListNode(0);
    dummyHead->next=head;
	ListNode* cur = dummyHead;
	while (cur != nullptr && cur->next!=nullptr) {            //注意cur和cur->next都不能为空
        ListNode* p = cur->next;
		ListNode* q = p->next;                 //如果没有cur->next不为空这个条件，q无指向
		if (q != nullptr){
            ListNode* t=q->next;         
			cur->next=cur->next->next;           //等于cur->next=q;
            cur->next->next=p;                     //不等于q->next-p；没有把cur带动起来
            cur->next->next->next=t;           //不等于p->next=t；没有带动cur
            cur=cur->next->next;                 //不等于cur=p；两者相同是，牵一发动全身
		}
		else {
            cur->next = p;
            cur=cur->next;
		}
	}
    cur->next=nullptr;
	return dummyHead->next;
    }
};

2.6删除链表中倒数第N个节点

例题1（19题）给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例

//想找到链表的节点数目，再换算成正数要删除的位置。该方法不是在一次循环里解决。
/**
* 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* removeNthFromEnd(ListNode* head, int n) {
   if (head == nullptr || (head->next==nullptr && n==1))
   {
   	return nullptr;
   }
   ListNode* dummyHead = new ListNode();
   dummyHead->next = head;
   ListNode* cur = dummyHead;
   int sz = 0;
   while (cur->next != nullptr)
   {
   	sz++;
   	cur = cur->next;
   }
   ListNode* p =dummyHead;
   for (int i = 1; i <= sz; i++)
   {
   	if (i ==( sz - n + 1))
   	{
   		ListNode* t = p->next;
   		p->next = p->next->next;
   		delete t;
   		break;
   	}
   	else {
   		p = p->next;
   	}
   }
   return dummyHead->next;
   }
};

2.7 链表相交

例题1（面试题02.07）给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
示例
相交指的不是值相同，而是指针所指的位置相同。
先找到AB链表的长度，后主要是找到AB长度相同开始的位置，如果A的长度>B的长度，则将A移动到与B一样长的位置处，反之亦然。找到同时开始的位置后，两指针同时向后移动，直到找到指针所指位置相同处。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
      	ListNode* dummyHead1 = new ListNode();
	dummyHead1->next = headA;
	ListNode* dummyHead2 = new ListNode();
	dummyHead2->next = headB;
	int sza = 0, szb = 0, d;
	ListNode* q = dummyHead1;
	ListNode* p = dummyHead2;
	while (q->next != nullptr)
	{
		sza++;
		q = q->next;
	}
	q = headA;
	while (p->next != nullptr)
	{
		szb++;
		p = p->next;
	}
	p = headB;
	d = (sza - szb) >= 0 ? (sza - szb) : (szb - sza);
	while (d > 0 )
    {
    if(sza>=szb)
	{
		q = q->next;
		d--;//-1
	}
    else{
        p=p->next;
        d--;
    }
    }
	while (q != p && q!=nullptr)
	{
		q = q->next;
		p = p->next;
	}
    if(q == nullptr)  {
		return nullptr;
	}
	else {
		return q;
	}
    }
};

2.8 环形链表||

例题1（142题）给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。不允许修改 链表。
示例

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *detectCycle(ListNode *head) {
        int pos=-1;
        ListNode* dummyHead=new ListNode();
        dummyHead->next=head;
        ListNode* cur=dummyHead->next;
        unordered_map<ListNode*,int> position;//哈希表中保存节点的地址，地址为指针类型
        while(cur!=nullptr)
        {
            position[cur]++;//把链表节点位置存入哈希表
            auto it=position.find(cur);//找到当前存的节点赋给it
            if(it->second>1)
            {
                return cur;
            }
            cur=cur->next;
        }
        return nullptr;
    }
};

2.9 链表总结

  • 链表的种类主要为：单链表，双链表，循环链表
  • 链表的存储方式：链表的节点在内存中是分散存储的，通过指针连在一起。
  • 链表是如何进行增删改查的。
  • 数组和链表在不同场景下的性能分析。

虚头节点

加入虚头节点后，头节点不需要每次单独列出来考虑，可以统一操作

链表的基本操作

2.3中设计链表这道题很好地囊括了链表的基本增删改查操作：

  • 获取链表第index个节点的数值
  • 在链表的最前面插入一个节点
  • 在链表的最后面插入一个节点
  • 在链表第index个节点前面插入一个节点
  • 删除链表的第index个节点的数值

反转链表

迭代法、递归法、栈、头插法
总结思维导图

小小小码猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现输出链表中倒数第k个节点
09-04
主要介绍了C语言实现输出链表中倒数第k个节点,主要涉及链表的遍历操作,是数据结构中链表的常见操作。需要的朋友可以参考下
leetcode学习——链表
qq_50714222的博客
10-12 261
本文主要记录了自己跟着代码随想录通过leetcode上与链表有关的题学习链表知识时整理的笔记。首先学习链表的基础知识，比如链表的定义、类型、存储方式、定义的代码等。然后对链表的基本操作进行简单的介绍，比如链表删除节点、添加节点。同时，分析对比了链表和数组的性能。此外，通过leetcode上链表的经典题目的分析和实现来掌握链表的具体使用，例如删除、增加、查找、两两交换链表的节点、反转链表、判断两个链表是否相交，相交则求出相交的节点、判断链表是否有环，有环则求出环的入口等等。最后，对本文的知识点进行了总结。
Leetcode链表——707.设计链表
等待星球的博客
10-31 85
707 设计链表
LeetCode力扣刷题——指针三剑客之一：链表
指北针_N的博客
11-13 1000
单链表，链表是由节点和指针构成的数据结构，每个节点存有一个值，和一个指向下一个节点 的指针，因此很多链表问题可以用递归来处理。不同于数组，链表并不能直接获取任意节点的值， 必须要通过指针找到该节点后才能获取其值。同理，在未遍历到链表结尾时，我们也无法知道链 表的长度，除非依赖其他数据结构储存长度。LeetCode 默认的链表表示方法如下。int val;};由于在进行链表操作时，尤其是删除节点时，经常会因为对当前节点进行操作而导致内存或 指针出现问题。
写过的LeetCode中关于链表的思路值得我学习的题
weixin_44980842的博客
10-01 315
第一题（对应LeetCode题库的第141题） （当然，后续if自己看不懂自己的总结，可以去力扣网站翻阅回对应的题目去看题解！） 题目：给定一个链表，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回...
LeetCode链表问题总结
奔跑の蜗牛
09-04 431
在力扣中单链表的定义为： struct ListNode{ int val; ListNode *next; ListNode():val(x),next(nullptr) {} ListNode(int x):val(x),next(nullptr) {} ListNode(int x,ListNode *next):val(x),next(next) {} } 203. 移除链表元素 移除链表中的某一个元素,只需遍历这个链表，如果这个结点的下一个结点的值等
Java输出链表倒数第k个节点
08-29
主要介绍了Java输出链表倒数第k个节点的相关内容，涉及三种设计思路及代码示例，具有一定参考价值，需要的朋友可以了解下。
Leetcode 刷题（8）简单单链表： 删除链表倒数第N个元素
12-22
19. 删除链表的倒数第N个节点 难度： 中等 题目分析： 链表中的题目，指针相当于免费资源，可以根据需要增加。双指针法、快慢指针法在环形链表，应用很多。 解法一： # 对于这种题目，循环结束条件设为快指针到达...
PHP获取链表中倒数第K个节点的方法
10-18
主要介绍了PHP获取链表中倒数第K个节点的方法,涉及php针对链表的遍历、判断等相关操作技巧,需要的朋友可以参考下
剑指Offer(Python多种思路实现):链表中倒数第k个节点
01-20
剑指Offer(Python多种思路实现):链表中倒数第k个节点 面试22题： 题目：链表中倒数第k个节点 题：输入一个链表，输出该链表中倒数第k个结点。 解题思路一：为了实现只遍历链表一次就能找到倒数第k个节点，我们可以...
B.D.S.代码随想录训练营day_3
BDS的朝圣路
12-09 1173
B.D.S.代码随想录训练营第五期打卡day_3
【代码随想录】【LeetCode】学习笔记03-链表
qdsn的博客
12-08 738
双指针法、虚拟节点、链表的构造结构体的写法
移除链表元素（力扣简单题）（链表）
Hyx1273724818的博客
11-09 242
移除链表元素 给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == 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 输出：[] 提示： 列表中的节点数目在范围 [0, 104] 内 1 <= Node.val <
Leetcode算法系列二（链表）
weixin_44337475的博客
10-16 360
1.8道经典链表常考题目 例1-a：反转链表 例1-b：反转链表2 例2：链表求交点 例3：链表求环 例4：链表划分 例5：复杂链表的复制 例6-a：2个排序链表归并 例6-b：K个排序链表归并 206.反转链表 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？ public class Solution {
力扣-----链表
laugh哥的博客
09-15 738
力扣专题：链表 链表是一种特殊的线性结构，由于不能像数组一样进行随机的访问，所以和链表相关的问题有他自身的穿针引线特点。
Leetcode学习笔记（143. 重排链表）
SGL_LGS的博客
05-16 216
解法一：引入栈和队列的性质，缺点就是引入大量的额外空间； /** * 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, ListNo.
2023年前端面试题汇总-数据结构（链表）
越陌度阡
06-05 1000
在计算机里，不保存在连续存储空间中，而每一个元素里都保存了到下一个元素的地址的数据结构，我们称之为链表（Linked List）。链表上的每一个元素又可以称它为节点（Node），而链表中第一个元素，称它为头节点（Head Node），最后一个元素称它为尾节点（Tail Node）。链表的结构定义中，包含了两个信息，一个是数据信息，用来存储数据的，也叫做数据域；另外一个是地址信息，用来存储下一个节点地址的，也叫做指针域。
链表经典 10题
mu_tong_的博客
10-12 2155
链表10 道经典例题
c++ listnode 赋值,ListNode
weixin_39946313的博客
04-01 989
2. 两数相加2021-03-31 13:33:58给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。您可以假设除了数字 0 之外，这两个数都不会以 0开头。示例：输入：(2 -难度简单205目录题目：[剑指 Offer 24. 反转链表](htt...
删除链表的倒数第n个节点
最新发布
12-13
要删除链表的倒数第n个节点，可以采取双指针的方法，首先设置两个指针p1和p2，让p2指针先走n步，然后p1和p2一起向后移动，直到p2指针到达链表末尾。此时p1指向的节点就是需要删除的倒数第n个节点的前一个节点。然后...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值