【数据结构】链表的一些面试题

最新推荐文章于 2024-11-15 20:48:32 发布
最新推荐文章于 2024-11-15 20:48:32 发布
阅读量1.1k 收藏 8
点赞数 18
分类专栏： 初阶数据结构（C语言实现） 文章标签： 数据结构 链表 面试 c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Lixinze__/article/details/135943293
版权

简单不先于复杂，而是在复杂之后。

在这里插入图片描述

链表面试题

  1. 删除链表中等于给定值 val 的所有结点。OJ链接
//1.常规方法

struct ListNode* removeElements(struct ListNode* head, int val) {
    struct ListNode* cur = head, *prev = NULL;
    while(cur)
    {
        if(cur->val == val)
        {
            //1.头删
            //2.非头删

            if(cur == head)
            {
                head = head->next;
                free(cur);
                cur = head;
            }
            else
            {
               prev-> next = cur->next;
               free(cur);
               cur = prev-> next;
            }

        }
        else
        {
            prev = cur;
            cur = cur->next;
        }
    } 

    return head;
}

//2.新思路
//创建一个新链表，把非val的结点尾插到新链表
struct ListNode* removeElements(struct ListNode* head, int val) {
   struct ListNode* newhead =NULL, *cur = head, *tail = NULL;
   while(cur)
   {
       if(cur->val != val)
       {
           if(tail == NULL)
           {
               newhead = tail = cur;
           }
           else
           {
               tail->next = cur;
               tail = tail->next;
           }
           cur = cur->next;
       }
       else
       {
            struct ListNode* del = cur;
            cur = cur->next;
            free(del);
       }
   }

   //最后的节点是val就会出现此问题

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


   return newhead;
}

小技巧：在涉及到链表的题的时候调试不太方便，我们需要快速构建一个链表。

int main()
{
    struct ListNode* n1 = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(n1);
      struct ListNode* n2 = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(n2);
      struct ListNode* n3 = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(n3);
      struct ListNode* n4 = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(n4);
      struct ListNode* n5 = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(n5);
      struct ListNode* n6 = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(n6);
      struct ListNode* n7 = (struct ListNode*)malloc(sizeof(struct ListNode));
    assert(n7);

    n1->next = n2;
    n2->next = n3;
    n3->next = n4;
    n4->next = n5;
    n5->next = n6;
    n6->next = n7;
    n7->next = NULL;

    n1->val = 1;
    n2->val = 2;
    n3->val = 6;
    n4->val = 3;
    n5->val = 4;
    n6->val = 5;
    n7->val = 6;

    return 0;
}

带哨兵位的链表：

  • 哨兵节点（Sentinel Node）： 这是一个特殊的节点，它不包含实际数据，仅用于简化代码逻辑。哨兵节点通常作为链表的头部存在，这意味着链表中始终有一个节点，即使链表为空。哨兵节点的存在简化了对链表头部的特殊处理，因为无论链表是否为空，我们都可以始终通过哨兵节点来引导链表的访问。
  • 优点： 哨兵节点可以简化代码实现，避免在对头部进行操作时需要额外的条件检查。

不带哨兵位的链表：

  • 特殊处理头部： 在不使用哨兵节点的情况下，需要特殊处理链表头部，因为在空链表或者插入第一个节点时，需要进行额外的条件检查，以确保正确处理链表头部。
  • 优点： 节省了一个节点的空间开销，因为没有用于哨兵的额外节点。

带哨兵位和不带哨兵位的区别：

在这里插入图片描述

//利用带哨兵位的头节点的链表可以免去判空的步骤

struct ListNode* removeElements(struct ListNode* head, int val) {
   struct ListNode* cur = head;
   struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
   struct ListNode* tail = guard;
   while(cur)
   {
       if(cur->val != val)
       {
            tail->next = cur;
            tail = tail->next;
            cur = cur->next;
       }
       else
       {
            struct ListNode* del = cur;
            cur = cur->next;
            free(del);
       }
   }

   //最后的节点是val就会出现此问题

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

    head = guard->next;
    free(guard);
    return head;
}

替代之前实现单链表时候传参用的二级指针有两种方式：

  • 返回新的链表头指针
  • 设计为带哨兵位的链表

(单链表在实际应用中很少带头，OJ题链表基本不带头)

  1. 反转一个单链表。OJ链接

在这里插入图片描述

struct ListNode* reverseList(struct ListNode* head) {
   struct ListNode* cur = head;
   struct ListNode* newhead = NULL;

   while(cur)
   {
        struct ListNode* next = cur->next;
        cur->next = newhead;
        newhead = cur;

        cur = next;
   }
   return newhead;
}

//思路2：将链表的指针指向反转
struct ListNode* reverseList(struct ListNode* head) {
    struct ListNode* prev = NULL;
    struct ListNode* cur = head;
    while(cur)
    {
        struct ListNode* next = cur->next;
        cur->next = prev;
        //迭代器
        prev = cur;
        cur = next;
    }
    return prev;
}
  1. 给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。OJ链接

在这里插入图片描述

struct ListNode* middleNode(struct ListNode* head) {
    struct ListNode* fast,*slow;
    fast = slow = head;
    while(fast && fast->next)
    {
        slow = slow->next;
        fast = fast->next->next;
    }

    return slow;
}
  1. 输入一个链表，输出该链表中倒数第k个结点。OJ链接

在这里插入图片描述

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k ) {
    // write code here
    struct ListNode* slow, *fast;
    slow = fast = pListHead;

    while(k--)
    {
       //判断k大于链表长度
        if(!fast)
        {
            return NULL;
        }
         fast = fast->next;
    }
    while(fast)
    {
        slow = slow->next;
        fast = fast->next;

    }

    return slow;
}
  1. 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有结点组成的。OJ链接
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    struct ListNode* guard = (struct ListNode*)malloc(sizeof(struct ListNode));
    guard->next = NULL;
    struct ListNode* tail = guard;
    struct ListNode* cur1 = list1, *cur2 = list2;
    while(cur1 && cur2)
    {
        if(cur1->val < cur2->val)
        {
            tail->next = cur1;
            cur1 = cur1->next;
        }
        else
        {
            tail->next = cur2;
            cur2 = cur2->next;
        }
        tail = tail->next;



    }
     if(cur1)
            tail->next = cur1;
        if(cur2)
            tail->next = cur2;

    struct ListNode* head = guard->next;
    free(guard);
    return head;
}
  1. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大小或等于x的结点之前。OJ链接

在这里插入图片描述

在这里插入图片描述

class Partition {
  public:
    ListNode* partition(ListNode* pHead, int x) {
        // write code here
       struct ListNode* lessTail,*lessGuard,*greaterTail,*greaterGuard;
       lessTail = lessGuard = (struct ListNode*)malloc(sizeof(struct ListNode));
       greaterTail = greaterGuard = (struct ListNode*)malloc(sizeof(struct ListNode));
       struct ListNode* cur = pHead;

       greaterGuard->next = NULL;
       lessGuard->next = NULL;

       while(cur)
       {
        if(cur->val < x)
        {
            lessTail->next = cur;
            lessTail = lessTail->next;
        }
        else 
        {
            greaterTail->next = cur;
            greaterTail = greaterTail->next;
        }
        cur = cur->next;
       }

       lessTail->next = greaterGuard->next;
       greaterTail->next = NULL;

       pHead = lessGuard->next;
       free(greaterGuard);
       free(lessGuard);

       return pHead;
    }
};
  1. 链表的回文结构。OJ链表

在这里插入图片描述

class PalindromeList {
  public:
    struct ListNode* middleNode(struct ListNode* head) {
        struct ListNode* fast, *slow;
        fast = slow = head;
        while (fast && fast->next) {
            slow = slow->next;
            fast = fast->next->next;
        }

        return slow;
    }

    struct ListNode* reverseList(struct ListNode* head) {
        struct ListNode* prev = NULL;
        struct ListNode* cur = head;
        while (cur) {
            struct ListNode* next = cur->next;
            cur->next = prev;
            //迭代器
            prev = cur;
            cur = next;
        }
        return prev;
    }

    bool chkPalindrome(ListNode* head) {
        // write code here
        struct ListNode* mid = middleNode(head);
        struct ListNode* rmid = reverseList(mid);

        while(head && rmid)
        {
            if(head->val != rmid->val)
                return false;

            head = head->next;
            rmid = rmid->next;
        }

        return true;

    }
};
  1. 输入两个链表，找出它们的第一个公共结点。OJ链表

在这里插入图片描述

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
    struct ListNode* curA = headA, *curB = headB;

    if(headA == NULL || headB == NULL)
    {
        return NULL;
    }

    int lenA = 1;
    while(curA->next)
    {
        curA = curA->next;
        lenA++;
    }

      int lenB = 1;
    while(curB->next)
    {
        curB = curB->next;
        lenB++;
    }

    if(curA != curB)
    {
        return NULL;
    }

    struct ListNode* longList = headA,*shortList = headB;
    if(lenA < lenB)
    {
        longList = headB;
        shortList = headA;
    }

    int gap = abs(lenA - lenB);
    while(gap--)
    {
        longList = longList->next;
    }

    while(longList != shortList)
    {
        longList = longList->next;
        shortList = shortList->next;
    }

    return longList;
}
  1. 给定一个链表，判断链表中是否有环。OJ链表

在这里插入图片描述

bool hasCycle(struct ListNode *head) {
    struct ListNode* fast, *slow;
    fast = slow = head;

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

        if(slow == fast)
            return true;
    }

    return false;
}

【思路】

快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表起始位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾。

【扩展问题】

  • 为什么快指针每次走两步，慢指针走一步可以？

假设链表带环，两个指针最后都会进入环，快指针先进环，慢指针后进环。当慢指针刚进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。

此时，两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在慢指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。

  • 快指针一次走3步，走4步，…n步行吗？

    • 快指针一次走 3 步：

      假设slow进环后，fast和slow之间差距N，追赶距离就是N，每追赶一次，之间的距离缩小2步

      如果N是偶数，距离一定会减少到0，也就是两个指针相遇；

      如果N是奇数，距离会减少到1，fast会越过slow指针，fast和slow之间得距离变成了-1,也就是C-1，（C-1是环长度),如果C-1是偶数，再追一圈就可以追上，如果C-1是奇数，永远追不上；

  1. 给定一个链表，返回链表开始入环的第一个结点。如果链表无环，则返回 NULL。OJ链接

在这里插入图片描述

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)
        {
            struct ListNode* meet = slow;

            while(meet != head)
            {
                meet = meet->next;
                head = head->next;
            }

            return meet;
        }
    }
    return NULL;
}

在这里插入图片描述

struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
  struct ListNode* curA = headA, *curB = headB;
  
  int lenA = 1;
  while(curA->next)
  {
      curA = curA->next;
      lenA++;
  }

  int lenB = 1;
  while(curB->next)
  {
      curB = curB->next;
      lenB++;
  }

  if(curA != curB)
  {
      return NULL;
  }

  struct ListNode* longList = headA, *shortList = headB;
  if(lenA < lenB)
  {
      longList = headB;
      shortList = headA;
  }

  int gap = abs(lenA - lenB);

  while(gap--)
  {
      longList = longList->next;
  }

  while(longList != shortList)
  {
      longList = longList->next;
      shortList = shortList->next;
  }

  return longList;
}

struct ListNode *detectCycle(struct ListNode *head) {
   struct ListNode* slow, *fast;
   slow = fast = head;

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

       if(slow == fast)
       {
            struct ListNode* meet = slow;
            struct ListNode* next = meet->next;
            meet->next = NULL;
            
            struct ListNode* entry =  getIntersectionNode(head,next);
            meet->next = next;
            return entry;
         
       }
       
   }
   return NULL;
   
}

在这里插入图片描述

  1. 给定一个链表，每个结点包含一个额外增加的随机指针，该指针可以指向链表中的任何结点或空结点。

​ 要求返回这个链表的深度拷贝。OJ链接

struct Node* copyRandomList(struct Node* head) {
	// 1.插入copy节点
    struct Node* cur = head;
    struct Node* copy;
    struct Node* next;
    while(cur)
    {
        // 复制链接
        next = cur->next;
        copy = (struct Node*)malloc(sizeof(struct Node));
        copy->val = cur->val;

        cur->next = copy;
        copy->next = next;

        // 迭代往后走
        cur = next;
    }

    //2. 更新copy->random
   cur = head;
   while(cur)
   {
       copy = cur->next;

       if(cur->random == NULL)
            copy->random = NULL;
       else
            copy->random = cur->random->next;

       //迭代
       cur = copy->next;
   } 

   //3. copy节点要解下来链接在一起，然后恢复原链表
   struct Node* copyHead = NULL, *copyTail = NULL;
   cur = head;
   while(cur)
   {
       copy = cur->next;
       next = copy->next;

       //取节点尾插
       if(copyTail == NULL)
       {
           copyHead = copyTail = copy;
       }
       else
       {
           copyTail->next = copy;
           copyTail = copyTail->next;
       }

       //恢复原链表链接
       cur->next = next;

       //迭代
       cur = next;
   }

   return copyHead;
}
  1. 其他。ps：链表的题当前因为难度及知识面等等原因还不适合当前学习，下面有OJ链接。

Leetcode OJ链接 + 牛客 OJ链接

2024_极限年
关注
专栏目录
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6813
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
Java常见数据结构面试题（带答案）
08-29
"Java常见数据结构面试题（带答案）" 以下是对Java常见数据结构面试题的...本篇文章主要介绍了Java常见数据结构面试题，涵盖了栈、队列、链表、线性表、树、算法、数据结构等知识点，希望对广大的程序爱好者有所帮助。
数据结构 之 链表 高频面试题
CSNZのBlog
10-11 3339
一：面试时链表解题的方法论 1、对于笔试，不用太在乎空间复杂度，一切为了时间复杂度 2、对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法 二：链表面试题常用数据结构和技巧 1、使用容器（哈希表、数组等） 2、快慢指针 使用快慢指针的面试题： 1、输入链表头结点，奇数长度返回中点，偶数长度返回上中点 * //输入链表头结点，奇数长度返回中点，偶数长度返回上中点 public static <T> Node<T> midOrUpMidNode(Node<T&g
链表经典面试题
GOATLong的博客
05-02 2674
1.删除链表中等于给定值的所有结点1.删除链表中等于给定值的所有结点2.反转一个单链表这里我们需要在原链表中进行操作我们定义三个指针如下图所示：接下来就是改变l2指针的next指向l1之后l1指针走到l2，l2走到l3，l3走到l2的next，不断循环一直到l2为空指针这里有一个小细节如下图。
【数据结构】7道经典链表面试题
2302_81312180的博客
10-10 1058
题目描述： 给你一个链表的头节点head，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪next指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数pos来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos不作为参数进行传递。仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回true。 否则，返回false。 题目描述： 给定一个链表的头节点 head，返回链表开始入环的第一个节点。如果链表无环，则返回null
【初阶数据结构】——链表常见面试题剖析
m0_70980326的博客
01-09 1424
几道链表相关的经典面试题解析
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1452
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
java 数据结构常见面试题
Misszhoudandan的博客
07-05 2852
因为 Set 的底层结构是 Map ，所以三者的特点和使用场景可以参考HashMap 和 TreeMap 和 LinkedHashMap ，需要注意的是，Set 中元素是不允许重复的（Set 的值是底层时存储在 Map 的 Key 中的，key 是不能重复的）。其中 Collection 是所有集合继承的最顶层接口，其中声明的方法有对集合的操作的 增删改查等，所有具体的集合类都继承这个接口。强调：使用map接口的实现类时，切记不要修改key的属性值，否则就会找不到key 所对应的 value值。
链表常见面试题分析
GG_Bruse的博客
11-04 7195
接下来我们会从易到难，逐步讲解有关链表的常见面试，部分题目来自Leetcode和牛客
10道经典链表面试题
xaiobit_hl的博客
05-18 4077
目录 1.删除链表中等于给定值val的所有节点 2.反转一个单链表 3.给定一个带有头结点head的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所 有节点组成的 6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的 结点之前 7. 链表的回文结构 8. 输入两个链表，找出它们.........
【数据结构与算法】之五道链表进阶面试题详解！
2301_80221228的博客
05-06 2838
的输入如下（你设计的程序。
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
链表是一种基础且重要的数据结构，在计算机科学特别是数据结构...同时，熟悉常见的链表面试题，有助于提升解决实际问题的能力。通过深入学习和实践，我们可以掌握如何有效地利用链表这一数据结构来优化算法和程序设计。
2021数据结构与算法面试题
08-14
数据结构与算法是计算机科学的基础，对于...以上知识点是数据结构与算法面试题中常见的部分，每个主题下都可能有深入的理论讲解和实践题目，对于准备面试的开发者来说，全面掌握这些内容将大大提升在面试中的竞争力。
C语言链表相关面试题.zip
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
数据结构-递归函数的调用栈过程
qq_52291558的博客
11-12 240
这道题考察的是递归函数的调用栈过程。
数据结构 ——— 层序遍历链式二叉树
weixin_55341642的博客
11-13 648
利用队列先进先出的性质实现层序遍历链式二叉树
数据结构 -- 二叉搜索树
最新发布
zy1215058242的博客
11-15 484
场景2：商场无人值守车库，入口进场时扫描车牌，记录车牌和入场时间，出口离场时，扫描车牌，查找入场时间，用当前时间减入场时间计算出停车时长，计算出停车费用，缴费后抬杆，车辆离场。场景1：校区无人值守车库，校区车库买了车位的业主才能进小区，那么物业会把买了车位的业主的车牌号录入后台系统，车辆进入时扫描车牌在不在系统中，在就允许进入，不再则不能进入。场景3：统计⼀篇文章中单词出现的次数，读取⼀个单词，查找单词是否存在，不存在这个说明第⼀次出现，（单词，1），单词存在，则++单词对应的次数。
Pandas 数据结构
王小工小工历程
11-15 780
andas是Python数据分析库，其核心数据结构为DataFrame和Series，这两种数据结构不仅提供了高效的数据处理能力，还支持丰富的数据操作功能。
【数据结构】【线性表】单链表4—单链表的建立(附C语言源码)
weixin_58498967的博客
11-12 855
按位序插入，位序说明本身就链表就已经存在，一般是用在某一个单链表的某个位置进行插入，指定结点插入分前插和后插，由于单链表的不可逆性，前插操作需要找到前驱结点，这个过程需要经过类似于按位序插入的遍历结点的过程，比较复杂，而指定结点的后插只需要指定结点，一切顺理成章，操作简单，时间复杂度低。每次我们都将结点插入到头部，相当于一个倒序插入，而每次插入到尾部即为顺序插入，如果插入到中间则是无序，无序的线性表一般来说没有意义，因此我们用的最多的是头部插入和尾部插入，同时尾部插入又是最常用的插入方式。
链表面试题精讲：掌握数据结构核心问题
9. 链表的变种数据结构：除了基本的链表结构，还存在一些变种，如跳表（Skip List）能够提供更快的搜索速度，双向循环链表结合了双向链表和循环链表的特性，而红黑树和B+树等高级数据结构在内部也使用了链表的某些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

2024_极限年

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值