链表相关题目的实现

最新推荐文章于 2024-05-01 13:46:38 发布
最新推荐文章于 2024-05-01 13:46:38 发布
阅读量800 收藏
点赞数
分类专栏： 算法与OJ C/C++ 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhyh1435589631/article/details/51510911
版权

1. 环形链表的插值

有一个整数val，如何在节点值有序的环形链表中插入一个节点值为val的节点，并且保证这个环形单链表依然有序。
给定链表的信息，及元素的值A及对应的nxt指向的元素编号同时给定val，请构造出这个环形链表，并插入该值。
测试样例：
[1,3,4,5,7],[1,2,3,4,0],2
返回：{1,2,3,4,5,7}

本质就是链表的插值

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class InsertValue {
public:
    ListNode* insert(vector<int> A, vector<int> nxt, int val) {
        // write code here
        auto res = createList(A, nxt);

        return insertList(res, val);
    }

private:
    // create the list
    ListNode * createList(vector<int> & A, vector<int> & nxt){
        ListNode myhead(0);
        ListNode * pre = &myhead;
        int count = 0;
        int id = 0;
        while (count < (int)nxt.size()){
            ListNode * newNode = new ListNode(A[id]);
            pre->next = newNode;
            pre = newNode;
            id = nxt[id];
            count++;
        }
        //pre->next = myhead.next;
        return myhead.next;
    }

    // insert node
    ListNode * insertList(ListNode * head, int val){
        ListNode myhead(0);
        myhead.next = head;
        ListNode * pre = &myhead;
        bool notfirst = false;
        //while (head != myhead.next || !notfirst){
        while (head){
            notfirst = true;
            if (val <= head->val){
                ListNode * newNode = new ListNode(val);
                pre->next = newNode;
                newNode->next = head;
                return myhead.next;
            }
            else{
                pre = pre->next;
                head = head->next;
            }
        }

        ListNode * newNode = new ListNode(val);
        pre->next = newNode;
        newNode->next = head;
        return myhead.next;
    }
};

2. 访问单个节点的删除

实现一个算法，删除单向链表中间的某个结点，假定你只能访问该结点。
给定带删除的节点，请执行删除操作，若该节点为尾节点，返回false，否则返回true

把后面一个节点的值复制过来， 然后删除后面一个节点

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Remove {
public:
    bool removeNode(ListNode* pNode) {
        // write code here
        if (!pNode || !pNode->next)
            return false;

        pNode->val = pNode->next->val;
        pNode->next = pNode->next->next;
        return true;
    }
};

3. 链表的分化

对于一个链表，我们需要用一个特定阈值完成对它的分化，使得小于等于这个值的结点移到前面，大于该值的结点在后面，同时保证两类结点内部的位置关系不变。
给定一个链表的头结点head，同时给定阈值val，请返回一个链表，使小于等于它的结点在前，大于等于它的在后，保证结点值不重复。
测试样例：
{1,4,2,5},3
{1,2,4,5}

分割成三段链表， 注意连接时候， 空链的判断

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Divide {
public:
    ListNode* listDivide(ListNode* head, int val) {
        // write code here
        if (!head) return nullptr;
        ListNode lower(0), higher(0), equal(0);
        ListNode * preLower = &lower, *preHigher = &higher, *preEqual = &equal;
        while (head){
            if (head->val < val){
                preLower->next = head;
                preLower = head;       
                head = head->next;
                preLower->next = nullptr;
            }
            else if (head->val > val){
                preHigher->next = head;
                preHigher = head;
                head = head->next;
                preHigher->next = nullptr;
            }
            else{
                preEqual->next = head;
                preEqual = head;
                head = head->next;
                preEqual->next = nullptr;
            }          
        }

        if (lower.next){
            preEqual->next = lower.next;
            preLower->next = higher.next;
        }
        else{
            preEqual->next = higher.next;
        }      

        return equal.next;
    }
};

4. 打印两个链表的公共值

现有两个升序链表，且链表中均无重复元素。请设计一个高效的算法，打印两个链表的公共值部分。
给定两个链表的头指针headA和headB，请返回一个vector，元素为两个链表的公共部分。请保证返回数组的升序。两个链表的元素个数均小于等于500。保证一定有公共值
测试样例：
{1,2,3,4,5,6,7},{2,4,6,8,10}
返回：[2.4.6]

类似归并排序的排序过程

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Common {
public:
    vector<int> findCommonParts(ListNode* headA, ListNode* headB) {
        // write code here
        vector<int> res;
        while (headA && headB){
            if (headA->val == headB->val){
                res.push_back(headA->val);
                headA = headA->next;
                headB = headB->next;
            }
            else if (headA->val < headB->val){
                headA = headA->next;
            }
            else{
                headB = headB->next;
            }
        }
        return res;
    }
};

5. 链表的k逆序

有一个单链表，请设计一个算法，使得每K个节点之间逆序，如果最后不够K个节点一组，则不调整最后几个节点。例如链表1->2->3->4->5->6->7->8->null，K=3这个例子。调整后为，3->2->1->6->5->4->7->8->null。因为K==3，所以每三个节点之间逆序，但其中的7，8不调整，因为只有两个节点不够一组。
给定一个单链表的头指针head,同时给定K值，返回逆序后的链表的头指针。

本质： 链表逆序

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class KInverse {
public:
    ListNode* inverse(ListNode* head, int k) {
        // write code here
        ListNode myhead(0);
        myhead.next = head;
        ListNode * pre = &myhead;

        int count = 1;
        while (head){
            head = head->next;
            count++;

            if (count >= k && head){
                ListNode * nextEnd = pre->next;
                ListNode * cur = pre->next;             
                ListNode * nextstart = head->next;
                ListNode * precur = head->next;

                while (cur != nextstart){
                    ListNode * next = cur->next;
                    cur->next = precur;
                    precur = cur;
                    cur = next;
                }
                pre->next = head;
                count = 1;

                pre = nextEnd;
                head = nextstart;
            }
        }

        return myhead.next;
    }
};

6. 链表指定值清除

现在有一个单链表。链表中每个节点保存一个整数，再给定一个值val，把所有等于val的节点删掉。
给定一个单链表的头结点head，同时给定一个值val，请返回清除后的链表的头结点，保证链表中有不等于该值的其它值。请保证其他元素的相对顺序。
测试样例：
{1,2,3,4,3,2,1},2
{1,3,4,3,1}

本质： 链表删除节点

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class ClearValue {
public:
    ListNode* clear(ListNode* head, int val) {
        // write code here
        ListNode myhead(0);
        ListNode * pre = &myhead;
        myhead.next = head;
        while (head){
            if (head->val == val){
                pre->next = head->next;
                head = pre->next;
            }
            else{
                pre = pre->next;
                head = head->next;
            }
        }
        return myhead.next;
    }
};

7. 链表回文结构

请编写一个函数，检查链表是否为回文。
给定一个链表ListNode* pHead，请返回一个bool，代表链表是否为回文。
测试样例：
{1,2,3,2,1}
返回：true
{1,2,3,2,3}
返回：false

本质： 快慢指针分割链表， 链表逆序

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class Palindrome {
public:
    bool isPalindrome(ListNode* pHead) {
        // write code here
        ListNode * left = pHead, * right = nullptr;
        divide(left, right);
        right = reverse(right);

        while (left && right){
            if (left->val != right->val)
                return false;
            left = left->next;
            right = right->next;
        }
        return true;
    }

private:
    void divide(ListNode * & left, ListNode * & right){
        ListNode myhead(0);
        myhead.next = left;
        ListNode * l1 = &myhead, *l2 = &myhead;
        while (l2 && l2->next){
            l1 = l1->next;
            l2 = l2->next->next;
        }
        right = l1->next;
        l1->next = nullptr;
    }

    ListNode * reverse(ListNode * right){
        ListNode * pend = nullptr;
        while (right){
            ListNode * next = right->next;
            right->next = pend;
            pend = right;
            right = next;
        }

        return pend;
    }
};

8. 复杂链表复制

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点）。

leetcode 上的一道经典题目

/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        RandomListNode * start = pHead;
        // clone
        while (pHead){
            RandomListNode * newNode = new RandomListNode(pHead->label);
            newNode->next = pHead->next;
            pHead->next = newNode;
            pHead = pHead->next->next;
        }
        // modify random pointer
        pHead = start;
        while (pHead){
            if (pHead->random)
                pHead->next->random = pHead->random->next;
            pHead = pHead->next->next;
        }
        // split
        RandomListNode myhead(0);
        RandomListNode * pre = &myhead;
        pHead = start;
        while (pHead){
            RandomListNode * tmp = pHead->next;
            pHead->next = tmp->next;
            pre->next = tmp;
            pre = tmp;
            pHead = pHead->next;
        }

        return myhead.next;
    }
};

9. 链表判环

如何判断一个单链表是否有环？有环的话返回进入环的第一个节点的值，无环的话返回-1。如果链表的长度为N，请做到时间复杂度O(N)，额外空间复杂度O(1)。
给定一个单链表的头结点head（注意另一个参数adjust为加密后的数据调整参数，方便数据设置，与本题求解无关)，请返回所求值。

本质： 快慢指针

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class ChkLoop {
public:
    int chkLoop(ListNode* head, int adjust) {
        // write code here
        ListNode myhead(0);
        myhead.next = head;
        ListNode *p1 = head, *p2 = head;
        while (p2 && p2->next){
            p1 = p1->next;
            p2 = p2->next->next;

            // has loop
            if (p1 == p2){
                p1 = myhead.next;
                while (p1 != p2){
                    p1 = p1->next;
                    p2 = p2->next;
                }
                return p1->val;
            }
        }

        return -1;
    }
};

10. 无环单链表判相交

现在有两个无环单链表，若两个链表的长度分别为m和n，请设计一个时间复杂度为O(n + m)，额外空间复杂度为O(1)的算法，判断这两个链表是否相交。
给定两个链表的头结点headA和headB，请返回一个bool值，代表这两个链表是否相交。保证两个链表长度小于等于500。

本质：将两个链表统一成一样长度比较

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class CheckIntersect {
public:
    bool chkIntersect(ListNode* headA, ListNode* headB) {
        // write code here
        int lenA = 0;
        ListNode * pA = headA, *pB = headB;
        while (headA){
            lenA++;
            headA = headA->next;
        }

        int lenB = 0;
        while (headB){
            lenB++;
            headB = headB->next;
        }

        if (lenA > lenB){
            int gap = lenA - lenB;
            headA = pA;
            headB = pB;
            while (gap){
                headA = headA->next;
                gap--;
            }
        }
        else if (lenA < lenB){
            int gap = lenB - lenA;
            headB = pB;
            headA = pA;
            while (gap){
                headB = headB->next;
                gap--;
            }
        }

        while (headA && headB){
            if (headA == headB)
                return true;

            headA = headA->next;
            headB = headB->next;
        }
        return false;
    }
};

11. 有环单链表相交判断

如何判断两个有环单链表是否相交？相交的话返回第一个相交的节点，不想交的话返回空。如果两个链表长度分别为N和M，请做到时间复杂度O(N+M)，额外空间复杂度O(1)。
给定两个链表的头结点head1和head2(注意，另外两个参数adjust0和adjust1用于调整数据,与本题求解无关)。请返回一个bool值代表它们是否相交。

区分两种情况：
这里写图片描述

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class ChkIntersection {
public:
    bool chkInter(ListNode* head1, ListNode* head2, int adjust0, int adjust1) {
        // write code here
        ListNode * p1 = chkLoop(head1);
        ListNode * p2 = chkLoop(head2);
        if (p1 == p2){
            //ListNode * res = chkIntersect(head1, head2, p1);
            return true;
        }
        else{
            ListNode * pcur = p1;
            bool flag = false;
            while (pcur != p1 || !flag){
                flag = true;
                pcur = pcur->next;
                if (pcur == p2)
                    return true;
            }
            return false;
        }
    }

private:
    ListNode * chkLoop(ListNode* head) {
        // write code here
        ListNode myhead(0);
        myhead.next = head;
        ListNode *p1 = head, *p2 = head;
        while (p2 && p2->next){
            p1 = p1->next;
            p2 = p2->next->next;

            // has loop
            if (p1 == p2){
                p1 = myhead.next;
                while (p1 != p2){
                    p1 = p1->next;
                    p2 = p2->next;
                }
                return p1;
            }
        }

        return nullptr;
    }
};

12. 单链表相交判断

给定两个单链表的头节点head1和head2，如何判断两个链表是否相交？相交的话返回true，不想交的话返回false。
给定两个链表的头结点head1和head2(注意，另外两个参数adjust0和adjust1用于调整数据,与本题求解无关)。请返回一个bool值代表它们是否相交。

本质： 上面几种讨论情形的综合情况

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};*/
class ChkIntersection {
public:
    bool chkInter(ListNode* head1, ListNode* head2, int adjust0, int adjust1) {
        // write code here
        ListNode * p1 = chkLoop(head1);
        ListNode * p2 = chkLoop(head2);

        if (p1 && !p2 || !p1 && p2)
            return false;
        else if (!p1 && !p2){
            ListNode * res = chkIntersect(head1, head2, nullptr);
            return res ? true : false;
        }
        else{
            if (p1 == p2){
                //ListNode * res = chkIntersect(head1, head2, p1);
                return true;
            }
            else{
                ListNode * pcur = p1;
                bool flag = false;
                while (pcur != p1 || !flag){
                    flag = true;
                    pcur = pcur->next;
                    if (pcur == p2)
                        return true;
                }
                return false;
            }
        }
    }

private:
    ListNode * chkLoop(ListNode* head) {
        // write code here
        ListNode myhead(0);
        myhead.next = head;
        ListNode *p1 = head, *p2 = head;
        while (p2 && p2->next){
            p1 = p1->next;
            p2 = p2->next->next;

            // has loop
            if (p1 == p2){
                p1 = myhead.next;
                while (p1 != p2){
                    p1 = p1->next;
                    p2 = p2->next;
                }
                return p1;
            }
        }

        return nullptr;
    }

    ListNode * chkIntersect(ListNode* headA, ListNode* headB, ListNode * pend) {
        // write code here
        int lenA = 0;
        ListNode * pA = headA, *pB = headB;
        while (headA != pend){
            lenA++;
            headA = headA->next;
        }

        int lenB = 0;
        while (headB != pend){
            lenB++;
            headB = headB->next;
        }

        if (lenA > lenB){
            int gap = lenA - lenB;
            headA = pA;
            headB = pB;
            while (gap){
                headA = headA->next;
                gap--;
            }
        }
        else if (lenA < lenB){
            int gap = lenB - lenA;
            headB = pB;
            headA = pA;
            while (gap){
                headB = headB->next;
                gap--;
            }
        }

        while (headA != pend && headB != pend){
            if (headA == headB)
                return headA;

            headA = headA->next;
            headB = headB->next;
        }
        return nullptr;
    }
};
枯萎的海风
关注
专栏目录
链表的建立以及插值
weixin_45410402的博客
08-06 830
链表 是一大堆有序数据的结合 一致性，有序性，不一定连续 链表的每一个元素称为“结点” 结点=数据域+指针域 链表=一个头指针+n个结点 我们可以吧（*p）.num改用p->num来代替，他表示p所值向的结构体变量中的num成员。 这有三种方法与之等价： 1，结构体变量。成员名 2.（*p）.成员名 3. p->成员名 创建链表 #include<stdio.h> ...
链表相关题目
LiuRenyou的博客
08-06 280
1:o(1)时间删除链表节点 private void del(ListNode head,ListNode del) { if(del==null)return; if(del.next!=null){ del.val = del.next.val; del.next = del.next.next; ...
链表相关习题
linxizi0622的博客
03-25 408
链表是笔试经常需要考到的类型，所以我查阅了相关资料，补充一下弹药库 typedef struct node {     char *data;      struct node *next;  } node_t; 给定一个结构体，结构体包含一个数据以及指向下一个节点的指针。 那么首先我们要将这个链表打印出来 void list_display(node_t *head)//打印链
链表相关题目详解
qq_43799957的博客
05-23 231
链表相关特点：无法高效获取长度，无法根据偏移快速访问元素。 根据链表的特点衍生出一系列问题：判断环的长度等和长度与位置有关的问题，获取倒数第k个元素，获取中间位置的元素，判断链表是否存在环。这些问题都可以通过灵活运用双指针来解决。 一、判断链表是否有环 141. 环形链表 思路：现在考虑一个环形链表，把慢指针和快指针想象成两个在环形赛道上跑步的运动员（分别称之为慢跑者与快跑者）。而快跑者最终一定会追上慢跑者。这是为什么呢？考虑下面这种情况（记作情况 A）- 假如快跑者只落后慢跑者一步，在下一次迭代中，它们就
链表练习题目（打印）1
08-08
题目要求从链表中删除所有数据成员为素数的结点。首先，我们需要一个辅助函数`IsPrime`来判断一个整数是否为素数： ```c int IsPrime(int n) { if(n) return 0; for(int i=2; i; i++) if(n%i==0) return 0; ...
学生信息管理系统（C++实现，链表实现，还有完整的实验报告）
06-27
定义结构体类型,使用动态链表结构编程实现学生 管理系统如下功能： (1)录入每个学生的基本信息； (2)计算每个学生的平均分； (3)按平均分从高到低输出学生信息； (4)按学生姓名的字典顺序输出学生基本信息； (5)按...
C语言链表题目（附答案）.docx
08-07
本资源摘要信息将详细解释C语言链表题目中的知识点，涵盖链表的建立、功能实现、指针、函数、动态结构建立等方面的知识。 一、链表的概念 链表是一种数据结构，它由多个节点组成，每个节点都包含一个指向下一个...
链表题目总结1
08-03
【链表题目总结1】 链表作为数据结构中的一种，其操作经常出现在编程面试和算法题目中。这里我们总结了几个关于链表的典型问题及其解题方法。 1. **返回倒数第k个节点** (剑指offer 22) - **方法一**：两次遍历法...
链表相关题解
travel_dream的博客
04-09 1169
以下题目皆来自力扣和牛客，可以通过搜索题目名找到对应题目 前期最好配合画图进行解题，要进行特殊情况的考虑。 在进行链表题训练时，最好自己先画图，然后再进行代码的书写，卡壳了或者完全没有思路再看解析。只看完本篇文章不代表你能从容解决链表题。 1. 删除链表中等于给定值 val 的所有节点。//这里的头结点是链表实现的一种方式，后面会介绍到。 画图分析，因为返回头结点，所以可以不用考虑头指针的因素。在实现单链表时也可以这样创建节点，但是要额外创建变量接受指针(返回值)，每次创建节点都要创
【典例】链表经典题目合集
浮光掠影
02-04 5506
爷把鱼缸搬出来了好吧~
链表经典练习题
最新发布
2302_81016149的博客
05-01 834
本篇文章到这里就结束了，如果有不理解的题目，可私信或在评论区留下问题，记得一定要练习，这是非常重要的。再强调：大部分题目解法只为了抛砖引玉。希望对大家有所启发。完！
链表经典 10题
mu_tong_的博客
10-12 2510
链表10 道经典例题
环形链表插值练习
njudongchen的博客
02-21 776
有一个整数val，如何在节点值有序的环形链表中插入一个节点值为val的节点，并且保证这个环形单链表依然有序。 给定链表的信息，及元素的值A及对应的nxt指向的元素编号同时给定val，请构造出这个环形链表，并插入该值。 测试样例： [1,3,4,5,7],[1,2,3,4,0],2 返回：{1,2,3,4,5,7}这道题bug太多，首先构造的时候并不是环形列表而是单链表，链表的头部并未指向值最
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6775
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
链表相关题目汇总
那一抹天空蓝的博客
07-21 587
目录 前言 1.反转单链表 2.反转部分单链表 3.查找单链表中的倒数第K个结点（k &gt; 0）  4.查找单链表的中间结点  5.从尾到头打印单链表 6.已知两个单链表pHead1 和pHead2 各自有序，把它们合并成一个链表依然有序  7.判断一个单链表是否有环，如果存在环，求第一个入环节点 8.判断两个单链表是否相交（分有环和无环），若相交，求交点 9.删除排序链表...
合并链表算法实现
题目"8580 合并链表"涉及的核心概念是链表的合并，特别是对于有序链表的合并操作。下面我们将详细解释相关的知识点。 1. **链表定义**： 链表是由节点（或称为元素）构成的数据结构，每个节点包含数据和指向下一个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值