数据结构之单链表常见面试题（二）

最新推荐文章于 2022-08-27 16:11:02 发布
原创 最新推荐文章于 2022-08-27 16:11:02 发布 · 248 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍如何判断两个链表是否相交并找出交点，探讨链表可能带环的情况，展示如何求两个已排序链表中的相同数据，以及提出两种复杂链表复制的有效方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

判断两个链表是否相交，若相交返回其交点位置（两链表都不带环）

解析：两个不带环的链表要能相交只能是Y字型相交，如下图。
这里写图片描述

所以判断相交只需要分别让两个链表都走到结束时，判断他们的data值是否相等。

//实现

LinkNode* HasCross(LinkNode* head1, LinkNode* head2)//判断两个链表是否相交
{
    if(head1 == NULL)
    {
        return NULL;
    }
    if(head2 == NULL)
    {
        return NULL;
    }

    LinkNode* cur1 = head1;
    LinkNode* cur2 = head2;
    size_t len1 = 0;
    size_t len2 = 0;

    while(cur1->Next != NULL)
    {
        cur1 = cur1->Next;
        len1++;
    }
    while(cur2->Next != NULL)
    {
        cur2 = cur2->Next;
        len2++;
    }

    if(cur1->data != cur2->data)
    {
        return NULL;
    }

    size_t len = 0;

    cur1 = head1;
    cur2 = head2;

    if(len1 > len2)
    {
        len = len1-len2;
        while(len--)
        {
            cur1 = cur1->Next;
        }
        while(cur1->data != cur2->data)
        {
            cur1 = cur1->Next;
            cur2 = cur2->Next;
        }
        return cur1;
    }
    else
    {
        len = len2-len1;
        while(len--)
        {
            cur2 = cur2->Next;
        }
        while(cur1->data != cur2->data)
        {
            cur1 = cur1->Next;
            cur2 = cur2->Next;
        }
        return cur2;
    }
}

判断两个链表是否相交，可能带环

两个链表总共有三种情况，两个都不带环、都带环、一个带环一个不带环，那就要分开讨论。如果都不带环就是我们刚才所写的Y字相交法，如果一个带环一个不带环那么是不可能相交的。着重讨论一下两个都带环的。
这里写图片描述

这里写图片描述

由此可见，若两个链表都带环且相交将有三种情况需要讨论，逐步进行。

//实现
LinkNode* HasCross2(LinkNode* head1, LinkNode* head2)//判断两个链表是否相交，可能带环
{
    if(head1 == NULL)
    {
        return NULL;
    }
    if(head2 == NULL)
    {
        return NULL;
    }

    LinkNode* ret1 = GetCycleEntry(head1);//调用之前的函数查看是否带环
    LinkNode* ret2 = GetCycleEntry(head2);

    if(ret1 == NULL && ret2 == NULL)
    {
        HasCross(head1,head2);//两个都不带环
    }
    else if((ret1 == NULL && ret2 != NULL) || (ret2 == NULL && ret1 != NULL))//一个不带环一个带环不可能相交
    {
        return NULL;
    }
    else
    {
        if(ret1->data == ret2->data)
        {
            //交点在环外
           size_t len1 = 0; 
           size_t len2 = 0; 

           LinkNode* tmp1 = head1;
           LinkNode* tmp2 = head2;
           while(tmp1 != ret1)
           {
               len1++;
               tmp1 = tmp1->Next;
           }
           while(tmp2 != ret1)
           {
               len2++;
               tmp2 = tmp2->Next;
           }

           size_t len = 0;
           tmp1 = head1;
           tmp2 = head2;

           if(len1 > len2)
           {
               len = len1-len2;
               while(len--)
               {
                   tmp1 = tmp1->Next;
               }
               while(tmp1->data != tmp2->data)
               {
                   tmp1 = tmp1->Next;
                   tmp2 = tmp2->Next;
               }
               return tmp1;
           }
           else
           {
               len = len2-len1;
               while(len--)
               {
                   tmp2 = tmp2->Next;
               }
               while(tmp1->data != tmp2->data)
               {
                   tmp1 = tmp1->Next;
                   tmp2 = tmp2->Next;
               }
               return tmp2;
           }
        }
        else//交点在环内
        {
            LinkNode* cur1 = ret1;
            while(cur1 != ret2)
            {
                if(cur1->Next == ret1)
                {
                    return NULL;//遍历一圈发现没有相同的，那么就没有相交
                }
                cur1 = cur1->Next;
            }
            return ret2;
        }
    }
}

求两个已排序链表中的相同数据

两个已排序链表当中，如果其中一个链表遍历结束，那么另外一个就没有遍历的必要了，因为必定没有相同的元素，将两个链表相同的元素插入一个新的链表即可。

//实现

LinkNode* UnionSet(LinkNode* head1, LinkNode* head2)//求两个已排序链表中的相同数据
{   
    if(head1 == NULL)
    {
        return NULL;
    }
    if(head2 == NULL)
    {
        return NULL;
    }
    LinkNode* new_head = NULL;
    LinkNode* tail = NULL;
    LinkNode* cur1 = head1;
    LinkNode* cur2 = head2;

    while(cur1 != NULL && cur2 != NULL)
    {
        if(cur1->data < cur2->data)
        {
            cur1 = cur1->Next;
        }
        else if(cur1->data > cur2->data)
        {
            cur2 = cur2->Next;
        }
        else 
        {
            if(new_head == NULL)
            {
                new_head = Creat(cur1->data);
                tail = new_head;
            }
            else
            {
                tail->Next = Creat(cur1->data);
                tail = tail->Next;
            }
            cur1 = cur1->Next;
            cur2 = cur2->Next;
        }
    }
    return new_head;
}

这个较为简单，所以不再赘述。

复杂链表的复制问题

首先说说什么是复杂链表，复杂链表就是链表的每个节点内的元素多一个random指针，这个指针可以指向任意位置，可以指向链表内其他元素，也可以指向NULL，所以在对其进行复制的时候需要注意对random的复制。

对复杂链表的复制这里有两个思路可以进行。

首先先定义一个新的节点

#define Comtype char//节点内元素类型

typedef struct ComplexNode{
    Comtype data;
    struct ComplexNode* next;
    struct ComplexNode* random;
}ComplexNode;//定义一个新类型的复杂单链表节点

接着，再封装一些基本函数来确保后面操作的执行。

//新节点的创建

ComplexNode* Creat1(Comtype value)//创建一个新的节点
{
    ComplexNode* new_Node = (ComplexNode*)malloc(sizeof(ComplexNode));
    if( new_Node == NULL)
    {
        printf("申请失败\n");
        return NULL;
    }
    new_Node->data = value;
    new_Node->next = NULL;
    new_Node->random = NULL;
    return new_Node;
}

//对复杂链表的打印，即要打印data，还有打印random所指向的内容

void ComPrint(ComplexNode* head)
{
    if(head == NULL)
    {
        return;
    }

    ComplexNode* cur = head;

    for( ; cur!=NULL; cur = cur->next)
    {
        printf("[%c] ",cur->data);
    }

    printf("\n");

    cur = head;

    for( ; cur!=NULL; cur = cur->next)
    {
        if(cur->random == NULL)
        {
            printf("[%c]->%p ",cur->data,cur->random);
            continue;
        }
        printf("[%c]->[%c] ",cur->data,cur->random->data);
    }
    printf("\n");
}

思路一

将链表内的每个元素的random的指向利用其偏移量的方式进行保存，偏移量是random指向的元素相对于头指针的偏移距离。如下图。
这里写图片描述
然后再进行复制新链表的data内容，复制完毕以后根据偏移量在进行random的复制。

//实现

void OffSet(ComplexNode* head, ComplexNode* new_head, ComplexNode* pos, ComplexNode* tail)//计算偏移量，并且根据复制其偏移量指向
{
    if(head == NULL)
    {
        return;
    }
    if(pos == NULL)
    {
        return;
    }
    if(pos->random == NULL)
    {
        tail->random = NULL;
        return;
    }

    ComplexNode* cur = head;
    ComplexNode* tmp = new_head;

    while(cur->data != pos->random->data)
    {
        cur = cur->next;
        tmp = tmp->next;
    }
    tail->random = tmp;
}

ComplexNode* CopyComplex(ComplexNode* head) //复杂链表的复制
{
    if(head == NULL)
    {
        return NULL;
    }
    ComplexNode* new_head = NULL;
    ComplexNode* tail = NULL;
    ComplexNode* cur = head;

    while(cur != NULL)
    {
        if(new_head == NULL)
        {
            new_head = Creat1(cur->data);
            tail = new_head;
        }
        else
        {
            tail->next = Creat1(cur->data);
            tail = tail->next;
        }
        cur = cur->next;
    }
    cur = head;
    tail = new_head;

    while(cur != NULL)
    {
        OffSet(head, new_head, cur, tail);
        cur = cur->next;
        tail = tail->next;
    }
    return new_head;
}

思路二

利用重复插入的方法，将每一个节点的后面再次插入一个与其相同的节点，且random的指向也是相同的，最后再将重复的拆下即可。如下图。
这里写图片描述

//实现

void  ComPush(ComplexNode* head, ComplexNode* cur, Comtype value)//在每个元素后插入一个相同的元素
{
    if(head == NULL)
    {
        return;
    }
    ComplexNode* tmp = cur->next;
    cur->next = Creat1(value);
    cur->next->next = tmp;
}

ComplexNode* CopyComplex2(ComplexNode* head) //复杂链表的复制
{
    if(head == NULL)
    {
        return NULL;
    }

    ComplexNode* cur = head;

    while(cur != NULL)
    {
        ComPush(head,cur,cur->data);
        cur = cur->next->next;
    }

    cur = head;
    ComplexNode* tmp = cur->next;

    while(1)
    {
        if(cur->random == NULL)
        {
            cur = cur->next->next;
            if(cur == NULL)
            {
                break;
            }
            tmp = cur->next;
            continue;
        }
        tmp->random = cur->random->next;
        cur = cur->next->next;
        if(cur == NULL)
        {
            break;
        }
        tmp = cur->next;
    }

    cur = head;
    tmp = cur->next;
    ComplexNode* new_head = NULL;
    ComplexNode* tail = NULL;

    while(1)
    {
        if(new_head == NULL)
        {
            new_head = tmp;
            cur->next = tmp->next;
            tail = new_head;
        }
        else
        {
            tail->next = tmp;
            cur->next = tmp->next;
            tail = tail->next;
        }
        cur = cur->next;
        if(cur == NULL)
        {
            break;
        }
        tmp = cur->next;
    }
    return new_head;
}

测试代码如下：

void TestCom()
{
    HEAD;
    printf("\n");
    printf("\n");
    printf("\n");
    ComplexNode* head;
    ComplexNode* a = Creat1('a');
    ComplexNode* b = Creat1('b');
    ComplexNode* c = Creat1('c');
    ComplexNode* d = Creat1('d');

    head = a;
    a->next = b;
    b->next = c;
    c->next = d;

    b->random = d;
    c->random = a;
    a->random = d;
    d->random = NULL;

    printf("=======================原链表=========================\n");
    ComPrint(head);
    ComplexNode* new_head = CopyComplex(head);
    printf("=======================新链表=========================\n");
    ComPrint(new_head);
}


void TestCom2()
{
    HEAD;
    printf("\n");
    printf("\n");
    printf("\n");
    ComplexNode* head;
    ComplexNode* a = Creat1('a');
    ComplexNode* b = Creat1('b');
    ComplexNode* c = Creat1('c');
    ComplexNode* d = Creat1('d');

    head = a;
    a->next = b;
    b->next = c;
    c->next = d;

    b->random = d;
    c->random = a;
    a->random = d;
    d->random = NULL;

    printf("=======================原链表=========================\n");
    ComPrint(head);
    printf("=======================新链表=========================\n");
    CopyComplex2(head);
    ComPrint(head);
}

void Test1()
{
    TestCom();
    TestCom2();
}

欢迎大家共同讨论，如有错误及时联系作者指出，并改正。谢谢大家！

单链表题目
Y2663438690的博客
04-22 974
根据需要动态地开辟内存空间，可以比较自由方便地插入新元素（结点)，支持随机访问，故使用链表可以节省内存，操作效率高。将指针p的下一个结点的下一个结点的地址赋给指针p的下一个结点，即p->next=q->next;C.结点的存储空间分两部分，一部分用于存储结点的数据，另一部分用于存储其他结点的指针。4.在一个单链表head中，若要在指针p所指结点后插入一个q指针所指结点，则执行（5.在一个单链表head中，若要删除指针p所指结点的后继结点，则执行（D）。10.带头结点的单链表的结点结构。
数据结构学习记录之单链表相关试题——方法实现
NotMeYa的博客
07-07 217
一、获取单链表节点的个数（如果是带头节点的链表，需求不统计头节点） /** *@param head 链表的头节点 *@return 返回的就是有效节点的个数 */ public static int getLength(HeroNode head){ if(head.next == null){ //空链表 return 0; } int length = 0; //定义一个辅助的变量,这里没有统计头节点 HeroNode cur = head.next; while(cur != n
数据结构面试之一——单链表常见操作
铭毅天下Elasticsearch
08-13 5903
数据结构面试之一——单链表常见操作 题注：《程序员面试宝典》有相关习题，但思路相对不清晰，排版有错误，本文对此参考相关书籍和自己观点进行了重写，供大家参考。 1.查找链表元素 Step1：置查找标记bfound=false;判断链表是否为空，是，提示“不能查找空链表”；否，进入step2。 Step2：从链表头开始查找，判断（当前点的info是否与待查找元素值相等&&指针未指向末尾），是，
数据结构之单链表常见笔试题
mignatian的博客
04-07 559
头文件以及定义的节点都在上一篇的单链表功能实现里面有写 逆序打印单链表 递归方式简洁明了 void linklist_reverseprintf(linklist *head) { if(head == NULL) { return;//空链表 } linklist_reverseprint(head-&gt;next); pr...
数据结构 单链表相关习题练习
雪碧柠七的博客
05-10 6583
1.逆序打印单链表采用递归的方法即可实现。//逆序打印单链表 void LinkListReversePrint(LinkNode* head) { if(head == NULL) { return; } LinkListReversePrint(head-&gt;next); printf("[%c] ",head-&gt;...
数据结构与算法（6）——单链表习题一
小菜鸟入门
03-23 695
题目1：向有序链表中插入一个结点 题目2：逆置单向链表 题目3：从单链表尾部开始输出该链表
Java常见数据结构面试题（带答案）
08-29
"Java常见数据结构面试题（带答案）" 以下是对Java常见数据结构面试题的知识点总结： 栈和队列 * 栈和队列的共同特点是只允许在端点处插入和删除元素。 * 栈通常采用的两种存储结构是线性存储结构和链表存储结构...
算法大全面试题数据结构单链表的13道面试题含代码
12-17
数据结构是计算机科学中的核心概念，它涉及到如何高效地存储和操作数据。在众多的数据结构中，单链表是一...通过阅读《算法大全-面试题-数据结构.pdf》和参考readme.txt，你可以深入理解每道题目的解题思路和代码实现。
面试-Java一些常见面试题+题解之数据结构-DataStructure.zip
最新发布
03-03
本资料包"面试-Java一些常见面试题+题解之数据结构-DataStructure.zip"聚焦于Java中的数据结构，旨在帮助求职者更好地准备面试。下面我们将详细探讨其中可能涉及到的一些关键知识点。 1. **数组**： - 数组是最...
数据结构学习（二）：单链表试题
KiMiWaWonderful的博客
03-22 259
1.编写一个方法，接收head节点，同时接收一个index 2.index表示倒数第index个节点 3.先把链表从头到尾遍历，得到链表的总长度（getLength） 4.得到size后，从链表的第一个开始遍历（size-index）个,就可以得到
数据结构中有关链表的题目
春风十米的博客
07-04 488
import java.util.HashMap; import java.util.Stack; /** * Created by wst on 2017/6/30. */ public class List_Algorithm { public static void main(String[] args) { Node n1 = new Node(1);
数据结构-单链表常见面试题
zgege的博客
04-22 283
一、题目 1、从尾到头打印单链表 (两种方法) 2、删除一个无头单链表的非尾节点（不能遍历链表） 3、在无头单链表的一个节点前插入一个节点（不能遍历链表） 4、单链表实现约瑟夫环(JosephCircle) 5、逆置/反转单链表 6、单链表排序（冒泡排序&amp;amp;快速排序） 7、合并两个有序链表,合并后依然有序 8、查找单链表的中间节点，要求只能遍历一次链表 9...
数据结构之单链表常见面试题2
mignatian的博客
04-07 209
判断两链表是否相交，返回交点（考虑带环） linklist *linklist_iscrossplus(linklist *head1,linklist *head2) { if(head1 == NULL) { return NULL; } if(head2 == NULL) { return NULL; } ...
【数据结构】单链表经典面试题10道及详细思路代码
weixin_59215611的博客
08-27 1386
快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表其实位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾。1.找到链表的中间节点，从中间节点的位置将链表分开，形成2个链表---->找中间节点:采用快慢指针ok。一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在满指针走到一圈之前，2.遍历原链表，将链表中的节点往两个新链表中尾插--新链表最好将其给成带头节点的单链表。1.创建两个链表，一个链表尾插值小于x的节点，另一个链表中插值大于等于x的节点。...
数据结构-链表的经典面试题
y6_xiamo的博客
04-12 1281
在前面的博客中我们对链表做了一些基本操作，所以在此不再赘述。直接来看，有哪些和链表有关的面试题以及如何去实现它们。 1.头文件声明 linklist.h #pragma once typedef char LinkNodeType; typedef struct LinkNode { LinkNodeType data; struct LinkNode *next; ...
数据结构单链表试题一
rumm
11-01 2339
数据结构单链表创建一个表格 单链表 单链表的表头指针为h，结点结构由data和next两个域构成，其中data域为字符型。写出算法dc（h,n）,判断该链表的前n个字符是否中心对称。例如xyx,xyyx都是中心对称（2018） int dc(LinkList h,int n){ char s[]; int i; LinkList *p=h->next; for(i=A;i<=n/B;i++){ s[i]=p->data; p=p->next; } i--
链表经典练习题
热门推荐
erwuhuoche的博客
04-16 2万+
链表经典练习题 一、从尾到头打印单链表 因为单链表是有指向的，前一节点只能指向下一节点，因此为了实现从尾到头打印链表可以使用一种非常简单的方法就是递归，先遍历再输出。 代码实现： void LinkListReversePrint(LinkNode* head){ 85 if(head == NULL){ 86 return;//空链表 8...
数据结构常见题目
gaibian_one的博客
09-13 2万+
链表 当删除一个节点时，并不一定要删除这个节点本身，可以把下一个节点的内容复制出来覆盖被删除节点的内容，然后把下一个节点删除。（提高单链表的删除效率，不用从头遍历链表，但删除的是最后一个节点时，仍需要从头遍历到前一个节点） 当我们用一个指针遍历链表不能解决问题时，可以尝试用两个指针遍历链表，让其中一个指针遍历的快一些。 如：（1）链表倒数第k个节点        思路：两个指针间隔k-1，
微软数据结构与算法面试100题全解析
"微软数据结构和算法面试题的精选合集，包含100道经典题目，涵盖了数据结构和算法的各个方面。这份资料包括题目、答案以及思路解析，且在网上具有唯一性。提供了不同版本的答案更新，供学习者参考和校正。题目分布于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值