C语言链表面试题(增强版)（转）

最新推荐文章于 2021-06-15 00:14:05 发布
最新推荐文章于 2021-06-15 00:14:05 发布
阅读量250 收藏 2
点赞数
分类专栏： 数据结构 c 链表
数据结构 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
链表
2 篇文章 0 订阅
订阅专栏
c
1 篇文章 0 订阅
订阅专栏

转自：https://blog.csdn.net/zhaoxaun666/article/details/79277774 

 

C语言诸多面试题，这里有常用的经典面试题，应用有多种算法，如替换法，快慢指针等等。 注：含有的有关头文件引用上一篇博客单链表的插与删，本篇文章不在写出。

面试题 一：从尾到头打印单链表。


///  1.从尾到头打印单链表 //
 
void SLitsPrintTailToHead(SListNode* pHead)//非递归算法(利用俩个指针一个定义到尾部p1，另一个定义到头开始循环p2，每当p2循环到尾部时，输出p2的值，让尾部p1指向p2.再次开始循环，以此往复。)
{
 
    SListNode *cur=NULL;
    while (cur!=pHead)
    {
        SListNode *tail=pHead;
        while(tail->next!=cur)
        {
            tail=tail->next;
        }
        printf("%d ",tail->data);
        cur=tail;
    }
 
}
void SListPrintTailToHeadR(SListNode* pHead)//递归算法
{
    if (pHead==NULL)
    {
        return;
    }
    SListPrintTailToHeadR(pHead->next);
    printf("%d ",pHead->data);
}
///
面试题二：删除一个无头单链表的非尾节点（不能遍历链表） 

void SListDelNonTailNode(SListNode* pos)//应用了向前替换法，把后一个的值赋值给pos替换原值，然后把pos指向pos下一个的下一个。
{
     SListNode *cur=NULL;
     cur=pos->next;
     pos->data=cur->data;
     pos->next=cur->next;
     free(cur);
}


面试题三：在无头单链表的一个节点前插入一个节点（不能遍历链表） 


void SListInsertFrontNode(SListNode* pos, DataType x)
{
    SListNode *cur=BuySListNode(pos->data);
    cur->next=pos->next;
    pos->data=x;
    pos->next=cur;
    
}


面试题四：单链表实现约瑟夫环(JosephCircle) 


/ 4.单链表实现约瑟夫环(JosephCircle) 约瑟夫环就比如说一群人围成一个圈，从一个人开始报数，如报到3的人就退出，下一个继续从1开始，直到只剩一个人时结束。
SListNode* SListJosephCircle(SListNode* pHead, int k)//phead是一个循环链表 
{
    SListNode *cur=pHead;
    SListNode *nx=NULL;
    while(cur->next!=cur)
    {
        int Coun=k;
        while (--Coun)
        {
            cur=cur->next;
        }
        nx=cur->next;//利用替换法不需要遍历链表进行删除节点
        cur->data=nx->data;
        cur->next=nx->next;
        free(nx);
    }
    return cur;
}


面试题五：逆置/反转单链表


SListNode* SListReverse(SListNode* list)//逆置/反转单链表 (重要多看看)
{
    SListNode *cur=list;
    SListNode *newlist=NULL;
    SListNode *_next=NULL;
    while (cur)
    {
        _next=cur->next;
        cur->next=newlist;
        newlist=cur;
        cur=_next;
    }
    return newlist;
}


面试题六：单链表排序（冒泡排序&快速排序） 


void SListBubbleSort(SListNode* list)//单链表排序（冒泡排序&快速排序） 冒泡排序俩俩比较。
{
    SListNode *tail=NULL;
    while (list!=tail)
    {
        int change=0;
        SListNode *cur=list;
        SListNode *_next=list->next;
        while (_next!=tail)
        {
            if (cur->data > _next->data)
            {
                DataType tmp=cur->data;
                cur->data=_next->data;
                _next->data=tmp;
                change=1;
            }
            _next=_next->next;
            cur=cur->next;
        }
        if (change==0)
        {
            break;
        }
        tail=cur;
    }
}


面试题七：合并两个有序链表,合并后依然有序 


SListNode* SListMerge(SListNode* list1, SListNode* list2)//合并两个有序链表,合并后依然有序 
{
    SListNode *newlist=NULL;//
    SListNode *list=NULL;
    if (list2==NULL)
    {
        return list1;
    }
    if (list1==NULL)
    {
        return list2;
    }
    if (list1->data < list2->data)
    {
        newlist=list=list1;//一个用来定位头，另一个用来遍历，返回时要返回头的指针才能遍历全部链表
        list1=list1->next;
    }
    else
    {
        newlist=list=list2;
        list2=list2->next;
    }
    while (list1&&list2)
    {
        if (list1->data < list2->data)
        {
            newlist->next=list1;
            list1=list1->next;
        }
        else
        {
            newlist->next=list2;
            list2=list2->next;
        }
        newlist=newlist->next;
    }
    if (list1)
    {
        newlist->next=list1;
    }
    if (list2)
    {
        newlist->next=list2;
    }
    return list;
}


面试题八：查找单链表的中间节点，要求只能遍历一次链表 


SListNode* SListFindMidNode(SListNode* list)//8.查找单链表的中间节点，要求只能遍历一次链表 
{
    SListNode *cur=NULL;//应用了快慢指针，快指针的速度是慢指针二倍，当快指针走到NULL时，慢指针所指的就是中间节点。
    SListNode *fast=NULL;
    cur=fast=list;
    while (fast && fast->next)
    {
        cur=cur->next;
        fast=fast->next->next;
    }
    return cur;
}


面试题九：查找单链表的倒数第k个节点，要求只能遍历一次链表 


SListNode* SListFindTailKNode(SListNode* list, size_t k)//9.查找单链表的倒数第k个节点，要求只能遍历一次链表 
{
    SListNode *cur,*fast;//一样用了快慢指针
    cur=fast=list;
    while(k--)
    {
        if (fast==NULL)
        {
            return 0;
        }
        fast=fast->next;
    }
    while(fast)
    {
        fast=fast->next;
        cur=cur->next;
    }
    return cur;
}


面试题十：删除链表的倒数第K个结点 


void SListFindPop(SListNode *list,size_t k)//10.删除链表的倒数第K个结点 
{
    SListNode *cur=NULL;
    SListNode *tail=list;
    cur=SListFindTailKNode(list,k);
    while(list->next!=cur)
    {
        list=list->next;
    }
    list->next=cur->next;
    free(cur);
}


面试题十一：判断是否带环


SListNode* SListIsCycle(SListNode* list)//11.判断是否带环
{
    SListNode *cur,*fast;
    cur=fast=list;
    while (fast && fast->next)
    {
        cur=cur->next;
        fast=fast->next->next;
        if (fast==cur)
        {
            return cur;
        }    
    }
    return NULL;
}


面试题十二：求环的长度


int SListCycleLen(SListNode* meetNode)//12.求环的长度
{
    int n=1;
    SListNode *cur=meetNode;
    while(cur->next!=meetNode)
    {
        ++n;
        cur=cur->next;
    }
    return n;
}


面试题十三：求环的入口点（环的入口点就是一个从链表开始另一个从相遇点开，当他们相交的点就是入口点）


SListNode* SListCrossEntreNode(SListNode* list, SListNode* meetNode) //13.求环的入口点（环的入口点就是一个从链表开始另一个从相遇点开，当他们相交的点就是入口点）
{
    while (list!=meetNode)
    {
        list=list->next;
        meetNode=meetNode->next;
    }
    return list;
}


面试题十四：判断两个链表是否相交。（假设链表不带环）


int SListIsCrossNode(SListNode* list1, SListNode* list2)//14.判断两个链表是否相交，若相交，求交点。（假设链表不带环）
{
    while (list1 && list1->next)
    {
        list1=list1->next;
    }
    while(list2 &&list2->next)
    {
        list2=list2->next;
    }
    if (list2==list1  && list1!=NULL)
    {
        return 1;
    }
    return 0;
}


面试题十四（2）：两个链表相交，求交点。

SListNode *SListEnterNode(SListNode* list1,SListNode* list2)//两个链表相交，求交点。
{
    SListNode *cur1=list1;
    SListNode *cur2=list2;
    int n1=0;
    int n2=0;
    while (cur1->next)
    {
        n1++;
        cur1=cur1->next;
    }
    while (cur2->next)
    {
        n2++;
        cur2=cur2->next;
    }
    cur1=list1;
    cur2=list2;
    if (n1-n2 >=0)
    {
        while (n1-n2!=0)
        {
            cur1=cur1->next;
            n1--;
        }
        while (cur1!=cur2)
        {
            cur1=cur1->next;
            cur2=cur2->next;
        }
    } 
    else
    {
        while (n2-n1!=0)
        {
            cur2=cur2->next;
            n2--;
        }
        while (cur1!=cur2)
        {
            cur1=cur1->next;
            cur2=cur2->next;
        }
    }
    return cur1;
}
测试代码：

void Test1()//1.从尾到头打印单链表
{ 
    SListNode *a=NULL;
    SListPushBack(&a,1);
    SListPushBack(&a,2);
    SListPushBack(&a,3);
    SListPushBack(&a,4);
    SListPushBack(&a,5);
    SListPrint(a);
    SLitsPrintTailToHead(a);//非递归 时间复杂度n平方
    SListPrintTailToHeadR(a);//递归
} 
void Test2()//2.删除一个无头单链表的非尾节点（不能遍历链表）
{
    SListNode *a=NULL;
    SListNode *pos=NULL;
    SListPushBack(&a,1);
    SListPushBack(&a,2);
    SListPushBack(&a,3);
    SListPushBack(&a,4);
    SListPushBack(&a,5);
    SListPrint(a);
    pos=SListFind(a,3);
    SListDelNonTailNode(pos);
    SListPrint(a);
}
void Test3()//3.在无头单链表的一个节点前插入一个节点（不能遍历链表）
{
    SListNode *a=NULL;
    SListNode *pos=NULL;
    SListPushBack(&a,1);
    SListPushBack(&a,2);
    SListPushBack(&a,3);
    SListPushBack(&a,4);
    SListPushBack(&a,5);
    SListPrint(a);
    pos=SListFind(a,3);
    SListInsertFrontNode(pos,8);
    SListPrint(a);
}
void Test4()//4.单链表实现约瑟夫环(JosephCircle)
{ 
    SListNode* list = NULL;
    SListNode* tail;
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);
    SListPushBack(&list, 4);
    SListPushBack(&list, 5);
 
    tail = SListFind(list, 5);
    tail->next = list;
 
    printf("最后的幸存者:%d\n", SListJosephCircle(list, 3)->data);
 
}
void Test5()//5.//逆置/反转单链表
{ 
    SListNode* list = NULL;
    SListNode* newList;
    SListPushBack(&list, 1);
    SListPushBack(&list, 2);
    SListPushBack(&list, 3);
    SListPushBack(&list, 4);
    SListPushBack(&list, 5);
 
    newList = SListReverse(list);
    SListPrint(newList);
 
}
void Test6()//6.单链表排序（冒泡排序&快速排序）
{ 
    SListNode* list = NULL;
    SListPushBack(&list, 1);
    SListPushBack(&list, 22);
    SListPushBack(&list, 33);
    SListPushBack(&list, 40);
    SListPushBack(&list, 5);
 
    SListBubbleSort(list);    
    SListPrint(list);
}
void Test7()//7.合并两个有序链表,合并后依然有序
{ 
    SListNode *a=NULL;
    SListNode *b=NULL;
    SListNode *c=NULL;
    SListPushBack(&a,1);
    SListPushBack(&a,2);
    SListPushBack(&a,3);
    SListPushBack(&a,4);
    SListPushBack(&a,5);
    SListPushBack(&a,7);
    SListPushBack(&a,9);
 
    SListPushBack(&b,2);
    SListPushBack(&b,2);
    SListPushBack(&b,3);
    SListPushBack(&b,4);
    SListPushBack(&b,5);
    c=SListMerge(a,b);
    SListPrint(c);
}
void Test8()//8.查找单链表的中间节点，要求只能遍历一次链表 
{ 
    SListNode *a=NULL;
    SListNode *b=NULL;
    SListPushBack(&a,1);
    SListPushBack(&a,2);
    SListPushBack(&a,3);
    SListPushBack(&a,4);
    SListPushBack(&a,5);
    b=SListFindMidNode(a);
    SListPrint(b);
}
void Test9()//9.查找单链表的倒数第k个节点，要求只能遍历一次链表 
{ 
    SListNode *a=NULL;
    SListNode *b=NULL;
    SListPushBack(&a,1);
    SListPushBack(&a,2);
    SListPushBack(&a,3);
    SListPushBack(&a,4);
    SListPushBack(&a,5);
    b=SListFindTailKNode(a,2);
    SListPrint(b);
}
void Test10()//10.删除链表的倒数第K个结点 
{
    SListNode *a=NULL;
    SListNode *b=NULL;
    SListPushBack(&a,1);
    SListPushBack(&a,2);
    SListPushBack(&a,3);
    SListPushBack(&a,4);
    SListPushBack(&a,5);
    SListFindPop(a,3);
    SListPrint(a);
}
void Test11_12_13()//11.判断是否带环 12.求环的长度 13。求环的入口点
{
    SListNode *a=NULL;
    SListNode *enter=NULL;
    SListNode *tail=NULL;
    SListNode *cur=NULL;
    SListPushBack(&a,1);
    SListPushBack(&a,2);
    SListPushBack(&a,3);
    SListPushBack(&a,4);
    SListPushBack(&a,5);
    tail=SListFind(a,5);//构建带环
    enter=SListFind(a,3);
    tail->next=enter;
    cur=SListIsCycle(a);
    printf("是否带环：%d\n",cur->data);
    printf("环长度为：%d\n",SListCycleLen(cur));
    printf("环入口点为:%d\n",SListCrossEntreNode(a,cur)->data);
}
void Test14()//14。判断两个链表是否相交，若相交，求交点。（假设链表不带环）
{
    SListNode *a,*b;
    SListNode *n1=BuySListNode(1);
    SListNode *n2=BuySListNode(2);
    SListNode *n3=BuySListNode(3);
    SListNode *n4=BuySListNode(4);
 
    a=BuySListNode(7);
    b=BuySListNode(8);
    n1->next=n2;
    n2->next=n3;
    n3->next=n4;
        a->next=b;
        b->next=n3;
        printf("是否带环：%d \n",SListIsCycle(a,n1));
        printf("环的入口点为：%d \n",SListEnterNode(a,n1)->data);
}


主函数：

int main()
{
    //Test1();
    //Test2();
    //Test3();
    //Test4();
    //Test5();
    //Test6();
    //Test7();
    //Test8();
    //Test9();
    //Test10();
    //Test11_12_13();
    Test14();
    system("pause");
    return 0;
}


如上就是经典面试题的解法。灵活应用，后续会继续更新。


 

南国小豆a
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言链表面试题(增强版)
zhaoxaun666的博客
02-07 2723
C语言诸多面试题，这里有常用的经典面试题，应用有多种算法，如替换法，快慢指针等等。 注：含有的有关头文件引用上一篇博客单链表的插与删，本篇文章不在写出。 面试题 一：从尾到头打印单链表。 /////// 1.从尾到头打印单链表 ////////// void SLitsPrintTailToHead(SListNode* pHead)//非递归算法(利用俩个指针一个定义到尾部p1，另一个
C语言版数据结构、算法与各类面试题，C99编译器。.zip
01-20
标题中的"C语言版数据结构、算法与各类面试题，C99编译器"提示了我们，这个压缩包包含的内容主要是关于C语言的数据结构、算法的学习资料，以及可能的面试题目，使用的编程环境是C99标准。这些知识点是计算机科学的...
C语言经典面试题 与 C语言面试宝典
热门推荐
开挂的熊猫
12-22 11万+
1 预处理 问题1：什么是预编译？何时需要预编译？ 答： 预编译又称预处理，是整个编译过程最先做的工作，即程序执行前的一些预处理工作。主要处理#开头的指令。如拷贝#include包含的文件代码、替换#define定义的宏、条件编译#if等。. 何时需要预编译： 1、总是使用不经常改动的大型代码体。 2、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的
C语言面试题大汇总之华为面试题
一缕阳光的博客
02-11 4760
该面试题大全可以很好地提高C++/C程序员的技术综合实力 1、局部变量能否和全局变量重名？ 　 　答：能，局部会屏蔽全局。要用全局变量，需要使用"::"  ;局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。对于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局部变量，而那个局部变量的作用域就在那
C语言面试题
JIWilliams
08-01 5万+
1 预处理 问题1：什么是预编译？何时需要预编译？ 答： 预编译又称预处理，是整个编译过程最先做的工作，即程序执行前的一些预处理工作。主要处理#开头的指令。如拷贝#include包含的文件代码、替换#define定义的宏、条件编译#if等。. 何时需要预编译： 1、总是使用不经常改动的大型代码体。 2、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，...
C语言经典面试题与C语言面试宝典
Xdong_Gui的博客
05-20 414
https://blog.csdn.net/qq_26093511/article/details/78874424
《求职》第一部分 - 语言篇 - C语言常见面试题
不问归期的博客
04-07 2289
1.变量 面试题1-1：变量的声明和定义有什么区别 为变量分配地址和存储空间的称为定义，不分配地址的称为声明。一个变量可以在多个地方声明，但只能在一个地方定义。加入extern修饰的是变量的声明，说明此变量将在文件以外或在文件后面部分定义。 说明：很多时候一个变量，只是声明，不分配内存空间，知道具体使用时才初始化，分配内存空间，如外部变量。 面试题1-2：a和 &a 有什么区别 主要目的是...
c语言面试题大全
PuRuiLing的博客
10-09 3727
C语言面试题大汇总 4. static有什么用途？（请至少说明两种） 1.限制变量的作用域(DL:使其只在定义的当前文件中起作用，static是只能由与变量在同一个文件中定义的程序存取的全局变量。也就是说使全局变量成为文件的私有变量，以致其他文件不可以通过将它们定义为extern而存取这些变量。) 2.设置变量的存储域（DL：存储在最开始的静态存储空间里面） 7. 引用与指针有什么
白盒测试c语言面试,【面经】C++面试题总结
weixin_29699041的博客
05-19 558
【求助怎么加目录】数据类型说明 C和C++的区别C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入进行运算处理得到输出。而对于C++，c++在c的基础上增添类，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出。如何理解封装、继承、多态封装封装可以隐藏实现细节，使得代码模块化；封装是把过程和数...
C语言面试题总结
kv110的专栏
06-15 617
1 预处理 问题1：什么是预编译？何时需要预编译？ 答： 预编译又称预处理，是整个编译过程最先做的工作，即程序执行前的一些预处理工作。主要处理#开头的指令。如拷贝#include包含的文件代码、替换#define定义的宏、条件编译#if等。. 何时需要预编译： 1、总是使用不经常改动的大型代码体。 2、程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下，可以将所有包含文件预编译为一个预编译头。 问题2：写一个“标准”宏，这个宏输入两个参数并返回较小的一个 答:#define
程序员面试题和面试宝典等资料
07-26
4. **C/C++面试题**：C++是C语言的扩展，增加了面向对象编程的概念，如类、对象、封装、继承、多态等。面试中可能会测试你对C++特性的理解，如模板、异常处理、STL（标准模板库）的使用，以及C++11及更高版本的新...
《数据结构》（C语言版）配书光盘
01-03
配书光盘通常包含与教材配套的资源，如源代码、练习题解答、教学课件等，以增强学习体验和理解。 在C语言中，数据结构是编程的核心概念之一，它涉及数组、链表、队列、栈、树、图等不同类型的结构。理解这些结构...
数据结构补充习题(C语言版）
09-09
在C语言中实现数据结构，可以深入理解底层操作，增强编程能力。本资料集是针对数据结构学习的一系列C语言版习题，旨在帮助学生巩固课堂所学，提升实践技能。 第7章“图”是数据结构中的一个重要章节，它涵盖了图的...
yolo-fastest.zip
07-28
yolo-fastest
mysql安装配置教程.pdf
最新发布
07-28
MySQL的安装配置教程可以细分为以下几个步骤，这里以Windows系统为例进行说明： 一、下载MySQL 1.访问MySQL官网： 1.前往MySQL的官方网站（https://www.mysql.com/）下载MySQL Community Server。 2.选择下载版本： 1.在官网的Downloads页面，选择“MySQL Community (GPL) Downloads”下的“MySQL Installer for Windows”。 2.跳过注册步骤，直接下载MySQL安装包。 二、安装MySQL 1.运行安装包： 1.找到下载好的MySQL安装包文件，双击运行。 2.选择安装类型： 1.在安装向导中，选择安装类型（通常建议选择“Custom”进行自定义安装）。 2.选择操作系统的位数（如64位），并勾选“Enable the Select Features...”等选项（如果提示缺少运行库，需要先安装相应的VC_redist）。 3.设置安装路径： 1.选择MySQL的安装路径和数据存储路径，建议将MySQL安装在非系统盘（如D盘）以避免潜在的问题。 4.设置密码：
基于transformers+pytorch实现非结构化商业文本信息中隐私信息识别python源码（比赛获奖项目）.zip
07-28
基于transformers+pytorch实现非结构化商业文本信息中隐私信息识别python源码（比赛获奖项目）.zip CCF大数据与计算智能大赛-非结构化商业文本信息中隐私信息识别方案 bert base + flat + crf + fgm + swa + pu learning策略 + clue数据集 = test1单模0.906 词向量：https://github.com/Embedding/Chinese-Word-Vectors SGNS(Mixed-large 综合) loss mask相关代码为pu learning策略的实现 主要模块版本 python 3.6.9 torch 1.1.0 transformers 3.0.2 pytorchcrf 1.2.0 torchcontrib 0.0.2 主要功能点 使用BERT base作为基础模型 采用flat结构进行命名实体识别 使用CRF层进行序列标注 采用对抗训练(FGM)和平滑权重平均(SWA)策略提高模型泛化能力 使用PU learning策略处理标注不全的数据 利用clue数据集进行训练
（verilog）基于MIPS指令集的单周期CPU设计
07-28
相关代码及Vivado项目工程文件
C语言编程面试题：合并有序表与链表操作
C语言编程笔试题大全涵盖了一系列经典的编程题目，旨在测试应聘者的C语言基础、算法理解和数据结构运用能力。以下是从给出的部分内容中提炼的知识点： 1. 合并有序线性表: - 这部分题目涉及到了数组或链表操作中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值