单链表的几道经典面试题（1）

最新推荐文章于 2023-04-04 17:25:32 发布
最新推荐文章于 2023-04-04 17:25:32 发布
阅读量207 收藏 1
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/L_X_Y_HH/article/details/79747396
版权

1. 从尾到头打印单链表
2.约瑟夫环问题
3. 单链表的逆置
4. 单链表的排序（冒泡法）
5. 合并两个有序单链表之后使新的单链表依旧有序
6. 查找单链表的中间节点，且只能遍历一次链表
7.查找单链表的倒数第K个节点
8. 删除倒数第k个节点

从尾到头打印单链表

这道题的思路是要运用递归来实现 
   407 //逆置打印链表
   408 #include <stdio.h>
   409 void LinkListPrintReverse(LinkNode* head)
   410 {
   411     if(head == NULL)
   412     {
   413         //空链表                                                                                       
   414         return ;
   415     }
   416     //运用递归
   417     LinkListPrintReverse(head->next);
   418     printf("%c",head->data);
   419 }

约瑟夫环问题

约瑟夫环问题是指：已知n个人（以编号1，2，3，...，n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的人出列；他的下一个人又开始从1开始报数，数到m的人出列；依次规律重复下去，直至圆桌周围的人全部出列，只剩下一个人。 
   421 //约瑟夫环
   422 LinkNode* JosphCricle(LinkNode* head,int M)    
   423 {
   424     if(head == NULL)
   425     {                                                                                                    
   426         //空链表
   427         return NULL;
   428     }
   429     LinkNode* cur=head;
   430     while(cur->next!=cur)
   431     {
   432         int i=1;
   433         for(;i<M;++i)
   434         {
   435             cur=cur->next;
   436         }
   437         //cur指向的元素就是要被吃掉的元素
   438         printf("%c\n",cur->data);
   439         cur->data=cur->next->data;
   440         LinkNode* to_delete=cur->next;
   441         cur->next=to_delete->next;
   442         DestroyNode(to_delete);
   443     }                                                                                                  
   444     return cur;
   445 }


单链表的逆置

方法一：（推荐使用）


  447 //链表逆置
   448 void LinkListReverse(LinkNode** phead)
   449 {
   450     if(phead == NULL)                                                                                  
   451     {
   452         //非法输入
   453         return;
   454     }
   455     if(*phead == NULL)
   456     {
   457         //空链表
   458         return ;
   459     }
   460     if((*phead)->next == NULL)
   461     {
   462         //只有一个元素                                                                                 
   463         return ;
   464     }
   465     LinkNode* cur=*phead;
   466     while(cur->next!=NULL)
   467     {
   468         LinkNode* to_delete=cur->next;
   469         //把这个节点删除掉
   470         cur->next=to_delete->next;
   471         //把删除掉的元素插入到链表头部
   472         to_delete->next=*phead;
   473         *phead=to_delete;
   474     }
   475     return ;                                                                                           
   476 }

方法二： 
   479 void LinkListReverse2(LinkNode** phead)
   480 {
   481     if(phead == NULL)
   482     {
   483         //非法输入                                                                                     
   484         return ;
   485     }
   486     if(*phead == NULL)
   487     {
   488         //空链表
   489         return ;
   490     }
   491     if((*phead)->next==NULL)
   492     {
   493         //只有一个元素                                                                                 
   494         return ;
   495     }
   496     LinkNode* cur=(*phead)->next;
   497     LinkNode* pre=(*phead);
   498     while(cur!=NULL)
   499     {
   500         LinkNode* next=cur->next;
   501         //修改cur->next指针的指向
   502         cur->next=pre;
   503         //交换pre cur指针                                                                              
   504         pre=cur;
   505         cur=cur->next;
   506     }
   507     //修改头指针指向
   508     *phead=pre;
   509 }

单链表的排序（冒泡法） 
   511 //交换两个值
   512 void Swap(LinkNodeType* a,LinkNodeType* b)
   513 {
   514     LinkNodeType tmp=*a;
   515     *a=*b;                                                                                             
   516     *b=tmp;
   517 }

   518 //对单链表进行排序（冒泡法）
   519 void LinkListBubbleSort(LinkNode* head)
   520 {
   521     if(head == NULL)
   522     {
   523         //空链表
   524         return ;                                                                                       
   525     }
   526     if(head->next = NULL)
   527     {
   528         //只有一个节点
   529         return;
  530     }
   531     LinkNode* count=head;
   532     LinkNode* tail=NULL;//结束标记
   533     //第一重循环表示排序的趟数
   534     for(;count!=NULL;count=count->next)
   535     {                                                                                                  
   536         LinkNode* cur=head;
   537         //第二重循环表示保证将当前最大值冒到最后
   538         for(;cur->next!=tail;cur=cur->next)
   539         {
   540             if(cur->data>cur->next->data)
   541             {
   542                 Swap(&cur->data,&cur->next->data);
   543             }
   544         }
   545         tail=cur;
   546     }                                                                                                  
   547     return ;
   548 }

合并两个有序单链表之后使新的单链表依旧有序
比较cur1和cur2的大小，将较小的放入新链表的new_head中 

   550 //合并两个有序链表并且之后依旧有序
   551 LinkNode* LinkListMerge(LinkNode* head1,LinkNode* head2)
   552 {
   553     if(head1 == NULL)                                                                                  
   554     {
   555         return head2;
   556     }
   557     if(head2 == NULL)
   558     {
   559         return head1;
   560     }
   561     LinkNode* cur1=head1;
   562     LinkNode* cur2=head2;
   563     //用来指向新链表的头结点和尾节点
   564     LinkNode* new_head=NULL;
   565     LinkNode* new_tail=NULL;
   566     while(cur1=NULL&&cur2!=NULL)                                                                       
   567     {
   568         if(cur1->data<cur2->data)
   569         {
   570             if(new_tail == NULL)
   571             {
   572                 new_tail=new_tail=cur1;
   573             }
   574             else
   575             {
   576                 new_tail->next=cur1;                                                                   
   577                 new_tail=new_tail->next;
   578             }
   579             cur1=cur1->next;
   580         }
   581         else if(cur1->data>cur1->data)
   582         {
   583             if(new_tail == NULL)
   584             {
   585                 new_tail=new_tail=cur2;
   586             }
   587             else                                                                                       
   588             {
   589                 new_tail->next=cur2;
   590                 new_tail-new_tail->next;
   591             }
   592         }
   593     }
   594     //有一方已经先到达结尾，要将剩余部分接到新的链表之后
   595     if(cur1=NULL)
   596     {
   597         new_tail->next=cur1;
   598     }                                                                                                  
   599     else
   600     {
   601         new_tail->next=cur2;
   602     }
   603     return new_head;
   604 }

查找单链表的中间节点，且只能遍历一次链表
定义两个指针分别是fast和slow，开始都指向链表头部，让fast指针一次走两步，slow指针一次走一步，这样当fast指针走到链表结尾时，slow指针刚好走到链表中间节点的位置。 

   606 //查找单链表的中间节点，只能遍历一次链表
   607 LinkNode* LinkListFindMidNode(LinkNode* head)
   608 {
   609     if(head == NULL)
   610     {
   611         //空链表
   612         return ;                                                                                       
   613     }
   614     LinkNode* slow=head;
   615     LinkNode* fast=head;
   616     while(fast!=NULL&&fast->next!=NULL)
   617     {
   618         slow=slow->next;
   619         fast=fast->next->next;
   620     }
   621     return slow;
   622 }

查找链表的倒数第k个节点
方法同上一个问题，定义两个指针，fast和slow，让fast指针先走k步，然后再一起出发，都一次走一步，当fast指针走到结尾，则slow指针指向的就是倒数第k个节点。 
   624 //查找链表的倒数第k个节点
   625 LinkNode* LinkListFindLastKNode(LinkNode* head,int k)
   626 {
   627     if(head == NULL)
   628     {
   629         //空链表                                                                                       
   630         return ;
   631     }
   632     LinkNode* fast=head;
   633     LinkNode* slow=head;
   634     //让fast先走k步
   635     int i=0;
   636     for(;i<k;++i)
   637     {
   638         if(fast==NULL)
   639         {
   640             break;                                                                                     
   641         }
   642         fast=fast->next;
   643     }
   644     if(i!=NULL)
   645     {
   646         //没走完，k的数值超过链表长度
   647         return NULL;
   648     }
   649     while(fast!=NULL)
   650     {
   651         fast=fast->next;                                                                               
   652         slow=slow->next;
   653     }
   654     return slow;
   655 }

删除倒数第k个节点 
   657 //删除倒数第k个节点
   658 void LinkListEraseLastKNode(LinkNode** phead,int k)                                                    
   659 {
   660     if(phead == NULL)
   661     {
   662         //非法输入
   663         return ;
   664     }
   665     if(*phead == NULL)
   666     {
   667         //空链表
   668         return ;
   669     }
   670     int len=LinkListSize(*phead);                                                                      
   671     if(k>len)
   672     {
   673         return ;
   674     }
   675     if(k == len)
   676     {
   677         //要删除的元素为第一个
   678         LinkNode* to_delete=*phead;
   679         *phead=(*phead)->next;
   680         DestroyNode(to_delete);
   681         return ;
   682     }                                                                                                  
   683     LinkNode* pre=*phead;
   684     int i=0;
   685     for(;i<len-(k+1);++i)
   686     {
   687         pre=pre->next;
   688     }
   689     //循环结束后意味着pre已指向要删除元素的前一个节点
   690     LinkNode* to_delete=pre->next;
   691     pre->next=to_delete->next;
   692     DestroyNode(to_delete);
   693     return ;                                                                                           
   694 }

L_X_Y_HH
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
逆置反转单链表
Hyacinth_Dy
07-16 600
定义一个函数，输入一个链表的头节点，反转链表反转链表并输出反转后的链表头节点。
【经典面试题】单链表的常见面试题
01-20
文章目录求单链表中有效节点的个数查找单链表中倒数第k个节点【新浪面试题】单链表的反转【腾讯面试题】从尾到头打印单链表【百度面试题，要求方式1：反向遍历。方式2：Stack栈】 单链表的常见面试题有如下： 1.求...
【单链表面试题】--------链表的逆置
zhangye3017的博客
12-29 271
逆置单链表 两种方法 1）利用头插法，和前面讲述的从尾到头是一个道理，不在做详细研究 2）三个指针翻转（具体过程如下图） 代码：/*三个指针*/ SListNode* ReverseList(SListNode* pHead) { SListNode* n1, *n2, *n3; if (pHead == NULL || pHead->_next == NULL)
逆序打印单链表
liru_1996的博客
03-31 232
从尾到头打印单链表。 分析：利用递归的思想，依次访问到每一个结点，递归的出口为NULL. 然后依次打印就能逆序得出链表。 代码如下： void LinkListReversePrint(LinkNode* head) { if(head == NULL) { //空链表 return; }else{ LinkListReversePrint(head->next);
数据结构（二）：链表及面试常考的算法
bb8886的博客
04-04 193
链表及面试题
链表经典练习题
qq_40754866的博客
11-19 331
转载：链表经典练习题 一、从尾到头打印单链表 因为单链表是有指向的，前一节点只能指向下一节点，因此为了实现从尾到头打印链表可以使用一种非常简单的方法就是递归，先遍历再输出。 代码实现： void LinkListReversePrint(LinkNode* head){ 85 if(head == NULL){ 86 return;//空链表 87 } 88 LinkListReversePrint(head -> next);
算法大全面试题数据结构单链表的13道面试题含代码
最新发布
12-17
本篇将详细探讨单链表相关的13道面试题，涵盖其基本操作、查找、反转等重要知识点。 1. **单链表反转**：单链表反转是一项常见的算法题目，主要考察对链表节点操作的理解。通过改变节点间的指向关系，将原链表的...
C++经典面试题1.pdf
10-10
在C++编程语言中，面试题常常涉及到对语言特性的理解和应用，如对象构造与析构、内存管理以及数据结构的处理。以下是对题目中提到的一些知识点的详细解释： 1. **构造函数与析构函数**： - 构造函数在创建对象时被...
力扣面试经典150题力扣面试经典150题
11-21
在LeetCode中，面试经典150题主要分为以下几个类别： 1. **数组**：数组是最基础的数据结构，涉及到的问题包括数组排序、查找、旋转等。例如，你可以遇到经典的“两数之和”问题，要求在给定数组中找到两个数，使得...
超经典C面试题
04-06
本篇将详细解析"超经典C面试题"中可能涉及的关键知识点，帮助面试者更好地准备。 1. **基本语法与类型系统** - **变量声明**：理解各种基本类型如int, char, float, double的内存占用及取值范围。 - **指针操作**...
数据结构 单链表相关习题练习
雪碧柠七的博客
05-10 6466
1.逆序打印单链表采用递归的方法即可实现。//逆序打印单链表 void LinkListReversePrint(LinkNode* head) { if(head == NULL) { return; } LinkListReversePrint(head-&gt;next); printf("[%c] ",head-&gt;...
数据结构---链表的基本知识
weixin_46666517的博客
10-08 755
链表的基本概念 struct ListNode { int num; ListNode *next; }; 链表的基本操作 输出链表 void printList(ListNode *head){ ListNode *p=head; while(p!=NULL) { cout<<p->num<<endl;//这个可以改变 p=p->next; } } 遍历链表并且查找元素 ListNode *Locate(ListNode *hea
【单链表算法】设带头结点的非空单链表 L，设计一个算法删除 L 中奇数序号 的结点，即删除 L 中第 1、3、5…结点。
weixin_45963815的博客
04-02 4842
【单链表算法】设带头结点的非空单链表 L，设计一个算法删除 L 中奇数序号 的结点，即删除 L 中第 1、3、5…结点。 #include<stdio.h> #include<malloc.h> typedef struct node { int data; struct node* next; }node; // 定义结构体 node* creat(int l...
四道有趣的单链表面试题（单链表反序、找出链表的中间元素、链表排序、判断一个单链表是否有环）
行走的天马
03-15 1019
参考：http://blog.sina.com.cn/s/blog_725dd1010100tr4y.html 四道有趣的单链表面试题（单链表反序、找出链表的中间元素、链表排序、判断一个单链表是否有环） 以下给出链表结点的数据结构： template struct LinkNode{   //链表节点 T data; LinkNode* link; LinkNode(LinkNod
删除单链表中的指定节点
Jeff_的博客
09-05 4万+
题目1： 编写在带头结点的单链表L中删除一个最小值结点的高效算法（假设最小值结点是唯一的）。时间复杂度为O(n)，空间复杂度为O(1)。 问题解答： 算法思想：用p从头至尾扫描单链表，pre指向*p结点的前驱，用minp保存值最小的结点指针（初值为p），minpre指向*minp结点的前驱（初值为pre）。一边扫描，一边比较，若p-&gt;dafa小于minp-&gt;dara，则将p、pr...
单链表的逆置（头插法和就地逆置）
热门推荐
摩尔的博客
05-23 7万+
今天课间的时候偶然看到了一个面试题：单链表的逆置，看了题解感觉乖乖的，貌似和以前看的版本不搭，于是重新进行了一番探究 单链表的逆置分为两种方法：头插法和就地逆置法，这两种方法虽然都能够达到逆置的效果，但还是有着不小的差别头插法算法思路：依次取原链表中的每一个节点，将其作为第一个节点插入到新链表中，指针用来指向当前节点，p为空时结束。 核心代码void reverse(node*head) {
数据结构之带头结点单链表面试题public int getLength(Node head){ if (head.next == null){ return 0
mly15191882818的博客
08-04 817
一、得到链表中的有效节点个数，不包括头节点。 这个题较简单，不啰嗦直接上代码： public int getLength(Node head){ if (head.next == null){ return 0; } //链表中的第一个节点 Node cur = head.next; int count = 0; while (cur != null){ co
链表常见笔试题
liru_1996的博客
04-09 965
声明： typedef char LinkNodeType; typedef struct LinkNode { LinkNodeType data; struct LinkNode* next; }LinkNode; 1.逆序打印单链表 分析：应用递归的思想，遍历链表，递归出口为head==NULL，代码如下： void LinkListReversePrint(LinkNo
数据结构与算法之单链表
Happy_Boy_z的博客
01-04 956
链表链表的介绍单链表(带头节点)添加（创建） 链表的介绍 链表是有序的列表，它在内存中的存储如下 链表是以节点的方式来存储，是链式存储 每个节点包含data域，next域：指向下一个节点 如图: 发现链表的个个节点不一定是连续存储 链表分带头节点的链表和没有头结点的链表，根据需求来确定 单链表(带头节点) 使用一个带head头的单向链表实现排行榜管理 完成对英雄人物的增删改查操作 ...
经典算法题：链表操作与面试必备
"算法和面试题相关的知识点，主要涉及单链表操作，包括反转、查找特定位置元素、中间元素、删除节点、合并链表、处理二级链表、交换元素、检测环、判断链表相交等。" 单链表是数据结构中的基本元素，它由一系列节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值