【腾讯面试题】-判断两个单链表是否相交并求出相交的第一结点（转）

最新推荐文章于 2022-05-10 16:03:09 发布
转载 最新推荐文章于 2022-05-10 16:03:09 发布 · 391 阅读 · 0

本文探讨了两个单链表是否相交的问题，并给出了两种不同的算法解决方案。首先介绍了通过比较两个链表尾节点来判断是否相交的方法，其次提出了利用快慢指针寻找相交点的策略。

腾讯面试时的技术面试官喜欢问关于算法的问题。

问题描述

判断两个单链表是否相交,如果相交，给出相交的第一个点（假设两个链表都不存在环）。相交的链表示意图如下所示。 
这里写图片描述

解题思路

方法一

两个没有环的链表如果是相交于某一结点，如上图所示，这个结点后面都是共有的。所以如果两个链表相交，那么两个链表的尾结点的地址也是一样的。程序实现时分别遍历两个单链表，直到尾结点。判断尾结点地址是否相等即可。时间复杂度为O(L1+L2)。 
如何找到第一个相交结点？判断是否相交的时候，记录下两个链表的长度，算出长度差len，接着先让较长的链表遍历len个长度，然后两个链表同时遍历，判断是否相等，如果相等，就是第一个相交的结点。

方法二

另外一个方法则是将一个链表首尾相接，然后判断另外一个链表是否有环，如果有环，则两个链表相交。那么求第一个交点则求出有环的的那个链表的环结点即是。

代码实现

方法一

void Is_2List_Intersect(LinkList L1, LinkList L2) {
    if (L1 == NULL || L2 == NULL) {
        exit(ERROR);
    }
    LinkList p = L1;
    LinkList q = L2;
    int L1_length = 0;
    int L2_length = 0;
    int len = 0;

    while (p->next) {
        L1_length ++;
        p = p->next;
    }
    while (q->next) {
        L2_length ++;
        q = q->next;
    }



    printf("p: = %d\n", p);
    printf("q: = %d\n", q);

    printf("L1_length: = %d\n", L1_length);
    printf("L2_length: = %d\n", L2_length);



    if (p == q) {
        printf(" 相交\n");

        /*p重新指向短的链表 q指向长链表*/
        if (L1_length > L2_length) {
            len = L1_length - L2_length;
            p = L2->next;
            q = L1->next;
        }
        else {
            len = L2_length - L1_length;
            p = L1->next;
            q = L2->next;
        }

        while (len) {
            q = q->next;
            len--;
        }
        while (p != q) {
            p = p->next;
            q = q->next;
        }
        printf("相交的第一个结点是：%d\n", p->data );

    }

    else {
        printf("不相交 \n");
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61

方法二

int Is_ListLoop(LinkList L) {
    LinkList fast, slow;
    if (L == NULL || L->next == NULL) {
        exit(ERROR);
    }

    fast = slow = L;

    while (fast->next != NULL && fast->next->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
        if (fast == slow) {

            return TRUE;
        }
    }


    return FALSE;

}


int Find_Loop(LinkList L) {
    LinkList fast, slow;

    if (L == NULL || L->next == NULL) {
        exit(ERROR);
    }

    fast = slow = L;

    while (fast->next != NULL && fast->next->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
        if (fast == slow) {

            break;
        }
    }

    slow = L;
    while (fast != slow) {
        slow = slow->next;
        fast   = fast->next;
    }
    printf("%d\n", slow->data );

    return TRUE;

}

void Is_2List_Intersect2(LinkList L1, LinkList L2) {
    if (L1 == NULL || L2 == NULL) {
        exit(ERROR);
    }
    LinkList p = L1;
    LinkList q = L2;

    while (p->next) {
        p = p->next;
    }

    p->next = L1->next;

    if(Is_ListLoop(L2)){
        printf("相交\n");
        printf("相交的第一个结点是：");
        Find_Loop(L2);
    }
    else{
        printf("不相交\n");
    }


}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76

测试代码

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define  OK  1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef struct Node {
    int data;
    struct Node *next;
} Node, *LinkList;

int seed;
/*随机产生n个元素的带表头的单链表（头插法）*/
void CreatList_Head(LinkList *L, int n) {
    int i;
    LinkList p;
    seed = seed + 1;
    srand(seed);

    (*L) = (LinkList)malloc(sizeof(Node));
    if (!(*L)) {
        exit(ERROR);
    }

    (*L)->next = NULL;

    for (i = 0; i < n; i++) {
        p = (LinkList)malloc(sizeof(Node));
        if (!p) {
            exit(ERROR);
        }
        p->data = rand() % 100 + 1;
        p->next = (*L)->next;
        (*L)->next = p;
    }
}

/*随机产生n个元素的带表头的单链表（尾插法）*/
void CreatList_Tail(LinkList *L, int n) {
    LinkList p, r;
    int i;

    srand(time(0));

    (*L) = (LinkList)malloc(sizeof(Node));
    if (!(*L)) {
        exit(ERROR);
    }
    r = (*L);

    for (i = 0; i < n; i++) {
        p = (LinkList)malloc(sizeof(Node));
        if (!p) {
            exit(ERROR);
        }
        p->data = rand() % 100 + 1;
        r->next = p;
        r = p;
    }

    r->next = NULL;
}

void Print_List(LinkList L) {
    LinkList p;
    if (!L) {
        exit(ERROR);
    }

    p = L->next;
    while (p) {
        printf("%d   ", p->data);
        printf("address ： %d \n", p);
        p = p->next;
    }

    printf("\n");
}

void Print_List2(LinkList L) {
    LinkList p;
    if (!L) {
        exit(ERROR);
    }

    p = L->next;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }

    printf("\n");
}

void Clear_List(LinkList *L) {
    LinkList p, q;
    if ((*L) == NULL)
        exit(ERROR);

    p = (*L)->next;
    while (p) {
        q = p->next;
        free(p);
        p = q;
    }

    (*L)->next = NULL;
}

void Print_List_noHead(LinkList L) {
    LinkList p;
    if (!L) {
        exit(ERROR);
    }

    p = L;
    while (p) {
        printf("%d ", p->data);
        p = p->next;
    }

    printf("\n");
}



int Creat_ListLoop(LinkList *L, int n, int loop_index) {

    LinkList p, r, q;
    int i;

    srand(time(0));

    (*L) = (LinkList)malloc(sizeof(Node));
    if (!(*L)) {
        exit(ERROR);
    }
    r = (*L);

    for (i = 0; i < n; i++) {
        p = (LinkList)malloc(sizeof(Node));
        if (!p) {
            exit(ERROR);
        }
        p->data = rand() % 100 + 1;
        r->next = p;
        r = p;
        if (i == (loop_index - 1))
            q = r;
    }

    r->next = q;

}

void Print_List_Loop(LinkList L, int n) {
    LinkList p;
    int i;
    if (!L) {
        exit(ERROR);
    }

    p = L->next;
    for (i = 0; i < n; i++) {
        printf("%d ", p->data);
        p = p->next;
    }

    printf("\n");
}

int Is_ListLoop(LinkList L) {
    LinkList fast, slow;
    if (L == NULL || L->next == NULL) {
        exit(ERROR);
    }

    fast = slow = L;

    while (fast->next != NULL && fast->next->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
        if (fast == slow) {

            return TRUE;
        }
    }


    return FALSE;

}


int Find_Loop(LinkList L) {
    LinkList fast, slow;

    if (L == NULL || L->next == NULL) {
        exit(ERROR);
    }

    fast = slow = L;

    while (fast->next != NULL && fast->next->next != NULL) {
        slow = slow->next;
        fast = fast->next->next;
        if (fast == slow) {

            break;
        }
    }

    slow = L;
    while (fast != slow) {
        slow = slow->next;
        fast   = fast->next;
    }
    printf("%d\n", slow->data );

    return TRUE;

}

void Is_2List_Intersect(LinkList L1, LinkList L2) {
    if (L1 == NULL || L2 == NULL) {
        exit(ERROR);
    }
    LinkList p = L1;
    LinkList q = L2;
    int L1_length = 0;
    int L2_length = 0;
    int len = 0;

    while (p->next) {
        L1_length ++;
        p = p->next;
    }
    while (q->next) {
        L2_length ++;
        q = q->next;
    }



    printf("p: = %d\n", p);
    printf("q: = %d\n", q);

    printf("L1_length: = %d\n", L1_length);
    printf("L2_length: = %d\n", L2_length);



    if (p == q) {
        printf(" 相交\n");

        /*p重新指向短的链表 q指向长链表*/
        if (L1_length > L2_length) {
            len = L1_length - L2_length;
            p = L2->next;
            q = L1->next;
        }
        else {
            len = L2_length - L1_length;
            p = L1->next;
            q = L2->next;
        }

        while (len) {
            q = q->next;
            len--;
        }
        while (p != q) {
            p = p->next;
            q = q->next;
        }
        printf("相交的第一个结点是：%d\n", p->data );

    }

    else {
        printf("不相交 \n");
    }

}

void Is_2List_Intersect2(LinkList L1, LinkList L2) {
    if (L1 == NULL || L2 == NULL) {
        exit(ERROR);
    }
    LinkList p = L1;
    LinkList q = L2;

    while (p->next) {
        p = p->next;
    }

    p->next = L1->next;

    if(Is_ListLoop(L2)){
        printf("相交\n");
        printf("相交的第一个结点是：");
        Find_Loop(L2);
    }
    else{
        printf("不相交\n");
    }


}

int main(int argc, char const *argv[])
{
    LinkList L1 , L2, L3, L4;

    LinkList p, q;

    CreatList_Head(&L1, 8);

    CreatList_Head(&L2, 5);

    /*将L2尾结点指向L1的第4个结点处，构造相交链表*/
    p = L2;

    while (p->next)
        p = p->next;

    q = L1;
    for (int i = 0; i < 4; i ++)
        q = q->next;
    p->next = q;

    Print_List(L1);
    Print_List(L2);

    Is_2List_Intersect(L1, L2);
    Is_2List_Intersect2(L1, L2);

    CreatList_Head(&L3, 5);
    CreatList_Head(&L4, 5);
    Print_List(L3);
    Print_List(L4);
    Is_2List_Intersect(L3, L4);
    Is_2List_Intersect2(L3, L4);
    return 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160
  • 161
  • 162
  • 163
  • 164
  • 165
  • 166
  • 167
  • 168
  • 169
  • 170
  • 171
  • 172
  • 173
  • 174
  • 175
  • 176
  • 177
  • 178
  • 179
  • 180
  • 181
  • 182
  • 183
  • 184
  • 185
  • 186
  • 187
  • 188
  • 189
  • 190
  • 191
  • 192
  • 193
  • 194
  • 195
  • 196
  • 197
  • 198
  • 199
  • 200
  • 201
  • 202
  • 203
  • 204
  • 205
  • 206
  • 207
  • 208
  • 209
  • 210
  • 211
  • 212
  • 213
  • 214
  • 215
  • 216
  • 217
  • 218
  • 219
  • 220
  • 221
  • 222
  • 223
  • 224
  • 225
  • 226
  • 227
  • 228
  • 229
  • 230
  • 231
  • 232
  • 233
  • 234
  • 235
  • 236
  • 237
  • 238
  • 239
  • 240
  • 241
  • 242
  • 243
  • 244
  • 245
  • 246
  • 247
  • 248
  • 249
  • 250
  • 251
  • 252
  • 253
  • 254
  • 255
  • 256
  • 257
  • 258
  • 259
  • 260
  • 261
  • 262
  • 263
  • 264
  • 265
  • 266
  • 267
  • 268
  • 269
  • 270
  • 271
  • 272
  • 273
  • 274
  • 275
  • 276
  • 277
  • 278
  • 279
  • 280
  • 281
  • 282
  • 283
  • 284
  • 285
  • 286
  • 287
  • 288
  • 289
  • 290
  • 291
  • 292
  • 293
  • 294
  • 295
  • 296
  • 297
  • 298
  • 299
  • 300
  • 301
  • 302
  • 303
  • 304
  • 305
  • 306
  • 307
  • 308
  • 309
  • 310
  • 311
  • 312
  • 313
  • 314
  • 315
  • 316
  • 317
  • 318
  • 319
  • 320
  • 321
  • 322
  • 323
  • 324
  • 325
  • 326
  • 327
  • 328
  • 329
  • 330
  • 331
  • 332
  • 333
  • 334
  • 335
  • 336
  • 337
  • 338
  • 339
  • 340
  • 341
  • 342
  • 343
  • 344
  • 345
  • 346
  • 347
  • 348

结果输出

93   address ： 14678144 
87   address ： 14678112 
36   address ： 14678080 
94   address ： 14678048 
16   address ： 14678016 
78   address ： 14677984 
87   address ： 14677952 
84   address ： 14677920 

62   address ： 14678336 
76   address ： 14678304 
89   address ： 14678272 
20   address ： 14678240 
91   address ： 14678208 
94   address ： 14678048 
16   address ： 14678016 
78   address ： 14677984 
87   address ： 14677952 
84   address ： 14677920 

p: = 14677920
q: = 14677920
L1_length: = 8
L2_length: = 10
 相交
相交的第一个结点是：94
相交
相交的第一个结点是：94
26   address ： 14678528 
41   address ： 14678496 
69   address ： 14678464 
86   address ： 14678432 
47   address ： 14678400 

64   address ： 14678720 
27   address ： 14678688 
75   address ： 14678656 
84   address ： 14678624 
2   address ： 14678592 

p: = 14678400
q: = 14678592
L1_length: = 5
L2_length: = 5
不相交 
不相交

【面试题】-判断两个单链表是否相交并求出相交的第一结点
zengwh
05-15 6050
问题描述判断两个单链表是否相交,如果相交，给出相交的第一个点（假设两个链表都不存在环）。相交的链表示意图如下所示。 解题思路方法一两个没有环的链表如果是相交于某一结点，如上图所示，这个结点后面都是共有的。所以如果两个链表相交，那么两个链表的尾结点的地址也是一样的。程序实现时分别遍历两个单链表，直到尾结点。判断尾结点地址是否相等即可。时间复杂度为O(L1+L2)。方法二代码实现方法一void Is_
搞懂单链表常见面试题
王小六的博客
03-09 3388
搞懂单链表常见面试题 Hello 继上次的 搞懂基本排序算法，这个一星期，我总结了，我所学习和思考的单链表基础知识和常见面试题，这些题有的来自 《剑指 offer》 ,有的来自《程序员代码面试指南》，有的来自 leetCode，不是很全面，但都具有一定代表性，相信大家看完以后一定跟我一样，对面试的时候算法题又多了一份自信。 什么是单链表 链表（Linked list）是一种常...
判断两个链表是否相交
DSIslander的专栏
11-23 761
判断两个链表是否相交   2012-01-09 10:37:03|  分类： 默认分类 |  标签： |字号大中小 订阅 给出两个单向链表的头指针，判断这两个链表是否相交，如果相交给出相交的第一个结点 一、两个链表均不含有环 链表相交如下图    方法一：直接法    直接判断第一个链表的每个结点是否在第二个链表中，时间复杂度为O(len1*len2)，耗时很大 方
经典面试题：链表的相交与环问题
编程资料大全
05-19 239
1、 给出两个单向链表的头指针pHead1和pHead2，判断这两个链表是否相交。假设两个链表均不带环。示意图如下：如果两个链表相交于某一节点，那么在这个相交节点之后的所有节点都是两个链表所共有的。也就是说，如果两个链表相交，那么最后一个节点肯定是共有的。先遍历第一个链表，记住最后一个节点，然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交，否则不相交。时间复杂...
判断两个单链表是否相交，若相交并找出相交的第一个点
小程的博客
02-19 394
链表的正确相交情况如下： 判断两个链表是否相交 //确定两个单链表是否相交 (用两个指针跑到两个单链表的尾结点，然后判断是否是同一个尾结点) bool Intersect(PNode plist1, PNode plist2) { //assert PNode p1 = plist1; PNode p2 = plist2; for(p1; p1->next!=NULL; p1=p1->next); //此时for循环结束 p1在plist1这个单链表的尾结点上 .
两个单向链表是否相交 汇总
weixin_30883311的博客
08-19 257
投了腾讯IOS客户端开发岗，结果面试官大大问了一堆操作系统，数据结构，算法，计算机网络问题，orz，给大神跪了！最后问大神什么职位，大神说他就是IOS工程师。真服了！当时问了算法，关于链表，当时没想起来，面完之后拿个纸算算，我竟然会。写下来，mark一下。 问题：给出两个单向链表的头节点，判断两个链表是否相交，如果相交，请找出相交节点。 这个问题是分好几种情况的，要分支来判断： 假定两...
面试题快慢链表和快慢指针
08-30
快慢链表的原理基于标尺的思想，设置两个指针（一快一慢），即*search和*mid，刚开始都指向单链表的头结点。然后，让*search指针的移动速度是*mid的两倍。当*search到尾结点的时候，*mid刚好到了中间。这样可以快速...
【面经】找实习两个月（面试题以及答案）
yeahfeng
05-05 6177
题目转自：北邮人论坛https://bbs.byr.cn/#!article/Job/1888499 ### 格灵深瞳 (平台开发) 一面： 1. 介绍你知道的传输层协议 答：TCP，UDP等 2. unix socket和socket了解吗 3. HTTP和HTTPS了解吗 4. 数据库触发器 ### 携程  1. 快速排序是稳定的还是非稳定的？时间
数据结构与算法面试题80道
javalingyu的博客
05-10 517
1.把二元查找树转变成排序的双向链表 题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 10 / \ 6 14 / \ / \ 4 8 12 16 转换成双向链表 4=6=8=10=12=14=16。 首先我们定义的二元查找树 节点的数据结构如下： struct BSTreeNode { int m_nValue; // value of node BSTreeNode *m_pLeft; // left child
面试腾讯时遇到了“链表“的原题，so easy！
聊点技术
07-10 362
本文首发于微信公众号：聊点技术，原文标题《 面试腾讯时遇到了"链表"的原题，so easy！》 找工作的过程中，不论是参加笔试还是面试，我们都会遇到大量和链表有关的题目。我在找实习的时候，经历的第一场面试是腾讯的电话面试，两道编程题目中有一道就是本文中提到的：复杂链表的复制。秋招期间，在经历了多次笔试和面试后，我把曾经遇到过的与链表有关的题目进行了分类总结，总结成此文期待能够对各位朋友有所帮助。 本文总结了在面试中遇到频率最高的与链表有关的题目，并使用了C++进行编码实现。 链表节点定义如下： struct
判断两个单链表是否相交
weixin_30530523的博客
02-16 133
法1、对链表1中的每个节点p1，判断链表2中是否有一个节点p2指向p1loop:p1从head1到最后一个节点loop:p2从head2到最后一个节点 if(p2是否指向p1) 相交 break时间复杂度：O(list1.length * list2.length)空间复杂度：O(1)法2、使用hash表loop：p1从head1到最后一个节点把p1放入hash表table中loo...
判断两个链表是否相交并找出第一个相交节点
芮萌萌的博客
07-14 1848
引言：链表问题是数据结构中的常见问题，对于面试、笔试都有很大的作用，那么如何判断两个链表是否相交并找出第一个相交节点？ 分析：找出两个链表的交点首先就是判断链表是否相交，那么首先来看什么是两个链表相交？ 一、什么是链表相交？ 数据结构的链表定义中存储了指向下一个元素的指针，如果当两个链表有交点时，即两个链表会在各自链表中的某个结点，同时指向了相同的下一个结点，即如下图所示： 图中...
判断两个单链表是否相交及找到第一个交点
小呼哥的博客
04-26 2593
本文仅仅整理一下解题思路，没有代码供参考。
判断两链表是否相交，如果相交找到第一个交点
ruoshui1314的专栏
01-24 799
#include #include typedef struct LinkNode { struct LinkNode* next; int data; }LinkList; /*说明:都带头结点的单链表*/ /*创建链表*/ void createLinkList(LinkList* head, int* a, int n) { int i = 0; Link
判断两个链表是否相交并且返回第一个交点
gordon_rawe的专栏
11-10 537
在携程面试的一道算法题，主要的考点在于
判断链表是否相交
11-25 584
如题，代码如下： #include #include #define Yes 1 #define No 0 //链表类型 typedef struct list_t { int data; struct list_t *next; }list_t; list_t *create_list(int n); void print_list (list_t *head);
判断两个链表是否相交,若相交,求交点。
qingdou_aixuexi的博客
08-27 559
第一种情况：两个链表均不含有环 思路： 1、直接法 采用暴力的方法，遍历两个链表，判断第一个链表的每个结点是否在第二个链表中，时间复杂度为O(len1*len2)，耗时很大。 2、hash计数法 以链表节点地址为值，遍历第一个链表，使用Hash保存所有节点地址值，结束条件为到最后一个节点（无环）或Hash中该地址值已经存在（有环）。 再遍历第二个
两个链表是否相交问题
weixin_58104242的博客
01-23 827
给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。注意：可能会出现链式结构中出现环。 首先，判断单个链表是否成环，给定一个链表，返回链表开始入环的第一个节点。 从链表的头节点开始沿着 next 指针进入环的第一个节点为环的入口节点。如果链表无环，则返回 null。 很简单，快慢指针，如果成环，一定会在环内相遇，此时让fast=head，再各自一人走一步，一定会在成环位置相遇。 public ListNode d
c++判断两个单链表是否相交
最新发布
11-25
以下是C++判断两个单链表是否相交的代码实现： ```c++ //定义链表节点 struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; //判断两个单链表是否相交（判断尾节点是否...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值