刷题PIA 之 链表

已于 2023-08-09 16:49:45 修改
阅读量40 收藏
点赞数
分类专栏： C++ 数据结构 文章标签： 链表 数据结构
于 2023-05-25 23:49:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62789921/article/details/130855960
版权

0. 刷题BGM : A Day at the Beach - j'san./Pandrezz

1. 反转链表 

描述：题意简单不赘述       

输入：单链表的头结点 pHead 

输出：反转链表的表头

算法：前插法 + 迭代

class Solution {
public:
    ListNode* ReverseList(ListNode* pHead) {
        ListNode* pReverseList = NULL;
        ListNode* pNode = pHead;
        ListNode* pPre= NULL;
  
  
        while(pNode != NULL){
            ListNode* pNext = pNode->next;
            if(pNext == NULL){
                pReverseList = pNode;
            }
            pNode->next = pPre;
            pPre = pNode;
            pNode = pNext;
        }
        return pReverseList;
    }
};

分析：1）创建新的链表指针指向头结点（ListNode* pNode = pHead;），返回整个链表元素。

           2）本题由于每迭代后，Pnode与Ppre直接无连接，故直接返回Pnode无法获得正确结果。

           3）根据分析 2）可改写 while 循环内容，改写代码如下所示。

while(Pnode != NULL)
        {
            ListNode *Pnext = Pnode->next;
            Pnode->next = Ppre;
            Ppre = Pnode;
			if(Pnext != NULL)
			{
				Pnode = Pnext;
			}else {
				return Pnode;
			}
        }

TRICK：反转以平移思想为准，从 Pnow->next 到 Ppre 到 Pnow 顺序平移

2. 链表内指定区间反转

描述：固定区间实现局部链表反转      

输入：单链表的头结点 pHead 

输出：局部反转链表的表头

算法：前插法 + 迭代

/**
 * struct ListNode {
 *  int val;
 *  struct ListNode *next;
 * };
 */

#include <climits>
#include <cstdio>
#include <list>
class Solution {
  public:
    /**
     *
     * @param head ListNode类
     * @param m int整型
     * @param n int整型
     * @return ListNode类
     */
    ListNode* reverseBetween(ListNode* head, int m, int n) {
        if(!head & !head->next) return head;
        ListNode* B = head,* A = new ListNode(-1),* C;
        int k = m - 1;
        A->next = head;
        ListNode* RES = A;
        while (k--) {
            B = B->next;
            A = A->next;
        }
        ListNode* T = A;
        k = n - m;
        while(k--)
        {
            C = B->next;
            B->next = C->next;
            C->next = T->next;
            T->next = C; 
        }
        return RES->next;
    }
};

3.合并两个排序的链表

描述：合并两个子顺序链表成一个合并顺序链表     

输入：两个单链表的头结点 pHead 

输出：合并链表

算法：迭代

#include <list>
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {
        ListNode* RES = new ListNode(-1);
		ListNode* A = pHead1,*B = pHead2;
		ListNode* T = RES;
		while(A && B)
		{
			if(A->val < B->val)
			{
				T->next = A;
				A = A->next;
			}
			else
			{
				T->next = B;
				B = B->next;
			}
			T = T->next;
		}
		if(A)
		{
			T->next = A;
		}
		else 
		{
			T->next = B;
		}
		return RES->next;
    }
};

4.判断链表是否有环

描述：给出一链表，判断是否带环   

输入：单链表的头结点 pHead 

输出：带环BOOL

算法：双指针 + 快慢指针

class Solution {
public:
    bool hasCycle(ListNode *head) {
        bool res = false;
        ListNode* F = head,* S = head;
        while(F->next && F)
        {
            F = F->next->next;
            S = S->next;
            if(F == S)
            {
                res = true;
                break;
            }
            
        }
        return res;
    }
};

TRICK ：判断条件以快指针 F 及 F -> next 为条件。

5. 链表中环的入口结点

描述：给出一链表，判断是否带环 ,并输出入口节点  

输入：两个单链表的头结点 pHead 

输出：入口节点，若无环输出NULL

算法：双指针 + 快慢指针

#include <cmath>
class Solution {
  public:
    ListNode* EntryNodeOfLoop(ListNode* pHead) {
        ListNode* F = pHead, * S = pHead;
        int tag = 0;
        while (F->next && F) {
            S = S->next;
            F = F->next->next;
            if (F == S) {
                tag = 1;
                break;
            }
        }
        if (tag == 0) return NULL;
        else {
            S = pHead;
            while (S != F && tag == 1) {
                S = S->next;
                F = F->next;
            }
            return S;
        }
    }

TRICK ：判断为有环后，将慢指针重置，两指针根据一次平移一格获得交汇点即为入口点。

6.链表中倒数最后k个结点

描述：给出一链表，给出链表后k个结点 

输入：单链表的头结点 pHead 

输出：后k个结点的头结点

算法：。。。

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    ListNode* FindKthToTail(ListNode* pHead, int k) {
        int num = 0;
        ListNode* A = pHead;
        while(A) 
        {
            A = A ->next;
            num++;
        }
        if(num < k) return NULL;
        else{
        for(int i(0);i<num-k;i++)
        {
            pHead = pHead->next;
        }
        return pHead;
        }
    }

7. 删除链表的倒数第n个节点

描述：题意简单不赘述 

输入：单链表的头结点 pHead 

输出：除倒数第k个的链表表头

算法：。。。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

#include <endian.h>
#include <list>
#include <memory>
class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @param n int整型 
     * @return ListNode类
     */
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        // write code here
        int num = 0;
        ListNode* A = head;
        ListNode* res = new ListNode(-1);
        res->next = head;
        ListNode* temp = res;
        while(A)
        {
            A = A->next;
            num++;
        }
        for(int i(0);i<num-n;i++)
        {
            temp = temp->next;
        }
        temp->next = temp->next->next;
        return res->next;
    }
};

TRICK：返回值可能包含前置链表时，实用动态创建链表

8. 两个链表的第一个公共结点

描述：题意简单不赘述 

输入：两个单链表的头结点 pHead 

输出：第一个共同的结点

算法：。。。

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
#include <climits>
class Solution {
  public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        ListNode* A = pHead1;
        while (A) {
            ListNode* B = pHead2;
            while (B) {
                if (A->val == B->val && A == B) {
                    return A;
                } else {
                    B = B->next;
                }
            }
            A = A->next;
        }
        return NULL;
    }

TRICK：将A、B两链表遍历成环，即A -> next = NULL 时 A -> next = pHead2，B同理。

9.判断一个链表是否为回文结构

描述：题意简单不赘述 

输入：单链表的头结点 pHead 

输出：BOOL是否为回文标志

算法：。。。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 the head
     * @return bool布尔型
     */
    bool isPail(ListNode* head) {
        // write code here
        int l = 0;
        bool res = true;
        ListNode* A = head;
        while (A) {
            A=A->next;
            l++;
        }
        l = l/2;
        ListNode* B = head;
        while (l--) {
            B = B ->next;
        }
        B = ReverseList(B);
        ListNode* C = head;
        while (B) {
            if (C->val != B->val) {
                res = false;
            }
            C = C->next;
            B = B->next;
        }
        return res;
    }
    ListNode* ReverseList(ListNode* pHead) {
        ListNode* pReverseList = NULL;
        ListNode* pNode = pHead;
        ListNode* pPre= NULL;
  
  
        while(pNode != NULL){
            ListNode* pNext = pNode->next;
            if(pNext == NULL){
                pReverseList = pNode;
            }
            pNode->next = pPre;
            pPre = pNode;
            pNode = pNext;
        }
        return pReverseList;
    }
};

10. 删除有序链表中重复的元素-I

描述：题意简单不赘述 

输入：单链表带重复元素的头结点 pHead 

输出：无重复元素的链表头结点

算法：。。。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

class Solution {
public:
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* deleteDuplicates(ListNode* head) {
        // write code here
        ListNode* A = new ListNode(-1);
        A->next = head;
        ListNode* T = head;
        while(T&&T->next)
        {
            if (T->val == T->next->val) {
                T->next = T->next->next;
            }else
            {
                
            T = T->next;
            }
        }
        return A->next;
    }

11.链表的奇偶重排

描述：给一个单链表，使奇数编号项在前输出偶数编号项在后输出 

输入：单链表带重复元素的头结点 pHead 

输出：奇偶重排元素的链表头结点

算法：。。。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 *	ListNode(int x) : val(x), next(nullptr) {}
 * };
 */
#include <cmath>
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    ListNode* oddEvenList(ListNode* head) {
        // write code here
        if(!head || !head->next) return head;
        ListNode* A = head,* B = head->next,* mid = head->next;
        while (B&&B->next) {
            A->next = A->next->next;
            B->next = B->next->next;
            A = A->next;
            B = B->next;
        }
        A->next = mid;
        return head;
    }
};

12 单链表的排序

描述：题意简单不赘述

输入：单链表无序的头结点 pHead 

输出：有序链表头结点

算法：。。。

/**
 * struct ListNode {
 *	int val;
 *	struct ListNode *next;
 * };
 */

#include <cmath>
#include <cstddef>
#include <vector>
class Solution {
public:
    /**
     * 
     * @param head ListNode类 the head node
     * @return ListNode类
     */
    ListNode* sortInList(ListNode* head) {
        // write code here
        if (!head) {
            return head;
        }
        ListNode* iter = head;
        vector<int> array;
        while (iter) {
            array.push_back(iter->val);
            iter = iter->next;
        }
        sort(array.begin(),array.end());
        int i = 0;
        iter = head;
        while (iter) {
            iter->val = array[i++];
            iter = iter->next;
        }
        delete iter;
        return head;
    }
};

TRICK：将链表内容存入vexctor，再通过sort排序，最后导入链表中。

注意 :

new ListNode(NULL) 含 value = 0；

ListNode * d = null ，不含value

专业刷题Pia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Leetcode刷题笔记之链表篇】234. 回文链表
大家好我叫张同学
01-15 1138
给你一个单链表的头节点 `head` ，请你判断该链表是否为`回文链表`。 如果`是`，返回 `true` ；否则，返回` false` 。 具有对称性的链表就具有回文结构 如果是单数个结点，中间的结点无需考虑，如果其他结点对称肯定是回文结构 例如：1 2 3 1 2 也是回文结构 这里借助求链表倒数第k个结点的思路。 只要链表的.....
剑指offer刷题日记-链表
01-20
链表03-从尾到头打印链表（python） #采用insert方法 class Solution: def printlist(self,listNode): if not listNode: return [] result=[] while listNode: result.insert(0,listNode.val) ...
刷题训练之链表
AAlykk的博客
06-15 684
最早博主续写了牛客网130道题，这块的刷题是让同学们快速进入C语言，而我们学习c++已经有一段时间了，知识储备已经足够了但缺少了实战，面对这块短板博主续写刷题训练，针对性学习，把相似的题目归类，系统的刷题，而我们刷题的官网可以参考：​​​​​​力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台牛客网 - 找工作神器|笔试题库|面试经验|实习招聘内推，求职就业一站解决_牛客网⭐知识讲解画图，一定要画图，只有画好图才能直观形象便于我们理解。引入虚拟"头"结点。不要吝啬空间，大胆去定义变量。
leetcode刷题之回文链表
不能再留遗憾了的博客
03-17 1039
leedcode刷题之回文链表（图文并茂，保证你能学会）
LeetCode刷题之环形链表
圆师傅的博客
05-10 829
为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。从图上可以看到，链表中环前面的长度是a，环的长度是r，环的起点是A，快慢指针相遇的点是B， AB两点之间的距离是b。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。很容易可以想到，遍历链表，把链表元素添加到Set中，如果这个元素在Set中已经存在了，那么说明当前链表是有环的。如果全部链表都遍历完，也没有重复的元素，那说明链表是没有环的。
leetcode刷题总结之链表
algsup
01-18 9017
前言： 今年过年前的任务就是回顾之前的刷过题，然后弄清以前没有弄懂的知识点，最后归纳整理形成自己的体系。因为“学而不思则罔，思而不学则殆”，在比赛或者面试做题时，只有三种情况，会让你不能ak所有题目，这三种情况分别是：sb失误、不会做、状态不佳。然而写总结所要做的是就是将之前的sb失误减小为0，之前不会做的题做熟做透，摸清套路，至于状态嘛，睡好觉兴奋点就是发挥出真正水平呀。 文章目录1、链表2、...
牛客每日刷题之链表
m0_60264772的博客
08-04 1716
兄弟们，一起来刷题👉嘎嘎的写题。
坚持刷题｜环形链表
weixin_44435110的博客
02-13 425
Hello，大家好，我是阿月。坚持刷题，老年痴呆追不上我，刷了一段时间二叉树啦，今天换链表刷：环形链表
Python刷题LeetCode——链表
gandebeautiful的博客
06-27 251
Python链表刷题相关的知识点和解题方法
【Leetcode刷题笔记之链表篇】160. 相交链表
大家好我叫张同学
01-16 833
给你两个单链表的头节点 `headA` 和 `headB` ，请你找出并返回两个单链表`相交`的`起始节点`。如果两个链表`不存在`相交节点，返回 `null `。 图示两个链表在节点 c1 开始相交：理解相交：不是指A链表中有和B链表中val值相同的结点，而是指这个两个链表中存在相同的结点，如果我们通过指针去遍历A、B两个链表，能够在A、B中找到相同地址的结点，那A、B相交，否则就是不相交。
牛客网刷题-反转链表
k666499436的博客
09-02 1142
前言： 想要学好嵌入式，C语言与数据结构是必要熟练掌握的，而想熟练掌握一门语言，必须经过大量的练习，刷题，至少需要一两万行的代码量，才能具有一定的编程能力，至少拿到一个功能，怎么去用编程语言去实现它，从现在开始我要开启刷题之路，提高自己的编程水平，还有最重要的面试能力。 推荐一款刷题神器 -> 点击跳转进入网站(数据结构算法方向)题目原型： 输入输出示例： 1.题目分析：题目意思很简单就是链表头尾交换，将整个链表反向连接起来，实现之后返回新链表的头结点。2.解题思路： 思路二：头插法 创建一个新的空链
[宫水三叶的刷题日记]：链表1
08-03
【宫水三叶的刷题日记】：链表1 链表是计算机科学中一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。本篇日记探讨了两个与链表相关的LeetCode问题：1. 两数相加（2. Add Two ...
Python数据结构之链表实现
02-27
1.使用Python语言实现链表数据结构 2.基于类封装思想 3.实现链表增删改查功能 4.有测试数据
01基础数据结构之链表
09-14
链表数据结构知识点 链表是一种基本的数据结构，它是一种非顺序存储结构，通过指针将各个节点连接起来，每个节点都包含了数据和指向下一个节点的指针。链表的优点是可以动态地增减节点，插入和删除节点的时间复杂度...
leetcode刷题笔记之JavaScript
11-08
leetcode刷题笔记之JavaScript LeetCode刷题笔记之JavaScript知识分享 在本篇文章中，我们将讨论LeetCode中的二叉树、数组、链表、哈希表、栈、队列、图等数据结构和算法题目，并提供相应的JavaScript解决方案。 ...
数据结构（初阶3.单链表）
最新发布
2401_83968713的博客
07-14 651
一、单链表1.1概念与结构1.2结点1.3链表的性质1.4链表的打印二、实现单链表SList.hSList.c申请新节点尾插头插尾删头删在指定位置之前插入数据在指定位置之后插入数据删除指定位置结点删除指定位置之后的结点销毁结点test.c。
数据结构【顺序表】
qq_67578580的博客
07-12 1404
我们需要创建一个seqlist.h头文件，seqlist.c文件存放函数，还有一个.c的测试文件。
【数据结构】栈和队列
奋斗的小羊的博客
07-12 1813
栈超超超详解
数据结构第23节 线性搜索
hummhumm的专栏
07-12 403
线性搜索（Linear Search），也称为顺序搜索，是最基本的搜索算法之一。它的工作原理是通过遍历数组或列表中的每一个元素，直到找到目标值为止，或者遍历完所有元素后确定目标值不存在于列表中。线性搜索的时间复杂度为O(n)，其中n是列表中元素的数量。这是因为最坏情况下，你可能需要检查列表中的每一个元素才能找到目标值或确定它不在列表中。
宫水三叶的刷题日记 | 链表1：删除链表的倒数第n个节点
宫水三叶的刷题日记中的这一篇是关于链表操作的，具体是删除链表的倒数第n个节点。从目标出发，我们需要确定倒数第n个节点的位置，而为了找到倒数第n个节点，我们可以利用双指针的思想。 首先，我们定义两个指针 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值