数据结构第四讲：单链表OJ题

最新推荐文章于 2024-11-07 15:11:39 发布
最新推荐文章于 2024-11-07 15:11:39 发布
阅读量374 收藏 10
点赞数 9
分类专栏： 数据结构初阶 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79761834/article/details/140686707
版权

数据结构第四讲：单链表OJ题

这一讲全部都是关于单链表的数据结构题目，这里有几个注意点：
1.博客中不会出现关于题目的讲解，讲解通过注释或画图来表现出来
2.所有题目都会上传两种代码：一种是代码纯享版，一种是添加了注释之后的代码，所有的画图都会在代码最后进行展示
3.理解是自己在写代码时自己的一些理解，可能不太成熟，请见谅

1.移除链表元素

链接: OJ题目链接

typedef struct ListNode ListNode;

struct ListNode* removeElements(struct ListNode* head, int val) {
	//创建一个头节点和尾节点
    ListNode *phead, *ptail;
    phead = ptail = NULL;

    ListNode* pcur = head;
    while (pcur) {
        if (pcur->val != val) {
            if (phead == NULL) {
                phead = ptail = pcur;
            } else {
                ptail->next = pcur;
                ptail = ptail->next;
            }
        }
        pcur = pcur->next;
    }
    if (ptail) {
        ptail->next = NULL;
    }
    return phead;
}

typedef struct ListNode ListNode;

struct ListNode* removeElements(struct ListNode* head, int val) {
    //首先创建了一个头节点和尾节点
    //理解1：对于单链表OJ题，知道了一个头节点和尾节点就可以了，头节点方便找到链表的头部
    //尾节点用来找到在哪个地方插入新的节点
    ListNode *phead, *ptail;
    //对链表指针进行初始化
    phead = ptail = NULL;

    //使用一个指针来保存头节点，防止头节点移动
    ListNode* pcur = head;
    while (pcur) {
        //如果节点中的数据值不等于要删除的数据，将该节点进行链接
        if (pcur->val != val) {
            if (phead == NULL) {
                phead = ptail = pcur;
            } else {
                //这里一定要写成pcur，不能写成head
                ptail->next = pcur;
                ptail = ptail->next;
            }
        }
        pcur = pcur->next;
    }
    if (ptail) {
        ptail->next = NULL;
    }
    return phead;
}

2.反转链表

链接: OJ题目链接

typedef struct ListNode ListNode;

struct ListNode* reverseList(struct ListNode* head) {
    if (head==NULL || head->next==NULL) {
        return head;
    }
    ListNode *left, *phead, *right;
    left = NULL;
    phead = head;
    right = head->next;
    while (phead) {
        phead->next = left;
        left = phead;
        phead = right;
        if(right)
            right = right->next;
    }
return left;
}

typedef struct ListNode ListNode;
//使用三个指针即可
struct ListNode* reverseList(struct ListNode* head) {
    if (head==NULL || head->next==NULL) {
        return head;
    }
    ListNode *left, *phead, *right;
    left = NULL;
    phead = head;
    right = head->next;
    while (phead) {
        phead->next = left;
        left = phead;
        phead = right;
        if(right)
            right = right->next;
    }
return left;
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.链表的中间节点

链接: OJ题目链接

typedef struct ListNode ListNode;

struct ListNode* middleNode(struct ListNode* head) {
    ListNode *fast, *slow;
    fast = slow = head;

    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

typedef struct ListNode ListNode;

struct ListNode* middleNode(struct ListNode* head) {
    //这道题定义了两个指针，使用的是快慢指针的思想
    //想像两个人A和B在走路，B每次走的距离都比A走的长二倍，那么当B走到终点时，A恰好走到中点
    //这样我们就找到了中间节点的位置了
    ListNode *fast, *slow;
    fast = slow = head;

    while (fast && fast->next) {
        slow = slow->next;
        fast = fast->next->next;
    }
    return slow;
}

在这里插入图片描述
在这里插入图片描述

4.合并两个有序链表

链接: OJ题目链接

typedef struct ListNode ListNode;

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    if (list1 == NULL) {
        return list2;
    }
    if (list2 == NULL) {
        return list1;
    }
    ListNode *phead, *ptail;
    phead = ptail = NULL;
    ListNode* p1 = list1;
    ListNode* p2 = list2;

    while (p1 && p2) {
        if (p1->val <= p2->val) {
            if (phead == NULL) {
                phead = ptail = p1;
            } else {
                ptail->next = p1;
                ptail = p1;
            }
            p1 = p1->next;
        } else {
            if (phead == NULL) {
                phead = ptail = p2;
            } else {
                ptail->next = p2;
                ptail = p2;
            }
            p2 = p2->next;
        }
    }
    if (p1 == NULL) {
        ptail->next = p2;
    } else {
        ptail->next = p1;
    }
    return phead;
}

typedef struct ListNode ListNode;

//这道题的思路是：
//先创建一个新的链表
//再创建两个指针变量p1和p2,比较p1->val和p2->val的大小，谁小就尾插新的链表
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
    if (list1 == NULL) {
        return list2;
    }
    if (list2 == NULL) {
        return list1;
    }
    ListNode *phead, *ptail;
    phead = ptail = NULL;
    ListNode* p1 = list1;
    ListNode* p2 = list2;

    while (p1 && p2) {
        if (p1->val <= p2->val) {
            if (phead == NULL) {
                phead = ptail = p1;
            } else {
                ptail->next = p1;
                ptail = p1;
            }
            p1 = p1->next;
        } else {
            if (phead == NULL) {
                phead = ptail = p2;
            } else {
                ptail->next = p2;
                ptail = p2;
            }
            p2 = p2->next;
        }
    }
    if (p1 == NULL) {
        ptail->next = p2;
    } else {
        ptail->next = p1;
    }
    return phead;
}

在这里插入图片描述

5.链表分割

链接: OJ题目链接

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        ListNode* lesshead = (ListNode*)malloc(sizeof(ListNode));
        ListNode* lesstail = lesshead;
        ListNode* bighead = (ListNode*)malloc(sizeof(ListNode));
        ListNode* bigtail = bighead;

        ListNode* pcur = pHead;
        while(pcur)
        {
            if(pcur->val < x)
            {
                lesstail->next = pcur;
                lesstail = lesstail->next;
            }
            else 
            {
                bigtail->next = pcur;
                bigtail = bigtail->next;    
            }
            pcur = pcur->next;
        }
        lesstail->next = bighead->next;
        bigtail->next = NULL;
        return lesshead->next;
    }
};

class Partition {
public:
    ListNode* partition(ListNode* pHead, int x) {
        //直接创建两个节点lesshead和bighead
        //val值小于x的尾插到lesshead节点
        //val值大于x的尾插到bighead节点
        ListNode* lesshead = (ListNode*)malloc(sizeof(ListNode));
        ListNode* lesstail = lesshead;
        ListNode* bighead = (ListNode*)malloc(sizeof(ListNode));
        ListNode* bigtail = bighead;

        ListNode* pcur = pHead;
        while(pcur)
        {
            if(pcur->val < x)
            {
                lesstail->next = pcur;
                lesstail = lesstail->next;
            }
            else 
            {
                bigtail->next = pcur;
                bigtail = bigtail->next;    
            }
            pcur = pcur->next;
        }
        lesstail->next = bighead->next;
        //这里必须要将最后一个节点的指针指向NULL
        bigtail->next = NULL;
        return lesshead->next;
    }
};

6.链表的回文结构

链接: OJ题目链接

6.1方法1：创建数组

这个方法并不使用于所有情况，题目要求为空间复杂度为O（1），由于题目要求链表长度不大于900，所以我们创建了一个常量的数组，如果链表长度不确定，该题的空间复杂度就变成了O（n）

class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
        //创建一个数组，将节点中的值存储在数组中，通过数组判断是否是回文数
        ListNode* pcur = A;

        int arr[900];
        int sz = 0;
        while(pcur)
        {
            arr[sz++] = pcur->val;
            pcur = pcur->next;
        }
        int left = 0;
        int right = sz-1;
        while(left < right)
        {
            if(arr[left++] != arr[right--])
            {
                return false;
            }
        }
        return true;
    }
};

class PalindromeList {
public:
    bool chkPalindrome(ListNode* A) {
        //创建一个数组，将节点中的值存储在数组中，通过数组判断是否是回文数
        ListNode* pcur = A;

        int arr[900];
        int sz = 0;
        while(pcur)
        {
            arr[sz++] = pcur->val;
            pcur = pcur->next;
        }
        //使用数组进行检查的思路为：
        //定义两个头尾指针，判断头尾指针指向的值是否相同
        int left = 0;
        int right = sz-1;
        //left不能够大于right，这可以作为循环条件
        while(left < right)
        {
            if(arr[left++] != arr[right--])
            {
                //当存在一个数不同时，就不是回文数
                return false;
            }
        }
        return true;
    }
};

6.2方法2：反转链表

class PalindromeList {
public:
    ListNode* FindBet(ListNode* phead)
    {
        //快慢指针进行查找
        ListNode* slow, *fast;
        slow = fast = phead;
        while(fast && fast->next)
        {
            slow = slow->next;
            fast = fast->next->next;
        }
        return slow;
    }

    ListNode* Reserve(ListNode* A, ListNode* bet)
    {
        ListNode* left = NULL;
        ListNode* phead = A;
        ListNode* right = A->next;

        while(phead != bet)
        {
            phead->next = left;
            left = phead;
            phead = right;
            if(right != bet)
                right = right->next;
        }
        return left;
    }

    bool chkPalindrome(ListNode* A) {
        //先查找链表中有几个节点
        int count = 0;
        ListNode* pcur = A;
        while(pcur)
        {
            count++;
            pcur = pcur->next;
        }

        //先找到中间节点
        ListNode* bet = FindBet(A);

        //然后进行逆置
        ListNode* phead = Reserve(A, bet);

        if(count%2 != 0)
            bet = bet->next;
        while(bet)
        {
            if(phead->val != bet->val)
            {
                return false;
            }
            phead = phead->next;
            bet = bet->next;
        }
        return true;
    }
};

7.相交链表

链接: OJ题目链接

typedef struct ListNode ListNode;

struct ListNode* getIntersectionNode(struct ListNode* headA,
                                     struct ListNode* headB) {
    // 首先先判断是否存在相交节点
    // 存在相交节点的充要条件为：两个链表中的最后一个节点是同一个节点
    ListNode *ptail1, *ptail2;
    ptail1 = headA;
    ptail2 = headB;

    int count1 = 0;
    int count2 = 0;
    while (ptail1->next) {
        count1++;
        ptail1 = ptail1->next;
    }
    while (ptail2->next) {
        count2++;
        ptail2 = ptail2->next;
    }
    if (ptail1 != ptail2) {
        return NULL;
    } else {
        // 将长链表截取一部分
        int cut = abs(count1 - count2);
        ListNode* lesslong = headA;
        ListNode* morelong = headB;
        if (count1 > count2) {
            lesslong = headB;
            morelong = headA;
        }
        while (cut--) {
            morelong = morelong->next;
        }
        while (lesslong != morelong) {
            lesslong = lesslong->next;
            morelong = morelong->next;
        }
        return lesslong;
    }
}

typedef struct ListNode ListNode;

//思路为：
//先分别求出两个链表的长度，将长的那个链表截取几个节点，使得两个链表一样长
//分别从两个链表的头节点进行遍历，当两个节点相同时，这个相同的节点就是相交的节点
struct ListNode* getIntersectionNode(struct ListNode* headA,
                                     struct ListNode* headB) {
    // 首先先判断是否存在相交节点
    // 存在相交节点的充要条件为：两个链表中的最后一个节点是同一个节点
    ListNode *ptail1, *ptail2;
    ptail1 = headA;
    ptail2 = headB;

    //后续我们要求长链表向后移动多少，所以我们要知道每一个链表的长度
    int count1 = 0;
    int count2 = 0;
    while (ptail1->next) {
        count1++;
        ptail1 = ptail1->next;
    }
    while (ptail2->next) {
        count2++;
        ptail2 = ptail2->next;
    }
    if (ptail1 != ptail2) {
        return NULL;
    } else {
        // 将长链表截取一部分
        int cut = abs(count1 - count2);
        ListNode* lesslong = headA;
        ListNode* morelong = headB;
        if (count1 > count2) {
            lesslong = headB;
            morelong = headA;
        }
        while (cut--) {
            morelong = morelong->next;
        }
        while (lesslong != morelong) {
            lesslong = lesslong->next;
            morelong = morelong->next;
        }
        return lesslong;
    }
}

8.环形链表一

链接: OJ题目链接

typedef struct ListNode ListNode;

bool hasCycle(struct ListNode *head) {
    ListNode* slow, *fast;
    slow = fast = head;

    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
            return true;
    }
    return false;
}

在这串代码中，我们使用了快慢指针的方法，让慢指针一次走一步，快指针一次走两步，如果两个指针相同了，就证明存在环形链表，那这是为什么呢？

8.1原理解释

在这里插入图片描述

8.2拓展思维

那么如果我让fast指针一次走三个单位，那么两个指针还会不会相遇呢？
在这里插入图片描述
在这里插入图片描述
所以我们知道了：追不上只有一种情况：N为奇数，C为偶数
我们再来看：
在这里插入图片描述
在这里插入图片描述
对于2L = (x+1)C-N这个公式来说，公式左边一定为偶数，当N为奇数时，为让等式成立，那么(x+1)C也必须为奇数，所以说根本就不存在N为奇数，C为偶数的情况

所以说，不管fast比slow快多少，如果它们两个能够相遇，就证明存在环形链表，但是一般我们还是让fast比slow快两倍来求

9.环形链表二

链接: OJ题目链接

typedef struct ListNode ListNode;

struct ListNode *detectCycle(struct ListNode *head) {
    //先判断是否存在环形链表
    ListNode* slow, *fast;
    slow = fast = head;

    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast)
            break;
    }
    if(fast==NULL || fast->next==NULL)
        return NULL;
    //此时说明肯定存在环形链表，这时需要找到环形节点存在的位置
    ListNode* pcur = head;
    while(1)
    {
        if(fast == pcur)
            return pcur;
        fast = fast->next;
        pcur = pcur->next;
    }
}

这次的代码还是很简单，只需要先通过快慢指针找到两指针的相遇点，再让一个指针指向头指针，将头指针和相遇点指针向后移，两指针相遇的位置就是环形链表成环的位置

9.1原理解释

在这里插入图片描述
在这里插入图片描述

10.随机链表的复制

链接: OJ题目链接

10.1题目解析

题目就是指：
一个节点中多出了一个random指针，该指针指向的位置不确定，可以指向NULL，可以指向自己，可以指向链表中其他节点的地址。
我们要做的是对这样的一个链表进行深拷贝，也就是需要单独创建空间并进行赋值

10.解题代码

typedef struct Node Node;

//申请空间的函数
Node* BuyNode(int x)
{
    Node* newnode = (Node*)malloc(sizeof(Node));
    newnode->val = x;
    newnode->next = newnode->random = NULL;

    return newnode;
}

struct Node* copyRandomList(struct Node* head) {
    if(head == NULL)
        return NULL;
    Node* pcur = head;

    //将链表间链接起来
    while(pcur)
    {
        Node* Next = pcur->next;
        Node* newnode = BuyNode(pcur->val);
        pcur->next = newnode;
        newnode->next = Next;

        pcur = Next;
    }
    //对加入的新的节点进行赋值
    pcur = head;
    while(pcur)
    {
        Node* copy = pcur->next;
        if(pcur->random != NULL)
        {
            copy->random = pcur->random->next;
        }
        pcur = copy->next;
    }
    //将两个链表分开
    pcur = head;
    Node* newHead, *newTail;
    newHead = newTail = pcur->next;
    while(pcur->next->next)
    {
        pcur = pcur->next->next;
        newTail->next = pcur->next;
        newTail = newTail->next;
    }
    return newHead;
}

在这里插入图片描述

爆炒脑仁
关注
专栏目录
西南科技大学 swust oj #952: 单链表的插入操作的实现
zs_10110的博客
11-08 943
题目描述 建立长度为n的单链表，在第i个结点之前插入数据元素data。 输入 第一行为自然数n，表示链式线性表的长度； 第二行为n个自然数表示链式线性表各元素值； 第三行为指定插入的位置i；第四行为待插入数据元素data。 输出 指定插入位置合法时候，输出插入元素后的链式线性表的所有元素，元素之间用一个空格隔开。输入不合法，输出"error!"。 样例输入 5 1 2 3 4 5 3 6 样例输出 1 2 6 3 4 5 #include<stdio.h> #incl
数据结构：单链表OJ题
qq_71391318的博客
10-11 1252
相交链表、环形链表、链表随机复制（深拷贝）
数据结构_第五关：单链表OJ题练习
weixin_60630270的博客
04-04 1002
一些关于数据结构链表部分的OJ题练习和解答
数据结构（Java）：力扣单链表面试OJ题
2401_83595513的博客
07-08 2266
单链表面试题
数据结构：单链表OJ
Early_East_Moon的博客
11-02 114
上述十道题都是很经典的链表OJ题，读者不妨一试，以加深对链表的了解。t=N7T8t=N7T8t=N7T8t=N7T8t=N7T8t=N7T8t=N7T8t=N7T8t=N7T8t=N7T8力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？力扣提供海量技术面试资源，帮助你高效提升编程技能，轻松拿下世界 IT 名企 Dream Offer。力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台备战技术面试？
数据结构 ——— 单链表oj题：反转链表
weixin_55341642的博客
10-03 570
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表
数据结构--单链表OJ题
m0_74068921的博客
08-03 699
上文回顾---单链表这章将来做一些链表的相关题目。目录1.移除链表元素2.反转链表3.链表的中间结点4.链表中的倒数第k个结点5.合并两个有序链表6.链表分割7.链表的回文结构8.相交链表9.环形链表​编辑 10.环形链表II​编辑 ​编辑 答案： 2.反转链表 答案： 答案： 答案： 答案： 答案： 答案： 答案： 9.环形链表 答案： 10.环形链表II 答案：
数据结构 ——— 单链表oj题：链表中倒数第K个节点
weixin_55341642的博客
10-03 396
输入一个链表，输出该链表中的倒数第K个节点（注意：k的值小于等于链表节点的总个数）
数据结构 ——— 单链表oj题：返回链表的中间节点
weixin_55341642的博客
10-02 444
slow 指针一次走一步，fast 指针一次走两步，那么 fast 指针就是 slow 指针的二倍
【数据结构】单链表OJ题（一）
小王又困了的博客
08-05 2050
在上一期中我们给大家介绍了单链表，也了解了单链表的实现。接下来就让我们进入实践，练习一些经典题目，让我们拿捏单链表。
数据结构与算法初阶刷题篇1：线性表—单链表OJ面试题训练
King_lm_Guard的博客
07-08 795
数据结构与算法初阶篇：单链表经典面试OJ题分析及讲解。
数据结构——线性表（SWUSTOJ 952: 单链表的插入操作的实现）
无聊人的博客
07-16 3547
952: 单链表的插入操作的实现题目描述输入输出样例输入样例输出源代码 题目描述 建立长度为n的单链表，在第i个结点之前插入数据元素data。 输入 第一行为自然数n，表示链式线性表的长度； 第二行为n个自然数表示链式线性表各元素值； 第三行为指定插入的位置i；第四行为待插入数据元素data。 输出 指定插入位置合法时候，输出插入元素后的链式线性表的所有元素，元素之间用一个空格隔开。输入不合法，输出"error!"。 样例输入 5 1 2 3 4 5 3 6 样例输出 1 2 6 3 4 5 源代码 #in
SDUTOJ（1138）数据结构上机测试2-1:单链表操作A
朕与众爱卿皆瞠目结舌的博客
02-26 221
数据结构上机测试2-1:单链表操作ATime Limit: 1000 ms Memory Limit: 4096 KiB Submit Statistic Discuss Problem Description输入n个整数，先按照数据输入的顺序建立一个带头结点的单链表，再输入一个数据m,将单链表中的值为m的结点全部删除。分别输出建立的初始单链表和...
BJFU_OJ系统数据结构习题目录
热门推荐
雪地行进
11-27 2万+
欢迎登录北京林业大学OJ系统 http://www.bjfuacm.com 持续补充中 黑色标题意味代码未完成 204基于顺序存储结构的图书信息表的创建和输出 205基于顺序存储结构的图书信息表的排序 206基于顺序存储结构的图书信息表的修改 207基于顺序存储结构的图书信息表的逆序存储 208基于顺序存储结构的图书信息表的最贵图书的查找 209基于顺序存储结构的图书信息表的最爱图书的查找 210...
【数据结构与算法】-空间复杂度
baidu_25347287的博客
11-07 894
空间复杂度是衡量算法在运行过程中临时占用存储空间大小的一个重要指标。它描述了算法所需的额外存储空间与输入数据规模之间的关系。空间复杂度通常也用大O表示法（Big O notation）来表示。递归调用栈：考虑递归调用栈的深度。动态规划：考虑中间结果的存储空间。多维数组：考虑多维数组的大小。缓存和哈希表：考虑缓存和哈希表的大小。图的遍历：考虑访问状态记录和递归调用栈的大小。
数据结构之单链表（C语言）
最新发布
Duan1044592637的博客
11-07 896
1 链表的概念 2 节点创建与链表打印 3 单链表尾插法与头插法 4 单链表尾删法与头删法 5 指定位置插入与删除 6 链表数据的查找与链表销毁 7 单链表全程序及演示结果
交换排序与快速排序
h3286918168的博客
11-05 888
3、在走的过程中，若end遇到小于key的数，则停下，begin开始走，直到begin遇到一个大于key的 数时，将begin和right的内容交换，end再次开始走，如此进行下去，直到begin和end最终相遇，此 时将相遇点的内容与key交换即可。基本思想: 所谓交换，就是根据序列中元素值进行比较，根据比较结果对两个数据进行位置的相互交换序列中的位置，交换特点：将键值大的元素向序列尾部移动或将键值小的元素向序列的前部移动。4.此时key的左边都是小于key的数，key的右边都是大于key的数。
力扣第39题：组合总和（C语言解法）
weixin_48941116的博客
11-05 498
在一个无重复元素的数组candidates中找到所有和为目标值target的组合。数组中的数字可以多次使用，且组合中的元素按非递减顺序排列。
开放寻址法、链式哈希数据结构详细解读
m0_61840987的博客
11-06 909
开放寻址法在低负载因子时效率较高，而链式哈希在高负载因子下表现更稳定。
C语言数据结构课程设计：九度OJ题目解题代码集锦
资源摘要信息: "九度OJ,c语言数据结构课程设计源码报告,c语言程序" 1. 九度OJ简介 九度OJ（Online Judge）是一个在线程序设计竞赛平台，为编程爱好者提供了一个在线提交代码并进行算法与数据结构题目的测试环境。它...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值