链表

最新推荐文章于 2024-06-14 09:15:00 发布
最新推荐文章于 2024-06-14 09:15:00 发布
阅读量164 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ftworld21/article/details/107330620
版权

1.环形链表插值

从小到大环形列表，测试用例:

[1,3,4,5,7],[1,2,3,4,0],2
返回：{1,2,3,4,5,7}

方法一

class InsertValue {
public:
    ListNode* insert(vector<int> A, vector<int> nxt, int val) {
        if(A.size()==0){
            ListNode *node=new ListNode(val);
            node->next=node;
            return node;
        }
        ListNode *head=new ListNode(A[0]);
        ListNode *h1=head;
        for(int i=1;i<A.size();i++){
            h1->next=new ListNode(A[i]);
            h1=h1->next;
        }
        h1->next=NULL;
        ListNode *pre=head,*cur=head->next;
         
        if(pre->val>=val){
            ListNode *node=new ListNode(val);
            node->next=head;
            head=node;
            return head;
        }
        while(cur!=NULL){
            if(pre->val<=val&&val<=cur->val){
                ListNode *node=new ListNode(val);
                pre->next=node;
                node->next=cur;
                break;
            }
            pre=pre->next;
            cur=cur->next;
        }
         
        if(cur==NULL){
            ListNode *node=new ListNode(val);
            pre->next=node;
            node->next=NULL;
        }
        return head;
    }
};

方法二

class InsertValue {
public:
    ListNode* insert(vector<int> A, vector<int> nxt, int val) {
        
        ListNode* root = NULL;
        if (A.empty()) return root;
        
        root = new ListNode(A[0]);
        ListNode *p = root;
        
        for (int i = 1; i < A.size(); ++i) {
            ListNode* tmp = new ListNode(A[nxt[i-1]]);
            p->next = tmp;
            p = tmp;
        }
        //p->next = root;
        p->next = NULL;
        if (root->val > val) {
            ListNode *tmp = new ListNode(val);
            tmp->next = root;
            root = tmp;
            //p->next = root;
            p->next = NULL;
            return root;
        }
        p = root;

        //while (p->next != root) {

        while (p->next) {
            if (val >= p->val && val <= p->next->val) {
                ListNode *tmp = new ListNode(val);
                tmp->next = p->next;
                p->next = tmp;
                return root;
            }
            p = p->next;
        }
        ListNode *tmp = new ListNode(val);
        p->next = tmp;
        //tmp->next = root;
        tmp->next = NULL;
        return root;
    }
};

题目中说是环形链接，但是实际返回返回环形链表在牛客网却通不过，而且觉得数组作用不大。

2.删除单链表中的一个节点

给出头节点和被删除的数字

class Remove {
public:
    ListNode* removeNode(ListNode* pHead, int delVal) {
        
        ListNode* pre=pHead;
        ListNode* cur=pHead->next;
        if(delVal==pre->val)
        {
            pHead=cur;
            delete pre;
            return pHead;
        }
        while(cur!=NULL)
        {
            if(delVal==cur->val)
            {
                pre->next=cur->next;
                delete cur;
                return pHead;
            }
            pre=cur;
            cur=cur->next;
        }
        return pHead;
    }
};

3.链表的分化

小的元素放前面，大的放后面

class Divide {
public:
    ListNode* listDivide(ListNode* head, int val) {
        
        ListNode small(0);//记得分配内存
        ListNode big(0);
        ListNode *cur=head;
        ListNode *psmall=&small,*pbig=&big;
        while(cur)
        {
            if(val>=cur->val)
            {
                psmall->next=cur;
                psmall=psmall->next;
            }
            else
            {
                pbig->next=cur;
                pbig=pbig->next;
            }
            cur=cur->next;
        }
        psmall->next=big.next;
        pbig->next=NULL;
        return small.next;
    }
};

4.链表k逆序

方法一

每k个元素逆序一下

class KInverse {
public:
    ListNode* inverse(ListNode* head, int k) {
        
        if(head==NULL||k<2)
            return head;
        ListNode* p=head;
        int count=0;
        while(p!=NULL)
            {
            count++;
            p=p->next;
        }
        ListNode* node=new ListNode(0);
        ListNode* pre=node;
        node->next=head;
        ListNode* cur=head;
        ListNode* temp=head->next;
        for(int i=0;i<count/k;i++)
            {
            for(int j=0;j<k-1;j++)
                {
                cur->next=temp->next;
                temp->next=pre->next;
                pre->next=temp;
               // pre=temp;
                temp=cur->next;
            }
            pre=cur;
            cur=cur->next;
            temp=cur->next;
        }
        return node->next;
         
    }
};

方法二

class KInverse {
public:
    ListNode* inverse(ListNode* head, int k) {
        
        if(head==NULL||k<2)
            return head;
        ListNode* p=head;
        int count=0;
        while(p!=NULL)
        {
            count++;
            p=p->next;
        }
        ListNode* root=new ListNode(0);
        p = root;
        int cnt = (count % k) ? (count-(count%k)-1) : (count-1);
        for(int i=0;i<=cnt;i++){
            ListNode *node = new ListNode(head->val);//头插法建立链表
            node->next = p->next;
            p->next = node;
            if ((i+1)%k==0) {//移动k的位置
                int j = k;
                while (j--) {
                    p = p->next;
                }
            }
            ListNode *tmp = head;
            head = head->next;
            delete tmp;
        }
        p->next = head;
        return root->next;
         
    }
};

5.删除指定值

class ClearValue {
public:
    ListNode* clear(ListNode* head, int val) {
        
        ListNode* pre=new ListNode(0);
        ListNode* cur=pre;
        while(head)
        {
            if(val!=head->val)
            {
               cur->next=head;
               cur=cur->next;
            } else {
                ListNode *tmp = head;
                head=head->next;
                delete tmp;
                continue;
            }
            head=head->next;
        }
        cur->next=NULL;
        return pre->next;
    }
};

6.判断回文

方法一

使用一个栈

class Palindrome {
public:
    bool isPalindrome(ListNode* pHead) {
        
        stack<int> s;
        int x;
        ListNode* p=pHead;
        ListNode* cur=pHead;
        if(pHead==NULL||pHead->next==NULL)
            return true;
        while(p){
            s.push(p->val);
            p=p->next;    
        }
        p=pHead;
        while(p){
            x=s.top();
            if(p->val!=x)
                return false;
            s.pop();
            p=p->next;
        }
        return true;
         
    }
};

方法二

使用vector数组

class Palindrome {
public:
    bool isPalindrome(ListNode* pHead) {
      
        vector<int> vec;
        int x;
        ListNode* p=pHead;
        ListNode* cur=pHead;
        if(pHead==NULL||pHead->next==NULL)
            return true;
        while(p){
            vec.push_back(p->val);
            p=p->next;    
        }
        int i = 0;
        int j = vec.size() - 1;
        while(i<=j){
            if (vec[i] == vec[j]) {
                ++i;
                --j;
                continue;
            }
            return false;
        }
        return true;
         
    }
};

方法三

不需要额外空间，直接逆转后半部分链表

class Palindrome {
public:
    bool isPalindrome(ListNode* pHead) {
       
        vector<int> vec;
        int x;
        ListNode* p=pHead;
        ListNode* cur=pHead;
        if(pHead==NULL||pHead->next==NULL)
            return true;
        int len = 0;
        while(p){
            vec.push_back(p->val);
            p=p->next;
            ++len;
        }
        int i = 0;
        p = pHead;
        while(p){
            if (i >= len/2) {
                //逆转
                ListNode* p1 = p->next;
                p->next = NULL;
                while (p1) {
                    ListNode* tmp = p1->next;
                    p1->next = p;
                    p = p1;
                    p1 = tmp;
                }
                break;
            }
            ++i;
            p = p->next;
        }
        ListNode*head = pHead;
        ListNode*end = p;
        while(head&&end){
            if (head->val == end->val) {
                head = head->next;
                end = end->next;
                continue;
            }
            return false;
        }
        return true;
         
    }
};

7.复制复杂链表


struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};

class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead) return NULL;
        RandomListNode* cur=pHead;
        while(cur)
        {
            RandomListNode* node=new RandomListNode(cur->label);
            node->next=cur->next;
            cur->next=node;
            cur=node->next;
        }
        cur=pHead;
        RandomListNode* fol=cur->next;
        while(cur)
        {
            if(cur->random==NULL) fol->random=NULL;
            else fol->random=cur->random->next;//指向random指针的下个节点
            cur=fol->next;//等价于cur->next->next;
            fol=cur->next;//等价于fol->next->next;
        }
        cur=pHead;
        RandomListNode* pre=cur->next;
        //RandomListNode* fol1=pre;
        fol=pre;//这里用老指针新指针都行！！
        while(cur)
        {
            if(cur->next->next)
            {
                
            cur->next=fol->next;//必须先维持旧链表
            fol->next=cur->next->next;//才能建立新链表
            }
            else
            {
                
                fol->next=NULL;//这里两者的先后顺序无区别
                cur->next=NULL;
            }
            
            cur=cur->next;//这里也是两者的先后顺序无区别；
            fol=fol->next;
        }
        return pre;
    }
};

8.链表判环

判断链表是否有环，并且返回入环节点的值

class ChkLoop {
public:
    int chkLoop(ListNode* head, int adjust) {
        
        if(head==NULL||head->next==NULL) return -1;
        ListNode* p1=head;
        ListNode* p2=head;
        //while(p2->next&&p2->next->next)
        while(p2&&p2->next)
        {
            p1=p1->next;
            p2=p2->next->next;
            if(p1==p2)
            {
                p2=head;
                while(p2!=p1)
                {
                    p2=p2->next;
                    p1=p1->next;
                }
                return p2->val;
            }

        }
        return -1;
    }
};

9.无环单链表相交练习

方法一

先走多出来的长度

class CheckIntersect {
public:
    bool chkIntersect(ListNode* headA, ListNode* headB) {
        
        if(!headA||!headB) return 0;
        ListNode* pa=headA;
        ListNode* pb=headB;
        int ia=0,ib=0;
        while(pa)
        {
            pa=pa->next;
            ++ia;
        }
        while(pb)
        {
            pb=pb->next;
            ++ib;
        }
        pa=headA;
        pb=headB;
        if(ia>ib)
        {
            //int n=ia-ib;
            //while(n)
            int n=0;
            while(n<(ia-ib+1))
            {
                pa=pa->next;
                //--n
                ++n;
            }
            while(pa&&pb)
            {
                if(pa==pb)
                    return true;
                else
                {
                    pa=pa->next;
                    pb=pb->next;
                }
            }
            return false;
        }
        else
        {
            //int n=ib-ia;
            //while(n)
            int n=0;
            while(n<(ib-ia+1))
            {
                pb=pb->next;
                //--n;
                ++n;
            }
            while(pa&&pb)
            {
                if(pa==pb)
                    return true;
                else
                {
                    pa=pa->next;
                    pb=pb->next;
                }
            }
            return false;
        }
    }
};

方法二

直接判断有没有重复的节点即可

class ChkLoop {
public:
    int chkLoop(ListNode* head, int adjust) {
     
        set<ListNode*> tmp_set;
        while(head) {
            if (tmp_set.count(head)) {
                return head->val;
            }
            tmp_set.insert(head);
            head = head->next;
        }
        return -1;
    }
};

10.有环单链表相交

先找到入环节点，然后判断这两个入环节点是否一样

class ChkIntersection {
public:
    bool chkInter(ListNode* head1, ListNode* head2, int adjust0, int adjust1) {
        
        ListNode* cy1=entry(head1);
        ListNode* cy2=entry(head2);
        if(cy1==cy2) return true;//即如果在入环之前前相交，则入环节点必定相等，
        //如果有不同的入环节点，则遍历cy1/cy2，则必定等于另一个，否则没相交；
        ListNode* trycy1=cy1->next;
        while(trycy1!=cy1)
        {
            if(trycy1==cy2)
                return true;
            trycy1=trycy1->next;
        }
        return false;
    }
    ListNode* entry(ListNode *&head)
    {
        ListNode* first=head;
        ListNode* slow=head;
        while(first&&first->next)
        {
            first=first->next->next;
            slow=slow->next;
            if(first==slow)
            {
                first=head;
                while(first!=slow)
                {
                    first=first->next;
                    slow=slow->next;
                }
                return first;
            }
        }
        return NULL;
    }
};

11.单链表相交判断

分为无环和有环两种来判断

class ChkIntersection {
public:
    bool chkInter(ListNode* head1, ListNode* head2, int adjust0, int adjust1) {
        
        if(head1==NULL||head2==NULL) return false;
        ListNode* cy1=checkcyc(head1);
        ListNode* cy2=checkcyc(head2);
        if(cy1&&cy2)
        {
            if(cy1==cy2) return true;
            ListNode* trycy1=cy1->next;
            while(trycy1!=cy1)
            {
                if(trycy1==cy2)
                    return true;
                trycy1=trycy1->next;
            }
            return false;
        }
        //要不都有环，而且是同一个环；要不都没有环；
        else
        {
            return nocyccut(head1,head2);
        }
    }
    //判断无环时是否相交
     bool nocyccut(ListNode*& head1, ListNode*& head2)
     {
        ListNode* p=head1;
        ListNode* q=head2;
        while(p->next!=NULL)
            p=p->next;
        while(q->next!=NULL)
            q=q->next;
        if(p==q)
            return true;
        else
            return false;
     }
    //判断有无环
    ListNode* checkcyc(ListNode *&head)
    {
        ListNode* first=head;
        ListNode* slow=head;
        while(first&&first->next)
        {
            first=first->next->next;
            slow=slow->next;
            if(first==slow)
            {
                first=head;
                while(first!=slow)
                {
                    first=first->next;
                    slow=slow->next;
                }
                return first;
            }
        }
        return NULL;//这里必须存在，少一个return 编译不通过，可能逻辑上没什么问题；
    }
};

Ftworld21
关注
专栏目录
静态链表
Minix的博客
03-27 2317
静态链表 静态链表（static linked list）是用数组来表示单链表，用数组元素的下标来模拟单链表的指针。这种描述方法称为游标（cursor）实现法。 静态链表，也是线性存储结构的一种，它兼顾了顺序表和链表的优点于一身，可以看做是顺序表和链表的升级版。 在链表的指针实现中有两个重要的特点： 数据存储在一组结构体中，每一个结构体包含有数据以及指向下一个结构体的指针； 一个新的结构体可以通过调用 malloc() 函数从系统全局内存得到，并可通过调用 free() 函数而被释放。 游标法必须能够模
PTA 两个有序链表序列的合并
10-07
在编程领域，有序链表序列的合并是一个常见的问题，尤其在数据结构和算法的学习中占有重要地位。这个题目“PTA 两个有序链表序列的合并”主要涉及到链表的操作和合并策略，这对于理解和掌握链表操作有极大的帮助。...
C语言链表超详解
k666499436的博客
05-17 12万+
详细对比顺序表与链表的区别， 实现单链表，与双向带头循环链表，以及各中类型的链表
链表基础知识详解（非常详细简单易懂）
qq_61672347的博客
07-10 18万+
数据结构链表详解，创建，遍历，释放，节点的查找，节点的删除，插入节点，链表排序等操作，非常详细
C++ 链表
m0_62175410的博客
07-26 3万+
C++链表笔记
c语言链表详解（超详细）
热门推荐
Endeavor_G的博客
06-03 62万+
链表是一种常见的基础数据结构，结构体指针在这里得到了充分的利用。链表可以动态的进行存储分配，也就是说，链表是一个功能极为强大的数组，他可以在节点中定义多种数据类型，还可以根据需要随意增添，删除，插入节点。链表都有一个头指针，一般以head来表示，存放的是一个地址。链表中的节点分为两类，头结点和一般节点，头结点是没有数据域的。链表中每个节点都分为两部分，一个数据域，一个是指针域。说到这里你应该就明白...
反转链表详解
最新发布
Weirdo的博客
06-14 1861
这些数据项通常以链表的形式组织起来，其中最近使用的数据项位于链表的头部，最久未使用的数据项位于链表的尾部。反转链表指的是将链表的头尾节点对调，使得原本链表的第一个节点变为最后一个节点，原本链表的最后一个节点变为第一个节点，其他节点的相对位置也进行相应调整。通过对反转链表算法的深入理解和实践应用，我们可以更好地掌握链表的基本操作和指针的使用，并提高编程能力和解决问题的能力。然而，锁的使用会降低程序的性能。在实际应用中，我们可能需要在反转链表的同时进行其他操作，例如计算链表长度、检查链表中的重复元素等。
C语言链表详解附实例
xiaoxiaodawei的博客
03-11 2万+
链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。链表和数组比较，不用事先确定存储空间，而是根据需要开辟内存单元。本文章实现了用C语言编写学生管理系统，可以实现添加、删除、增加..,等功能
链表经典面试题
GOATLong的博客
05-02 2588
1.删除链表中等于给定值的所有结点1.删除链表中等于给定值的所有结点2.反转一个单链表这里我们需要在原链表中进行操作我们定义三个指针如下图所示：接下来就是改变l2指针的next指向l1之后l1指针走到l2，l2走到l3，l3走到l2的next，不断循环一直到l2为空指针这里有一个小细节如下图。
链表知识及编程练习总结
张彦峰的博客
10-24 1万+
了解链表结构，并在单链表或双链表中实现遍历、插入和删除以及分析在单链表或双链表中的各种操作的复杂度，同时附上相关面试考点的基本分类试题库（反转链表、链表中环的检测、链表中环的入口点、删除链表中倒数第K个节点、两个链表的第一个公共节点、链表的中间节点、合并两个有序链表、删除链表中的重复元素、排序链表、K 个一组翻转链表、旋转链表、分隔链表、奇偶链表、合并k个排序链表、链表相加、回文链表判定、回文链表重排、交换相邻节点、删除指定元素、反转链表指定部分、存在回文链表、链表最长递增子序列）
07丨链表（下）：如何轻松写出正确的链表代码？1
08-03
【链表】是一种重要的数据结构，它不像数组那样在内存中连续存储，而是通过节点间的指针连接起来。链表的每个节点包含数据和指向下一个节点的指针，这种结构使得链表在插入和删除操作上相比数组更具优势，但同时也...
链表填空题（打印）1
08-08
【链表基础知识】 链表是一种线性数据结构，与数组不同，它不连续存储数据，而是通过节点间的指针连接。每个节点包含数据部分和一个指向下一个节点的指针。链表分为单向链表、双向链表和循环链表等类型。 1. **...
Python单向链表和双向链表原理与用法实例详解
09-20
链表是一种重要的数据结构，它不同于数组，不连续存储元素，而是通过节点之间的引用关系连接。在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只...
北大OJ
Ftworld21的专栏
08-10 1739
以前一直在九度OJ上做题，最近这个OJ登陆不上去，转到北大OJ做题，希望通过做题学习和熟悉一些常用的算法。 这是一道比较简单的模拟题，只要分情况讨论，一一求解即可 1 首先把起点到终点的方向定为西北、西、西南、南，由8个方向减少到4个方向。 2 考虑王的步数情况，分西北、西、西南、南四种情况考虑，对于西北方向，即终点在起点的左上方，则起点先沿西北方向走，当与终点平行的时候，再选择往西或者往东走到终点的位置，此时，走过的步数就是王的步数；对于西这个方向，直接从起点向西走到终点就是王的总步数；对于西南方.
九度OJ
Ftworld21的专栏
08-10 969
1.1016 这是一道简单题，主要要考虑到，比如说108，8，2这种类似的情况，其中8被认为是08，所以最后两位相同，输出-1。 #include <stdio.h> #include <stdlib.h> #include <string.h> int main() { char a[20], b[20], *p, *q; int k, a1, b1, len1, len2, a2, b2; while (scanf("%s%s%d", a, b, &a...
算法思想汇总
Ftworld21的专栏
05-20 590
95% 的算法都是基于这 6 种算法思想 - 知乎 一文图解弄懂八大常用算法思想！ - 掘金 八种常用算法思想 | 智能后端和架构 【总结】递归、回溯、深度优先、广度优先_递归算法与深度优先算法-CSDN博客 https://www.cnblogs.com/cdaniu/p/16369446.html
秋招编程题
Ftworld21的专栏
08-10 529
一.京东2018 第一题：疯狂的序列 有一个序列1,2,2,3,3,3,4,4,4,4,5,5,5,5,5....，求第n项是多少？ 解法一：暴力法，i从1开始穷举，直到满足i(i+1)/2-i<n<=i(i+1)/2，则输出i，代码如下： #Include <stdio.h> int main() { long longn; while (scanf("%lld", &n) != EOF) { long long i = 1; while (1)..
动态规划
Ftworld21的专栏
09-08 437
第一题：找零钱问题 有数组penny，penny中所有的值都为正数且不重复。每个值代表一种面值的货币，每种面值的货币可以使用任意张，再给定一个整数aim(小于等于1000)代表要找的钱数，求换钱有多少种方法。 给定数组penny及它的大小(小于等于50)，同时给定一个整数aim，请返回有多少种方法可以凑成aim。 分为有该种货币与无该种货币进行讨论，代码如下： class Ex
链表基础与单向链表解析
"链表是一种动态数据结构，与数组相比，它允许在程序运行时根据需要增加或减少元素，克服了数组预设长度和插入删除效率低的问题。链表主要由节点组成，每个节点包含数据域和指针域，指针域指向下一个节点。单向链表...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值