devbox
小小林熬夜学编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

链表经典面试题

作者：小小林熬夜学编程 | 2024-05-04 00:56:59

赞

踩

链表经典面试题

1. 删除链表中等于给定值 val 的所有结点

这里我们的思路就是先创建一个新链表，接着便利原链表把不是的值尾差到我们的新链表中就可以了代码如下： 
  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  8.  typedef struct ListNode ListNode;
  9. struct ListNode* removeElements(struct ListNode* head, int val) {
  10.     ListNode * pcur = head;
  11.     ListNode * newhead = NULL;
  12.     ListNode * newtail = NULL;
  13.     while(pcur)
  14.     {
  15.         if(pcur->val != val)
  16.         {
  17.             if(newhead==NULL)
  18.             {
  19.                 newhead = newtail = pcur;
  20.             }
  21.             else 
  22.             {
  23.                 newtail->next = pcur;
  24.                 newtail = pcur;
  25.             }
  26.         }
  27.         pcur = pcur->next;
  28.     }
  29.     if(newtail)
  30.     newtail->next = NULL;
  31.     
  32.     return newhead;
  33.  
  34. }

2. 反转一个单链表

oj链接

这里我们需要在原链表中进行操作

我们定义三个指针如下图所示：

接下来就是改变l2指针的next指向l1之后l1指针走到l2，l2走到l3，l3走到l2的next，不断循环一直到l2为空指针这里有一个小细节如下图

当我们把最后一个节点next指针重置后此时要进行下一步时l1走到l2，l2走到l3，可当l3要移动到l2的下一个位置l2已经为空了，我们不能对空指针解引用因此我们每次在l3移动时应该加判断条件l2不能为空下面是代码

  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  8.  typedef struct  ListNode Listnode;
  9. struct ListNode* reverseList(struct ListNode* head) {
  10.     if(head==NULL)
  11.     {
  12.         return NULL;
  13.     }
  14.     Listnode *l1 = NULL;
  15.     Listnode *l2 = head;
  16.     Listnode *l3 = head->next;
  17.     while(l2)
  18.     {
  19.         l2->next = l1;
  20.         l1 = l2;
  21.         l2 = l3;
  22.         if(l2!=NULL)
  23.         l3 =l2->next;
  24.     }
  25.     return l1;
  26. }

3.给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点

oj链接

这里我们用了快慢指针让快指针每次走两步慢指针每次走一步也就是快指针走的路程是慢指针的两倍这样当快指针遍历完链表时直接返回慢指针此时指向的val值就可以了

  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  8.  typedef struct ListNode ListNode;
  9. struct ListNode* middleNode(struct ListNode* head) {
  10.     ListNode * qfast = head;
  11.     ListNode * qslow = head;
  12.     while(qfast && qfast->next)
  13.     {
  14.         qfast = qfast->next->next;
  15.         qslow = qslow->next;
  16.     }
  17.     return qslow;
  18. }

4.输入一个链表，输出该链表中倒数第k个结点

oj链接

思路同样是快慢指针让快指针想走k步接着两个指针同时走这样当快指针走到空指针时在返回慢指针的val就可以了

  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  8. typedef struct ListNode ListNode;
  9.  
  10. int kthToLast(struct ListNode* head, int k){
  11.     ListNode *fast = head,*slow = head;
  12.     while(k--)
  13.     {
  14.         fast = fast->next;
  15.     }
  16.     while(fast)
  17.     {
  18.         fast = fast->next;
  19.         slow = slow->next;
  20.     }
  21.     return slow->val;
  22. }

5. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有结点组成的

oj链接

这里我们的思路就是先创建一个带头的新链表定义两个指针分别便利原链表然后进行比较把val值小的尾插到新链表中如果两个原链表都是空链表直接返回空如果其中一个为空则直接返回另一个链表

  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  8.  typedef struct ListNode ListNode;
  9. struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
  10.     ListNode * newhead ,* newtail;
  11.     newhead = newtail = (ListNode *)malloc(sizeof(ListNode));
  12.     ListNode * l1 = list1;
  13.     ListNode * l2 = list2;
  14.     if(l1==NULL)
  15.     return l2;
  16.     if(l2==NULL)
  17.     return l1;
  18.     if(l1==NULL&&l2==NULL)
  19.     return NULL;
  20.     while(l1 && l2)
  21.     {
  22.         if(l1->val<l2->val)
  23.         {
  24.             newtail->next = l1;
  25.             newtail = newtail->next;
  26.             l1 = l1->next;
  27.         }
  28.         else
  29.         {
  30.             newtail->next = l2;
  31.             newtail = newtail->next;
  32.             l2 = l2->next;
  33.         }
  34.     }
  35.     if(l1)
  36.     newtail->next = l1;
  37.     if(l2)
  38.     newtail->next = l2;
  39.     ListNode * ret = newhead->next;
  40.     free(newhead);
  41.     newhead = NULL;
  42.     return ret;
  43. }

6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。

oj链接

这里我们创建两个新链表然后便利原链表把小的放在一个链表中，大的放在一个链表中最后将两个链表相连返回新链表就行。

如下图

记得把存放大值的链表的尾指针的next置为空指针最后返回存放小值链表的头的next指针就可以了

最好再返回之前把哨兵位释放哈~

  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  8. typedef struct ListNode ListNode;
  9. struct ListNode* partition(struct ListNode* head, int x){
  10.     ListNode * newhead1 = (ListNode *)malloc(sizeof(ListNode));
  11.     ListNode * newhead2 = (ListNode *)malloc(sizeof(ListNode));
  12.     newhead1->next = NULL;
  13.     newhead2->next = NULL;
  14.     ListNode * newtial1 = newhead1;
  15.     ListNode * newtial2 = newhead2;
  16.     ListNode * pcur =head;
  17.     while(pcur)
  18.     {
  19.         if(pcur->val < x)
  20.         {
  21.             newtial1->next = pcur;
  22.             newtial1 = pcur;
  23.         }else
  24.         {
  25.             newtial2->next = pcur;
  26.             newtial2 = pcur;
  27.         }
  28.         pcur = pcur->next;
  29.     }
  30.     newtial1->next = newhead2->next;
  31.     newtial2->next = NULL;
  32.     ListNode * ret = newhead1->next;
  33.     free(newhead1);
  34.     free(newhead2);
  35.     newhead1 = NULL;
  36.     newhead2 = NULL;
  37.     return ret;
  38.  
  39.  
  40. }

7. 链表的回文结构

oj链接

如下图我们先进行分析

这是偶数的分析下面是奇数

可以看到两者一致所以代码如下：

  1. /*
  2. struct ListNode {
  3.     int val;
  4.     struct ListNode *next;
  5.     ListNode(int x) : val(x), next(NULL) {}
  6. };*/
  7. #include <cstddef>
  8. class PalindromeList {
  9. public:
  10.     //找到中间节点
  11.     ListNode * findmid(ListNode * head)
  12.     {
  13.         ListNode * pslow ,*pfast;
  14.         pslow = pfast = head;
  15.         while(pfast && pfast->next)
  16.         {
  17.             pfast = pfast->next->next;
  18.             pslow = pslow->next;
  19.         }
  20.         return pslow;
  21.     }
  22.     //逆置链表并返回新链表
  23.     ListNode * reserve(ListNode * head)
  24.     {
  25.         ListNode * l1  = NULL;
  26.         ListNode *l2  = head;
  27.         ListNode * l3 = head->next;
  28.         while(l2)
  29.         {
  30.             l2->next = l1;
  31.             l1 = l2;
  32.             l2 = l3;
  33.             if(l3!=NULL)
  34.             {
  35.                 l3 = l3->next;
  36.             }
  37.         }
  38.         return l1;
  39.     }
  40.     bool chkPalindrome(ListNode* A) {
  41.         // write code here
  42.         ListNode * mid = findmid(A);
  43.         ListNode * rmid = reserve(mid);
  44.         while(A&&rmid)
  45.         {
  46.             if(A->val!=rmid->val)
  47.             {
  48.                 return false;
  49.             }
  50.             A=A->next;
  51.             rmid = rmid ->next;
  52.         }
  53.         return true;
  54.     }
  55. };

8. 输入两个链表，找出它们的第一个公共结点

判断链表是否相交我们直接看最后一个节点是否相等就行了
找相交链表我们就可以定义两个指针让他们从离交点相同的位置开始走一直到走到交点停止
如何找到刚开始指针出发的位置呢？
如下所示 
  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  8.  typedef struct ListNode ListNode;
  9. struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
  10.     //先找到尾部节点
  11.     ListNode *pcura = headA;
  12.     ListNode *pcurb = headB;
  13.     int lena =1;
  14.     int lenb =1;
  15.     while(pcura->next)
  16.     {
  17.         pcura = pcura->next;
  18.         lena++;
  19.     }
  20.     while(pcurb->next)
  21.     {
  22.         pcurb = pcurb->next;
  23.         lenb++;
  24.     }
  25.     if(pcura!=pcurb)
  26.     {
  27.         return NULL;
  28.     }
  29.     else
  30.     {
  31.         int ret = abs(lena-lenb);
  32.         ListNode *longlist = headA,*shortlist = headB;
  33.         if(lena<lenb)
  34.         {
  35.             longlist = headB;
  36.             shortlist = headA;
  37.         }
  38.         while(ret--)
  39.         {
  40.             longlist = longlist->next;
  41.         }
  42.         while(longlist != shortlist)
  43.         {
  44.             longlist = longlist->next;
  45.             shortlist = shortlist->next;
  46.         }
  47.         return longlist;
  48.     }
  49. }

9. 给定一个链表，判断链表中是否有环

下面是思路分析

  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  8.  typedef struct ListNode ListNode;
  9. bool hasCycle(struct ListNode *head) {
  10.     ListNode * pslow = head,* pfast = head;
  11.     while(pfast && pfast->next)
  12.     {
  13.         pslow = pslow ->next;
  14.         pfast = pfast->next->next;
  15.         if(pfast == pslow)
  16.         {
  17.             return true;
  18.         }
  19.     }
  20.     return false;
  21. }

9.1 环形链表2

142. 环形链表 II - 力扣（LeetCode）

  1. /**
  2.  * Definition for singly-linked list.
  3.  * struct ListNode {
  4.  *     int val;
  5.  *     struct ListNode *next;
  6.  * };
  7.  */
  8.  typedef struct ListNode ListNode;
  9. struct ListNode *detectCycle(struct ListNode *head) {
  10.     ListNode * pfast = head,*pslow = head;
  11.     while(pfast && pfast->next)
  12.     {
  13.         pfast = pfast->next->next;
  14.         pslow = pslow->next;
  15.         if(pfast==pslow)
  16.         {
  17.             ListNode * meet = pfast;
  18.             while(head != meet)
  19.             {
  20.                 head = head->next;
  21.                 meet = meet->next;
  22.             }
  23.             return meet;
  24.         }
  25.     }
  26.     return NULL;
  27. }

9.2链表的扩展

【扩展问题】
为什么快指针每次走两步，慢指针走一步可以？
假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。当慢指针刚进环时，可
能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。此时，两个指针每移动
一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在满指针走到一圈之前，
快指针肯定是可以追上慢指针的，即相遇。
快指针一次走 3 步，走 4 步， ...n 步行吗？

11. 给定一个链表，每个结点包含一个额外增加的随机指针，该指针可以指向链表中的任何结点或空结点。 要求返回这个链表的深度拷贝

oj链接

  1. /**
  2.  * Definition for a Node.
  3.  * struct Node {
  4.  *     int val;
  5.  *     struct Node *next;
  6.  *     struct Node *random;
  7.  * };
  8.  */
  9. typedef struct Node Node;
  10. struct Node* copyRandomList(struct Node* head) {
  11. 	Node * pcur = head;
  12.     while(pcur)
  13.     {
  14.         Node * copy = (Node *)malloc(sizeof(Node));
  15.         copy->val = pcur->val;
  16.         copy->next = pcur->next;
  17.         pcur ->next = copy;
  18.         pcur = copy->next;
  19.     }
  20.     //处理random指针
  21.     pcur = head;
  22.     while(pcur)
  23.     {
  24.        Node * copy = pcur->next;
  25.         if(pcur->random==NULL)
  26.         {
  27.             copy->random = NULL;
  28.         }
  29.         else
  30.         {
  31.             copy->random = pcur->random->next;
  32.         }
  33.         pcur = copy->next;
  34.     }
  35.     Node * newhead = NULL,*newtail = NULL;
  36.     pcur = head;
  37.     while(pcur)
  38.     {
  39.        Node * copy = pcur->next;
  40.         if(newhead==NULL)
  41.         {
  42.             newhead = newtail = copy;
  43.         }
  44.         else
  45.         {
  46.             newtail ->next = copy;
  47.             newtail = copy;
  48.         } 
  49.         pcur->next = copy->next;
  50.         pcur = copy->next;   
  51.     }
  52.     return newhead;
  53. }

关于链表的知识我们就分享到这里

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/532344
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号