5道入门单链表初阶题目

已于 2022-05-11 22:24:42 修改
阅读量603 收藏 13
点赞数 30
分类专栏： 数据结构初阶 文章标签： 链表 数据结构
于 2022-05-10 22:46:17 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ll_R_lL/article/details/124699330
版权

目录

1. 删除链表中等于给定值 val 的所有结点

1.1第一种方法：

1.2第二种方法：

1.3改善代码

2.逆置单链表

2.1头插思路：

2.2指针方向颠倒：

3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

4. 输入一个链表，输出该链表中倒数第k个结点

5. 将两个有序链表合并为一个新的有序链表并返回。

5.1不带哨兵位的写法：

5.2带哨兵位的写法：

1. 删除链表中等于给定值 val 的所有结点

基础题

力扣

小tips：默认链表是不带哨兵位的。

1.编译出错是语法问题

2.执行出错：

  • 走读代码（跟着逻辑）画图分析
  • 找不到错误可以调试 画图+vs调试，用报错的那个测试

接口型oj

1.1第一种方法：

这道题没有使用二级指针

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* prev = NULL;
    struct ListNode* cur = head;

    while(cur)
    {
        if(cur->val == val)
        //头删--特殊情况
        if(cur == head)
        {
            head = cur->next;
            free(cur);
            cur = head;
        }
        else
        {
            //删除
            prev->next = cur->next;
            free(cur);
            cur = prev->next; 
        }
        else//没有与val相等的值就接着往下走
        {
            prev = cur;//将cur赋值给prev
            cur = cur->next;//cur接着下一个

        }
    }
    return head;//回到头结点

}

1.2第二种方法：

给两个指针，tail最开始置成空，去标记这个尾

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val){
struct ListNode * tail = NULL;
struct ListNode* cur = head;
head = NULL;
while(cur)
{
        if(cur->val == val)
        {
            struct ListNode* del = cur;
            cur = cur->next;
            free(del);//释放与val相等的结点
        }
        
        else
        {
         //尾插
         //遍历原链表，把不是val的结点拿出来尾插到新链表
         if(tail == NULL)
         {
             head = tail = cur;
         }
         else
         {
             tail->next = cur;
             tail = tail->next;
         }
         cur = cur->next;
        }
    }
    if(tail)
    tail->next = NULL;

    return head;
}

1.3改善代码

简化代码不用考虑头删的情况，但释放的时候也得处理

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* removeElements(struct ListNode* head, int val){
    struct ListNode* tail = NULL;
    struct ListNode* cur = head;

//带哨兵位的头结点（简化尾插）
    head = tail = (struct ListNode*)malloc(sizeof(struct ListNode));
    tail->next = NULL;

    while(cur)
    {
        if(cur->val == val)
        {
            struct ListNode* del = cur;
            cur = cur->next;
            free(del);
        }
        else
        {
            tail->next = cur;
            tail = tail->next;
            cur = cur->next;
        }
    }
    //解决问题tail->next还是指向之前的结点
    tail->next = NULL;
    struct ListNode* del = head;
    head = head->next;
    free(del);//将哨兵位释放
    return head;

}

2.逆置单链表

力扣

2.1头插思路：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){
    struct ListNode* newhead = NULL;
    struct ListNode* cur = head;
    while(cur)
    {
        struct ListNode* next = cur->next;//头插之前设置一个next，保留原链表剩余的结点
        //头插
        cur->next = newhead;//设置一个newhead指针指向NULL，然后将cur->next指向newhead
        newhead = cur;//更新newhead，next赋值给cur

        cur = next;//头插一次之后将下一个结点给cur
    }

    return newhead;

}

2.2指针方向颠倒：

定义n1，n2，n3

让n2的next指向n1

 

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* reverseList(struct ListNode* head){
    //空链表逆置还是空
    if(head==NULL)
       return NULL;

    struct ListNode* n1,*n2,*n3;//不加*就是定义结构体，加*是定义结构体指针
    n1 = NULL;
    n2 = head;
    n3 = n2->next;

    while(n2)//当n2走到NULL的时候结束
    {
        //倒指向
        n2->next = n1;//原本n2->next指向的应该是n3，现在给它倒回去指向n1
        //n1是NULL，相当于n2指向NULL

        //迭代，迭代法也称辗转法，是一种不断用变量的旧值递推新值的过程
        //往后走
        n1 = n2;
        n2 = n3;
        
        if(n3)//判断n3是否为空
           n3 = n3->next;//n3如果不为null，就会一直往下走下去
           //只需要设置逆置前面几个指针，后面的指针就会依次逆置下去
    }


   return n1;//n1变为新链表的头

}

3. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

力扣

快慢指针

奇数：

slow一次一步

fast一次两步

fast走到最后一个结点，就找到中间结点

偶数（有两个中间结点要求返回第二个结点）

fast走到NULL

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */


struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* slow,*fast;
    slow = fast = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;

}

4. 输入一个链表，输出该链表中倒数第k个结点

链表中倒数第k个结点_牛客题霸_牛客网

快慢指针：

1.fast先走k步 fast走到NULL

2.fast先走k-1步 fast走到尾

fast先走，然后与slow同时走，两个指针之间就会有k（k-1）步距离

k--就是走k步

--k就是k-1次

k大于链表的长度会出现段错误

fast还没有走出k步，链表没有k步长

代码中有两个while循环时是先走完一个循环，再往下走第二个循环

比如以下代码中，先走让fast走k步的循环，再走fast为NULL时结束的循环

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

class Solution {
public:
    ListNode* FindKthToTail(ListNode* pListHead, unsigned int k) {
        struct ListNode* slow,*fast;
        slow = fast = pListHead;//从头指针开始，默认不带哨兵位
        
        //先走k步
        while(k--)
        {
            //处理fast还没有走出k步，链表没有k步长的情况
            if(fast == NULL)
                return NULL;
            
            fast = fast->next;
        }
        //当fast走到NULL的时候就找到倒数第k个结点
        while(fast)
        {
            slow = slow->next;
            fast = fast->next;
        }
        //返回倒数第k个结点
        return slow;
    
    }
};

5. 将两个有序链表合并为一个新的有序链表并返回。

新链表是通过拼接给定的两个链表的所有结点组成的

力扣

链表经典题：逆置+合并

归并：

将两个有序的链表归并成一个大的链表，归并之后依旧有序

分别用两个指针指向两个链表的第一个结点，从头比较，取小的尾插到新链表

结束：其中有一个走完

三种情况：

  1. list1为NULL返回list2
  2. list2为NULL返回list1
  3. list1和list2都不为NULL

5.1不带哨兵位的写法：

/**
 * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if(list1 == NULL)
        return list2;
        if(list2 == NULL)
        return list1;

        struct ListNode* head,*tail;
        head = tail = NULL;

        while(list1 && list2)
        {
            //当list1小于list2的时候就把list1尾插
            //相等的情况下就无所谓的，谁先尾插都行
            if(list1->val < list2->val)
            {
                //第一次尾插
                if(tail == NULL)
                {
                    head = tail = list1;//小的先尾插进去
                }
                //tail不等于NULL的时候
                else
                {
                    tail->next = list1;
                    tail = tail->next;
                }
                list1 = list1->next;
            }
            //list2比list1小  >=
            else
            {
                if(tail == NULL)
                {
                    head = tail = list2;
                }
                else
                {
                    tail->next = list2;
                    tail = tail->next;
                }
                list2 = list2->next;

            }
        }
        //当其中一个为NULL时就结束了
        if(list1)
        tail->next = list1;

        if(list2)
        tail->next = list2;
        //不用更新tail，因为返回的是head
        
        return head;
    }
};

5.2带哨兵位的写法：

/**
 * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {

        struct ListNode* head,*tail;
        head = tail = (struct ListNode*)malloc(sizeof(struct ListNode));
        tail->next = NULL;

        while(list1 && list2)
        {
            if(list1->val < list2->val)
            {
                //当tail等于NULL的时候
                if(tail == NULL)
                {
                    head = tail = list1;//小的先尾插进去
                }
                else
                {
                    tail->next = list1;
                    tail = tail->next;
                }
                list1 = list1->next;
            }
            //list2比list1小
            else
            {
                if(tail == NULL)
                {
                    head = tail = list2;
                }
                else
                {
                    tail->next = list2;
                    tail = tail->next;
                }
                list2 = list2->next;

            }
        }
        //当其中一个为NULL时就结束了
        if(list1)
        tail->next = list1;

        if(list2)
        tail->next = list2;
        //不用更新tail，因为返回的是head

        struct ListNode* list = head->next;
        free(head);
        
        return list;
    }
};

Hey pear!
关注
  • 30
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 22
    评论
专栏目录
单链表及其常见习题
qq_40873772的博客
10-20 327
单链表的概念 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中每个元素都包含在一个称之为节点的结构中，节点由数据域加引用域构成，当向链表新添加一个元素的时候，就会产生一个包含它的节点，每个节点和它相邻的节点通过引用域相连接。 简单图解 新增节点 删除节点 常见习题 1、逆序输出所给定的单链表 //逆序输出单链表 public static &lt...
C++入门（初阶）
11-22
这个是百度之星上面的小教程，自己整理成了pdf文档。对于C++新手来讲，照着打一遍会对该语言有个大致的了解。其框架，结构等等。当然，该教程并没有设计面向对象，甚至没有涉及数组和指针。只是入门基础。
链表基础题目
不屈土豆的博客
11-15 324
探究链表特性及基础问题。
单链表经典题总结(c语言版)
remake_m的博客
03-29 2935
这些例题具体的解法并不重要，重要的是找到有什么是之前不会的，学习之后会了的。 掌握解决问题的技巧是关键的，再做题中会发现很多没有思路或者有但只有一点思路的题，这个时候打开电脑自带的画图工具画图思考是解决问题关键的一步。 思考所有可能的方法，以免钻牛角尖。 考虑常见的边界情况（对单链表而言是，头尾，空，非空）,完善代码。 积累做题的技巧，对于第一次见到的题目可以不会，但是第3次见到类似的题目就一定要做出来。 下面的OJ题是基于单链表的增删查改上的提升 下面做题一定要做三件事： 画图！画图！！画图
【链表】：必写的四道基础题
最新发布
幻想有一天能进大厂
04-25 1299
这里给大家推荐必写的四道单链表基础题！！！
【数据结构】 链表 -习题
m0_74195626的博客
04-01 1345
解释：链表中的结点是动态开辟出来的，跟连不连续没关系，可能会动态开辟连续的两块内存空间，但是大概率还是不连续的，因此连续或不连续都可以。在一个单链表head中，若要在指针p所指结点后插入一个q指针所指结点，则执行▁▁▁▁▁。对于D：p->next为a中第二个结构体{7，&a[2]}，p->next->n即为7。对于一个头指针为head的带头结点的单链表，判定该表为空表的条件是▁▁▁▁▁。在一个单链表head中，若要删除指针p所指结点的后继结点，则执行（）。链表要求内存中可用存储单元的地址 ▁▁▁▁▁。
9 道经典单链表题目助你领略单链表逻辑结构的 “魅力”
honglan297的博客
08-01 737
上一篇文章，我们具体讲述了链表的相关知识。本篇紧承上集，通过 9 道单链表较为 ”简单“ 的题目的讲解，让你领略单链表的别样的逻辑结构 “魅力“。同时，单链表作为笔试常考话题之一，简单题目的回顾希望能够帮助大家夯实操作单链表的基础...
Python基础入门练习题 Python基础笔试题 Python面试初阶题目 共7页.pdf
06-17
5. **MonkeyRunner和MonkeyDevice**： MonkeyRunner是Android SDK的一部分，用于自动化测试。MonkeyDevice对象提供了对设备进行各种操作的方法，如点击、滑动、安装和卸载APK等。具体的函数使用方法和参数意义需要...
C++初阶 - 入门.pdf
01-15
C++初阶 - 入门.pdf C++是一种功能强大且灵活的编程语言，它是由Bjarne Stroustrup在1983年开发的。C++是C语言的超集，添加了对象导向编程的特性，使得编程更加灵活和高效。 1. C++98标准 C++98是C++语言的第一个...
理财教程-分入门-初阶-进阶教程
07-05
我花时间静心制作的一个教程。 这是一个投zi货币的一个教程，教你如何一步步理财到实现财务自由 适合投资小白，也适合有一定基础的同学进阶学习。 资源是视频教程，非常细致详尽 涉及多方面知识，K线图等
C语言初阶指针.zip
01-14
本资料"《C语言初阶指针》"将帮助初学者理解这一关键概念。 首先，我们要知道什么是指针。指针变量是一个特殊的变量，它存储的是另一个变量的地址，即内存中的位置。在C语言中，通过使用`*`运算符，我们可以声明一...
基础链表练习（附详细注释）
04-08
实现一个带头结点的字符串链表，每插入一个字符串，链表会对其进行按字典进行排序。 重复插入的字符串自动忽略。 通过索引号可以获取到对应位置上的字符串。 移除一个特定的元素 返回链表中存储的字符串个数
单链表基础实现+单双链表数组模拟+STL使用+习题练习（超详解）
2302_79366101的博客
11-04 184
链表由一系列节点（链表中每一个元素称为节点）组成，节点在运行时动态生成 （malloc），每个节点包括两个部分：一个是存储数据元素的数据域data另一个是存储下一个节点地址的指针域next*
链表经典 10题
mu_tong_的博客
10-12 2238
链表10 道经典例题
链表简单例题
qq_51542797的博客
03-19 454
1.给你一个链表的头节点 head ，判断链表中是否有环。 bool hasCycle(struct ListNode *head) { //快慢结点法 //定义两个结点，一个快结点，一个慢结点，所谓快结点就是一次跳两个，慢结点按部就班一次跳一个 //若链表有环则快结点一定先进入在环中旋转，慢结点后进入，当两个结点相遇时说明存在环 //若快结点直接跑到NULL了说明没有环 if(head == NULL || head->next == NULL) .
【数据结构】链表入门基础题
weixin_72437555的博客
12-03 420
最近笔者正在准备实验室的考核，用一些时间简单刷了一些leetcode中的简单链表题，其中遇到了些许问题并通过自己的思考加以解决，现以此博客写下自己的题解并记录自己刷题的心得。如有错误，请不吝指出。为了方便读者写博客，也为了方便读者读博客，现在下方放出笔者定义的链表存储结构与用尾插法创建链表的代码链表存储结构 尾插法创建链表 二、链表的基础操作 首先在做题之前，希望读者能够仔细阅读以下的基础操作，后续笔者的例题与以下的操作息息相关思路： ①声明一个指针指向链表第一个有效节点，也就是头结点后面的第一个结点。初始
【算法专题】链表排序算法总结
weixin_42638946的博客
10-24 4968
链表排序算法总结 概述 问题描述：给定一个链表，请将这个链表升序排列。 节点定义： struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; 1 链表插入排序 题目描述：Leetcode 0147 链表进行插入排序 分析 因为头结点可能会改变，因此需要设置一个虚拟头结点dummy。 我们从前向后遍历整个链表，假设当前考察节点为p，我们需要从
链表-基础算法题
CenShell
12-27 610
0.基本概念 单链表结点的结构 struct ListNode { int data; struct ListNode* next; ListNode() {} ListNode(int data, ListNode* next = NULL) : data(data), next(next) {} }; 有无头结点只对尾插法的操作有影响，对头插法没有影响 ⚠️尾插法一定要提供尾指针 1.添加/删除链表节点 添加值为 x 的结点 带头结点的递增有序的单链表 L 添加一个值为 x 的结
扁平化图标设计入门：初阶形状与色彩策略
【设计经验传承】图标设计初阶要先型 在UI设计领域，图标作为至关重要的组成部分，随着扁平化设计潮流的发展，对图标的要求已经转向了简洁明了的象征性表达，平面图标已经成为主流。图标设计是一项核心技能，这篇...
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hey pear!

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值