【单向链表高频笔试题】

最新推荐文章于 2024-07-13 16:00:03 发布
最新推荐文章于 2024-07-13 16:00:03 发布
阅读量693 收藏 9
点赞数 15
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gpb2714446205/article/details/138976025
版权

1、单向链表的原地反转

image.png

逻辑：

  • 使用两个指针prev 和 pCur，pCur是需要反转的结点，prev为需要反转的结点的前驱结点

  • 让prev的指针域指向需要反转结点的下一个结点：prev->next = pCur->next

  • 将pCur反转到prev前：pCur->next = head->next

  • 将头指针的next指向反转后的结点：head->next = pCur

  • pCur指向下次需要反转的结点：pCur = prev->next

image.png

image.png

算法实现：单向链表的反转.c

#include <stdio.h>
#include <stdlib.h>
​
#define TRUE   0
#define FALSE -1
​
typedef int ElemType;
​
typedef struct LNode{
    ElemType data;  //数据域
    struct LNode *next; //指针域，指向当前结点的直接后继（下一个结点）
}LNode, *LinkList; //LinkList的类型为 LNode *
​
LinkList list_init()
{
    LNode *t;
    t = (LNode *)malloc(sizeof(LNode)); //创建一个头结点
    t->next = NULL; //头结点的指针域为空
​
    LinkList head;  //定义一个头指针
    head = t; //头指针指向头结点
    return head;
}
​
/*
 * @brief 头插法插入一个结点
 * @param 需要插入的链表的头指针
 * @param 需要插入的数据
 * @return 成功返回TRUE， 失败返回FALSE
 * */
int head_insert(LinkList head, ElemType data)
{
    if (NULL == head)
        return FALSE;
​
    //创建一个新的结点p
    LNode *p = (LNode *)malloc(sizeof(LNode));
    p->data = data;
    //将新的结点p的next指向头节点的下一个结点（head->next）
    p->next = head->next;
    //头节点的next指向新的结点p
    head->next = p;
​
    return TRUE;
}
​
/*
 * @brief 输出链表中的所有结点
 * @param head 链表的头指针
 * @return 成功返回TRUE，失败返回FALSE
 * */
int print_list(LinkList head)
{
    if (NULL == head)
        return FALSE;
​
    //使用一个临时指针对链表进行遍历
    LNode *t;
    t = head->next;
    while (t != NULL)
    {
        printf("%d ", t->data);
        t = t->next;
    }
    printf("\n");
    return TRUE;
}
​
LinkList reverse(LinkList head)
{
    if (NULL == head || NULL == head->next)
        return head;
​
    LNode *prev, *pCur;
    //prev 指向第一个数据结点
    prev = head->next;
    //pCur指向第二个数据结点
    pCur = prev->next;
    if (NULL == pCur) //如果只有一个数据结点，不需要反转
        return head;
​
    while (pCur != NULL)
    {
        prev->next = pCur->next;
        pCur->next = head->next;
        head->next = pCur;
        pCur = prev->next;
    }
​
    return head;
}
​
int main()
{
    LinkList head;
    head = list_init();
​
    int i;
    for (i = 0; i < 5; i++)
        head_insert(head, 100+i);
​
    print_list(head);
​
    head = reverse(head);
    print_list(head);
​
    return 0;
}

2、查找链表的中间结点

要求：只能遍历一次链表

思路：快慢指针

  • 定义两个指针slow、fast

  • slow每次遍历一个结点

  • fast每次遍历两个结点

image.png

image.png

image.png

image.png

算法实现：get_mid.c

#include <stdio.h>
#include <stdlib.h>
​
#define TRUE   0
#define FALSE -1
​
typedef int ElemType;
​
typedef struct LNode{
    ElemType data;  //数据域
    struct LNode *next; //指针域，指向当前结点的直接后继（下一个结点）
}LNode, *LinkList; //LinkList的类型为 LNode *
​
LinkList list_init()
{
    LNode *t;
    t = (LNode *)malloc(sizeof(LNode)); //创建一个头结点
    t->next = NULL; //头结点的指针域为空
​
    LinkList head;  //定义一个头指针
    head = t; //头指针指向头结点
    return head;
}
​
/*
 * @brief 头插法插入一个结点
 * @param 需要插入的链表的头指针
 * @param 需要插入的数据
 * @return 成功返回TRUE， 失败返回FALSE
 * */
int head_insert(LinkList head, ElemType data)
{
    if (NULL == head)
        return FALSE;
​
    //创建一个新的结点p
    LNode *p = (LNode *)malloc(sizeof(LNode));
    p->data = data;
    //将新的结点p的next指向头节点的下一个结点（head->next）
    p->next = head->next;
    //头节点的next指向新的结点p
    head->next = p;
​
    return TRUE;
}
​
/*
 * @brief 输出链表中的所有结点
 * @param head 链表的头指针
 * @return 成功返回TRUE，失败返回FALSE
 * */
int print_list(LinkList head)
{
    if (NULL == head)
        return FALSE;
​
    //使用一个临时指针对链表进行遍历
    LNode *t;
    t = head->next;
    while (t != NULL)
    {
        printf("%d ", t->data);
        t = t->next;
    }
    printf("\n");
    return TRUE;
}
​
LNode *get_mid(LinkList head)
{
    LNode *slow, *fast;
    slow = head->next;
    fast = head->next;
    while (fast != NULL && fast->next != NULL)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
​
    return slow;
}
​
int main()
{
    LinkList head;
    head = list_init();
​
    int i;
    for (i = 0; i < 6; i++)
        head_insert(head, 100+i);
​
    print_list(head);
​
    LNode *item;
    item = get_mid(head);
    printf("%d\n", item->data);
​
    return 0;
}

3、判断链表是否有环

image.png

思路：

  • 使用快慢指针

  • 如果存在环，最终在某个时间点快慢指针会相遇

image.png

image.png

image.png

image.png

image.png

image.png

算法实现：find_loop.c

#include <stdio.h>
#include <stdlib.h>
​
#define TRUE   0
#define FALSE -1
​
typedef int ElemType;
​
typedef struct LNode{
    ElemType data;  //数据域
    struct LNode *next; //指针域，指向当前结点的直接后继（下一个结点）
}LNode, *LinkList; //LinkList的类型为 LNode *
​
LinkList list_init()
{
    LNode *t;
    t = (LNode *)malloc(sizeof(LNode)); //创建一个头结点
    t->next = NULL; //头结点的指针域为空
​
    LinkList head;  //定义一个头指针
    head = t; //头指针指向头结点
    return head;
}
​
/*
 * @brief 头插法插入一个结点
 * @param 需要插入的链表的头指针
 * @param 需要插入的数据
 * @return 成功返回TRUE， 失败返回FALSE
 * */
int head_insert(LinkList head, ElemType data)
{
    if (NULL == head)
        return FALSE;
​
    //创建一个新的结点p
    LNode *p = (LNode *)malloc(sizeof(LNode));
    p->data = data;
    //将新的结点p的next指向头节点的下一个结点（head->next）
    p->next = head->next;
    //头节点的next指向新的结点p
    head->next = p;
​
    return TRUE;
}
​
/*
 * @brief 输出链表中的所有结点
 * @param head 链表的头指针
 * @return 成功返回TRUE，失败返回FALSE
 * */
int print_list(LinkList head)
{
    if (NULL == head)
        return FALSE;
​
    //使用一个临时指针对链表进行遍历
    LNode *t;
    t = head->next;
    while (t != NULL)
    {
        printf("%d ", t->data);
        t = t->next;
    }
    printf("\n");
    return TRUE;
}
​
LNode *find_loop(LinkList head)
{
    LNode *fast, *slow ; 
    slow = fast = head->next ; 
   
    while (slow != NULL && fast fast -> next != NULL) 
    { 
        slow = slow -> next ; 
        fast = fast -> next -> next ; 
        if (slow == fast) 
            return slow;
    } 
​
    return NULL;
}
​
int main()
{
    LinkList head;
    head = list_init();
​
    int i;
    for (i = 0; i < 6; i++)
        head_insert(head, 100+i);
    print_list(head);
​
    //人为在链表上添加一个环
    //使用一个指针记住链表上的第三个结点
    LNode *flag = head->next->next->next;
​
    //找到最后一个结点
    LNode *tail = head->next;
    while (tail->next != NULL)
        tail = tail->next;
​
    LNode *p = (LNode *)malloc(sizeof(LNode));
    p->data = 200;
​
    tail->next = p;
    p->next = flag;
​
    LNode *loop = find_loop(head);
    if (loop != NULL)
        printf("%d\n", loop->data);
    else
        printf("no loop\n");
​
    return 0;
}

4、查找带环链表中环的入口

image.png

通过判断一个单向链表是否有环我们知道，如果有环的存在，假设环的长度为r，那么当快指针fast和慢指针slow相遇的时候，假如fast指针已经在环上走了n圈，假如slow走了s步，那么fast就走了2s步，又因为fast走过的步数 = s + n*r，则有下面的等式：

2*s = s + n * r ; (1)

=> s = n*r； (2)

如果假设整个链表的长度是L，入口和相遇点的距离是x（如上图所示），起点到入口点的距离是a(如上图所示)，则有：

a + x = s = n * r; (3) 由（2）推出

a + x = (n - 1) * r + r = (n - 1) * r + (L - a) (4) 由环的长度 = 链表总长度 - 起点到入口点的距离求出

a = (n - 1) * r + (L -a -x) (5)

集合式子（5）以及上图我们可以看出，从链表起点开始到入口点的距离a,与从slow和fast的相遇点（如图）到入口点的距离相等。

因此我们就可以分别用一个指针（ptr1, prt2），同时从head与slow和fast的相遇点出发，每一次操作走一步，直到ptr1 == ptr2，此时的位置也就是入口点！

算法实现：find_entrance.c

#include <stdio.h>
#include <stdlib.h>
​
#define TRUE   0
#define FALSE -1
​
typedef int ElemType;
​
typedef struct LNode{
    ElemType data;  //数据域
    struct LNode *next; //指针域，指向当前结点的直接后继（下一个结点）
}LNode, *LinkList; //LinkList的类型为 LNode *
​
LinkList list_init()
{
    LNode *t;
    t = (LNode *)malloc(sizeof(LNode)); //创建一个头结点
    t->next = NULL; //头结点的指针域为空
​
    LinkList head;  //定义一个头指针
    head = t; //头指针指向头结点
    return head;
}
​
/*
 * @brief 头插法插入一个结点
 * @param 需要插入的链表的头指针
 * @param 需要插入的数据
 * @return 成功返回TRUE， 失败返回FALSE
 * */
int head_insert(LinkList head, ElemType data)
{
    if (NULL == head)
        return FALSE;
​
    //创建一个新的结点p
    LNode *p = (LNode *)malloc(sizeof(LNode));
    p->data = data;
    //将新的结点p的next指向头节点的下一个结点（head->next）
    p->next = head->next;
    //头节点的next指向新的结点p
    head->next = p;
​
    return TRUE;
}
​
/*
 * @brief 输出链表中的所有结点
 * @param head 链表的头指针
 * @return 成功返回TRUE，失败返回FALSE
 * */
int print_list(LinkList head)
{
    if (NULL == head)
        return FALSE;
​
    //使用一个临时指针对链表进行遍历
    LNode *t;
    t = head->next;
    while (t != NULL)
    {
        printf("%d ", t->data);
        t = t->next;
    }
    printf("\n");
    return TRUE;
}
​
LNode *find_entrance(LinkList head)
{
    LNode *fast, *slow ; 
    slow = fast = head->next ; 
   
    while (slow != NULL && fast -> next != NULL) 
    { 
        slow = slow -> next ; 
        fast = fast -> next -> next ; 
        if (slow == fast) 
            break;
    } 
    if (slow == NULL || fast -> next == NULL) 
        return NULL ; //没有环，返回NULL值 
​
    LNode * ptr1 = head->next ; //链表开始点 
    LNode * ptr2 = slow ; //相遇点 
    while (ptr1 != ptr2)  
    { 
        ptr1 = ptr1 -> next ; 
        ptr2 = ptr2 -> next ; 
    } 
    return ptr1 ; //找到入口点 
}
​
int main()
{
    LinkList head;
    head = list_init();
​
    int i;
    for (i = 0; i < 6; i++)
        head_insert(head, 100+i);
    print_list(head);
​
    //人为在链表上添加一个环
    //使用一个指针记住链表上的第三个结点
    LNode *flag = head->next->next->next;
​
    //找到最后一个结点
    LNode *tail = head->next;
    while (tail->next != NULL)
        tail = tail->next;
​
    LNode *p = (LNode *)malloc(sizeof(LNode));
    p->data = 200;
​
    tail->next = p;
    p->next = flag;
​
    LNode *loop = find_entrance(head);
    if (loop != NULL)
        printf("%d\n", loop->data);
    else
        printf("no loop\n");
​
    return 0;
}

5、约瑟夫环

问题描述：

传说有这样一个故事，在罗马人占领乔塔帕特后，39 个犹太人与约瑟夫及他的朋友躲到一个洞中，39个犹太人决定宁愿死也不要被敌人抓到，于是决定了一个自杀方式，41个人排成一个圆圈，第一个人从1开始报数，依次往后，如果有人报数到3，那么这个人就必须自杀，然后再由他的下一个人重新从1开始报数，直到所有人都自杀身亡为止。然而约瑟夫和他的朋友并不想遵从。于是，约瑟夫要他的朋友先假装遵从，他将朋友与自己安排在第16个与第31个位置，从而逃过了这场死亡游戏 。

问题转换：

41个人坐一圈，第一个人编号为1，第二个人编号为2，第n个人编号为n。

1.编号为1的人开始从1报数，依次向后，报数为3的那个人退出圈；

2.自退出那个人开始的下一个人再次从1开始报数，以此类推；

3.求出最后退出的那个人的编号。

image.png

解题思路：

  • 构建含有41个结点的单向循环链表，分别存储1~41的值，分别代表这41个人；

  • 使用计数器count，记录当前报数的值；

  • 遍历链表，每循环一次，count++；

  • 判断count的值，如果是3，则从链表中删除这个结点并打印结点的值，把count重置为0；

算法实现：JosephRing.c

#include <stdio.h>
#include <stdlib.h>
​
#define TRUE   0
#define FALSE -1
​
typedef int ElemType;
​
typedef struct LNode{
    ElemType data;  //数据域
    struct LNode *next; //指针域，指向当前结点的直接后继（下一个结点）
}LNode, *LinkList; //LinkList的类型为 LNode *
​
/*
 * @brief 输出链表中的所有结点
 * @param head 链表的头指针
 * @return 成功返回TRUE，失败返回FALSE
 * */
int print_list(LinkList head)
{
    if (NULL == head)
        return FALSE;
​
    //使用一个临时指针对链表进行遍历
    LNode *t;
    t = head;
    int i = 0;
    for (i = 0; i < 41; i++)
    {
        printf("%d ", t->data);
        t = t->next;
    }
    printf("\n");
    return TRUE;
}
​
void JosephRing(int num)
{
    //使用不带头结点的方式创建一个约瑟夫环
    int i;
    LNode *head; //第一个结点/头指针
    head = (LNode *)malloc(sizeof(LNode));
    LNode *tail = head;
    for (i = 1; i < 41; i++)
    {
        tail->data = i;
        tail->next = (LNode *)malloc(sizeof(LNode));
        tail = tail->next;
    }
    tail->data = i;
    tail->next = head;
    print_list(head);
​
    LNode *t = head;
    LNode *pre = NULL;
​
    int cnt = 0;
    while (t != t->next)
    {
        cnt++;
        if (cnt == num)   
        {
            printf("%d: out\n", t->data);
            pre->next = t->next;
            free(t);
            t = pre->next;
            cnt = 0;
        }
        else 
        {
            pre = t;
            t = t->next;
        }
    }
    printf("%d :left\n", t->data);
}
​
int main()
{
    JosephRing(3);
​
    return 0;
}
章鱼哥学编程
关注
  • 15
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现单向链表反转
08-27
Java实现单向链表反转 Java实现单向链表反转是指将单向链表的顺序颠倒，例如原链表为A->B->C->D->E->F，反转后变为F->E->D->C->B->A。这种操作在实际开发中非常有用，例如在数据处理、数据分析等领域。 单向链表...
C++实现简单单向链表
12-17
在本文中，我们将深入探讨如何使用C++实现一个简单的单向链表。单向链表是一种数据结构，其中每个节点包含一个数据元素和一个指向下一个节点的指针。在这个实现中，我们创建了一个名为`Node`的结构体来表示链表中的...
数据结构 之 链表 高频面试题
CSNZのBlog
10-11 3283
一：面试时链表解题的方法论 1、对于笔试，不用太在乎空间复杂度，一切为了时间复杂度 2、对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法 二：链表面试题常用数据结构和技巧 1、使用容器（哈希表、数组等） 2、快慢指针 使用快慢指针的面试题： 1、输入链表头结点，奇数长度返回中点，偶数长度返回上中点 * //输入链表头结点，奇数长度返回中点，偶数长度返回上中点 public static <T> Node<T> midOrUpMidNode(Node<T&g
BAT互联网大厂高频笔试题-------链表系列
weixin_57909254的博客
02-19 382
反转单链表 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL class Solution { public: //递归 ListNode *reverseList1(ListNode *head) { //递归结束条件肯定是head走到最后了那就是要么是null要么是末尾元素 if (head == NULL || hea.
【JAVA】链表面试题
Xian meng在努力呐-的博客
08-09 537
链表面试题
数据结构笔记--链表经典高频题
牵一只蜗牛去散步
08-09 548
题目：给定一个单链表的头结点head，结点的值类型是整型，再给定一个整数pivot，实现一个调整链表的的函数，将链表调整为左部分都是值小于pivot的结点，中间部分都是值等于pivot的结点，右部分都是值大于pivot的结点；与反转单向链表类似，使用 pre，cur 和 next 指向前一个节点，当前节点和后一个节点，不断遍历更新三个指针所指向的节点即可，并修改对应的前驱指针和后驱指针；面试做法可以参考反转单向链表，将链表反转，与原链表的结点进行比较即可，当反转链表与原链表的结点不相等，表明不是回文链表；
Leetcode（力扣）超高频题讲解（一）
立志成为一个前端、后端、测试全方位发展的程序员
01-21 1228
高频题(一) 文章目录高频题(一)一、反转链表(206)1. 双指针迭代2. 递归二、无重复字符的最长字串(3)三、LRU缓存机制(146)1. 题目描述2. LRU算法的介绍3. 数据结构的选择4. 代码实现四、数组中的第k个最大元素(215)1. 快排变形2. 大顶堆五、K个一组翻转链表(25)六、两数之和(1)1. 一遍哈希表2. 两遍哈希表七、三数之和(15)八、环形链表II(142)1. 哈希表2. 快慢指针九、环形链表(141)1. 哈希表2. 快慢指针十、合并两个有序链表(21)1. 递归2.
笔试面试高频算法题总结
wwxy1995的博客
11-19 785
经中遇到的题： 1、数组的逆序数 2、LRU //hashMap加双向链表，双向链表有头尾节点， 3、最长回文序列 leetocde 5 4、矩阵中的最长递增路径，可以上下左右一起都走； leetcode329 5、判断一个二叉树是另一个二叉树的子树 6、归并排序的时间复杂度 // NlongN 7、求给出01矩阵中的最大正方形面积（全为1） lc221 8、求二叉树中距离最远的节...
笔试面试高频题（操作系统）
wjduguyuyun的博客
09-05 274
有那么一些零碎的小知识点，偶尔很迷惑，偶尔被忽略，偶然却发现它们很重要，也是各大笔试和面试高频出现考点。这段时间正好在温习这些，就整理在这里，一起学习一起提高！后面还会继续补充。 ——前言 1.进程和线程 　　线程是指进程内的一个执行单元,也是进程内的可调度实体. 　　与进程的区别: 　　(1)地址空间:进程内的一个执行单元;进程至少有一个线程;它们共享进程的地址空间
LinkedList与链表
如风暖阳的博客
07-05 461
LinkedList与链表
题解 | #输出单向链表中倒数第k个结点#
每天多一点干货
10-31 878
中兴网络技术工程师，第三世界出差+加班+夜班，害怕自己一年都撑不了，想进国企躺平，移动这种运营商就行，现在大部分国企流程要走起来了，双非硕要不要赌一手国企啊，拿。鼠鼠目前拿到了顺丰跟金蝶的offer，两者基本薪资都差不多，但是顺丰优点是有房补，其他补贴啥的，所以综合收入可能会比金蝶高一点，并且平台也更大，但是缺点是裁员好;#如何判断面试是否凉。9硕2本，秋招求职意向是互联网产品经理，就一段相关实习，家在无锡，地点江浙沪都可以接受1. 美的洗衣机事业部，n+2*14，base无锡，产品企划岗其实不太了解。
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
单向链表类模板_单向链表类模板_fastchq_
10-03
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。在C++编程中，为了实现通用性，我们通常会使用模板类来创建单向链表，以便它可以处理不同类型的元素。标题"单向链表类...
C语言之单向链表详解及实例代码
12-31
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有...
数据结构 Java DS——链表部分经典题目 (1)
cjejwe的博客
07-09 677
笔者计划在暑假啃完JavaDS,Mysql的内容当然也会继续更这次给读者们分享的是链表的几个比较典型的题目,关于如何手搓一个链表,笔者还在筹划中,毕竟链表的种类也有那么多,但是在下面的题目中,只有单向链表。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 585
递归算法，爬楼梯等解法
二分查找和斐波那契查找
最新发布
weixin_50960004的博客
07-13 184
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。
数据结构day6链式队列
picians的博客
07-10 565
主程序dequeue(Q);Q=NULL;return 0;源程序free(Q);Q=NULL;H->len=0;Q->head=H;Q->tail=H;return Q;return -1;return new;return;return;=NULL)
C语言链表详解.ppt
11-15
C语言链表详解.ppt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值