基础数据结构之单链表常见面试题（单链表逆置，判断两个单链表是否存在交点，判断单链表是否存在环）

已于 2022-11-04 07:58:40 修改
阅读量145 收藏
点赞数
分类专栏： 基础数据结构 c语言 文章标签： 数据结构 链表 c语言 链表
于 2022-10-28 21:37:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55703811/article/details/127563418
版权

文章目录

一、单链表的逆置（两种方法）

1.无限头插法（简单）

这里所写代码都是带头结点的

首先我们来演示什么是无限头插法

1）首先断开头结点，并设立两个指针，指针p和指针q,指针p指向plist->next,
指针q指向p->next,（这里的思路可以参照之前写过的单链表销毁2）
在这里插入图片描述

2）将头节点后面的节点依次头插到头结点后面，具体步骤看下图演示
在这里插入图片描述

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
以此类推，就可以将链表完全逆置了

其次我们进行代码的实现

单链表基本操作

#include<stdio.h>
#include <cassert>
#include <stdlib.h>

typedef int ELEM_TYPE;

typedef struct Node {
	ELEM_TYPE data;//数据域（保存数据的有效值）
	struct Node* next;//指针域（保存下一个有效结点的地址）
}Node,*PNode;

//初始化
void Init_list(struct Node* plist) {
	assert(plist !=NULL);
	plist->next = NULL;
}

//按位置插
bool Insert_pos(PNode plist, int pos, ELEM_TYPE val) {
	assert(plist != NULL);
	//assert(pos >= 0 && pos <=Getlength(plist));
	struct Node* pnewnode = (struct Node*)malloc(1 * sizeof(struct Node));
	pnewnode->data = val;
	struct Node* p = plist;
	for (int i = 0; i < pos; i++) {
		p = p->next;
	}
	pnewnode->next = p->next;
	p->next = pnewnode;
	return true;
}

//打印
void Show(PNode plist) {
	assert(plist != NULL);
	struct Node* p = plist->next;
	for (; p != NULL; p = p->next) {
		printf("%d ",p->data);
	}
	printf("\n");
}

核心代码


//方法一，无限头插  如果需要逆置，至少需要存在两个节点
void Resver1(struct Node* plist) {
	assert(plist != NULL);
	int length = Getlength(plist);
	if (length < 2) {
		return;
	}

	//1.申请两个指针p和q 分别指向第一个有效节点和第二个有效节点
	struct Node* p = plist->next;
	struct Node* q = p->next;

	//2.断开头结点
	plist->next = NULL;

	//通过p和q的搭配，将所有节点依次头插进来
	while (p!=NULL) {
		q=p->next;
		p->next = plist->next;
		plist->next = p;
		p = q;
	}
}

测试代码

int main(){
    struct Node head;
	Init_list(&head);
	for (int i = 0; i <10; i++) {
		Insert_pos(&head, i, i + 1);
	}
	Show(&head);

	Resver1(&head);
	Show(&head);
}

运行结果
在这里插入图片描述

2.利用三个指针（较难）

图示法演示具体操作

这个方法较上一个方法有些难度
1）设置三个指针，并断开头结点，将p设置为空
在这里插入图片描述
2）q的指针域保存p的地址，从而将箭头反转
在这里插入图片描述
3）p=q; q=r; 从而实现指针的反复利用
在这里插入图片描述
4）将头结点插入到p节点后面

在这里插入图片描述
思考：这个循环截至条件是什么？ 答：我们知道在p节点之后还要插入头结点，所以p指针是不能指向空的，此时只有当q为空时，循环才会结束

代码实现

单链表具体操作

#include<stdio.h>
#include <cassert>
#include <stdlib.h>

typedef int ELEM_TYPE;

typedef struct Node {
	ELEM_TYPE data;//数据域（保存数据的有效值）
	struct Node* next;//指针域（保存下一个有效结点的地址）
}Node,*PNode;

//初始化
void Init_list(struct Node* plist) {
	assert(plist !=NULL);
	plist->next = NULL;
}

//按位置插
bool Insert_pos(PNode plist, int pos, ELEM_TYPE val) {
	assert(plist != NULL);
	//assert(pos >= 0 && pos <=Getlength(plist));
	struct Node* pnewnode = (struct Node*)malloc(1 * sizeof(struct Node));
	pnewnode->data = val;
	struct Node* p = plist;
	for (int i = 0; i < pos; i++) {
		p = p->next;
	}
	pnewnode->next = p->next;
	p->next = pnewnode;
	return true;
}

//打印
void Show(PNode plist) {
	assert(plist != NULL);
	struct Node* p = plist->next;
	for (; p != NULL; p = p->next) {
		printf("%d ",p->data);
	}
	printf("\n");
}

核心代码


//第二种方法 三个指针
void Reserve2(PNode plist) {
	assert(plist != NULL);
	int length = Getlength(plist);
	if (length < 2) {
		return;
	}
	struct Node* p = plist->next;
	struct Node* q = p->next;
	struct Node* r ;
	p->next = NULL; //第一步操作
	while (q != NULL) {  
		r=q->next;
		q->next = p; //第二步操作
		p = q;     //第三步操作
		q = r;
	}
	plist->next = p;  //第四步操作
}

测试代码

int main(){
	
	struct Node head;
	Init_list(&head);
	for (int i = 0; i <10; i++) {
		Insert_pos(&head, i, i + 1);
	}
	Show(&head);

	Resver1(&head);
	Show(&head);
	
	Reserve2(&head);
	Show(&head);	
}

测试结果
在这里插入图片描述

二、如何判断两个链表是否存在交点，如果存在，则返回第一个相交点（中等难度）

在这里插入图片描述

1）这道题的思路是：尾结点相同，即两个单链表相交，所以我们需要定义两个指针p和q分别指向单链表头结点的下一个节点，然后遍历到最后一个节点。

2）但是我们又该如何判断相交点在哪里呢？我们这里要注意到一个问题是两个单链表的长度有可能不相同，所以我们应该将长度较长的单链表先进行遍历，遍历的长度为他们之间链表长度的差值，然后同时向后遍历，直到两个节点相同
由于这道题思路较为简单，于是我们直接进行代码的实现
单链表基本操作

#include<stdio.h>
#include <cassert>
#include <stdlib.h>

typedef int ELEM_TYPE;

typedef struct Node {
	ELEM_TYPE data;//数据域（保存数据的有效值）
	struct Node* next;//指针域（保存下一个有效结点的地址）
}Node,*PNode;

//初始化
void Init_list(struct Node* plist) {
	assert(plist !=NULL);
	plist->next = NULL;
}

//按位置插
bool Insert_pos(PNode plist, int pos, ELEM_TYPE val) {
	assert(plist != NULL);
	//assert(pos >= 0 && pos <=Getlength(plist));
	struct Node* pnewnode = (struct Node*)malloc(1 * sizeof(struct Node));
	pnewnode->data = val;
	struct Node* p = plist;
	for (int i = 0; i < pos; i++) {
		p = p->next;
	}
	pnewnode->next = p->next;
	p->next = pnewnode;
	return true;
}

//打印
void Show(PNode plist) {
	assert(plist != NULL);
	struct Node* p = plist->next;
	for (; p != NULL; p = p->next) {
		printf("%d ",p->data);
	}
	printf("\n");
}

核心代码

struct Node* Intersection(struct Node *plist1,struct Node* plist2) {
	//0.安全性处理
	assert(plist1 != NULL&&plist2!=NULL);
	
	//1.定义两个指针，让它们分别走到到最后的节点处，判断是否相交
	struct Node* p = plist1->next;
	struct Node* q = plist2->next;
	for (; p != NULL; p = p->next);
	for (; q != NULL; q = q->next);
	if (p== q) {
		printf("存在交点\n");
	}
	
	//3，找到相交点
	int len1 = Getlength(plist1);
	int len2 = Getlength(plist2);
	struct Node* m = (len1 > len2) ? plist1 : plist2;//将较为长的单链表给plist1
	struct Node* n = (len1 > len2) ? plist2 : plist1;//将较为短的链表给plist2
	
	//4.让两链表起始长度相同，abs库函数，意思为：|len1-len2|
	for (int i = 0; i < abs(len1-len2); i++) {
		m = m->next;
	}
	
	//5.找到相交点
	while (m != n) {
		m = m->next;
		n = n->next;
	}
	return m;
}

测试代码

int main(){
	struct Node head1, head2;
	Init_list(&head1);
	for (int i = 0; i < 10; i++) {
		Insert_pos(&head1, i, i + 1);
	}
	Show(&head1);

	Init_list(&head2);
	for (int i = 0; i <=15; i++) {
		Insert_pos(&head2, i,i+11);
	}
	Show(&head2);

  //将两个单链表手动相交
	struct Node* p = &head2;
	for (int i = 0; i < 12; i++) {
		p = p->next;
	}
	struct Node* q = &head1;
	for (int i = 0; i < 7; i++) {
		q = q->next;
	}
	
	p->next = q->next;
	Show(&head1);
	Show(&head2);
	
	struct Node* tem= Intersection(&head1, &head2);
	printf("%d", tem->data);
	
}

运行结果
在这里插入图片描述

三、判断一个单链表是否存在环，如果存在环，则找到如环点（较难）

画图演示

在这里插入图片描述
那我们如何发现此单链表存在环呢？根据快慢指针，我们知道，如果存在环，则当快慢指针都进入环的时候，一定会在环内相遇，而当不存在环的时候，快指针在遇到NULL时，直接退出，循环结束就可以了

在这里插入图片描述
由上图可知：我们最终的得出结论，让相遇处的结点与起始点的结点同时出发，这样当两节点相同时，便是入口处的节点

代码实现

单链表基本操作

#include<stdio.h>
#include <cassert>
#include <stdlib.h>

typedef int ELEM_TYPE;

typedef struct Node {
	ELEM_TYPE data;//数据域（保存数据的有效值）
	struct Node* next;//指针域（保存下一个有效结点的地址）
}Node,*PNode;

//初始化
void Init_list(struct Node* plist) {
	assert(plist !=NULL);
	plist->next = NULL;
}

//按位置插
bool Insert_pos(PNode plist, int pos, ELEM_TYPE val) {
	assert(plist != NULL);
	//assert(pos >= 0 && pos <=Getlength(plist));
	struct Node* pnewnode = (struct Node*)malloc(1 * sizeof(struct Node));
	pnewnode->data = val;
	struct Node* p = plist;
	for (int i = 0; i < pos; i++) {
		p = p->next;
	}
	pnewnode->next = p->next;
	p->next = pnewnode;
	return true;
}
//判空
bool IsEmpty(PNode plist) {
	if (plist->next == NULL) {
		return true;
	}
	return false;
}

核心代码

struct Node* Ring(struct Node* plist) {
	//.安全性处理
	assert(plist != NULL);
	if (IsEmpty(plist)) {
		return NULL;
	}
	//1.定义两个快慢指针，快指针一次走两步，慢指针一次走一步
	struct Node* fast = plist;
	struct Node* slow = plist;
	slow = slow->next;
	fast = fast->next;
	if (fast != NULL) { //进行安全性处理
		fast = fast->next;
	}
	//2.同步向后走
	while (fast != slow && fast != NULL) {
		slow = slow->next;
		fast = fast->next;
		if (fast != NULL) { //进行安全性处理
			fast = fast->next;
		}
	}
	if (fast == NULL) {
		return NULL;
	}
	else {
		printf("存在入环点\n");
	}
	//如果if没有进去，则代表有环，找到入环点
	struct Node* p = plist;
	while (fast != p) {
		fast = fast->next;
		p = p->next;
	}
	return p;
}

测试代码

int main(){
    //1.插入数据
	struct Node head;
	Init_list(&head);
	for (int i = 0; i < 10; i++) {
		Insert_pos(&head, i, i + 1);
	}
	//2.手动给单链表设置一个入环点
	struct Node* q = &head;
	for (int i = 0; i < 10; i++) {
		q = q->next;
	}
	struct Node* p = &head;
	for (int i = 0; i < 6; i++) {
		p = p->next;
	}

	q->next = p;

   //3.测试入环点的数据
	struct Node* tem =  Ring(&head);
	printf("%d", tem->data);

四、单链表给一个随机节点的地址，如何在o(1)时间内删除这个节点（不能是尾结点）（简单）

思路：我们知道了这个节点的地址，但是由于是单链表，我们不清楚头结点在哪里，因此我们始终无法找到当前待删除节点的上一个节点，所以我们只能进行替换的方法，就是将待删除节点的下一个节点的数据域给到待删除节点，然后删除待删除节点的下一个节点
核心代码

bool Del_Node(struct Node* del_node) {
	assert(del_node != NULL);
	//狸猫换太子
	if (del_node->next == NULL) {//狸猫得存在
		return false;
	}
	del_node->data = del_node->next->data; //将狸猫化妆为太子
	struct Node* p = del_node->next; //让p指向狸猫
	del_node->next = p->next;  //跨越指向
	free(p);  //释放待删除节点
	return true;
}
淡蓝色的经典
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
逆置反转单链表
Hyacinth_Dy
07-16 612
定义一个函数，输入一个链表的头节点，反转链表反转链表并输出反转后的链表头节点。
链表面试题-逆置单链表和逆序打印单链表
Maple的博客
03-13 571
先来讨论逆序打印的问题： 逆序打印： 所谓逆序打印，就是先打印整个链表的最后一个节点，故此可以使用一个栈，只要节点存在就一直入栈，当所有的节点都入栈后，此时最后一个节点就在栈顶了，然后一次pop()即可。 代码实现： void PrintTailToHead(Node* Head) { if(Head == NULL) return； stack&...
面试高频题：单链表的逆置操作/链表逆序
聚精会神搞建设
07-29 1941
函数内修改的是实参的副本。要想在函数内部修改输入参数，要么传入的是实参的引用，要么传入的是实参的地址。
链表面试题之单链表逆置
zy20150613的博客
02-26 300
题目：反转一个单链表 链表结构如下： struct ListNode { int val; struct ListNode *next; }; 方法一： 算法思想：用三个指针 n1 , n2 , n3  起初，n1指向头head，n2指向第二个结点，n3指向第三个结点；先让n1的next指向空，循环判断n2是否为空，让n2头插到n1后面（n2-&gt;next = n1），再挪动指...
数据结构---链表经典面试题之逆置/反转单链表
IT_xiaoye的博客
03-28 451
题目：将单链表整个逆置，相当于产生了一个新链表，不只是逆序打印那么简单 方法一：从头节点开始，将下一个节点移除，将其插入到链表头部，循环下去，直到链表的最后一个节点插入到头部 - 代码实现： 290 LinkNode* LinkListReverseOne(LinkNode* head) ...
数据结构与算法面试题80道
m0_54854484的博客
05-27 8783
1.把二元查找树转变成排序的双向链表 题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 10 / \ 6 14 / \ / \ 4 8 12 16 转换成双向链表 4=6=8=10=12=14=16。 首先我们定义的二元查找树 节点的数据结构如下： struct BSTreeNode{int m_nValue; // value of nodeBSTreeNode *m_pLeft; // left child of nodeBSTreeNo
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6696
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
单链表的实现和相关面试题及其详解（C语言）
半暖的博客
08-02 509
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的链接次序实现的 链表 链表 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。 每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。
数据结构+算法面试100题
2301_78102191的博客
06-17 2123
他们决定这么分： 抽签决定自己的号码（1、2、3、4、5） 首先，由1号提出分配方案，然后大家表决，当且仅当超过半数的人同意时， 按照他的方案进行分配，否则将被扔进大海喂鲨鱼 如果1号死后，再由2号提出分配方案，然后剩下的4人进行表决， 当且仅当超过半数的人同意时，按照他的方案进行分配，否则将被扔入大海喂鲨鱼。那就， 连续来几组微软公司的面试题，让你一次爽个够： ====================== 97.第1组微软较简单的算法面试题 1.编写反转字符串的程序，要求优化速度、优化空间。
面试题5：实现单链表的逆置
taotaoahui
10-02 633
node *reverse(node *head) // 单链表的逆置 { printf("\n单链表的逆置\n"); if(head == NULL || head->next == NULL) return head; node *p1, *p2, *p3; p1 = head; p2 = p1->next; while(p2) { p3 = p2->next; p2
单链表逆置
f__yuan的博客
07-27 683
单链表的逆置是一个经常被问到的面试题，也是一个非常基础的问题。比如一个链表是这样的：1->2->3->4->5通过逆置后成为5->4->3->2->1。 指路：单链表的插入、删除。 最容易想到的方法是遍历一遍链表，利用一个辅助指针，存储遍历过程中当前指针指向的下一个元素，然后将当前节点元素的指针反转后，利用已经存储的指针往后面继续遍历。 首先...
程序员面试题准备(1)单链表逆置
weixin_30851867的博客
07-17 111
面试中程序测试，单链表的操作应该是比较容易出现的。单链表的一般操作，比如创建、遍历、插入、删除、清空等常规操作应该是必须掌握的操作，那么程序员面试中可能会出现“非常规”的链表操作，比如链表逆置。 由分析可知，长度为N的链表逆置需循环N次，每次循环将当前结点的Next指针保存，改变当前结点的Next指针指向前一指针（在上一次循环中保存）。 程序参考链接：http://shijuanfeng.bl...
记录：一道单链表逆置题（智商真的不够用，没救了）
qq_34785454的博客
03-14 125
大佬们发来这样一道面试题，三行三句代码，完成单链表逆置功能。 一开始我的想法，是在reverse(Node head)这个方法里递归，在后一个reverse方法里完成具体逆置操作。 于是在后一个reverse方法里，我是这么写的： Node newNode = next.node; next.node = cur; 这样就完成了单个节点的逆置 但是在第一个reverse方法里，反复试了好几次递...
【Weiss】【第03章】练习3.12：单链表倒置
weixin_30376163的博客
03-18 92
【练习3.12】 a.编写一个非递归过程以O(N)时间反转单链表。 b.使用常数附加空间编写一个过程以O(N)时间反转单链表。 Answer: 这题的b貌似没啥意义，在a小题里直接用头插法，不断地将头节点后移， 并将当前头节点所在的节点的后继指针指回前驱就能倒置链表了，不需要额外的空间。 所以就写了a。 测试代码： 1 #include <iost...
高频面试题之链表专题-逆置一个单链表
aiqq136的博客
05-27 259
逆置一个单链表 OJ链接：https://leetcode-cn.com/problems/reverse-linked-list/description/ 高频考察的大厂云图 题目:给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 示例 2： 输入：head = [1,2] 输出：[2,1] 示例 3： 输入：head = [] 输出：[] 提示： ...
树、二叉树
最新发布
2301_79909332的博客
08-30 118
1、满二叉树：满二叉树是一种特殊的二叉树，其中每个层级的节点数都是最大值，即每个层级都是完全填充的。深度： 从根节点出发到达节点的分支节点个数称为该节点的深度。高度：从叶子节点出发到该节点最大的节点个数称为该节点的高度。树的高度：整个树形结构中高度最高的节点的高度称为树的高度。树的深度：整个树形结构中深度最深的节点的深度称为树的深度。3、二叉树特点：叶子节点、只有左孩子、只有右孩子、左右孩子都有。树的层数 == 树的高度 == 树的深度。3.叶子节点：没有后继的节点。节点的度： 叶子节点度数为0。
【数据结构】—— 树和二叉树
mist的博客
08-26 1515
树和二叉树、堆（顺序结构）、二叉树链式结构
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1121
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1224
KMP算法：理解next[]表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

淡蓝色的经典

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

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

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

打赏作者

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

抵扣说明：

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

余额充值