链表常见的笔试题

最新推荐文章于 2023-05-02 23:19:22 发布
最新推荐文章于 2023-05-02 23:19:22 发布
阅读量318 收藏
点赞数 1
分类专栏： 数据结构-链表 文章标签： 单链表 笔试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hanmamnhanah/article/details/79815346
版权

    美好的一天开始了一半，结束了一半，作业写完了一半，还有一半，因为作业写完了一半所以我认为美好的一天刚刚开始，又因为还有很多作业没写，所以剩下的一天是否还是美好的呢？我把这一刻定义为薛定谔的美好的一天。

    在薛定谔的美好的一天中上传一个链表常见的笔试题，供大家参考也供自己日后复习，前提：无头结点

接下来介绍一下各个函数的功能：

void LinkListReversePrint(LinkNode* head);
逆序打印单链表
oid LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value); 
不允许遍历链表, 在 pos之前插入
LinkNode* JosephCycle(LinkNode* head, size_t food);
实现约瑟夫环
void LinkListReverse(LinkNode** head);
单链表逆置
void LinkListBubbleSort(LinkNode* head);
单链表的冒泡排序
LinkNode* LinkListMerge(LinkNode* head1, LinkNode* head2);
将两个有序链表, 合并成一个有序链表
LinkNode* FindMidNode(LinkNode* head);
找到中间节点
LinkNode* FindLastKNode(LinkNode* head, size_t K);
找到倒数第 K 个节点
void EraseLastKNode(LinkNode** head, size_t K);
删除倒数第K个节点
LinkNode* HasCycle(LinkNode* head); 
判定单链表是否带环. 如果带环返回1
size_t GetCycleLen(LinkNode* head); 
如果链表带环, 求出环的长度
LinkNode* GetCycleEntry(LinkNode* head);
如果链表带环, 求出环的入口 
LinkNode* HasCross(LinkNode* head1, LinkNode* head2);
判定两个链表是否相交, 并求出交点
更新！：

int HasCrossWithCycle(LinkNode* head1, LinkNode* head2); 判定两个链表是否相交. 但是链表可能带环
LinkNode* UnionSet(LinkNode* head1, LinkNode* head2); 求两个有序链表的交集 
ComplexNode* CopyComplex(ComplexNode* head);复制复杂链表
ComplexNode* CopyComplex2(ComplexNode* head); 复制复杂链表
 
    linklist.h
 
#pragma once
typedef char LinkNodeType;

typedef struct LinkNode{
	LinkNodeType data;
	struct LinkNode* next;
}LinkNode;

typedef LinkNode* PLinkNode;
void LinkListReversePrint(LinkNode* head);

void LinkListInsertBefore(LinkNode* head,LinkNode* pos,LinkNodeType value);

LinkNode* JosephCycle(LinkNode* head,size_t food);

void LinkListReverse(LinkNode** head);

void LinkListBubbleSort(LinkNode**head);

LinkNode* LinkListMerge(LinkNode* head1,LinkNode* head2);

LinkNode* FindMidNode(LinkNode* head);

LinkNode* FindLastKNode(LinkNode* head,size_t k);

void EraseLastKNode(LinkNode** head,size_t k);

LinkNode* HasCycle(LinkNode* head);

size_t GetCycleLen(LinkNode* head);

LinkNode* GetCycleEntry(LinkNode* head);

LinkNode* HasCross(LinkNode* head1,LinkNode* head2);

更新：！

int HasCrossWithCycle(LinkNode* head1,LinkNode* head2);

LinkNode* UnionSet(LinkNode* head1,LinkNode head2);

typedef struct ComplexNode{
	LinkType data;
	struct ComplexNode* next;
	struct ComplexNode* random;
}ComplexNode;i

ComplexNode* CopyComplex(ComplexNode* head);

ComplexNode* CopyComplex2(ComplexNode* head);

linklist.c

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

void LinkListReversePrint(LinkNode* head){
	if(head == NULL){
		return;
	}
	LinkNode* cur = head;
	if(cur->next == NULL){
		return cur->data;
	}else{
		return (cur->next);
	}
	return;
}

void LinkListInsertBefore(LinkNode* head,LinkNode* pos,LinkNodeType value){
	if(head == NULL || pos == NULL){
		return;
	}
	if(head == pos){
		LinkListPushBack(&head,value);
	}
	LinkListInsert(pos,pos->data);
	pos->data = value;
	19970218
		<F6>return;
}

LinkNode* JosephCycle(LinkNode* head,size_t food){
	if(head == NULL){
		return;
	}
	size_t i = 0;
	LinkNode* cur = NULL;
	while(head->next != head){
		for(;i < food - 1;++i){
			cur = head;
			head = head->next;
	}
		printf("%c was killed",head->data);
		cur->next = head->next;
		DestroyNode(head);
		head = head->next;
	}
	return head;
}

void LinkListReverse(LinkNode** head){
	if(head == NULL){
		return;
	}
	if(*head == NULL){
		return;
	}
	LinkNode* cur = head->next;
	LinkNode* pre = head;
	while(cur != NULL){
		if(head == pre){
			head->next = cur->next;
			cur->next = head;
		*head = cur;
		pre = cur->next;
		cur = pre->next;
	}
		pre->next = cur->next;
		cur->next = head;
		*head = cur;
		cur = pre->next;
	}
	return;
}

void swap(LinkNode* cur,LinkNode* next){
	cur ^= next;
	next ^= cur;
	cur ^= next; 
}

void LinkListBubbleSort(LinkNode** head){
	if(head == NULL){
		return;
	}
	if(*head == NULL || *head->next == NULL){
		return;
	}
	LinkNode* count = *head;
	LinkNode* tail = NULL;
	for(;count != NULL;count = count->next){
		LinkNode* cur = *head;
		for(;cur->next != tail;cur = cur->next){
			if(cur->data > cur->next->data){
				swap(&cur->data.cur->next->data);
			}
			tail = cur;
		}
		return;
}

LinkNode* LinkListMerge(LinkNode* head1,LinkNode* head2){
	if(head1 == NULL){
		return;
	}
	if(head2 == NULL){
		return;
	}
	LinkNode* new_head = NULL;
	LinkNode* new_tail = NULL;
	LinkNode* cur1 = head1;
	LinkNode* cur2 = head2;
	while(cur1 != NULL || cur2 != NULL){
		if(cur1->data < cur2->data){
			if(new_tail == NULL){
				new_tail = new_head = cur1;
				cur1 = cur1->next;
			}
			else{
				new_tail->next = cur1;
				new_tail = new_tail->next;
				cur1 = cur1->next;
			}
		}
		else{
			if(new_tail == NULL){
				new_tail = new_head = cur2;
				cur2 = cur2->next;
			}
			else{
				new_tail->next = cur2;
				new_tail = new_tail->next;
				cur2 = cur2->next;
			}
		}
		if(cur != NULL){
			new_tail->next = cur1;
		}else{
			new_tail->next = cur2;
		}
	}
}

LinkNode* FindMidNode(LinkNode* head){
	if(head == NULL){
		return NULL;
	}
	LinkNode* fast = head;
	LinkNode* slow = head;
	while(fast != NULL && fast->next != NULL){
	slow = slow->next;
	fast = fast->next->next;
	}
	return slow;
}

LinkNode* FindLastKNode(LinkNode* head,size_t k){
	if(head == NULL){
		return;
	}
	LinkNode* fast = head;
	LinkNode* slow = head;
	size_t i = 0;
	for(;i < k;++i){
		if(fast == NULL){
			break;
		}
		fast = fast->next;
	}
	if(i != k){
		return NULL;
	}
	while(fast->next != NULL){
		fast = fast->next;
		slow = slow->next;
	}
	return slow;
}

void EraseLastKNode(LinkNode** head,size_t k){
	if(head == NULL){
		return;
	}
	if(*head == NULL){
		return;
	}
	int len = LinkListSize(*head);
	if(k > len){
		return;
	}
	if(k == len){
		LinkListPopFront(*head);
		LinkNode* to_delete = *head;
		*head = (*head)->next;
		DestroyNode(to_delete);
		return;
	}
	LinkNode* to_delete_prev = LinkListFind(head,k-1);
	LinkNode* to_delete = to_delete_prev->next;
	to_delete_prev->next = to_delete->next;
	DestroyNode(to_delete);
	return;
}

LinkNode* HasCycle(LinkNode* head){
	if(head == NULL){
		return NULL;
	}
	LinkNode* fast = head;
	LinkNode* slow = head;
	while(fast != NULL && fast->next != NULL){
		fast = fast->next->next;
		slow = slow->next;
		if(fast == slow){
		return 1;
		}
	}
	return 0;
}

size_t GetCycleLen(LinkNode* head){
	if(head == NULL){
		return 0;
	}
	LinkNode* meet_node = HasCycle(head);
	if(meet_node == NULL){
		return 0;
	}
	LinkNode* cur = meet_node->next;
	size_t len = 1;
	while(cur != meet_node){
		cur = cur->next;
		++len;
	}
	return len;
}

LinkNode* GetCycleEntry(LinkNode* head){
	if(head == NULL){
		return NULL;
	}
	LinkNode* meet_node = llh(head);
	if(meet_node == NULL){
		return NULL;
	}
	LinkNode* cur1 = head;
	LinkNode* cur2 = meet_node;
	while(cur1 != cur2){
		cur1 = cur1->next;
		cur2 = cur2->next;
		return cur1;
	}
}

LinkNode* HasCross(LinkNode* head1,LinkNode* head2){
	if(head1 == NULL || head2 == NULL){
		return NULL;
	}
	LinkNode* cur1 = head1;
	LinkNode* cur2 = head2;
	while(cur1->next != NULL){
		cur1 = cur1->next;
	}
	while(cur2->next != NULL){
		cur2 = cur2->next;
	}
	if(cur1 == cur2){
		return cur1;
	}else{
		return NULL;
	}
}

更新！：

int HasCrossWithCycle(LinkNode* head1,LinkNode* head2){
	if(head1 == NULL || head2 == NULL){
		return 0;
	}
	//1.qiulianggelianbiaode rukoudian
	LinkNode* entry1 = GetCycleEntry(head1);
	LinkNode* entry2 = GetCycleEntry(head2);
	if(entry1 == NULL || entry2 == NULL){
		return 0;
	}
	if((entry1 == NULL || entry2 != NULL)||(entry != NULL || entry2 == NULL)){
		return 0;
	}
	if(entry1 == entry2){
		return 1;
	}
	LinkNode* cur = entry1->next;
	while(cur != entry1){
		if(cur ==  entry2){
			return 1;
		}
		cur = cur->next;
	}
	return 0;
}

LinkNode* UnionSet(LinkNode* head1,LinkNode* head2){
	LinkNode* new_head = NULL;
	LinkNode* new_tail = NULL;
	LinkNode* cur1 = head1;
	LinkNode* cur2 = head2;
	while(cur1 != NULL && cur2 != NULL){
		if(cur1->data < cur2->data){
			cur1 = cur1->next;
		}else if(cur1->data > cur2->data){
			cur2 = cur2->next;
		}else{
			if(new_head == NULL){
				new_head = new_tail = CreatNode(cur1->data);
			}
			else{
				new_tail->next = CreatNode(cur1->data);
				 new_tail = new_tail->next;
			}
		}
	}
	new_tail->next = NULL;
	return new_head;
}

ComplexNode* CreateComplexNode(LinkNodeType value){
	ComplexNode* new_node = (ComplexNode*)malloc(sizeof(ComplexNode));
	new_node->data = value;
	new_node->next = NULL;
	new-node->random = NULL;
	return  new_node;
}

size_t Diff(ComplexNode* src,ComplexNode* dest){
	size_t offset = 0;
	for(;src != dest;src = src->next){
	++offset;
	}
	return offset;
}

ComplexNode* Step(ComplexNode* head,size_t offset){
	ComplexNode* cur = head;
	size_t i = 0;
	while(1){
		if(cur == NULL){
			return NULL;
		}
		if(i >= offset){
			return cur;
		}
		++i;
		cur = cur->next;
	}
	return NULL;
}

ComplexNode* CopyComplex(ComplexNode* head){
	ComplexNode* new_head = NULL;
	ComplexNode* new_tail = NULL;
	ComplexNode* cur = head;
	for(;cur != NULL;cur = cur->next){
		ComplexNode* new_node = CreateComplexNode(cur->data);
		if(new_head == NULL){
			new_head = new_tail = new_node;
		}else{
			new_tail->next = new_node;
			new_tail = new_tail->next;
		}
	}
	ComplexNode* new_cur = new_head;
	for(cur = head;;cur != NULL;cur = cur = cur->next,new_cur = new_cur->next){
		size_t offset = Diff(head,cur->random);
		ComplexNode* random = Step(new_head,offset);
	}
	return new_head;
}

ComplexNode* CopyComplex2(ComplexNode* head){
	ComplexNode* cur = head;
	for(;cur != NULL;cur = cur->next->next){
		ComplexNode* new_node = CreateComplexNode(cur->data);
		new_node->next = cur->next;
		cur->next = new_node;
	}
	for(cur = head;cur != NULL;cur = cur->next->next){
		ComplexNode* new_cur = cur->next;
		if(cur = random == NULL){
			new_cur->random = NULL;
			continue;
		}
	new_cur->random = cur->random->next;
	
	ComplexNode* new_head = NULL;
	ComplexNode* new-tail = NULL;
	for(cur = head;cur != NULL;cur = cur->next){
		ComplexNode* new_cur = cur->next;
		cur->next = new_cur->next;
		if(new_head == NULL){
			new_head = new_tail = new_cur;
		}else{
			new_tail->next = new_cur;
			new_tail = new_tail->next;
		}
	}
}

    如果有个别函数中调用了本文中没有的函数，请参考我的两篇单链表文章，如果你喜欢我的文章请给我点个赞或留言吧，如果代码哪里有错误也请在留言中指出，谢谢阅读
HanMamnHanah
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
华为常见笔试题大全常考知识点
08-31
华为常见笔试题大全，常考知识点如static，IP地址，数据结构，链表，指针，字符串常见函数的实现，文件操作等
10道经典链表面试题
xaiobit_hl的博客
05-18 3491
目录 1.删除链表中等于给定值val的所有节点 2.反转一个单链表 3.给定一个带有头结点head的非空单链表，返回链表的中间结点。如果有两个中间结点，则 返回第二个中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所 有节点组成的 6. 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的 结点之前 7. 链表的回文结构 8. 输入两个链表，找出它们.........
经典十二道链表笔试题！
分享C语言，linux相关知识
05-16 795
1. 删除链表中等于给定值val的所有节点 /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ typedef struct ListNode Node; struct ListNode* removeElem...
链表——题目集合
Go的全部
10-25 145
package linkedList import ( "fmt" "testing" ) /* 链表问题 面试时链表解题的方法论 1.对于笔试，不用太在乎空间复杂度，一切为了时间复杂度 2.对于面试，时间复杂度依然放在第一位，但是一定要找到空间最省的方法(吸引面试官要你不要别人) 链表面试题常用的数据结构 1.使用容器 哈希表、数组等 2.快慢指针 快慢指针 1.输入链表头节点，奇数长度返回中点，偶数长度返回上中点 2.输入链表头节点，奇数长度返回中点，偶数长度返回下中点 3.输入链表头节点
链表经典笔试题（LeetCode刷题）
m0_62692838的博客
03-12 643
链表-LeetCode刷题
链表常用考题
qq_51141456的博客
05-02 167
2.分别查询出两个链表的长度，La长度为9，Lb链表长度为6，然后将p1指针向后移动（9-6）个结点，p1所指结点为C, p1指针所指部分链表长度为6，p2此时所指链表长度也为6，相等；然后再让p1和p2一起向后移动，当p1移动到NULL时，p2正好在倒数第二个结点，大家可以自己对照表格比划一下；3.然后p1,p2开始向后一起移动，当p1==p2时，此时的地址即为汇聚结点；先让p1从头结点向后移动两个结点，p2不动，此时p1已经到了结点B，思路：假定链表La，Lb为两个汇聚的单链表；
知名公司笔试中常见数据结构试题
03-31
知名公司常见的数据结构笔试试题，希望对大家有用
面试中常见---链表题,C/C++
07-30
数据结构， 链表，笔试，很多次碰到，数据结构， 链表，笔试，很多次碰到。
数据结构笔试常见题解
03-21
BNF.txt fibonacci.txt link.txt misc.txt 二叉树公共祖先.txt 二叉树路径.txt 大数运算.txt 排序.txt 最小公倍数和最大公约.txt 求值表达式.txt 测试用例.txt 英文名词.txt 链表循环检测.txt
C++链表逆序经典实现
06-07
IT公司最常见笔试题。2010-06-07编写。欢迎讨论。 QQ：114723704
常见的链表面试题大汇总
09-05
常见的链表面试题大汇总： 1，创建一个链表结点 2，遍历链表中的所有结点 3，倒序打印链表 4，往链表末尾添加结点 5，往链表前端添加结点, 6，获取链表的节点数目 7，销毁链表 8，求链表中倒数第K个节点 9，反转链表 10，查找链表中间节点 11，判断链表是否有环 12，判断链表是否有环，并返回环上的节点数目
【面试必看】链表的常见笔试题
Money、坤的博客
06-26 370
1. 合并链表链接：https://leetcode.cn/problems/merge-two-sorted-lists 2. 反转链表 3. 链表中倒数第k个节点 4. 删除链表的倒数第N个节点 5. 相交链表 6. 环形链表 7. 回文链表 8. 反转指定区间上范围的链表
链表相关笔试题
m0_52083255的博客
11-20 927
链表面试题目删除链表给定的结点链表的反转（逆置链表）链表的中间结点链表的倒数第K个结点链表的第一个公共结点合并两个排序的链表分割链表删除链表中的重复元素II 删除链表给定的结点 leetcode:删除链表中给定的结点 链表的反转（逆置链表） leetcode:反转链表 链表的中间结点 leetcode：链表的中间结点 链表的倒数第K个结点 leetcode：链表的倒数第K个结点 链表的第一个公共结点 leetcode：链表的第一个公共结点 合并两个排序的链表 leetcode：合并两个排序的链
【链表】链表常见笔试题和面试题(C语言)
热门推荐
HongKnight的博客
06-15 1万+
本文为链表常见的笔试题和面试题，包含链表反转、判断链表是否有环、查找环形入口、查找公共结点、合并两个有序链表、查找倒数第K个结点、查找中间结点、删除有序链表重复结点
链表相关练习题
学习C++的小陈同学
04-04 74
对一些较为入门的链表编程题进行整理，方便今后复习
链表高频笔试的OJ题
weixin_67596609的博客
12-02 882
一、合并两个有序链表 二、反转链表 三、分割链表 四、链表的回文结构 五、链表相交 六、环形链表 七、复制带有随机指针的复杂链表 OJ题目及解析和解题代码。通俗易懂，赶快进来看看吧！！！
链表经典 10题
mu_tong_的博客
10-12 2074
链表10 道经典例题
【数据结构】单链表经典面试题10道及详细思路代码
weixin_59215611的博客
08-27 946
快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表其实位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾。1.找到链表的中间节点，从中间节点的位置将链表分开，形成2个链表---->找中间节点:采用快慢指针ok。一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在满指针走到一圈之前，2.遍历原链表，将链表中的节点往两个新链表中尾插--新链表最好将其给成带头节点的单链表。1.创建两个链表，一个链表尾插值小于x的节点，另一个链表中插值大于等于x的节点。...
顺序表和链表面试题（练习题）
baotu的博客
10-22 484
解析：链表的插入和删除不是所有情况下都比顺序表快，比如尾插尾删，顺序表的时间复杂度为O（1），并且如果是单链表，如果要在中间某个节点的前面插入/删除一个节点，则需要遍历。B错误：链表中的元素在内存中不一定连续，因为new的时候，会从堆上分配空间，具体分配出来的空间是否每次都连续，这个不一定。A正确：链表中节点之间是通过next引用相互指向的，故插入或者删除元素时只需要修改几个引用的指向即可，不需要搬移元素。C错误：链表的空间不连续，插入时也不需要扩容之类的，因此不需要事先预估存储空间大小。
电子科大 复试 c语言笔试真题
最新发布
06-20
电子科技大学的复试C语言笔试是一道比较综合性的测试题，主要涉及C语言的基础知识、指针、链表、排序算法、动态内存管理等内容。笔试时间为90分钟，总共有10道题目。 第一道题目是简答题，要求回答C++和C语言的基本...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值