链表究极分析总结大作战

最新推荐文章于 2022-05-02 17:55:39 发布
最新推荐文章于 2022-05-02 17:55:39 发布
阅读量250 收藏
点赞数
分类专栏： 编程心得
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdoyuxuan/article/details/78622614
版权

1 打印俩个有序链表公共部分

思路

 这道题很简单，核心思路就是，如果当L1的值小于L2当前的值，L1一直往后走，直到找到大于等于L2的值，等于输出，大于的话，L2就开始遍历做跟L1一样的事情。

代码
#include<iostream>
using namespace std;
struct Node
{
    int _data;
    Node * next;
}
void Print(Node * head1 , Node * head2)
{
    assert(head1&&head2);
    while(head!=NULL&&head2!=NULL)
    {
        int temp = head2->_data;
        while(head&&head2&&head->_data<temp)
            head = head->next;
        if(head2&&head&&temp==head->_data)
        {
            cout<<temp<<" ";
                   head = head->next;
        }
        if(head)
           temp=head->_data;
        while(head&&head2&&head2->_data<temp)
            head2 = head2->next;
        if(head&&head2&&temp==head2->_data)
        {
            cout<<temp<<" ";
            head2 = head2->next;
        }
    }
}
实现方法2
void printf2(Node * head1 , Node *head2)
{
    assert(head1&&head2);
    while(head1&&head2)
    {
        if(head1->_data<head2->_data)
            head1 = head1->next;
       else if(head1->_data < head2->_data)
            head2 = head2->next;
        else
        {
            cout<<head1->_data;
            head1 = head1->next;
            head2 = head2->next;
        }
    }
}

2在单链表中总有N个节点让你删除倒数第K个节点

方法1

 删除倒数第K个节点就是让你找到第N-K个节点，仔细想下，让你删除倒数第一个节点，你得找到第N-1个节点，因为第N个节点是最后一个节点，你得找到它前面的那个节点。
 找到第N-K个节点的方法，遍历一次链表直到NULL，每次迭代的时候，K值减一。从第一个节点到NULL这个位置，刚好走迭代N次，因为一开始是从第一个节点走的，那么到第N个节点，一共走了N-1步，再走到NULL的时候，刚好迭代了N次。
 此时，k的值为k-N , 那么我们现在开始再次遍历链表，每走一次让k+1，直到走到值为0的节点，那个节点就是N-K个节点。因为 (N-K) + (K-N) = 0 , 所以当K走到0的时候，就一共走了N-K步，那么就找到了第N-K个节点。

方法2

 先找到倒数第K个节点，然后从头开始走判断下一个节点是否等于它，等于它跳出循环。
 找到倒数第K个节点的方法，先让一个快指针走K步，然后慢指针开始走，当fast走到最后一个节点了，那么此时慢指针指向的节点就是倒数第K个节点。

细节总结

 如果是第一个方法，K=0就代表被删除节点为头节点。但是对于第二个方法得自己把这个情况先过滤一遍。

Node * DeletelastK(Node*head,int k)
{
    assert(head);
    if (k < 1)
        return NULL;
    Node * pCur = head;
    Node * del = nullptr;
    while (pCur)
    {
        --k;
        pCur = pCur->next;
    }
    if (k>0)
        return pCur;
    else if (k == 0)
    {
        del = pCur = head;
        pCur = head->next;
    }
    else 
    {
         /// 现在 k  == K-N  , 因为 共走了 N步， 每走一步 K减1  此时 K 的值等于 K - N 
        // 我们 可以让 K加到0 ，然后 让它走 N-K步。找到 第 N-K个节点 ，它就是倒数第K个节点的前一个节点
        pCur = head;
        while (++k < 0) // ++k 是因为直接从1号节点进入，2号节点，所以得先把1号节点那
        {           //份值减掉
            pCur = pCur->next;
        }
        del = pCur ->next;
        pCur = del->next;
    }
    delete del;
    return pCur;
}
Node *DeletelastK(Node * head, int K)
{
    assert(head != NULL&&K >= 1);
    Node * fast = head;
    Node * last = head;
    while (fast&&--K)
    {
        fast = fast->next;
    }
    if (K > 0)
        return NULL;
    while (fast->next)
    {
        fast = fast->next;
        last = last->next;
    }
    /*先找到第K个节点*/
    Node * del = head;
    if (last == head)
    {
        del = head;
        head = head->next;
    }
    else
    {
        while (del->next != last)
        {
            del = del->next;
        }
        del->next = last->next;
        del = last;
    }
    delete del;
    return head;
}

删除链表的中间节点和a/b处的节点

思路

 方法一先把链表遍历一边，得到链表的长度，然后找到待删节点位置的前一个节点即可。
 方法二，慢节点走一步，快节点走俩步，当快节点，走到最后一个位置的时候，慢节点找到待删节点的前一个位置。（最后一个位置可能是最后一个节点，也可能是倒数第二个节点）

题目描述

  1->2 删除1 , 1->2->3 删除2 ， 1->2->3->4 删除2，这里有个规律就是，如果是偶数就待删除的中间节点就是，N/2处的节点，如果是奇数，待删除节点就是N/2+1的节点。
 第二道题待删除节点是这样找的，(N*a)/b 就是待删除位置，这个位置如果小于0就是非法return 即可，否则删除掉。

Node* deleteMid(Node*head)
{
    int Length = 0;
    Node * pCur =head;
    while(pCur)
    {
        ++Length;
        pCur = pCur->next;
    }
    if(Length==1)
    {
        delete head;
        return NULL;
    }
    Length = (Length%2>0)?((Length>>1)+1):Length>>1;
    Length-=1;
    Node * del = head; // 下面递归结束 del 就是被删除的前一个节点
    while(Length>0&&--Length)
    {
         del = del->next;
    } // -- Length是因为 直接从1号节点出发 所以得先减再判断
    if(del == head)
    {
       head = head->next;
       delete del;
       return head;
    }
    del->next = del->next->next;
    delete del->next;
    return del;
}


Node * DeleteMid(Node * head)
{
    if(head==NULL||head->next==NULL)
        return head;
    Node * del = NULL;
    if(head->next->next==NULL)
    {
        del = head->next;
        delete del;
    }
    Node * last = head;
    del = head->next->next;
    while(del->next&&del->next->next)
    {
        last = last ->next;
        del = del->next->next;
    }
    last->next = last->next->next;
    delete last->next;
    return last;
}

/*删除 第 a/b个节点*/
Node*removeRatio(Node*head,int a, int b)
{
    if(a/b>1||head==NULL)
        return head;
    int N = 0;
    Node * pCur = head;
    while(pCur)
    {
        N++;
        pCur=pCur->next;
    }
    N = (a*N)/b;
    pCur = head;
    if(N==1)
    {
        head = head->next;
        delete pCur;
    }
   if(N>1)
    {
        while(--N!=1)
        {
            pCur=pCur->next;
        }
        pCur->next = pCur->next->next;
        delete pCur->next;
    }
    return head;
}

反转链表/反转部分链表

思路

 定义一个新节点，头插法即刻解决。
 第二道题，就是找到部分区间的前一个节点与后一个节点，反转部分节点后，将其再拼接即可。主要细节就是，可能从第一个节点开始反转，则可能更换头节点，所以做个条件过滤即可。

/*反转单链表*/
Node * reserve(Node*head)
{
   if(head==NULL)
       return NULL;
   Node * NewHead = NULL;
   Node * pCur =head;
   Node * pNext = NULL;
   while(pCur)
   {
       pNext = pCur->next;
       pCur->next = NewHead;
       NewHead = pCur;
       pCur = pNext;
   }
   return NewHead;
}
Node* reversepart(Node*head,int from ,int to)
{
    Node * fpre = NULL;
    Node * Nto = head;
    int length = 0;
    Node * pCur = head;
    int temp=0;
    while(pCur)
    {
        ++length;
        pCur = pCur->next;
    }
    if(from>to||to>N||from<1)
        return head;
    temp = from;
    if(temp != 1)
    {
        fpre = head;
        while(--temp!=1)
        {
           fpre = fpre->next;
        }
    }
    temp = to;
    while(--temp!=-1)
    {
        Nto = Nto->next;
    }
    Node * pNext = NULL;
    Node * Newhead = Nto;
    if(fpre!=NULL)
       pCur = fpre;
    else
       pCur = head;
    while(pCur!=Nto)
    {
        pNext = pCur->next;
        pCur->next = NewHead;
        NewHead = pCur;
        pCur = pNext;
    }
    if(fpre)
    {
        fpre->next=NewHead;
        NewHead = head;
    }
    return NewHead;
}

复杂链表的赋值

方法1

 用unordered_map ， 保存每一个节点得到指针和新构造出来的节点指针。然后遍历链表的时候，用operator[] 返回对应key的复制出来节点的指针，然后如果这个当前节点next/random有值的话，可以快速从unordered_map中查找到，对应的value就是复制出来的节点，原理很绕口，代码很简单。

方法2

 上面的空间复杂度O(n),那么可以不用 unordered_map， 就直接定义临时变量，然后把新复制的节点，放到原节点的后面，设置下一个位置的时候，复制节点的下一个位置就是它的下一个位置的下一个位置，random就是原节点的random的下一个位置。因为它们串插在链表中，所以复制节点的下一个节点是原节点的下一个节点，那么原节点的下一个节点就是复制节点的下一个节点，看代码即可。

方法1：
Node* CopyRandList(Node*head)
{    
    unordered_map<Node*,Node*> hash;
    Node * pCur = head;
    while(pCur)
    {
        hash.insert(pair<Node*,Node*>(pCur,new Node(*pCur)));
        pCur = pCur->next;
    }
    pCur = head;
      while(pCur)
    {
        hash[pCur]->next =(pCur->next)?hash[pCur->next]:NULL;    
        hash[pCur]->rand =(pCur->rand)?hash[pCur->rand]:NULL;
        pCur = pCur->next;
    }
    return hash[head];
}
方法 2 ：
    RandomListNode *copyRandomList(RandomListNode *head) 
    {     
      if(head==NULL)
        return NULL;
     Node * Copy =NULL;
     Node * pCur = head;
     Node * pNext =NULL;
     /*复制*/
     while(pCur)
     {
         Copy = new Node(*pCur);
         pNext = pCur->next;
         Copy->next = pNext;
         pCur->next = Copy;
         pCur = pNext;
     }
     /*设置随机指针*/
     pCur = head;
      while(pCur)
     {
        Copy = pCur->next;
        Copy->random = (pCur->random)?(pCur->random->next):(NULL);
        pCur = pCur->next->next;
     }
     /*拆分*/
     pCur = head;
     pNext = pCur->next;//保存新链表的第一个节点
     Copy =pCur->next;
     while(pCur)
     {
        pCur->next = Copy->next;
        if(Copy->next)
        {
            Copy->next = Copy->next->next;
            Copy = Copy->next;
        }
        else
        {
           Copy->next = NULL;
           Copy = NULL;
        }
        pCur = pCur->next;
     }
     return pNext;
}

返回俩个可能带环链表的交点

分析

先判断俩个链表是否带环，如果都带环/都不带环可能有交点否则无交点。
第二步，如果都不带环，进入不带环返回交点的函数。
第三部，都带环，有俩个模型：
这里写图片描述
模型1与模型2是俩个带环相交的可能情况，模型三是俩个带环不相交的情况。

Node * LoopNode(Node * head)
{
    if(head == NULL)
        return NULL;
    Node * fast = head;
    Node * low  = head;
    while(fast&&fast->next)
    {
       fast = fast->next->next;
       low = low->next;
       if(low==fast)
           break;
    }
    if(fast==NULL||fast->next==NULL)
        return NULL;
    fast = head;
    while(fast!=low)
    {
        fast = fast->next;
        low = low->next;
    }
    return fast;
}
Node * Associate(Node * head1, Node* head2)//返回俩个不带环链表的交点
{
     if(head1==NULL||head2==NULL)
         return NULL;
     int Length1 = 0;
     int Length2 = 0;
     Node * pCur = head1;
     Node * pCur2 = head2;
     while(pCur->next)
     {
         ++Length1;
         pCur = pCur->next;
     }
     while(pCur2->next)
     {
         ++Length2;
         pCur2 = pCur2->next;
           }
     if(pCur!=pCur2)
         return NULL;
     Length1+=1;
     Length2+=2;
     pCur = (Length1>Length2)? head1 : head2;
     pCur2 = (Length1<Length2)? head1 : head2;
     Length1 = (Length1>Length2)?Length1-Length2:Length2-Length1;
     while(Length1--)
     {
        pCur = pCur->next;
     }
     while(pCur!=pCur2)
     {
          pCur=pCur->next;
          pCur2 = pCur2->next;
     }
     return pCur;
}
Node * LoopAssociate(Node * head1, Node * head2)//返回俩个可能带环链表的交点
{
     Node * Loop1 = LoopNode(head1);
     Node * Loop2 = LoopNode(head2);
     if(Loop1==NULL&&Loop2==NULL)
         return Associate(head1,head2);
     if(Loop1&&Loop2)
     {
        if(Loop1==Loop2)  // 环入口点相同，说明是俩个带环相交的模型1
            return Loop1;
        Node * pCur = Loop1->next;
        while(pCur!=Loop1&&pCur!=Loop2)//这里得判断下，俩个带换不一定就
        {                     //相交，如果相交的话，就为模型2，从Loop1转
            pCur = pCur->next;//一圈肯定内遇见Loop2,一圈没遇见说明没交点
        }
        if(pCur == Loop2)
            return Loop2;
        else
            return NULL;
     }
     return NULL;
}
sdoyuxuan
关注
专栏目录
C/C++ 获取链表的大小算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-06 7404
获取链表的大小算法的优点是简单明了，只需要遍历链表一次，时间复杂度为O(n)，n为链表的节点数量。另外，该算法适用于单向链表，对于双向链表或循环链表，需要根据具体情况进行相应的修改。缺点是需要遍历整个链表，如果链表很长，获取链表的大小算法的时间复杂度可能会比较高。获取链表的大小算法，即计算链表中节点的数量。可以通过遍历链表的方式来实现。
算法分析之链表问题
小朱小朱绝不认输的博客
12-01 1621
文章目录一、链表理论基础1. 链表的介绍2. 链表的类型1）单链表2）双链表3）循环链表3. 链表的存储方式4. 链表的定义5. 链表的操作1）删除节点2）添加节点6. 头指针和头节点二、leetcode例题讲解数组问题203. 移除链表元素707. 设计链表206. 反转链表24. 两两交换链表中的节点19. 删除链表的倒数第 N 个结点面试题 02.07. 链表相交142. 环形链表 II 链表是除数组外，另一个常用的数据结构，算法中经常会对链表进行处理，主要是指针的用法。 一、链表理论基础 1. 链表
查看运行结果
一直走，不要回头
11-14 258
看下列代码的运行结果 #include "pch.h" #include&lt;iostream&gt; using namespace std; class A { public: A() { a = 1; b = 2; } private: int a; int b; }; class B { public: B() { c = 3; } void prin...
数据结构与算法实验报告——实验一 链表
weixin_46055804的博客
04-28 9680
实验一 链表 实验目的和要求 1.理解线性表的链式存储结构。 2.熟练掌握动态链表结构及有关算法的设计。 根据具体问题的需要，设计出合理的表示数据的链表结构，并设计相关 算法。 实验任务 1. 对任意输入的一组数据，建立一个递增有序的单链表。 2. 将单链表Ｌ中的奇数项和偶数项结点分解开，并分别连成一个单链表。 3. 用递增有序的链表A、B表示两个集合，判断B是否是A的子集。 4. 用递增...
C语言链表分析
weixin_43985500的博客
08-22 251
链表的引入 从数组的缺陷说起 1、数组有两个缺陷，一个是数组中的所有元素的类型必须相同，第二个是数组的元素个数必须事先指定并且一但指定后就不能更改。 2、如何解决数组的第一个缺陷：数组的第一个缺陷靠结构体来解决。结构体允许其中的元素的类型不相同，因此解决了数组的第一个缺陷。所以说结构体是因为数组不能解决某些问题所以才发明的。 3、如何解决数组的第二个缺陷？我们希望数组的大小能够实时扩展。譬如我刚开始定了一个元素个数是10，后来程序运行时觉得不够因此动态扩展为20.普通的数组显然不行，我们可以对数组进行封装以
C++单链表插入翻转更新删除等基本操作及实例运行结果
IT_job的博客
12-23 861
链表是一种复杂的数据结构，其数据之间的相互关系使链表分成三种：单链表、循环链表、双向链表，这里介绍单链表。 我们希望构造动态的数组，随时可以调整数组的大小，以满足不同问题的需要。链表可以满足我们这种需求。它在程序的执行过程中根据需要，有数据存储就向系统要求申请存储空间，不会对存储区的浪费。链表中的每一个节点的数据类型为结构体类型，节点有两个成员：整型成员和指向下一个结构体类型节点的指针。 c+
链表操作总结
zjcheer_up的专栏
07-30 433
http://bylijinnan.iteye.com/blog/1345364 单个链表：          a.判断是否有环：快慢法（p1=p2=head,p1=p1.next,p2=p2.next.next）          b.环的第一个节点：假设p1,p2在环内的某点p相遇，则p1从p点继续遍历，p2从头节点开始遍历，两者相等的第一个点即为所求（证明略） 
数组和链表总结 数组和链表.txt
04-18
数组和链表总结 数组和链表.txt
链表构建详细过程分析
01-18
非常详细的链表构建过程，相信对于链表不怎么熟悉的人，会有很大帮助。
c语言链表总结
03-15
链表是学习数据结构的大门，在微软等大公司招聘c\c++技术人员的时候有3个会必然出现 的东西，指针、链表、二叉树！
单链表的建立，测长度，打印，删除，插入，逆置c++代码实例及运行结果
IT_job的博客
02-02 744
c++代码 #include using namespace std; typedef struct st { int data; struct st *next; }node; //单链表的创建 node *create() { node *head,*p,*s; int x,cycle; head=(node*)malloc(sizeof(
链表——单向链表 主要包括：《 单链表的完整接口实现代码 和 执行结果 》
dpfxaca6的博客
04-23 371
链表的概念：：链表是一种物理存储结构上《 非连续、非顺序 》的存储结构，数据元素的逻辑顺序是通过链表中的《 指针 》链接次序实现的。 在我们的实际链表应用中，有许多的样子的，总结一下就是8中结构： 1. 单向、双向 2. 带头、不带头 3. 循环、非循环 就是 《 二的三次方 》种 ...
单链表的简单运用
psr博客
11-27 537
单链表单链表的简单操作代码结构一、单链表数据结构二、创建节点三、删除节点四、插入节点五、打印节点六、main函数七、运行结果总结 单链表的简单操作 代码结构 一、单链表数据结构 typedef struct tag_SingleNodeLink SingleNodeLink; struct tag_SingleNodeLink { int data; SingleNodeLink* next; }; 二、创建节点 SingleNodeLink *CreateNode(int data) { si
数据结构系列2——双向链表和双向循环链表
喜欢C艹的小白的博客
09-23 4937
引入：双向链表是在原来的单链表基础上增加了一个可以保存某节点的上一个节点的指针域的数据结构，相较于单链表而言，双向链表在查找数据的时候所花费的时间是要小于单链表的，因为其可进可退。其缺点就是增删节点比单链表麻烦，而且在创建节点的时候也需要多申请一个指针存储空间。双向循环链表，顾名思义就是在双向链表的基础上，将尾节点的“right”指针指向头结点，同时头结点的“left”指针指向尾节点，它和双向链表的不同是，其判断节点是否遍历完毕的条件不再是是否为空，而是是否回到了头结点，优点是可以在任意位置插入数据，时间.
静态链表的建立/元素的插入/删除详细讲解(完整代码及运行结果)
weixin_45637300的博客
12-07 819
前言 最近，自己在学习静态链表的相关知识，当然，很多人学会了单链表后，就不想去学习静态链表了，因为单链表用指针显得更加的易操作，好理解。但是指针这个名词在C语言/C++中用的非常多，但对于想java等这样的语言又怎么去运行链表呢?在这里静态链表就起到了十分重要的作用，所以学习静态链表是非常有必要的。当然，在写这篇文章之前自己还是参考过其他博主的博客，在此我想以容易理解的方式呈现这个知识给大家。 C...
静态链表-----用数组实现的单链表。
Nactua的博客
05-02 748
静态链表是单链表的另外一种表现方式，具体的操作步骤的实现与单链表类似。 1、初始化 实现代码： include<stdio.h> #include<malloc.h> #define DEFAULT_SIZE 5 //宏观定义内存的大小，在静态连接节点的结构体里在设计一个静态链表的结构体 typedef struct StaticLinkedNode { char data; int next; }*NodePtr; typedef struct Stati.
基于Ssm和Vue的电影网站源码 电影网站代码（程序，中文注释）
最新发布
09-29
电影网站-电影网站-电影网站-电影网站-电影网站-电影网站-电影网站-电影网站-电影网站-电影网站-电影网站-电影网站 1、资源说明：电影网站源码，本资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 2、适用人群：计算机相关专业(如计算计、信息安全、大数据、人工智能、通信、物联网、自动化、电子信息等)在校学生、专业老师或者企业员工等学习者，作为参考资料，进行参考学习使用。 3、资源用途：本资源具有较高的学习借鉴价值，可以作为“参考资料”，注意不是“定制需求”，代码只能作为学习参考，不能完全复制照搬。需要有一定的基础，能够看懂代码，能够自行调试代码，能够自行添加功能修改代码。 4. 最新计算机软件毕业设计选题大全(文章底部有博主联系方式): https://blog.csdn.net/2301_79206800/article/details/135931154 技术栈、环境、工具、软件： ① 系统环境:Windows ② 开发语言：Java ③ 框架：Ssm ④ 架构:B/S、MVC ⑤ 开发环境:IDEA、JDK、Maven、Mysql ⑥ 数据库：mysql ⑦ 服
基于微盾品牌的VwFirewall防火墙设计源码
09-29
该项目为微盾品牌VwFirewall防火墙的完整设计源码，由342个文件组成，涵盖了多种编程语言和资源类型，包括55个头文件、40个GIF图像、34个ICO图标、33个C++源文件、27个PNG图片、21个BMP图像、19个PSD设计文件、12个数据文件、11个C源文件、8个可执行文件。该源码集合了C、C++、C、HTML、JavaScript和PHP等编程语言，适用于防火墙的安全防护设计开发。
链表排序算法实现与分析
"链表排序方法分析" 在计算机科学中，链表是一种常见的数据结构，用于存储一组动态的元素。链表与数组不同，数组中的元素是连续存储的，而链表中的元素则是通过指针链接在一起。链表排序是指对链表中的元素按照特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值