链表OJ练习一(精选OJ题)

已于 2023-02-08 09:05:36 修改
阅读量795 收藏 2
点赞数 4
分类专栏： 代码编程题 文章标签： 链表 数据结构
于 2023-02-06 10:49:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wutongguo/article/details/128883105
版权

前言

我们在前面学习了单链表的基本知识，我们需要运用它，才可以掌握它，所以我们选了几个经典OJ题，大家可以做做看着自己掌握没有 。

这时练习一，就有练习二,大家可以直接点击过去。

OJ练习

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

在这里插入图片描述

思路：我们可以先遍历一遍链表，在遍历的过程中，我们可以将其中不等于val的值尾插到一个新链表中，然后将等于val的结点直接删除。

struct ListNode* removeElements(struct ListNode* head, int val){
    //用新指针代表链表的移动
    struct ListNode* cur =head;
    //创建一个新链表，来进行尾插
    struct ListNode* newhead ,*tail;
    newhead = tail =NULL;

    //将上面这个链表遍历一遍
    while(cur)
    {
       //判断跟val是否相等
       if(cur->val!=val)
       {
           //如果第一个是空指针，就直接赋给它，第一个不是空指针就尾插
           if(tail==NULL)
           {
               newhead = tail = cur;
               cur = cur->next;
           }
           else
           {
               tail ->next = cur;
               tail = tail->next;
               cur=cur->next;
           }
       } 
       //如果不等于val就直接跳过
       else if(cur->val==val)
       {
           cur=cur->next;
       }
    }
    //防止最后一个结点等于val
    if(tail->next != NULL)
        tail->next = NULL;
    return newhead; 
}

在这里插入图片描述

我们发现程序并不能跑过去，我想进行调试但是好像不能进行调试，所以我们为了调试可以用自己写过的链表稍加修改就可以进行调试了，
这个工作确实有点难度，但是是提升自己能力的时候，我们不能放弃。

自己构建链表进行调试

下面是我的链表调试代码，大家可以参考一下。

#define _CRT_SECURE_NO_WARNINGS 1 
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

//动态开辟链表
SLTNode* BuySLTNode(SLTDataType n)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = n;
	newnode->next = NULL;
	return newnode;
}
//创建n个链表
SLTNode* CreatSList(int* arr)
{
	SLTNode* phead = NULL;
	SLTNode* ptail = NULL;
	for (int i = 0; i < 5; i++)
	{
		SLTNode* newnode = BuySLTNode(arr[i]);
		if (phead == NULL)
		{
			phead = ptail = newnode;
		}
		else
		{
			ptail->next = newnode;
			ptail = newnode;
		}
	}
	return phead;
}


//单链表的释放
void SLTDestroy(SLTNode** pphead)
{
	SLTNode* cur = *pphead;

	while (cur)
	{
		SLTNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

void SLTPushFront(SLTNode** pphead, SLTNode* cur)
{
	cur->next = *pphead;
	*pphead = cur;
}



int main()
{
	int arr[7] = { 1,2,6，3，4，5，6};

	SLTNode* plist = CreatSList(arr);

}

有了这个我们将上面的题目复制粘贴到我们的代码上我们就可以自己进行调试了。

我们发现两个问题，
第一个问题：如果链表是空链表的时候，我们没有处理。
第二个问题：在遍历完一遍链表，newhead还是空链表的时候，我们最后一步if判断进行了空链表的引用。
我们这时侯就感谢我们的自己构建的链表，在进行调试的时候，就可以解决了。

最后代码

truct ListNode* removeElements(struct ListNode* head, int val){
    //用新指针代表链表的移动
    struct ListNode* cur =head;
    //创建一个新链表，来进行尾插
    struct ListNode* newhead ,*tail;
    newhead=tail=NULL;
    //防止是空链表
    if(head==NULL)
    {
        return NULL;
    }
    //将上面这个链表遍历一遍
    while(cur)
    {
       //判断跟val是否相等
       if(cur->val!=val)
       {
           //如果第一个是空指针，就直接赋给它，第一个不是空指针就尾插
           if(tail==NULL)
           {
               newhead = tail = cur;
               cur = cur->next;
           }
           else
           {
               tail ->next = cur;
               tail = tail->next;
               cur=cur->next;
           }
       } 
       //如果不等于val就直接跳过
       else if(cur->val==val)
       {
           cur=cur->next;
       }
    }
    //防止最后一个结点等于val
    if(tail != NULL)
        tail->next = NULL;
    return newhead; 
}

拓展(使用哨兵位的头结点来做这个题)

为什们用哨兵位的头结点呢？
我们在尾删或者尾插的时候，可能我们在插或删的过程中，会遇到空链表，在插入的时候，需要用二级指针。但是我们用哨兵位的头结点的时候，我们就不需要考虑这个问题，因为无论如何我们都有一个哨兵位，不会成为空链表，所以我们用起来更舒服。

用哨兵位的头结点，很好尾插，所以我们遇到尾插的时候就可以用哨兵位的头结点。

struct ListNode* removeElements(struct ListNode* head, int val){
    //用新指针代表链表的移动
    struct ListNode* cur =head;
    //创建一个新链表，来进行尾插
    struct ListNode* guard,*tail;
    //创建一个表头
    guard = tail=(struct ListNode*)malloc(sizeof(struct ListNode));
    guard->next=NULL;
    //防止是空链表
    if(head==NULL)
    {
        return NULL;
    }
    //将上面这个链表遍历一遍
    while(cur)
    {
       //判断跟val是否相等
       if(cur->val!=val)
       {
           //现在就直接尾插就可以了，不用分两种情况
           tail->next=cur;
           cur=cur->next;
           tail=tail->next;
       } 
       //如果不等于val就直接跳过
       else if(cur->val==val)
       {
           cur=cur->next;
       }
    }
    tail->next = NULL;
    return guard->next; 
}

(2)反转链表

在这里插入图片描述

思路一：创建一个新链表，然后进行头插
思路二：将链表的箭头直接反过来不久好了吗

思路一：头插

struct ListNode* reverseList(struct ListNode* head){
   struct ListNode* newhead ;
	struct ListNode* cur, *next;
	cur  = head;
	newhead = NULL;
	while (cur)
	{
		next=cur->next;
        cur->next=newhead;
        newhead=cur;
        cur=next;
	}
	return newhead;
}

思路二：将箭头直接改变方向

在这里插入图片描述

我们想要实现这个东西，我们就要用三个指针，来进行链表方向的改动
n1和n2来进行方向的改变，而n3进行保留下一个结点的地址。

struct ListNode* reverseList(struct ListNode* head){
    //我们看着图命名
    struct ListNode* n1=NULL;
    struct ListNode* n2=head;
    struct ListNode* n3;
    //防止链表是空指针
    if(head!=NULL)
        n3=head->next;
    //循环的条件是就是n2等于空指针的时候
    while(n2)
    {
        n2->next=n1;
        n1=n2;
        n2=n3;
        //防止n3是空指针，形成空指针的解引用
        if(n3!=NULL)
            n3=n3->next;
    }
    return n1;

}

(3)合并两个有序链表

在这里插入图片描述

思路:创建一个新的链表，然后一个一个比较，然后在尾插，直到我们尾插完，我们上面说了尾插的时候，我们用哨兵位的头结点，这样简单

代码如下

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2){
    //创建一个哨兵位的新链表
    struct ListNode* Newhead,*tail;
    Newhead=tail=(struct ListNode*)malloc(sizeof(struct ListNode));
    Newhead->next=NULL;
    struct ListNode* cur1=list1;
    struct ListNode* cur2=list2;
    //空链表直接返回空指针
    if(list1==NULL&&list2==NULL)
    {
        return NULL;
    }
    //将两个链表进行遍历
    //循环的条件就是其中一个链表走完就是结束了
    while(cur1&&cur2)
    {
        //将list1的链表尾插
        if(cur1->val<=cur2->val)
        {
            tail->next=cur1;
            cur1=cur1->next;
            tail=tail->next;
        }
        //将list2的链表尾插
        else
        {
            tail->next=cur2;
            cur2=cur2->next;
            tail=tail->next;
        }
    }
    //将其中剩下的一个链表尾插上去
    if(cur1==NULL)
    {
        tail->next=cur2;
    }
    else if(cur2 ==NULL)
    {
        tail->next=cur1;
    }
    //提交的是哨兵位头结点的下一个
    return Newhead->next;
}

(4)链表的中间结点

在这里插入图片描述

思路：其实这道题考验的是逻辑问题，中间结点有两种
一个是奇数的中间结点，奇数的中间结点是就是中间的那一个
另一个是偶数的中间结点，偶数的中间结点有两个，我们选后面的那个

这时，我们想一下，我们在找的都是中间的东西，那么现在有一只猫和一只狗，已知狗的速度是猫的二倍，那么问题是等狗到终点，我们的猫在哪里。
很显然猫在离终点的一半位置。

所以我们可以按照这个思路，我能整两个指针，然后一个指针正常走，另一个指针的速度是他的二倍。我们找到中点就是我们的第一个指针。
在这里插入图片描述

从图中我们可以看出，
当是奇数的时候，当fast的next等于NULL的时候停下来。
当是偶数的时候，当fast等于NULL的时候停下来
代码如下

struct ListNode* middleNode(struct ListNode* head){
    struct ListNode* slow =head;
    struct ListNode* fast=head;
    //条件就是当fast的next或fast等于NULL
    while(fast&&fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}

(5)链表中倒数第k个结点

其实跟上一题的思路基本一致，也是速度差
但是我们找倒数第几个，先有两个指针，然后我们先将第一步将两个指针的距离隔上k步然后再依次走，直到fast等于空指针停下来。

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    struct ListNode* slow = pListHead;
    struct ListNode* fast = pListHead;
    struct ListNode* num = pListHead;
    int i=0;
    while(num)
    {
        num=num->next;
        i++;
    }
    if(k>i)
    {
        return NULL;
    }
    while(k--)
    {
        fast=fast->next;
    }
    while(fast)
    {
        slow=slow->next;
        fast=fast->next;
    }
    return slow;
}

(6)链表分割

在这里插入图片描述

其实思路还是很好写的，关键是代码的编写，
思路是先将比X小的创建一个链表，然后将比X大的创建一个链表，然后将链表合并。

代码如下

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        //用哨兵位的链表
        struct ListNode* SmallList,*GreatList,*Stail,*Gtail;
        GreatList=Gtail=(struct ListNode*)malloc(sizeof(struct ListNode));
        SmallList=Stail=(struct ListNode*)malloc(sizeof(struct ListNode));
        struct ListNode* cur = pHead;
        Gtail->next=NULL;
        Stail->next=NULL;
        //将小于x的值放到小的链表上去
        while(cur)
        {
            if(cur->val<x)
            {
                Stail->next=cur;
                Stail=Stail->next;
            }
            else if(cur->val>=x)
            {
                Gtail->next=cur;
                Gtail=Gtail->next;
            }
            cur=cur->next;     
        }
        //将链表合并
        Stail->next=GreatList->next;
        Gtail->next=NULL;
        pHead=SmallList->next;
        free(SmallList);
        free(GreatList);

        return pHead;
    }
};

(7)链表的回文结构

在这里插入图片描述

思路：我们先运用速度差，将来改链表分为两个链表，然后再将第二个链表反转，最后再将两个链表比较，直到第一个链表为空，如果相等，那么就是回文链表，不然则不是。

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

struct ListNode* reverseList(struct ListNode* head){
    //我们看着图命名
    struct ListNode* n1=NULL;
    struct ListNode* n2=head;
    struct ListNode* n3;
    //防止链表是空指针
    if(head!=NULL)
        n3=head->next;
    //循环的条件是就是n2等于空指针的时候
    while(n2)
    {
        n2->next=n1;
        n1=n2;
        n2=n3;
        //防止n3是空指针，形成空指针的解引用
        if(n3!=NULL)
            n3=n3->next;
    }
    return n1;

}


class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
        struct ListNode* slow =A;
        struct ListNode* fast=A;
        struct ListNode* pre =A;
        //条件就是当fast的next或fast等于NULL
        while(fast&&fast->next)
        {
            pre=slow;
            slow=slow->next;
            fast=fast->next->next;
        }
        //将链表一分为二
        pre->next=NULL;
        //反转链表
        slow=reverseList(slow);
        //判断是否是回文链表
        while(A)
        {
            if(A->val==slow->val)
            {
                A=A->next;
                slow=slow->next;
            }
            else
            {
                return false;
            }
        }
        return true;
    }
};

总结

这个就是对于单链表知识理解没有的掌握，我们将这些题做完，我们就会对我们的链表知识的掌握更加深刻。

桐桐超努力
关注
专栏目录
链表OJ练习
weixin_34352492的博客
01-21 649
链表OJ练习 使用力扣练习链表的增删改查 目录链表OJ练习一、链表的删除二、反转单链表2.读入数据总结 一、链表的删除 【题目】：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 【分析】: 需要判断删除节点是否为空 if(head == null){ return null; } 删除头节点 i
OJ习题.zip
12-22
《OJ习题.zip》是一个包含了多个编程题目和相关知识点的压缩包，主要涉及C/C++编程语言的基础和进阶概念。以下是对每个文件名称所对应的知识点的详细解释： 1. **结构体、共用体和枚举** 结构体是C/C++中一种复合...
链表OJ练习题
2302_76591114的博客
05-21 660
整体的思路就是创建快指针fast和慢指针slow，先让fast走k步，然后fast和slow一起走，当fast = NULL时，slow就是倒数第k个节点。假设当slow刚进入环时，fast距slow为N，fast在追赶slow，相当于是每次两者之间的距离都减小1。注：慢指针不可能走超过一圈，如果慢指针走一圈，说明快指针走了两圈，但是不可能，两者相遇就结束了。也是用快慢指针，一个fast每次走两步，一个slow每次走一部，相当于是追赶问题。不行，拿2举例，每次距离缩小2，必须是2的倍数才能相遇。
【数据结构与算法】链表OJ练习题
weixin_63726869的博客
08-05 845
详细讲解了11道链表练习题的分析思路，代码实现，以及多角度的思考，对链表的深入理解有非常大的帮助。
数据结构——链表OJ题
Renswc的博客
02-20 3573
链表oj题练习，链表尾插，我们可以用一个tail指针来记录尾插后的节点，尾插直接在tail节点后即可，这样就不用每次尾插都循环遍历，大大减少了时间复杂度 ，提高了运行效率。
链表OJ题练习
m0_61801103的博客
03-17 562
目录 反转链表 找链表的中间结点 合并两个有序链表 相交链表找公共结点 判断是否有环 判断一个链表是否是回文的 反转链表 题目描述：给你单链表的头节点 head ，反转链表，并返回反转后的链表。 问题分析： 我们可以申请三个指针，第一个指针叫 prev，最初是指向 null 的。第二个指针cur 指向 head，然后不断遍历 cur。第三个变量temp是一个临时变量，用来保存cur下一个节点。每次迭代到 cur，都将 cur 的 next 指向 prev，然后 p...
链表oj题（第一弹）
m0_64334842的博客
11-17 548
链表oj
链表Oj练习题 纯C语言
qq_61386381的博客
07-29 513
链表分割 链表分割 思路： 遍历原链表 把<x的插入到一个链表 把>=×的插入到一个链表 链表1和链表2链接起来 假设链表为3 5 1 6 3 4 则分为： 3 1 3 5 6 4 之后相连即可 魔鬼细节：如图所示，如果6是大链的最后一个数，那么greaterTail->next仍然指向3，会成环 所以需要greaterTail->next=NULL; 防止死循环 /* struct ListNode { int val; ......
链表OJ题
weixin_73077334的博客
06-01 2284
链表OJ题
链表OJ题练习2
qq_41420788的博客
09-03 244
链表OJ习题2链表的倒数第N个节点(双指针） 链表的倒数第N个节点(双指针） 链接：删除链表的倒数第 N 个结点 问题描述 给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。 进阶：你能尝试使用一趟扫描实现吗？ 方法1分析： 我们可以在遍历链表的同时将所有节点依次入栈。 根据栈「先进后出」的原则，我们弹出栈的第 n 个节点就是需要删除的节点，并且目前栈顶的节点就是待删除节点的前驱节点 (需要自己建栈，这里不再赘述) 方法2分析： 先让快指针走n步，再快慢指针同时走，同时记录慢指
西南科技大学SWUST OJ 线性结构，链表题解答案 线性结构.zip
12-31
SWUST OJ是一个在线编程平台，提供各种编程题目供学生练习和挑战，通过解决实际问题来提升编程技能和算法理解。 通过这些题目，学习者不仅可以巩固链表基础知识，还能锻炼逻辑思维和问题解决能力。理解并熟练掌握...
oj题.zip
10-18
这些文件名看起来是编程题目，很可能来源于在线编程竞赛（Online Judge，简称OJ）平台，如LeetCode、Codeforces或HackerRank等。每个.py文件可能代表一个独立的编程问题解决方案，采用Python语言编写。接下来，我们...
【数据结构】双向链表（Doubly Linked List）
2301_77727857的博客
10-05 561
双向链表（Doubly Linked List）是一种链式数据结构，它的每个节点都包含三个部分：数据、指向前一个节点的指针（prev），以及指向下一个节点的指针（next与单向链表不同，双向链表允许从任意节点向前或向后遍历，提供了更灵活的操作方式。
数据结构之图（6）
2301_76246515的博客
10-05 994
图G有顶点集V和边集E组成，记为G=(V,E),其中V（G）表示图G中顶点的有限非空集；E(G)表示图G中顶点之间的关系（边）集合。若V={v1,v2,…，vn}，则用|V|表示图G中顶点的个数。也称为图G的阶E={（u,v)|u ∈​​​V},用|E|表示图G中边的条数图不可以是空，V一定是非空集E是无向边（简称边）的有限集合E是有向边（弧）的有限集合弧是顶点的有序对，记为<v,w>,v为弧尾，w为弧头不存在重复边不存在顶点到自身的边。
C语言 动态数据结构的C语言实现内存映像
hangweijie的博客
10-04 403
在程序运行期间，用动态内存分配函数来申请的内 存都是从堆上分配的，动态内存的生存期由程序员 自己来决定。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自动释放这 些内存。在执行函数调用时，系统在栈上为函数内的局部变 量及形参分配内存，函数执行结束时，自释放这 些内存。存放函数参数值，局部变量值等。存放函数参数值，局部变量值等。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。C程序中变量的内存分配方式。
浙大数据结构：08-图9 关键活动
最新发布
qq_74924951的博客
10-11 238
拓扑排序找关键活动
【数据结构 | PTA】表
等风来
10-08 764
例如给定 L 为 21→-15→-15→-7→15，你需要输出去重后的链表 21→-15→-7，还有被删除的链表 -15→15。输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。输入分两行，分别在每行给出由若干个正整数构成的非降序序列，用−1表示序列的结尾（−1不属于这个序列）。已知两个非降序链表序列S1与S2，设计函数构造出S1与S2合并后的新的非降序链表S3。对每个测试用例，顺序输出重排后的结果链表，其上每个结点占一行，格式与输入相同。
八大排序--05堆排序
m0_74977981的博客
10-08 356
4.parent和child指向的值进行比较，若parent值更大，则符合大顶堆；若parent的值更小，则父子节点进行交换，parent指向child，child指向其左右孩子中的最大值，继续进行比较，直到child为空或是parent指向值最大，则停止。3.判断有没有右孩子，如果有右孩子，左右孩子进行比较，让child指向左右孩子中的最大值。②对顶元素和堆底元素进行交换，除堆底元素之外其余元素继续构造大顶堆；【大顶堆--父结点的值大于或等于左右孩子结点的值】【完全二叉树--数据从上到下，从左到右排列】
旋转链表 东华大学oj
06-03
旋转链表是一种操作链表的方法，它可以将链表中的元素向右旋转 k 个位置。具体来说，如果将链表中的每个节点向右移动 k 个位置，则从链表尾部开始计算，移动后的最后一个节点应该移动到链表头部，而倒数第二个节点...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

桐桐超努力

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

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

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

打赏作者

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

抵扣说明：

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

余额充值