链表面试题

最新推荐文章于 2025-02-24 17:44:03 发布
转载 最新推荐文章于 2025-02-24 17:44:03 发布 · 908 阅读 · 0
文章标签：

#面试 #null #list #struct #算法 #random

某本书上面说了，链表这个东西，实际用的并不多，但是可以提供很好的考察面试者编程技巧和思维能力的素材。这里总结一下，见过的面试题和对应的候选解法。

题一、给定单链表，检测是否有环。
使用两个指针p1,p2从链表头开始遍历，p1每次前进一步，p2每次前进两步。如果p2到达链表尾部，说明无环，否则p1、p2必然会在某个时刻相遇(p1==p2)，从而检测到链表中有环。

http://ostermiller.org/find_loop_singly_linked_list.html

这篇文章讲了很多好的坏得相关算法。

题二、 给定两个单链表(head1, head2)，检测两个链表是否有交点，如果有返回第一个交点。
如果head1==head2，那么显然相交，直接返回head1。
否则，分别从head1,head2开始遍历两个链表获得其长度len1与len2。假设len1>=len2，那么指针p1由head1开始向后移动len1-len2步。指针p2=head2，下面p1、p2每次向后前进一步并比较p1p2是否相等，如果相等即返回该结点，否则说明两个链表没有交点。

题三、 给定单链表(head)，如果有环的话请返回从头结点进入环的第一个节点。
运用题一，我们可以检查链表中是否有环。
如果有环，那么p1p2重合点p必然在环中。从p点断开环，方法为：p1=p, p2=p->next, p->next=NULL。此时，原单链表可以看作两条单链表，一条从head开始，另一条从p2开始，于是运用题二的方法，我们找到它们的第一个交点即为所求。

也可以不断开环。设重合点为p3,从p3开始遍历这个环，同时从表头开始走，检查每步是否在那个环中。这个方法大概有nlogn。

使用快慢指针，第一次相遇，表明存在循环。继续快慢指针，第二次相遇，得到的iteration步长为环的长度。分别从相遇点和第一个节点出发，都是步长为1的指针，当相遇时，得到的iteration步长为环首的位置。

题四、只给定单链表中某个结点p(并非最后一个结点，即p->next!=NULL)指针，删除该结点。
办法很简单，首先是放p中数据,然后将p->next的数据copy入p中，接下来删除p->next即可。

题五、只给定单链表中某个结点p(非空结点)，在p前面插入一个结点。
办法与前者类似，首先分配一个结点q，将q插入在p后，接下来将p中的数据copy入q中，然后再将要插入的数据记录在p中。

题六、给定单链表头结点，删除链表中倒数第k个结点。
使用两个节点p1,p2，p1初始化指向头结点，p2一直指向p1后第k个节点，两个结点平行向后移动直到p2到达链表尾部(NULL),然后根据p1删除对应结点。
题七、链表排序

链表排序最好使用归并排序算法。堆排序、快速排序这些在数组排序时性能非常好的算法，在链表只能“顺序访问”的魔咒下无法施展能力；但是归并排序却如鱼得水，非但保持了它O(nlogn)的时间复杂度，而且它在数组排序中广受诟病的空间复杂度在链表排序中也从O(n)降到了O(1)。真是好得不得了啊，哈哈。以上程序是递推法的程序，另外值得一说的是看看那个时间复杂度，是不是有点眼熟？对！这就是分治法的时间复杂度，归并排序又是divide and conquer。

double cmp(ListNode *p ,ListNode *q)

{return (p->keyVal - q->keyVal);}

ListNode* mergeSortList(ListNode *head)

{
ListNode *p, *q, *tail, *e;
int nstep = 1;
int nmerges = 0;
int i;
int psize, qsize;

if (head == NULL || head->next == NULL)
{return head;}
while (1)
{ p = head;
tail = NULL;
nmerges = 0;
while (p)
{ nmerges++; q = p; psize = 0;
for (i = 0; i < nstep; i++){
psize++;
q = q->next;
if (q == NULL)break;
}
qsize = nstep;
while (psize >0 || (qsize >0 && q))
{
if (psize == 0 ){e = q; q = q->next; qsize--;}

elseif (q == NULL || qsize == 0){e = p; p = p->next; psize--;}

elseif (cmp(p,q) <= 0){e = p; p = p->next; psize--;}

else{e = q; q = q->next; qsize--;}

if (tail != NULL){tail->next = e;}

else{head = e;}

tail = e;

}
p = q;

}
tail->next = NULL;
if (nmerges <= 1){return head;}
else{nstep <<= 1;}
}
}

题八、倒转单链表

给出非递归和递归解法：

#include <iostream>

using namespace std;

struct Node
{
int data;
Node* next;
}*head;

// 非递归写法
Node* InverseLinkedList(Node* head)
{
if(head == NULL)
return NULL;
Node* newHead = NULL;
while(head != NULL)
{
Node* nextNode = head->next;
head->next = newHead;
newHead = head;
head = nextNode;
}
return newHead;
}

// 递归写法
Node* InverseLinkedListRecur(Node* head)
{
if(head == NULL)
return NULL;
if(head->next == NULL)
return head;
Node* newHead = InverseLinkedListRecur(head->next);
Node *tmp = newHead;
while(tmp->next != NULL)
{
tmp = tmp->next;
}
tmp->next = head;
head->next = NULL;
return newHead;
}

int main()
{
// 构建链表 9->8->7->6->5->4->3->2->1->0->NULL
for(int i = 0; i < 10; i++)
{
Node* node = new Node();
node->data = i;
node->next = head;
head = node;
}
head = InverseLinkedList(head);
Node *tmp = head;
while(head != NULL)
{
cout << head->data << " ";
head = head->next;
}
cout << endl;
head = InverseLinkedListRecur(tmp);
tmp = head;
while(head != NULL)
{
cout << head->data << " ";
head = head->next;
}
cout << endl;
while(tmp != NULL)
{
Node* next = tmp->next;
delete tmp;
tmp = next;
}
}
题九、两个有序链表的合并

有两个有序链表，各自内部是有序的，但是两个链表之间是无序的

typedef struct node{
     int data;
     struct node * next;
}* List;
 
List mergeSortedLinkList(List list1, List list2)
{
     List pList1,pList2,mergedList,pCurNode;
 
     if (list1 == NULL)
     {
         return list2;
     }
     if (list2 == NULL)
     {
         return list1;
     }
 
     pList1 = list1;
     pList2 = list2;
     mergedList = NULL;
     if (pList1==pList2)
     {       
        mergedList = pList1;
         pList1 = pList1->next;
         pList2 = pList2->next;
     }
     else 
    {
         if (pList1->data <= pList2->data)
         {
             mergedList = pList1;
             pList1 = pList1->next;
         }
         else
         {
             mergedList = pList2;
             pList2 = pList2->next;
         }
     }
     pCurNode = mergedList;
     while(pList1 && pList2)
     {
         if (pList1==pList2)
         {
             pCurNode->next = pList1;
             pCurNode = pList1;
             pList1 = pList1->next;
             pList2 = pList2->next;
         }
         else
         {
             if (pList1->data <= pList2->data)
             {
                 pCurNode->next = pList1;
                 pCurNode = pList1;
                 pList1 = pList1->next;
             }
             else
             {
                 pCurNode->next = pList2;
                 pCurNode = pList2;
                 pList2 = pList2->next;
             }
         }
     }
 
     pCurNode->next =pList1?pList1:pList2;
 
     return mergedList;
}
 题十、找出链表的中间元素 
单链表的一个比较大的特点用一句广告语来说就是“不走回头路”，不能实现随机存取（random access）。如果我们想要找一个数组a的中间元素，直接a[len/2]就可以了，但是链表不行，因为只有a[len/2 - 1] 知道a[len/2]在哪儿，其他人不知道。因此，如果按照数组的做法依样画葫芦，要找到链表的中点，我们需要做两步（1）知道链表有多长（2）从头结点开始顺序遍历到链表长度的一半的位置。这就需要1.5n（n为链表的长度）的时间复杂度了。有没有更好的办法呢？有的。想法很简单：两个人赛跑，如果A的速度是B的两倍的话，当A到终点的时候，B应该刚到中点。这只需要遍历一遍链表就行了，还不用计算链表的长度。
tian_wen
关注
c语言实现链表面试题
dove1202ly的博客
11-18 2912
   以前实现过链表的简单函数，详细见http://blog.youkuaiyun.com/dove1202ly/article/details/77168657       今天我们来看看链表涉及的面试题相信大家都知道单链表面试题的重要性，既然知道，我们就应该把思路捋清楚，然后多敲几遍多敲几遍多敲几遍（重要的事情说三遍），在我身边好多编程好的把这几个函数敲了不下十遍，而我太菜，这才是第一次下定决心把这个整...
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
链表是一种基础且重要的数据结构，在计算机科学特别是数据结构...同时，熟悉常见的链表面试题，有助于提升解决实际问题的能力。通过深入学习和实践，我们可以掌握如何有效地利用链表这一数据结构来优化算法和程序设计。
JAVA实现链表面试题
09-03
【JAVA实现链表面试题】是针对Java编程语言中链表数据结构的一系列经典面试题的详细解析。链表是一种常见的数据结构，它不依赖于数组的连续内存空间，由一系列节点构成，每个节点包含数据和指向下一个节点的引用。本...
双向带头循环链表及链表面试题二
qq_57770005的博客
05-21 931
循环链表的实现及链表面试题二链表循环链表的实现双向带头循环链表的优越性程序部分1.链表的合并题目描述解题思路程序部分2.链表的分割题目描述解题思路程序部分3判断链表是否有环题目描述解题思路程序部分4.链表入环的第一个节点题目描述解题思路程序部分5.复杂链表的拷贝题目描述解题思路程序部分6.链表的插入排序题目描述解题思路程序部分7.删除链表中重复的结点题目描述解题思路程序部分 链表 循环链表的实现 双向带头循环链表的优越性 双向循环链表：有两个指针，一个指向前一个节点，一个指向后一个节点。 值得注意的是双向带
反转链表（leetcode每日打卡）
m0_60264772的博客
11-15 433
目录 题目描述 思路 题解 题目描述 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 思路 假设链表为 1→2→3→∅，我们想要把它改成∅←1←2←3。 在遍历链表时，将当前节点的 \textit{next}next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。 题解 c.
链表（LinkedList）面试题
CxK6666667的博客
02-24 1091
解题思路：将新的链表分成两段，设置bs（前面链表的头）、be（前面链表的尾）、as（后面链表的头）、ae（后面链表的尾），再设置一个cur值遍历链表，将值小于x的往前面链表中放，将大于x的值往后面链表中放，需要注意如果是前面或后面链表的第一个节点需要让头和尾一起指向它。解题思路：先定义一个新链表的头节点，再设计一个tmp等于这个头节点，它用来连接这个链表的元素，再通过两个链表的头节点对里面的元素进行比较，小的在前，大的在后，当有一个链表走完则退出循环，将剩余链表的元素塞在新链表后面。那么什么是链表有环呢？
链表面试题（一）
tt 博客
05-30 1528
1.反转一个单链表。 public class MySingleLinkedlmpl { class Node{ public int getData() { return data; } private int data; public Node next; public Node(i...
链表笔试面试题
热门推荐
fatshaw的专栏
05-28 1万+
<br />1.已知链表的头结点head,写一个函数把这个链表逆序<br />void List::reverse() { list_node * p = head; list_node * q = p->next; list_no
链表的面试题
编程鸟
07-05 3326
1、比较顺序表和链表的优缺点，它们分别在什么场景下使用？ 1）顺序表支持随机访问，单链表不支持随机访问。 2）顺序表插入/删除数据效率很低，时间复杂度为O(N)（除尾插和尾删），单链表插入/删除效率更高，时间复杂度为O(1)。 3）顺序表的CPU高速缓冲效率更高，单链表CPU高速缓冲效率低。2、打印单向链表 void Display(pList plist) { pNode c
链表面试题总结（一）
宇哲
06-11 1万+
基于上一次写的链表，现在，我们来讨论下面这些问题。1.链表的冒泡排序 2.删除无头非尾节点 3.反转链表 4.在当前节点前插入一个数据x 5.查找链表的中间节点。 6.删除单链表的倒数第K个节点（K>1&&K<总长度）对于上面这6个问题，我们进行分析与解答。链表的代码我都已经写过博客：数据结构—单链表的实现另外，我也在我的github上有链表的代码，github链接如还有什么问题，可以发邮
关于链表的面试题
biu
04-22 429
在O(1)的时间删除单向链表节点；两个单向链表的第一个公共节点；只遍历一遍，得到单向链表中倒数第k个节点；合并两个排序的链表 ；反转链表；
面试链表常考题目总结
HollowKathrine的博客
10-09 173
1.输入一个链表，按链表从尾到头的顺序返回一个ArrayList。（递归） public class Solution { ArrayList<Integer> arraylist=new ArrayList<Integer>(); public ArrayList<Integer> printListFromTailToHead(ListNod...
c语言 链表面试题
最新发布
06-20
<think>我们正在处理一个关于C语言链表面试题的问题。根据用户的问题，我们需要提供一些常见的C语言链表面试题，并给出解答。参考引用内容，我们可以总结出一些常见的链表面试题：1.从尾到头打印单链表（递归和非递归）2.删除一个无头单链表的非尾节点（不能遍历链表）3.移除链表元素4.反转链表5.链表的中间节点6.返回倒数第k个节点7.合并两个有序链表8.分割链表9.回文链表10.相交链表11.环形链表（判断是否有环，返回入环的第一个节点）12.随机链表的复制（深度拷贝）我们选择其中几个经典题目进行详细解答。注意：在回答中，我们需要使用正确的LaTeX格式，并且按照要求使用$...$和$$...$$。同时，回答使用中文，并在最后生成相关问题。由于引用中已经提供了一些代码和思路，我们可以参考这些内容，但需要用自己的话组织，并确保正确性。下面开始组织回答。</think>### C语言链表常见面试题解析 链表是数据结构中的核心内容，也是C语言面试的必考点。以下是常见题型及解析： #### 1. 反转链表 **题目要求**：将单链表所有节点逆序排列。 ```c struct ListNode* reverseList(struct ListNode* head) { struct ListNode *prev = NULL, *cur = head; while (cur) { struct ListNode *next = cur->next; // 保存后继节点 cur->next = prev; // 反转指针 prev = cur; // 前移prev cur = next; // 前移cur } return prev; // 新头节点 } ``` **核心思想**：三指针法（prev/cur/next），时间复杂度 $O(n)$，空间复杂度 $O(1)$[^2]。 #### 2. 环形链表检测 **题目要求**：判断链表是否有环，并返回入环节点。 ```c struct ListNode *detectCycle(struct ListNode *head) { struct ListNode *slow = head, *fast = head; while (fast && fast->next) { slow = slow->next; fast = fast->next->next; if (slow == fast) { // 相遇点 while (head != slow) { // 找入环节点 head = head->next; slow = slow->next; } return slow; } } return NULL; } ``` **数学原理**：设头到入环点距离 $a$，环长 $L$，快慢指针速度比 $2:1$，相遇时慢指针位移 $s$，则 $2s = s + nL$ → $s = nL$。重置指针后同步移动 $a$ 步必在入环点相遇[^3]。 #### 3. 删除无头链表非尾节点 **题目要求**：在无头节点指针情况下删除指定节点（非尾节点）。 ```c void deleteNode(struct ListNode* node) { node->val = node->next->val; // 复制后继值 struct ListNode* tmp = node->next; node->next = tmp->next; // 跳过后继节点 free(tmp); // 释放内存 } ``` **关键点**：通过值复制和指针跳过实现 $O(1)$ 删除[^1]。 #### 4. 合并两个有序链表 **题目要求**：将两个升序链表合并为一个新链表。 ```c struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) { if (!l1) return l2; if (!l2) return l1; if (l1->val < l2->val) { l1->next = mergeTwoLists(l1->next, l2); return l1; } else { l2->next = mergeTwoLists(l1, l2->next); return l2; } } ``` **优化方向**：递归法空间复杂度 $O(n)$，可改为迭代法优化至 $O(1)$[^4]。 #### 5. 复杂链表的复制 **题目要求**：深度拷贝带随机指针的链表。 ```c struct Node* copyRandomList(struct Node* head) { if (!head) return NULL; // 1. 创建交织链表: A->A'->B->B' struct Node* cur = head; while (cur) { struct Node* copy = (struct Node*)malloc(sizeof(struct Node)); copy->val = cur->val; copy->next = cur->next; cur->next = copy; cur = copy->next; } // 2. 复制随机指针 cur = head; while (cur) { if (cur->random) cur->next->random = cur->random->next; cur = cur->next->next; } // 3. 分离链表 cur = head; struct Node* newHead = head->next; while (cur) { struct Node* tmp = cur->next; cur->next = tmp->next; if (tmp->next) tmp->next = tmp->next->next; cur = cur->next; } return newHead; } ``` **核心技巧**：三次遍历（插入/复制随机指针/分离），时间复杂度 $O(n)$[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值