单链表面试题（一）

最新推荐文章于 2022-04-24 14:11:01 发布
最新推荐文章于 2022-04-24 14:11:01 发布
阅读量663 收藏
点赞数
分类专栏： C语言 文章标签： 面试题 单链表 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/love18792838953/article/details/76573984
版权

链表是最基本的数据结构，链表的相关操作也比较简单，同时它也包含了指针的运用，能把许多知识结合起来，因此链表的面试题在面试中占据很重要的地位，所以我整理了一些关于链表的面试题与大家分享。

下图是其中一道求带环链表入口点题的分析图
求带环链表环的入口点

//.h
#ifndef __LIST_H__
#define __LIST_H__
#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
typedef  int   Datatype;
typedef struct Node
{
    Datatype data;
    struct Node*next;
}Node, *pNode, *pList;
//打印链表信息
void display(pList plist);
//销毁链表
void Destroylist(pList*pplist);
//查找某个元素
pNode find(pList plist, Datatype x);
//头部插入数据
void pushfront(pList*pplist, Datatype x);
//逆序打印链表内容
void Invert_display(pList pplist);
//链表的逆序
void Invert_list(pList*pplist);
//链表的合并
pList Merge(pList*ls1, pList*ls2);
//链表的合并递归版本
pList _Merge(pList*ls1, pList*ls2);
//删除一个非尾节点
void DelNotTail(pNode pos);
//在一个位置前插入一个节点
void InsertFrontNode(pNode pos, Datatype x);
//约瑟夫环
void JosephCycle(pList plist, int k);
//寻找一个链表的中间节点，只能遍历一次
pNode FindMidNode(pList plist);
//对链表的冒泡排序
void Bubblesort(pList plist);
//删除倒数第k个元素
void DelKNode(pList *plist, int k);
//判断一个单链表是否有环
pNode CheckCycle(pList plist);
//求一个带环单链表环的长度
int GetCircleLength(pNode meet);
//法一：求一个带环单链表环的入口点
pNode GetCircleEntreNode(pNode meet, pList plist);
//法二：求一个带环单链表环的入口点
pNode _GetCircleEntreNode2 (pList plist,int Length);
//判断两个不带环单链表是否相交
pNode  CheckCross(pList plist1, pList plist2);
//求两个相交不带环单链表的交点
pNode GetCrossNode(pList plist1, pList plist2);
#endif //__LIST_H__
//.c
#include"list.h"
//打印
void display(pList plist)
{
    pNode head = plist;
    while (head != NULL)
    {
        printf("%d-->", head->data);
        head = head->next;
    }
    printf("over\n");
}
//查找特定元素
pNode find(pList plist, Datatype x)
{
    pNode head = plist;
    while (plist != NULL)
    {
        if (plist->data == x)
            return plist;
        plist = plist->next;
    }
    return NULL;
}
//销毁
void Destroylist(pList*pplist)
{
    pNode temp = NULL;
    assert(pplist);
    while (*pplist != NULL)
    {
        temp = (*pplist)->next;
        free(*pplist);
        *pplist = temp;
    }
}
//头插
void pushfront(pList*pplist, Datatype x)
{
    assert(pplist);
    pNode node = (pNode)malloc(sizeof(Node));
    if (node == NULL)
    {
        perror("malloc");
        exit(EXIT_FAILURE);
    }
    node->data = x;
    node->next = NULL;
    node->next = *pplist;
    *pplist = node;
}
//逆序打印
void Invert_display(pList pplist)
{
    if (pplist == NULL)
    {
        return;
    }
    if (pplist!= NULL)
    {
        Invert_display(pplist->next);
    }
    printf("%d-->", pplist->data);
}
//链表的逆序
void Invert_list(pList*pplist)
{
    assert(pplist);
    //保存当前要处理的节点的上一个节点的位置
    pNode temp = NULL;
    //当前要处理的节点位置
    pNode cur1 = *pplist;
    //保存当前要处理的节点的指向
    pNode cur2 = NULL;
    if (*pplist == NULL || (*pplist)->next == NULL)
        return;
    //当要处理的节点为空时，说明整个链表已经逆序完成。
    while (cur1 != NULL)
    {
        //保存当前节点的指向
        cur2 = cur1->next;
        //把当前节点的指向改为上一节点
        cur1->next = temp;
        //当前节点就成为下一个节点的的指向，所以提前保存起来
        temp = cur1;
        //使下次循环要处理的节点指向下一个节点
        cur1 = cur2;
    }
    *pplist = temp;
}
//合并两个有序链表非递归
pList Merge(pList*ls1, pList*ls2)
{
    assert(ls1&&ls2);
    pList New_list = NULL;
    pNode cur1 = *ls1;
    pNode cur2 = *ls2;
    pNode temp = NULL;
    pNode head = NULL;
    pNode tail = NULL;
    if (*ls1 == NULL&&*ls2 == NULL)
        return NULL;
    if (*ls1 == *ls2)
        return*ls1;
    if (*ls1 == NULL)
        return *ls2;
    if (*ls2 == NULL)
        return *ls1;
    if (cur1->data < cur2->data)
    {
        head = cur2;
        cur2 = cur2->next;
    }
    else
    {
        head = cur1;
        cur1 = cur1->next;
    }
    tail = head;
    tail->next = NULL;
    while (cur1 != NULL&&cur2 != NULL)
    {
        if (cur1->data < cur2->data)
        {
            tail->next = cur2;
            cur2 = cur2->next;
        }
        else
        {
            tail->next = cur1;
            cur1 = cur1->next;
        }
        tail = tail->next;
        tail->next=NULL;
    }
    if (cur1 == NULL)
        tail->next = cur2;
    else 
        tail->next = cur1;
    New_list = head;
    return New_list;
}
//递归合并两个有序链表，合并仍然是有序的
//从两个链表里挑出一个元素，并把他的地址返回去，最后一个一个元素串起来，形成一条新链表
pList _Merge(pList*ls1, pList*ls2)
{
    assert(ls1&&ls2);
    pNode cur1 = *ls1;
    pNode cur2 = *ls2;
    pNode head = NULL;
    //以下四个if语句进行特殊处理
    if (*ls1 == NULL&&*ls2 == NULL)
        return NULL;
    if (*ls1 == *ls2)
        return*ls1;
    if (*ls1 == NULL)
        return *ls2;
    if (*ls2 == NULL)
        return *ls1;
    //这个if语句在两个链表中跳出一个元素，把他的地址赋值给head
    if (cur1->data < cur2->data)
    {
        head = cur2;
        cur2 = cur2->next;
    }
    else
    {
        head = cur1;
        cur1 = cur1->next;
    }
    head->next = NULL;
    //如果两个链表没有处理完，就递归进行处理
    if (cur1 != NULL||cur2!=NULL)
        //用本次的head->next接受下一次处理好的节点的位置
        head->next = _Merge(&cur1, &cur2);
    //正常处理完之后返回处理的位置
    return head;
}
//删除一个非尾节点
void DelNotTail(pNode pos)
{
    pNode temp = NULL;
    pNode head = pos;
    if (head == NULL || head->next == NULL)
        return;
    //把该节点后面的节点内容覆盖到该节点，然后删除后面一个节点
    temp = head->next;
    head->data = head->next->data;
    head->next = head->next->next;
    free(temp);
}
//在一个位置前插入一个节点
void InsertFrontNode(pNode pos, Datatype x)
{
    pNode temp = (pNode)malloc(sizeof(Node));
    if (pos == NULL)
        return;
    if (temp == NULL)
    {
        perror("malloc");
        return;
    }
    //在该节点后面增加一个节点，交换两个节点数据，就相当于在该节点前面开辟一个节点一样
    temp->next = pos->next;
    pos->next = temp;
    temp->data = pos->data;
    pos->data = x;
}
//约瑟夫环
void JosephCycle(pList plist, int k)
{
    pNode temp = NULL;
    pNode head = plist;
    int count = k;
    if (plist == NULL)
        return;
    //删除后面节点法
    while (head!=head->next)
    {
        count = k;
        while (count- 1 > 0)
        {
            head = head->next;
            count--;
        }
        printf("%d ", head->data);
        temp = head->next;
        head->data = head->next->data;
        head->next = head->next->next;
        free(temp); 
    }
    删除当前节点
    //while (head != head->next)
    //{
    //  count = k;
    //  while (count - 2 > 0)
    //  {
    //      head = head->next;
    //      count--;
    //  }
    //  printf("%d ", head->next->data);
    //  temp = head->next;
    //  head->next = head->next->next;
    //  free(temp);
    //  head = head->next;
    //}
}
//寻找一个链表的中间节点，只能遍历一次
pNode FindMidNode(pList plist)
{
    pNode fast = plist;
    pNode slow = plist;
    if (fast == NULL)
        return NULL;
    while (fast!=NULL&&fast->next != NULL)
    {
        fast = fast->next->next;
        slow = slow->next;
    }
    return slow;
}
//对链表的冒泡排序
void Bubblesort(pList  plist)
{
    pNode cur1 = plist;
    pNode cur2 = NULL;
    //每次循环的标记
    pNode flag = NULL;
    Datatype Datmp = 0;
    if (plist == NULL||plist->next == NULL)
        return;
    while (cur1->next != flag)
    {

        while (cur1->next!= flag)
        {
            if (cur1->data < cur1->next->data)
            {
                Datmp = cur1->data;
                cur1->data = cur1->next->data;
                cur1->next->data = Datmp;
            }
            cur1 = cur1->next;
        }
        flag = cur1;
        cur1 = plist;
    }
}
//删除倒数第k个元素
void DelKNode(pList *plist, int k)
{
    Node*node = *plist;
    Node*first = *plist;
    Node*slow = *plist;
    if (*plist == NULL)
        return;
    if (k <= 0)
        return;
    if (k == 1)
    {
        while (node->next != NULL&&node->next->next != NULL)
        {
            node = node->next;
        }
        if ((*plist)->next == NULL)
        {
            free(*plist);
            *plist = NULL;
            return;
        }
        free(node->next);
        node->next = NULL;
        return;
    }
    while (first!=NULL)
    {
        while (k)
        {
            first = first->next;
            k--;
        }
        if (k > 0)
        {
            return;
        }
        if (first != NULL)
        {
            first = first->next;
            slow = slow->next;
        }
    }
    slow->data = slow->next->data;
    Node*temp = slow->next;
    slow->next = slow->next->next;
    free(temp);
}
t plist)
{
    pNode Fast = plist;
    pNode Slow = plist;
    while (Fast != NULL&&Fast->next!=NULL)
    {
        Fast = Fast->next->next;
        Slow = Slow->next; 
        if (Slow == Fast)
        {
            return Fast;
        }
    }
    return NULL;
}
//求一个带环单链表环的长度
int GetCircleLength(pNode meet)
{
    pNode Fast = meet;
    pNode Slow = meet;
    int count = 1;
    while (1)
    {
        Fast = Fast->next->next;
        Slow = Slow->next;
        if (Fast == Slow)
        {
            return count;
        }
        count++;
    }
    return count;
}
//法一：求一个带环单链表环的入口点
pNode GetCircleEntreNode(pNode meet, pList plist)
{
    assert(meet&&plist);
    pNode First = plist;
    pNode second = meet;
    while (First != second)
    {
        First = First->next;
        second = second->next;
    }
    return First;
}
//法二：求一个带环单链表环的入口点
pNode _GetCircleEntreNode2(pList plist, int Length)
{
    assert(plist);
    pNode First = plist;
    pNode second = plist;
    while (1)
    {
        if (Length <= 0)
            second = second->next;
        First = First->next;
        if (First == second)
            break;
        Length--;
    }
    return First;
}
//判断两个不带环的单链表是否相交
pNode CheckCross(pList plist1, pList plist2)
{
    pNode head1 = plist1;
    pNode head2 = plist2;
    if (plist1 == NULL || plist2 == NULL)
        return NULL;
    while (head1->next != NULL)
    {
        head1 = head1->next;
    }
    while (head2->next != NULL)
    {
        head2 = head2->next;
    }
    if (head1 == head2)
        return head1;
    return NULL;
}
//求两个相交不带环单链表的交点
pNode GetCrossNode(pList plist1, pList plist2)
{
    pNode head1 = plist1;
    pNode head2 = plist2;
    pNode meet = NULL;
    pNode EntryCross = NULL;
    pNode tail = NULL;
    tail = CheckCross(head1,head2);
    if (tail == NULL)
        return NULL;
    //把一个链表的头，接到链表尾上，形成一个带环链表，变成求环的入口点问题
    tail->next = head1;
    meet = CheckCycle(head2);
    EntryCross =  GetCircleEntreNode(meet, head2);
    tail->next = NULL;
    return EntryCross;
}
//.c
#include"list.h"
//链表的逆序打印和链表的逆序
void test1()
{
    pList list = NULL;
    pushfront(&list, 1);
    pushfront(&list, 2);
    pushfront(&list, 3);
    pushfront(&list, 4);
    display(list);
    逆序打印
    //Invert_display(list);
    //链表元素的逆置
    Invert_list(&list);
    display(list);
    Destroylist(&list);
}
//合并两个有序链表
void test2()
{
    pList list1 = NULL;
    pList list2 = NULL;
    pList New_list = NULL;
    //第一链表list1
    pushfront(&list1, 0);
    pushfront(&list1, 2);
    pushfront(&list1, 4);
    pushfront(&list1, 6);
    pushfront(&list1, 8);
    pushfront(&list1, 10);
    //第二条链表
    pushfront(&list2, 1);
    pushfront(&list2, 3);
    pushfront(&list2, 5);
    pushfront(&list2, 7);
    New_list = _Merge(&list1, &list2);
    display(New_list);
    Destroylist(&list1);
    Destroylist(&list2);
}
//删除一个非尾节点
void test3()
{
    pList list = NULL;
    pushfront(&list, 1);
    pushfront(&list, 2);
    pushfront(&list, 3);
    pushfront(&list, 4);
    display(list);
    DelNotTail(find(list, 3));
    display(list);
    Destroylist(&list);
}
//指定节点前面添加一个节点
void test4()
{
    pList list = NULL;
    pushfront(&list, 1);
    pushfront(&list, 2);
    pushfront(&list, 3);
    pushfront(&list, 4);
    display(list);
    InsertFrontNode(find(list,3), 5);
    display(list);
    Destroylist(&list);
}
//约瑟夫环
void test5()
{
    pList list = NULL;
    pushfront(&list, 1);
    pushfront(&list, 2);
    pushfront(&list, 3);
    pushfront(&list, 4);
    pushfront(&list, 5);
    display(list);
    find(list, 1)->next = list;
    JosephCycle(list, 3);
}
//寻找一个链表的中间节点，只能遍历一次
void test6()
{
    pList list = NULL;
    pushfront(&list, 1);
    pushfront(&list, 2);
    pushfront(&list, 3);
    pushfront(&list, 4);
    pushfront(&list, 5);
    pushfront(&list, 6);
    printf("%d\n",FindMidNode(list)->data);
    Destroylist(&list);
}
//对链表的冒泡排序
void test7()
{
    pList list = NULL;
    pushfront(&list, 1);
    pushfront(&list, 3);
    pushfront(&list, 5);
    pushfront(&list, 2);
    pushfront(&list, 4);
    pushfront(&list, 6);
    pushfront(&list, 2);
    pushfront(&list, 5);
    pushfront(&list, 7);
    Bubblesort(list);
    display(list);
    Destroylist(&list);
}
//删除倒数第k个元素
void test8()
{
    pList list = NULL;
    pushfront(&list, 1);
    pushfront(&list, 2);
    pushfront(&list, 3);
    pushfront(&list, 4); 
    display(list);
    DelKNode(&list, 2);
    display(list);
    Destroylist(&list);
}
//带环单链表问题
void test9()
{
    pList list = NULL;
    //相遇点
    pNode meet = NULL;
    //入口点
    pNode EntryCross = NULL;
    //环的长度
    int Length = 0;
    pushfront(&list, 1);
    pushfront(&list, 2);
    pushfront(&list, 3);
    pushfront(&list, 4);
    pushfront(&list, 5);
    pushfront(&list, 6);
    pushfront(&list, 7);
    pushfront(&list, 8);
    pushfront(&list, 9);
    find(list, 1)->next = find(list,7);
    meet = CheckCycle(list);
    Length = GetCircleLength(meet);
    printf("环的长度为:%d\n", Length);
    printf("环的第一次相遇点为:%d\n", meet->data);
    //法一判断环入口点
    EntryCross = GetCircleEntreNode(meet, list);
    printf("环的r入口点为:%d\n", EntryCross->data);
    //法二判断入口点
    EntryCross = _GetCircleEntreNode2(list,Length);
    printf("环的r入口点为:%d\n", EntryCross->data);
    /*if (meet)
    {
        printf("带环\n");
    }
    else
    {
        printf("不带环\n");
    }*/
}
//两个不带环单链表相交问题
void test10()
{

    pList list1 = NULL;
    pList list2 = NULL;
    //是否相交的返回值
    pNode ret = 0;
    //链表的交点
    pNode CrossNode = NULL;
    pushfront(&list1, 1);
    pushfront(&list1, 2);
    pushfront(&list1, 3);
    pushfront(&list1, 4);
    pushfront(&list1, 5);
    pushfront(&list1, 6);
    pushfront(&list1, 7);
    pushfront(&list1, 8);
    pushfront(&list1, 9);
    pushfront(&list2, 10);
    pushfront(&list2, 11);
    pushfront(&list2, 12);
    find(list2, 10)->next = find(list1, 5);
    /*ret = CheckCross(list1, list2);
    if (ret != NULL)
        printf("相交\n");
    else
        printf("不相交\n");*/
    CrossNode = GetCrossNode(list1, list2);
    if (CrossNode!=NULL)
    printf("%d\n", CrossNode->data);
}
int main()
{
    test10();
    system("pause");
    return 0;
}
AI_T
关注
专栏目录
链表面试题
Important_的博客
08-21 248
1.比较顺序表和链表的优缺点，说说它们分别在什么场景下使用？ 链表是一种动态的数据结构，因为在创建链表时，我们不需要知道链表的长度，当插入一个结点时，只需要为该结点分配内存，然后调整指针的指向来确保新结点被连接到链表中。所以，它不像顺序表，内存是一次性分配完毕的，而是每添加一个结点分配一次内存。正是因为这点，所以它没有闲置的内存，比起顺序表，空间效率更高。 顺序表 :两大问题...
Java单链表面试题
weixin_47219685的博客
10-09 155
单链表面试题 获取单链表长度 查找单链表倒数第k个元素 单链表反转 反向打印单链表（不破坏原有单链表） 合并两个有序的单链表，合并后依然有序
【数据结构与算法 4】单链表面试题
学Java，找哪吒
05-13 3738
一、获取到单链表的节点的个数 /* * head 链表的头节点 * 返回有效节点的个数,没有统计头节点 * */ public static int getLength(HeroNode head) { if(head.next == null) { return 0; } int length = 0; //定义一个辅助变量 HeroNode cur = head.next; while(cur != null) { length++; cur = cur.next;
单链表面试题汇总
Amber的博客
08-03 2787
之前我们实现过单链表的一些简单接口，而单链表还有一些面试题非常重要，今天来看一下一些常见面试题的实现 （注：本文调用的简单接口实现：http://blog.csdn.net/qq_34021920/article/details/76594389） 1.从尾到头打印单链表 void RPrintList(pList plist);//从尾到头打印链表(不改变链表) 从尾到头打印单链表，...
单链表面试题
Jiajun Zhu
11-19 793
1.单链表的反转
数据结构单链表面试题
ChenMeng9的博客
09-29 199
1 单链表如何逆置 逆置1 ：一直头插即可 bool Reverse(PNode plist) { assert(plist!=NULL); Node *p=plist->next; Node*q; plist->next=nullptr; //让头结点断开，方便尾部为空。 while(p!=NULL) { q=p->next; p->next=plst->next; plist->next=p; p=q; } ..
C++单链表面试题
honeyJ
11-19 1418
下面是C++中一些常见的单链表面试题，文中皆是无头单链表。 如下：我们必须构建节点，为了方便测试，我只写了尾插函数。 #include #include #include using namespace std; typedef struct Node { Node(const int& data) : _data(data) , _pNext(NULL) {} int _data
C语言实现单链表面试题汇总
ljx_5489464的博客
03-20 2915
这篇博客只有针对单链表的不同面试题的不同函数，没有对单链表的具体实现方法的介绍。 单链表的具体实现方法（创建，初始化，前插，后插，删除，插入，销毁等），可以参考我的另一边博客： http://blog.csdn.net/ljx_5489464/article/details/50893430以下是单链表面试题的具体实现：1、从尾到头打印单链表void PrintListTailToHead(PS
单链表面试题~带环链表的入口点
jhcconan614的博客
03-19 716
昨天做了一个小总结，发现单链表这块关于带环链表漏掉了，今天就来总结一下。要寻找一个单链表的环的入口点，首先得判断一个链表是否带环，那么又怎样判断一个单链表是否带环呢？首先我们得普及一下环有什么特性，我们知道无环的单链表有首节点和尾节点，那么带环的单链表呢？显然还是有首节点的，但是没有尾节点吧。如图所示： 带环的单链表既然没有尾结点，那么要是遍历的话，就会无限循环，我们就没法通过这样来判断这是带环的
Java数据结构与算法-链表(单链表、双向链表、环形链表、约瑟夫问题)[day02]
SwaeLeeUknow的博客
09-04 511
day02-链表 单链表介绍和内存布局 链表是有序的列表，但是内存中是实际存储结构如下： 小结: 1.链表是以节点的方式来存储,是链式存储(即各个节点之间并不一定是连续存储的，而是相互指向的); 2.每个节点包含 data 域:存放数据的域， next 域：指向下一个节点; 3.如图：发现链表的各个节点不一定是连续存储; 4.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定. 单链表(带头结点) 逻辑结构示意图如下: 单链表创建和遍历的分析实现 例子 使用带head头的单向
【单链表面试题】
qq_25355771的博客
04-24 224
面试题常见的面试题基础代码求单链表中有效节点的个数查找单链表中倒数第k个节点 [新浪]链表的反转 [腾讯]从尾到头打印单链表 [百度，要求：1.反向遍历；2.stack栈]合并两个有序的单链表，合并之后的链表依然有序。 常见的面试题 基础代码 代码： package Package01; public class SingleLinkedListDemo { public static void main(String[] args) { // 进行测试 // 先创建节
数据结构 --- 单链表面试题
yuan_dai_ma的博客
06-25 217
数据结构 --- 单链表试题 求单链表中有效节点的个数 查找单链表中倒数第k个节点 单链表的反转 单链表的逆序打印 package linkedlist; import java.util.Stack; public class SingleLinkedListDemo1 { public static void main(String[] args) { Node a = new Node(1); Node b = new Node(2);
单链表面试算法解析与实现
首先定义一个结构体 `student`，它包含一个整型数据 `data` 和一个指向下一个节点的指针 `next`。`creat()` 函数首先初始化头结点 `head` 为 `NULL`，然后通过循环不断输入数据（直到输入0为止）来构建链表。每次...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值