我的刷题之路--链表

最新推荐文章于 2022-11-17 17:03:02 发布
最新推荐文章于 2022-11-17 17:03:02 发布
阅读量182 收藏
点赞数
分类专栏： 力扣
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jklmf1/article/details/104819443
版权

1、链表
21.合并两个有序链表
题解；
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

解法一：递归法
ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
{
if (l1 == nullptr)
{
return l2;
}
if (l2 == nullptr)
{
return l1;
}
if (l1->val < l2->val)
{
l1->next = mergeTwoLists(l1->next, l2);
return l1;
}
else
{
l2->next = mergeTwoLists(l1, l2->next);
return l2;
}
}

解法二：迭代法

#include
using namespace std;

struct ListNode
{
int val;
struct ListNode *next;
ListNode(int x) //:val(x), next(NULL){}
{
this->val = x;
this->next = NULL;
}
};

ListNode *mergeTwoLists(ListNode *l1, ListNode *l2)
{
ListNode *head = new ListNode(-1); //哑节点简化代码
ListNode q = head;
while (l1 != nullptr && l2 != nullptr)
{
if (l1->val <= l2->val)
{
q->next = l1;
l1 = l1->next;
}
else
{
q->next = l2;
l2 = l2->next;
}
q = q->next;
}
if (l1)
q->next = l1;
else
{
q->next = l2;
}
Listnode newHead=head->next;
delete head;
return newHead;

}
void test()
{
ListNode *p1 = new ListNode(1);
ListNode *p2 = new ListNode(2);
ListNode *p3 = new ListNode(4);
p1->next = p2;
p2->next = p3;

ListNode *p4 = new ListNode(1);
ListNode *p5 = new ListNode(3);
ListNode *p6 = new ListNode(4);
p4->next = p5;
p5->next = p6;

ListNode *phead = mergeTwoLists(p1, p4);

while (phead)
{
	cout << phead->val << "　";
	phead = phead->next;
}

}

int main()
{
test();
system(“pause”);
return 0;
}

160.相交链表
编写一个程序，找到两个单链表相交的起始节点。
如下面的两个链表：

在节点 c1 开始相交。
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
方法一: 暴力法
对链表A中的每一个结点 ai，遍历整个链表 B 并检查链表 B 中是否存在结点和 ai 相同。
时间复杂度O(m * n) 空间复杂度O(1)
class Solution {
public:
//返回相交的节点
ListNode *getIntersectionNode(ListNode headA, ListNode headB) {
ListNode cur_a = headA;//为什么需要缓存结点

while (cur_a)
{
    ListNode* cur_b = headB;
    while (cur_b)
    {
        if (cur_a == cur_b)
        {
            return cur_a;
        }
        cur_b = cur_b->next;
    }
    cur_a = cur_a->next;
}

return nullptr;

}
};

方法二：双指针法

A的指针遍历完A 接着从headB开始遍历
B的指针遍历完B 接着从headA开始遍历
两个指针都最多会运行m + n次，当都为空时，表示不相交；当相等时，表示相交
让pA和pB分别指向链表A和B的首地址。同时开始访问，一旦一个指针到达末尾，比如pA到达末尾，则将指针指向链表B的首地址，继续遍历，同理pB到达末尾，则将指针指向链表A的首地址，继续遍历。当pA==pB则返回。

这里相当于大家都一共要走A+B链表长度这么长。而如果有公共节点的话，后面那段肯定是公共的。当两个指针同时到达末尾，则没有公共节点。

例如：A=[1,3,5,7,9] B=[2,4,7,9]

则pB相当于要走[2,4,7,9,1,3,5,7,9] pA相当于要走[1,3,5,7,9,2,4,7,9] 注意有公共节点，7,9，也就是说后面一定会遇到！

class Solution {
public:

ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

if(headA == nullptr || headB == nullptr) 
    return nullptr;

ListNode* cur_a = headA;
ListNode* cur_b = headB;

while(cur_a != cur_b)
{
    cur_a = (cur_a == nullptr ? headB : cur_a->next);
    cur_b = (cur_b == nullptr ? headA : cur_b->next);

两种写法
cur1=cur1?cur1->next:headB;
cur2=cur2?cur2->next:headA;

}

return cur_a;

}
};
206.反转链表
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
1、用栈来解决问题
class Solution {
public:
ListNode* reverseList(ListNode* head) {
stack<ListNode*> stk;
ListNode* pt = head;//可以用auto代替ListNode*
while(pt)
{
stk.push(pt);
pt = pt->next;
}
ListNode* dummy = new ListNode(0);
pt = dummy;//不用pt也行 但需要再定义一个指针来缓存这个dummy 存疑
while(stk.size())//这里pt又指向了新的链表 让栈里元素弹出 赋值给pt
{
pt->next = stk.top();
stk.pop();
pt = pt->next;
}
pt->next = nullptr;//这步必须有
ListNode* newHead = dummy->next;
delete dummy;
return newHead;
}
};
2、头插法
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* newHead = new ListNode(-1);
while (head != nullptr) {
ListNode* q = head->next;
head->next = newHead->next;//每次都让旧结点插入新头结点的下一个 这和栈的实现非常的相似 注意不能写q= newHead->next
newHead->next = head;
head = q;//这里不能直接写head=head->next 需要先将head->next缓存一下 因为需要让head指向其他地方
}
return newHead->next;
}
};

这么写错哪了//q->next 的值换了
ListNode* newHead = new ListNode(-1);
ListNode* q=head;
while(q)
{
q->next=newHead->next;//这里
newHead->next=q;
q=q->next;
}
return newHead->next;

  1. 删除排序链表中的重复元素?
    给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
    示例 1:
    输入: 1->1->2
    输出: 1->2
    1、双指针法
    class Solution {
    public:
    ListNode* deleteDuplicates(ListNode* head) {
    if(head){//不判断是否为空 提交会报错
    ListNode* cur = head->next, pre = head;
    while(cur){
    if(cur->val == pre->val){
    pre->next = cur->next;
    delete cur;
    cur = pre->next;
    }else{
    pre = cur;
    cur = cur->next;
    }
    }
    }
    return head;
    }
    };
    不明白返回的是head
    或者前面判断是否为空这么写if(headNULL||head->nextNULL)
    return head;
    2、递归法
    class Solution {
    public:
    ListNode     deleteDuplicates(ListNode* head) {
    if(!head||!head->next)
    return head;
    head->next=deleteDuplicates(head->next);
    if(head->val==head->next->val) head=head->next;
    return head;
    }
    };
    递归套路解决链表问题：
    找终止条件：当head指向链表只剩一个元素的时候，自然是不可能重复的，因此return
    想想应该返回什么值：应该返回的自然是已经去重的链表的头节点
    每一步要做什么：宏观上考虑，此时head.next已经指向一个去重的链表了，而根据第二步，我应该返回一个去重的链表的头节点。因此这一步应该做的是判断当前的head和head.next是否相等，如果相等则说明重了，返回head.next，否则返回head
    237.删除链表中的节点
    请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。

现有一个链表 – head = [4,5,1,9]，它可以表示为:

示例 1:
输入: head = [4,5,1,9], node = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
替身攻击
class Solution {
public:
void deleteNode(ListNode* node) {
node->val=node->next->val;
node->next=node->next->next;
}
};
19.删除链表的倒数第 n 个节点?
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2.
当删除了倒数第二个节点后，链表变为 1->2->3->5.
双指针
解题思路与官方所给方法相同，使用两个指针分别指向头节点和第n个节点，当后一个指针到达最后一个节点时，第一个指针正好位于倒数第n+1个节点处，删除第一个指针的下一个结点即可。
我的理解：倒数第n个结点，正数为总结点数-n+1，让一个指针指向第n个结点，另一个结点从头开始遍历，一起出发，第一个走完时，第二个指针指向总数-n即倒数第n+1个结点
代码
/**

  • Definition for singly-linked list.
  • struct ListNode {
  • int val;

  • ListNode *next;

  • ListNode(int x) : val(x), next(NULL) {}
  • };
    /
    class Solution {
    public:
    ListNode     removeNthFromEnd(ListNode* head, int n) {
    ListNode* first = new ListNode(NULL);
    first->next = head; //添加头节点，便于操作
    ListNode* ptr = first; //搜索节点
    ListNode* current = first; //中间节点
    for (int i = 0; i < n; i++)//将该指针指第n个节点
    {
    current = current->next;
    }
    while (current->next != NULL) //到达最后一个节点
    {
    ptr = ptr->next;
    current = current->next;
    }
    ListNode* p = ptr->next;
    ptr->next = p->next; //删除ptr指向节点
    delete p; //释放空间
    return first->next;
    }
    两个问题：1、为什么delete的不是first new谁delete谁？
    2、为什么提交return head会报错
    24.两两交换链表中的结点
    给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
    你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
    示例:

给定 1->2->3->4, 你应该返回 2->1->4->3.
双指针
class Solution {
public:
ListNodeswapPairs(ListNodehead){
ListNode*dummHead=newListNode(0);
dummHead->next=head;

ListNodep=dummHead;
while(p->next&&p->next->next){
ListNodenode1=p->next;
ListNodenode2=node1->next;
ListNodenode3=node2->next;

p->next=node2;
node2->next=node1;
node1->next= node3;//顺序可颠倒

p=node1;//p=p->next但是p->next改变了所以用node1
}

ListNode*retNode=dummHead->next;
deletedummHead;//为了deletenew出来的结点所以多写两行

returnretNode;
}
};

445、两数相加
给定两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。
你可以假设除了数字 0 之外，这两个数字都不会以零开头。

进阶:
如果输入链表不能修改该如何处理？换句话说，你不能对列表中的节点进行翻转。
示例:
输入: (7 -> 2 -> 4 -> 3) + (5 -> 6 -> 4)
输出: 7 -> 8 -> 0 -> 7
两栈头插法
或者可以用三栈解决
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
if(!l1)
return l2;
if(!l2)
return l1;
stacks1,s2;
//把l1和l2放进栈里
while(l1)
{
s1.push(l1->val);
l1=l1->next;
}
while(l2)
{
s2.push(l2->val);
l2=l2->next;
}

    int carry = 0,n1 = 0,n2 = 0,sum = 0;
    ListNode* dummy=new ListNode(-1);

    while(!s1.empty() || !s2.empty() || carry)
    {
      if(s1.empty())n1 = 0;//这里必须要判断 因为while中或是全为假才跳出循环 即s1s2都为空 carry也为0
        else {n1 = s1.top();s1.pop();}
        
        if(s2.empty())n2 = 0;
        else{n2 = s2.top();s2.pop();}

        sum=n1+n2+carry;//求和与进位值

        ListNode* tmp=new ListNode(sum%10);//插入取余的值
        tmp->next=dummy->next;
        dummy->next=tmp;

        carry=sum/10;//处理进位 取整不要余数
    }

ListNode* newHead=dummy->next;
delete dummy;
return newHead;
}
};

234、回文链表
Vector数组 双指针
/**

  • Definition for singly-linked list.

  • struct ListNode {

  • int val;

  • ListNode *next;

  • ListNode(int x) : val(x), next(NULL) {}

  • };
    /
    class Solution {
    public:
    bool isPalindrome(ListNode     head) {
    if(headNULL) return true;
    if(head->next    NULL)return true;

     ListNode *i=head;
 vector<int> val;
 //将链表值放入数组
 while(i!=NULL){
     val.push_back(i->val);
     i=i->next;
 }
 int m=0,n=val.size()-1;
 while(m<n){
     if(val[m]!=val[n])
         return false;
     m++;
     n--;
 }
 return true;

    }
    };
    栈 一一出栈比较
    class Solution {
    public:
    bool isPalindrome(ListNode* head) {
    stack s;
    ListNode *p = head;
    while§{
    s.push(p->val);
    p = p->next;
    }
    p = head;
    while§{
    if(p->val != s.top()){
    return 0;
    }
    s.pop();
    p = p->next;
    }
    return 1;
    }
    };

  1. 移除链表元素
    /**
  • Definition for singly-linked list.
  • struct ListNode {
  • int val;

  • ListNode *next;

  • ListNode(int x) : val(x), next(NULL) {}
  • };
    /
    class Solution {
    public:
    ListNode     removeElements(ListNode* head, int val) {
    ListNode* newHead=new ListNode(-1);
    newHead->next=head;
    ListNode* p=newHead;
    while(p->next)
    {
    if(p->next->val==val)
    {
    p->next=p->next->next;
    }
    else
    p=p->next;
    }
    return newHead->next;
    }
    };
沐芳莫弹冠
关注
专栏目录
c++ listnode 赋值_C++操作单链表ListNode
weixin_35677043的博客
01-26 1887
C++操作单链表ListNode通过C++进行单链表的创建、打印以及利用栈实现逆序打印。单链表的创建和打印#include using namespace std;//定义结构体struct ListNode{int val;ListNode* next;};class operateList{public:/*创建单链表*/void createList(ListNode *head){int ...
【链表】(五) 小结
闻韶
07-14 442
LeetCode - 探索卡片 - 链表 - 五 - 小结
代码随想录 链表模块小结
weixin_52620153的博客
11-17 172
刷题笔记
一文读懂list_head相关
u013989284的专栏
01-03 1637
1.list_entry的作用 struct list_head { 　　struct list_head *next, *prev; }; 没有数据区怎么使用，更多的时候是嵌入到其他结构体中使用。 struct file_node{ 　　char c; 　　struct list_head node; }; 当我们知道 list_head的地址时，就可以通过宏 list_entr
list不带头节点，一层指针传入head与两层指针传入head
qq_32828145的博客
09-06 270
当list不带头节点的时候，如果想要main函数中的链表改变，当为一层指针传入头结点时，调用的函数必须要有返回值。 #include <stdio.h> #include <malloc.h> struct node { int data; struct node *next; }; struct node *create(struct...
【力扣刷题】数组-链表-哈希-双指针
06-21
"数组-链表-哈希-双指针" 在计算机科学中，数组是一种基本的数据结构，用于存储相同类型的数据元素。数组中的每个元素都可以通过下标索引来访问，下标从0开始计数。数组的元素是不能删除的，只能覆盖。不能释放单个...
Leetcode刷题方法总结---链表全解
修行的凡人的博客
08-24 1094
Leetcode刷题方法总结---链表全解
刷题记录----链表
HandsomeDog_L的博客
07-20 371
链表的相关操作
蓝桥杯刷题真解析-小白到大师的进阶之路
最新发布
06-03
《蓝桥杯刷题真解析-小白到大师的进阶之路》是一份旨在帮助参赛者逐步提升编程技能、深入理解算法与数据结构的资源集合。"蓝桥杯"是一项全国性的编程竞赛，对于计算机科学和技术专业学生以及热衷于编程的爱好者来说...
leetcode刷题思路-----链表
qq_41523065的博客
04-29 404
leetcode刷题思路-----链表 1. 基本模板 单链表的问题没什么模板，大家按照自己习惯都有各自的方法去删除，插入等。 对于力扣的问题也没有太难的题，都是基本的方法的组合，比如从反转链表到k个一组反转链表，合并两个链表到合并k个有序链表，我们从最基本的开始。 建立ListNode类 public class ListNode { int val; ListNode next; public ListNode(){} //给两个有参构造，方便建立普通节点和哨兵节点
链表作为函数参数传递，Node* head, or Node** pHead(无法把指针变量本身传递给一个函数)?
intfreedom的博客
06-03 5074
链表作为函数参数传递，Node head, or Node* pHead?** 1.C语言，函数形参是值传递，当函数形参是，如果函数内部对这个形参做了修改，在函数返回后，不会改变这个形参的值; 1.1以上这点，很容易明白，但当这个形参本身是一个变量时，就容易产生迷惑，我传的是一个指针，把指针作为函数参数，函数返回时，一定会修改改变一些东西。很容易想到修改的是形参本身(本身是个指针)。 1.2如函数void add(Node* head, int number);如果你想在函数返回时，head被修改，你一定要
关于内核数据结构struc list_head的用法。
u012566181的专栏
07-31 3636
关于内核数据结构struc list_head的用法。 在list.h头文件中，定义了struct list_head这个双向链表结构，它是怎样的呢？ Struct list_head { struct list_head *prev; struct list_head *next; } 粗略一看，起始很普通，就是定义了两个指针而已，但是却相当有用。 我们平时定义双链表的数据结构的时候，是
数据结构和算法 leetcode链表刷题007
hufanglei007的博客
03-09 265
链表数据结构刷题leetcode206: Reverse Linked List 将链表反序class Solution { public: ListNode* reverseList(ListNode* head) { //创建三个指针 ListNode *pre=NULL; ListNode *curr=head; if(...
反转链表（reverse ListNode）
世上只有一种英雄主义
05-09 5870
反转链表：java类public class ListNode{ int key; ListNode next; }思路分析： 需要三个指针，current，prev和next。 current.next = prev之前需要next = current.next(判断next是否为空)，同时一直往后遍历 while（node ！= null） - 代码：public ListN
ListNode list=new ListNode() 、 ListNode list=new ListNode(0) 与 ListNode list=null 的区别
热门推荐
看风起云落的博客
08-17 2万+
ListNode list=new ListNode()初始化一个空节点，无值,不提倡此种写法。 ListNode list=new ListNode(0) 初始化一个节点值为0的空节点，最常用最正规写法 ListNode list=null 为空，什么都没有，一般不这么写； ...
2122数据结构实验之链表七：单链表中重复元素的删除
小自洽
07-20 435
数据结构实验之链表七：单链表中重复元素的删除 Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 按照数据输入的相反顺序（逆位序）建立一个单链表，并将单链表中重复的元素删除（值相同的元素只保留最后输入的一个）。 Input 第一行输入元素个数 n (1 &lt;= n &lt;= 15)； 第二行输入 n 个整...
两数相加ii（add-two-numbers-ii）
e891377的专栏
02-16 453
文章目录两数相加ii（add-two-numbers-ii）双栈+单链表插入法双栈+单链表插入解题思路代码大神写的简洁版（双栈+单链表插入）解题思路代码递归解法解题思路代码测试用例参考资料 两数相加ii（add-two-numbers-ii） 给定两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储单个数字。将这两数相加会返回一个新的链表。 你可以假设除了数字 0 之外...
刷完31道链表题的一点总结
大灰狼的小绵羊哥哥的博客
05-30 243
  前几天第一次在 Segmentfault 发文—JavaScript：十大排序的算法思路和代码实现，发现大家似乎挺喜欢算法的，所以今天再分享一篇前两个星期写的 Leetcode 刷题总结，希望对大家能有所帮助。   本文首发于我的blog 前言   今天终于刷完了 Leetcode 上的链表专题，虽然只有 31 道题（总共是 35 道，但有 4 道题加了锁）而已，但也陆陆续续做了两三个星...
【每日算法/刷穿 LeetCode】24. 两两交换链表中的节点（中等）
宫水三叶的刷题日记
02-05 171
点击 这里 可以查看更多算法面试相关内容~ 题目描述 给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。 你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。 示例 1： 输入：head = [1,2,3,4] 输出：[2,1,4,3] 示例 2： 输入：head = [] 输出：[] 示例 3： 输入：head = [1] 输出：[1] 提示： 链表中节点的数目在范围 [0, 100] 内 0 <= Node.val <= 100 递归解法（哨兵技巧） 哨兵技.
LeetCode链表算法刷题笔记：移除元素、设计链表、反转链表
本文是关于LeetCode中三道与链表相关的算法题目的刷题笔记，包括203.移除链表元素、707.设计链表和206.反转链表。主要讨论了解题思路和Java语言的解决方案。 ### 203. 移除链表元素 这道题目要求从链表中删除所有值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值