数据结构------单链表相关的面试题

关注

原创最新推荐文章于 2026-09-03 09:21:23 发布 340 阅读 AI 写同款· GEO 优化 ›

【数据结构】面试题整理共36题链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和一个指向下一个节点的指针。与数组不同，链表中的元素在内存中不必是连续存储的，这使得链表在插入和删除操作时非常高效。单向链表（Singly Linked List）：每个节点只包含一个指向下一个节点的指针。双向链表（Doubly Linked List）：每个节点包含两个指针，一个指向下一个节点，一个指向前一个节点。循环链表（Circular Linked List）：链表的最后一个节点指向第一个节点，形成一个环。阅读详情

1、从尾到头来打印单链表
在以前我们学习C语言的时候，我们都比较熟悉的就是逆序字符、汉诺塔、还有就是实现斐波那契数列的时候我们当时所用的方法就是递归，在这类问题的实现过，我们就对递归这个算法换是比较熟悉的，今天我们就来用递归的思想来实现从尾到头来打印链表。
那么我们刚开始拿到这个题的时候有点困惑，一时半会没想到解决的办法，最后才想到了递归这个方法。我最后得出逆序打印链表主要有三种做法：
1、用递归的方法进行实现，这个方法虽然比较好用，但是不容易想到，代码相对于来说是比较简单的。
2、定义一个新的链表，然后在将第一个元素放入这个新的链表中，然后调用头插的方法，最后能够将链表实现逆序。
3、第三种方法是实现的是定义三指针的方法：
这里写图片描述
每次都采用这种调用头插的方法：依次往后进行每次调用头插之后让三个指针都往后进行遍历，然后在调用头插这样依次进行循环，直到所有的元素都进行逆序完毕。

void LinkListReversePrint(LinkNode* head)    // 逆序打印单链表
{
    if (head == NULL){
        return NULL;
    }
    LinkListReversePrint(head->next);//使用递归的思想来实现
    printf("[%c]|[%p]", head->data, head);
}

2、前面我们已经实现了在pos之前插入一个元素
现在我们就来继续实现下在pos之前去插入元素，条件是在不允许遍历链表的前提下，我们先来说说实现的思想就是我们之前也实现过在pos之后去插入一个元素，我们就将未知的问题就转化为已知的问题，先来在pos之后去插入一个元素，然后将其新插入的元素和pos的值最后激进型交换我们就能实现在pos前去插入一个元素。
我们现在就来用相关的图来演示下我们的思路：
这里写图片描述
具体的代码实现就如下所示：

    void LinkListInsert2(PLinkNode* phead, LinkNode* pos, LinkNodeType value)
    //在这里运用的主要的做法就是先调用后插，然后最后再交换两个位置的值
255 {
256        if(phead == NULL || pos==NULL)
257         {
258             return;
259         }
260         LinkListInsertAfter(phead,pos, value);
261         LinkNodeType ret = pos->data;
262         pos->data = pos->next->data;
263         pos->next->data = ret;
264         return;
265 }

3、单链表实现约瑟夫环
我们先来了解下一个比较有意思的故事：约瑟夫是犹太军队的一个将军，在反抗罗马的起义中，他所率领的军队被击溃，只剩下残余的部队40余人，他们都是宁死不屈的人，所以不愿投降做叛徒。一群人表决说要死，所以用一种策略来先后杀死所有人。
于是约瑟夫建议：每次由其他两人一起杀死一个人，而被杀的人的先后顺序是由抽签决定的，约瑟夫有预谋地抽到了最后一签，在杀了除了他和剩余那个人之外的最后一人，他劝服了另外一个没死的人投降了罗马。
我们这个规则是这么定的：

在一间房间总共有n个人（下标0～n-1），只能有最后一个人活命。
按照如下规则去杀人：
所有人围成一圈
顺时针报数，每次报到q的人将被杀掉被杀掉的人将从房间内被移走然后从被杀掉的下一个人重新报数，继续报q，再清除，直到剩余一人
在一间房间总共有n个人（下标0～n-1），只能有最后一个人活命。
在单链表实现约瑟夫环的过程就如下所示：

266 LinkNode* JosephCycle(LinkNode* head, size_t m)
267     //约瑟夫环
268     //主要实现的是三个步骤：构环，报数、删除
269 {
270           if(head==NULL){
271           return;
272  }
273           size_t count=0;
274           LinkNode* cur=head;
275           LinkNode* tmp= NULL;
276           while(cur->next!=cur){
277         count++;
278         cur=tmp;
279         cur=cur->next;
280         if(count==m)
281         {
282             printf("[%c]\n",tmp->data);
283             LinkListErase2(&tmp,tmp);
284             count=0;
285         }
286           }
287         return cur;
288 }
289

4、单链表的逆置/反转
在单链表的逆置反转中主要有两种做法：
方法一：
这里写图片描述
代码的实现如下所示：
//这里主要实现的是通过先修改头指针的指向，进行实现的

void LinkListReverse(LinkNode** head)
293 {
294         if(head==NULL){
295         return;
296         }
297         if((*head)->next==NULL){
298         return;
299         }
300         LinkNode* cur=*head;
301         LinkNode* to_erase=NULL;
302         while(cur->next!=NULL)
303        {                                                                                                                           
304         to_erase=cur->next;
305         cur->next=to_erase->next;
306         LinkListPushFront(head,to_erase->data);
307         Destroynode(to_erase); 
308         }
309 }

方法二：
这种方法主要是定义三个指针的方法，进行逆置的，相对来说有点复杂，我们有时候是很不容易去想到的

        //通过定义三个指针的方法
314 void LinkListReverse2(LinkNode** head){
315         if(head==NULL){
316         return;
317         }
318         if((*head)->next==NULL){
319         return;
320         }
321       LinkNode* pre=*head;
322       LinkNode* cur=pre->next;
323       LinkNode* pro=NULL;//pro刚开始必须初始化为空指针，因为每次执行完，所指的内容试不同的
324       while(pre->next!=NULL){
325         pro=cur->next;
326        pre->next=pro;
327        cur->next=pre;
328        cur->next=*head;
329        *head=cur;
330        cur=pre->next;
331         }
332 }

5、单链表的冒泡排序
冒泡排序之前我们已经写过很多的比较类似的这种方法实现的不同的要求。

        void swp(LinkNodeType *p1,LinkNodeType  *p2){//刚开始我在这没有定义成指针类型，最后才明白
        形参是实参的一份临时拷贝，必须用指针进行传里面的内容
335 
336     LinkNodeType ret=*p1;
337     *p1=*p2;
338     *p2=ret;
339 }
340 
341 void LinkListBubbleSort(LinkNode** head)
342  // 单链表的冒泡排序
343 {
344         if(head==NULL){
345             return;
346         }
347 
348          LinkNode* cur=*head;//趟数
349          LinkNode* tmp=*head;//次数
350          LinkNode* tal=NULL;//尾指针
351          for(cur=*head;cur->next!=NULL;cur=cur->next){
352              for(tmp=*head;tmp->next!=NULL;tmp=tmp->next){
353                  if((tmp->data)>(tmp->next->data)){
354                      swp(&(tmp->data),&(tmp->next->data));
355                  }
356              }
357          }
358          tmp=tal;
359 }
360 
361

6、将两个有序的链表合并成一个链表
首先我们定义两个指针指向各自的链表，在定义new_head指向指针的头部，定义new_tail指向尾部，cur1和cur2进行比较，将小的值放入到新链表中。
这里写图片描述
程序需要考虑如下情况：两个链表（函数参数）都有可能为空，可能连个链表其中一个为空，可能两个链表相等，也可能其中一个链表已经遍历完了，另一个链表还有很多元素，所以需要首先处理特殊情况。
1、非递归实现

LinkNode* LinkListMerge(LinkNode* head1, LinkNode* head2)// 将两个有序链表, 合并成一个有序链表
{
    //首先处理特殊情况  两个链表相等；l1为空链表，l2不为空
    //l1不为空，l2为空链表
     //先遍历一次让new_head指向最小的头指针，然后cur1、cur2进行往下走
           LinkNode* cur1=head1;
           LinkNode* cur2=head2;

      if(head1==head2){
          return head1;
      }
      if((head1!=NULL)&&(head2=NULL)){
          return head1;
      }
      if((head1=NULL)&&(head2!=NULL)){
          return head2;
      }
      LinkNode* new_head=NULL;
      LinkNode* new_tail=NULL;
      if((cur1->data)>(cur2->data)){
          new_head=cur2;
          cur2=cur2->next;
      }
     else
     {
          new_head=cur1;
          cur1=cur1->next;
     }
         new_tail=new_head;
              while((cur1!=NULL)&&(cur2!=NULL)){
          if((cur1->data)<(cur2->data)){
        new_tail->next=cur1;
          new_tail=cur1;//new_tail是往后遍历的指针   
          cur1=cur1->next;
          }
          else{
        new_tail->next=cur2;
          new_tail=cur2;
          cur2=cur2->next;
          }
          }
       if(cur1!=NULL){
           new_tail->next=cur1;
       }
      else
      {
           new_tail->next=cur2;
      }
      return new_head;
}

7、找到链表最中间的节点
该题目可算是比较有新意了，我们今天使用的方法是采用快慢指针的方法，之前我们在学习C语言的时候已经接触到了，今天我们就来看看采用这种方法进行解决问题，我们定义一个快指针，一个慢指针，先让慢指针走一步，快指针走两步，当快指针走到最后一个元素的时候，刚好慢指针就走到了最中间的位置，因此也就实现了我们所期望的结果。

  LinkNode* FindMidNode(LinkNode* head)//找到最中间的节点
415 {
416     if(head==NULL){
417         return  NULL;
418     }
419     LinkNode* fast=head;
420     LinkNode* slow=head;
421     while((fast!=NULL)&&(fast->next)!=NULL){//fast走的快，当fast满足条件时，slow肯定满        足条件
422         slow=slow->next;
423         fast=fast->next->next;
424     }
425     return slow;
426 }

8、找到倒数第k个结点，允许只遍历一次
首先我们的思路也是刚才的采用快慢指针的方法，首先让快指针走k步，然后就让slow、fast同时走，知道fast为空时，slow所指的位置就是倒数第k个结点

 LinkNode* FindLastKNode(LinkNode* head, size_t K)//找到倒数第 K 个节点.
431 {
432     if(head==NULL){
433         return;
434     }
435     LinkNode* fast=head;
436     LinkNode* slow=head;
437     int  k=2;//k必须要初始化确定的数值                                                                                             
438     int  i=0;
439     for(i=0;i<k;i++){//先让快指针走k步
440         if(fast==NULL){
441             break;
442         }
443         fast=fast->next;
444     }
445     while(fast!=NULL){//快指针走k步之后，两个指针同时走
446         slow=slow->next;
447         fast=fast->next;
448     }
449     return slow;
450 }
451

9、删除倒数k个结点
我们先来判断该节点是不是和链表的长度进行比较，在特殊位置的话就采用特殊位置的删除的方法，当k等于所要删除的链表的长度，我们就调用头删，要是超过链表的长度我们就返回，然后再对这些位置进行删除。

void EraseLastKNode(LinkNode** head, size_t K)//删除倒数第K个节点
454 {
455     if(head==NULL){
456         return;
457     }
458     if(*head==NULL){
459         return;
460     }
461     size_t len=LinkListSize(*head);
462     int k=3;//注意要进行初始化，这样才能找到要删的位置
463     if(k>len){
464         return;
465     }
466     if(k==len){                                                                                                                    
467         LinkListPopBack(head);
468     }
469     int i=0;
470     LinkNode* cur=*head;
471     for(i=0;i<len-(k+1);i++){//先让cur找到k结点前面的结点，然后我们所要删除的结点就是
          cur->next，这样再进行删除。
472         cur=cur->next;
473     }
474     LinkNode* to_kill=cur->next;
475     cur->next=to_kill->next;
476     Destroynode(to_kill);
477 }

10、判定单链表是否带环. 如果带环返回1
在判断链表是否代还我们采用的方法也是前面我们所用到的方法，那就是定义两个指针，快指针和慢指针，我们让快指针走两步，慢指针走一步，只要链表带环，两个指针总会相遇的。

int  HasCycle(LinkNode* head)// 判定单链表是否带环. 如果带环返回1
480 {
481     if(head==NULL){
482         return;
483     }
484     LinkNode* fast=head;
485     LinkNode* slow=head;
486     while((fast!=NULL)&&(fast->next!=NULL)){ 
487          fast=fast->next->next;
488          slow=slow->next;
489            if(fast==slow){
490               return 1;
491                }
492            }
493          return 0;
494 }

11、如果链表带环，求环的长度
我们定义两个指针fast和slow两个指针，只要我们知道fast和slow相遇的地点，然后我们再定义一个指针，绕环一周之后，我们得到的就是环的长度。
方法一：

size_t GetCycleLen(LinkNode* head)//如果链表带环, 求出环的长度
495 {
496         if(head==NULL){
497             return;
498         }
499         LinkNode* fast=head;
500         LinkNode* slow=head;
501    while((fast!=NULL)&&(fast->next!=NULL)){ 
502          fast=fast->next->next;
503          slow=slow->next;
504            if(fast==slow)
505                 break;
506            }
507         int count=1;//因为最后一次siow->next=fast，不会进入
508                //循环中，所以次数少加一次，所以count要从1开始
509            while(slow->next!=fast){
510                 count++;
511                slow=slow->next;
512            }
513            return count;
514 }

方法一的简化：

 size_t GetCycleLen2(LinkNode* head)//如果链表带环, 求出环的长度
518  {
519          if(head==NULL){
520              return;
521        }
522         LinkNode* meet = HasCycle(head);//求出快慢指针的相遇点
523         if (meet == NULL){
524                 //不带环的链表
525                 return 0;
526         }
527         LinkNode* cur = meet;
528         size_t count = 1;
529         while (cur->next != meet){ //循环在meet的前一个位置停止，少加一次，count从1开始数
530                 cur = cur->next;
531                 ++count;
532         }
533         return count;
534 }

12、如果链表带环，我们求环的入口点
我们的基本思路就是让头指针从头出发，相遇点指针从相遇点出发，当两个指针重合，那么这点就是我们所要找的入口点。

7 LinkNode* GetCycleEntry(LinkNode* head)// 如果链表带环, 求出环的入口
538 {
539     if(head==NULL){
540         return;
541     }
542          LinkNode* meet= HasCycle(head); 
543          LinkNode* cur=head;
544          LinkNode* cur2=meet;
545         if(meet==NULL){
546         return ;
547         }
548     while(cur!=cur2){
549         cur=cur->next;
550         cur2=cur2->next;
551     }
552     return cur;
553 }

13、判断两个链表是否相交，（假设链表不带环）
首先我们需要知道的是两个链表相交的情况只有Y字型的，没有X字型的。
这里写图片描述
我们的思路就是首先让第一个链表从第一个链表的头节点开始出发，第二个链表也从它的头结点进行出发，最后判断最后一个结点是否相等，那么这两个链表就有交点。

 LinkNode* HasCross(LinkNode* head1, LinkNode* head2)//判定两个链表是否相交, 并求出交点
556 {
557     if(head1==NULL){
558         return   NULL;
559     }
560     if(head2==NULL){                                                                                                               
561         return NULL;
562     }
563     LinkNode* cur1=head1;
564     LinkNode* cur2=head2;
565     while(cur1->next!=NULL){
566         cur1=cur1->next;
567     }
568     while(cur2->next!=NULL){
569         cur2=cur2->next;
570     }
571     if(cur1==cur2){
572         return cur1;
573     }
574     else
575     {
576         return NULL;

14、判断链表是否相交，假设可能带环
1、如果两链表都不带环(相交)
2、两个链表都带环 a、入口相等，交点在环外 b、入口不相等，交点在环上
3、两个链表一个带环，一个不带环，一定不相交

int HasCrossWithCycle(LinkNode* head1, LinkNode* head2)// 判定两个链表是否相交.//但是链表可能带环 ；它的返回值return 如果相交, 返回1, 否则返回0
{ 
    if((head1==NULL)||(head2==NULL))
   {
       return 0;
    }
    LinkNode* entry1=GetCycleEntry(head1);
    LinkNode* entry2=GetCycleEntry(head2);
    //1、如果两链表都不带环(相交)
    if((entry1==NULL)&&(entry2==NULL)){
    return HasCross(head1,head2)!=NULL?1:0;
    }
    //2、两个链表都带环
    if(entry1!=NULL&&  entry2!=NULL){
    //    a、入口相等，交点在环外
           if(entry1==entry2){   
           return 1;
       }
    //    b、入口不相等，交点在环上，两个入口点是不同的，但是能从其中的一个入口绕环几周，最后能到达另外一个入口点，该情况下两个环入口就是链表的交点。
           if(entry1!=entry2){
            LinkNode* cur1=entry1;
          LinkNode* cur2=entry2;
          while(cur1->next!=entry1){
              cur1=cur1->next;
              if(cur1==cur2){
              return 1;
              }
          }
             return  0;
       }
    }
    // 3、两个链表一个带环，一个不带环，一定不相交
    if((entry1!=NULL&& entry2==NULL)||(entry1==NULL &&entry2!=NULL)){
    return 0;
    }

}

15、求两个链表的交集
求两个有序链表的交集的整体思路就是分别定义两个指针 cur1, cur2,指向两个对应的链表的首元素，然后将 cur1 和 cur2 所指的链表的 data 进行比较，如果相等，将这个结点插入到一个新链表中，然后两个指针 cur1, cur2, 一起向后走一步，如果不相等，就将 data 值小的那个指针向后移动，而另外一个指针不动，在进行比较，重复以上动作，直到 cur1 或者 cur2 两个中其中一个为空，则停止循环。


624 LinkNode* UnionSet(LinkNode* head1, LinkNode* head2)//求两个有序链表的交集;返回表示交集的新链表
625 {
626     if(head1==NULL || head2==NULL){
627         return NULL;
628     }
629      LinkNode* cur1=head1;
630      LinkNode* cur2=head2;
631      LinkNode* newhead=NULL;
632      LinkNode* newtail=NULL;
633      while(cur1!=NULL&&cur2!=NULL){
634          if(cur1->data<cur2->data){
635              cur1=cur1->next;
636          }else if(cur1->data>cur2->data){
637                  cur2=cur2->next;
638              }
639              else{
640                  //cur1->data-cur2->dat
641 
642                  if(newhead==NULL){
643                       newhead= CreateNode(cur1->data);
644                      newtail=newhead;
645                  }
646                  else{
647                      newtail->next=CreateNode(cur1->data);
648                      newtail=newtail->next;
649                  }
650                  cur1=cur1->next;
651                  cur2=cur2->next;
652              }
653          }
654          return newhead;
655 }

16、拷贝复杂链表
链表的数据结构

typedef struct ComplexNode { 
LinkType data; 
struct ComplexNode* next; 
struct ComplexNode* random; 
} ComplexNode;

复杂链表中除了 data, next, 之外，还有一个 random，它可能指向链表中任何一个节点，还可能指向空。
在进行复杂链表的拷贝时，可以采用下面的方法，先将复杂链表按照简单链表进行复制，将其复制到一个新链表中，此时的新链表还是一个简单链表，然后再遍历旧链表，求出每一个节点所对应的 random 相对于头节点的偏移量，再遍历新链表，根据所求得的偏移量确定新链表中的 random 的指针的指向。

ComplexNode* CreateComplexNode(LinkNodeType value){
    ComplexNode* newnode = (ComplexNode*)malloc(sizeof(ComplexNode));
    newnode->data = value;
    newnode->random = NULL;
    newnode->next = NULL;
    return newnode;
}

size_t  Diff(ComplexNode* src, ComplexNode* dst){
    if (src == NULL || dst == NULL){
        return (size_t)-1;//无符号长整形是一个很大的数字用来表示找不到
    }
    size_t count = 0;
    while (src != NULL){
        //src跳出循环有两种情况src找到了dst，返回偏移量，src走到NULL也没找到，返回（size_t)-1
        if (src == dst){
            return count;
        }
        count++;
        src = src->next;
    }
    return (size_t)-1;
}


ComplexNode* Step(ComplexNode* pos, size_t offset){//从pos的位置走offset的位置
    if (pos == NULL){
        return NULL;
    }
    size_t i = 0;
    for (; i<offset; i++){
        pos = pos->next;
    }
    return pos;
}


ComplexNode* CopyComplex(ComplexNode* head)// 拷贝复杂链表
{
    if (head == NULL){
        return;
    }
    ComplexNode* newhead = NULL;
    ComplexNode* newtail = NULL;
    ComplexNode* cur = head;
    //复制链表
    for (; cur != NULL; cur = cur->next){
        ComplexNode* newnode = CreateComplexNode(cur->data);
        if (newnode == NULL){
            newtail = newhead = newnode;
        }
        else{
            newtail->next = CreateComplexNode(cur->data);
            newtail = newtail->next;
        }
    }
    //使cur和newcur保持同步，尽享便利
    ComplexNode* newcur = newhead;
    for (cur = head; cur != NULL && newcur != NULL; cur = cur->next, newcur = newcur->next){
        //cur到这里已经指向空了，我们必须对cur进行重置
        if (cur->random == NULL){
            newcur->random = NULL;
            continue;
        }
        size_t offset = Diff(head, cur->random);//求每个random指针修改head 的偏移步数
        newcur->random = Step(newcur, offset);//根据偏移量修改新链表的random指针的指向
    }
    return newhead;
}

方法二：

ComplexNode* CopyComplex2(ComplexNode* head){//拷贝复杂链表
    ComplexNode* cur = head;
    //遍历旧链表，给每一个节点都创建一个对应的节点，并且将这个节点插入到旧节点之后
    for (; cur != NULL; cur = cur->next->next){
        ComplexNode* newnode = CreateComplexNode(cur->data);
        newnode->next = cur->next;
        cur->next = newnode;
    }
    //遍历链表，更新每个新节点的random指针
    for (cur = head; cur != NULL; cur = cur->next->next){
        if (cur->random == NULL){
            cur->next->random = NULL;
            continue;
        }
        cur->next->random = cur->random->next;
    }
    //再遍历链表，把新节点拆下来，组装成新链表
    ComplexNode* newhead = NULL;
    ComplexNode* newtail = NULL;
    for (cur = head; cur != NULL; cur = cur->next){
        ComplexNode* to_delete = cur->next;
        cur->next = to_delete->next;
        if (newhead == NULL){
            newhead = newtail = to_delete;
        }
        else{
            newtail->next = to_delete;
            newtail = newtail->next;
        }
    }
    return newhead;

}