C语言链表面试题

最新推荐文章于 2024-10-10 19:45:26 发布
最新推荐文章于 2024-10-10 19:45:26 发布
阅读量288 收藏
点赞数
分类专栏： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_37964044/article/details/79331349
版权

SeqList.h 

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>
typedef int DataType;
typedef struct Node
{
	struct Node* next;
	DataType Data;
}Node;
void PushBack(Node**pphead,DataType x);//尾插
Node *BuyNode(DataType x);//创建结点
void Init(Node**pphead);//初始化链表
void PrintSeqlist(Node*phead);//打印链表
void*Find(Node*phead, DataType x);//在链表中查找某一结点
void PrintTailToHeadR(Node * phead);//从尾到头打印单链表递归
void PrintTailToHead(Node * phead);//非递归
void EraseNotTail(Node *pos);//删除无头单链表非尾结点
void InsertFront1(Node*pos, DataType x);//在一个无头单链表某个结点前插入一个结点 方法1
void InsertFront2(Node*pos, DataType x);//方法2
void Revese(Node**pphead);//逆置/反转单链表
Node * Josephus1(Node * hus, int k);//实现约瑟夫环问题 方法1
Node * Josephus2(Node * hus, int k);//方法2
Node * FindMidNodeF1(Node*phead);//方法1：如果结点个数是偶数，返回中间两个结点中的前一个结点
Node * FindMidNodeF2(Node*phead);//方法2：如果结点个数是偶数，返回中间两个结点中的前一个结点
Node * FindMidNodeL(Node*phead);//如果结点个数是偶数，返回中间两个结点中的后一个结点
Node * FindLastk(Node *phead,int k);//查找单链表的倒数第k个结点
Node * MergeList(Node*list1, Node*list2);//合并两个有序链表
void Sortlist(Node*phead);//单链表排序

SeqList.c 

#include"Seqlist.h"
void PushBack(Node**pphead,DataType x)
{
	assert(pphead);
	Node *tmp=*pphead;
	if (*pphead == NULL)
	{
		*pphead = BuyNode(x);
	}
	else
	{
		while (tmp->next)
		{
			tmp = tmp->next;
		}
		tmp->next  = BuyNode(x);

	}
}
Node *BuyNode(DataType x)
{
	Node*tmp = (Node*)malloc(sizeof(Node));
	tmp->next = NULL;
	tmp->Data = x;
	return tmp;
}
void Init(Node**pphead)
{
	assert(pphead);//判断参数
	*pphead =NULL;
}
void PrintSeqlist(Node*phead)
{
	Node *tmp = phead;
	if (phead == NULL)
	{
		printf("NULL");
	}
	while (tmp)
	{
		printf("%d->", tmp->Data);
		tmp = tmp->next;
	}
	printf("NULL\n");
}

void*Find(Node*phead, DataType x)
{
	assert(phead);
	Node *cur = phead;
	while (cur)
	{
		if (cur->Data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}
/
///链表面试题
/

//1.从尾到头打印单链表
void PrintTailToHeadR(Node * phead)//递归的思想从尾到头打印单链表
{
	if (phead == NULL)//如果为空直接返回
	{
		return ;
	}
	if (phead->next == NULL)//有一个结点直接打印
	{
		printf("%d ", phead->Data);
		
	}
	else//多个结点递归打印
	{
		PrintTailToHeadR(phead->next);
		printf("%d ", phead->Data);
	}
}
void PrintTailToHead(Node * phead)
{
	
	Node *tail = NULL;
	if (tail == phead)//如果为空不打印
	{
		return;
	}
	while (tail != phead)
	{
		Node *cur = phead;//弄两个指针，一个cur每次从头遍历，一个tail记录所要打印结点的next（最开始置为空，打印一个更新一次，直到tail与phead相等结束）
		while (cur->next != tail)
		{
			cur = cur->next;
		}
		printf("%d ", cur->Data);
		tail = cur;
	}
	printf("\n");
}
//2.删除无头单链表非尾结点
void EraseNotTail(Node *pos)
{
	assert(pos &&(pos->next) );//1检查参数
	Node*Next = pos->next;
	pos->next = Next->next;
	pos->Data = Next->Data;
	free(Next);
	Next = NULL;
}
//3.在一个无头单链表某个结点前插入一个结点
void InsertFront1(Node*pos, DataType x)
{
	Node *cur= BuyNode(x);//1.创建要插入的结点
	Node *Next = pos->next;//2.保存指定插入位置的下一个结点
	pos->next = cur;//3.在指定位置后面插入，把结点连接起来
	cur->next = Next;
	int tmp= pos->Data;//4.交换指定位置和插入位置元素的值
	pos->Data = cur->Data;
	cur->Data = tmp;
}
void InsertFront2(Node*pos, DataType x)
{
	Node *cur = BuyNode(x);//1.创建要插入的结点
	Node *Next = pos->next;//2.保存指定插入位置的下一个结点
	pos->next = cur;//3.在指定位置后面插入，把结点连接起来
	cur->next = Next;
	cur->Data = pos->Data;//4.为结点赋值
	pos->Data = x;
}
//4.逆置/反转单链表
void Revese(Node**pphead)
{
	assert(pphead);
	Node *prev = NULL;//逆置后新链表的头
	Node*cur = *pphead;//用来遍历链表，往prev上插
	Node*Next = (*pphead)->next;//记录下一个结点位置
	while (cur)
	{
		cur->next = prev;//1.逆置
		//2.后移动
		prev = cur;
		cur = Next;
		if (Next != NULL)
		{
			Next = Next->next;
		}

	}
	*pphead = prev;//3.传逆置后链表的头
}
//5.单链表实现约瑟夫环
Node * Josephus1(Node * hus, int k)//传统删除方法
{
	assert(hus&&k > 0);
	Node* man = hus;//找要删除的结点的前一个结点
	Node* del = hus;//要删除的结点
	while (man->next !=man)
	{
		int count = k-1;
		while (--count)
		{
			man = man->next;
			del = man;
		}
		
			del = del->next;
		Node*Next = del->next;//要删除结点下一个结点
		man->next = Next;//删除结点del
		free(del);

	}
	return man;
}
Node * Josephus2(Node * hus, int k)//替换删除法
{
	assert(hus&&k > 0);
	Node* man = hus;//找要删除的结点的前一个结点
	while (man->next != man)
	{
		int count = k;
		while (--count)
		{
			man = man->next;
		}

		Node *Next = man->next;//2.替换法删除
		man->Data = Next->Data;
		man->next = Next->next;
		free(Next);
		Next = NULL;
	}
	return man;
}
//6.查找单链表的中间结点
Node * FindMidNodeF1(Node*phead)//  方法1：如果结点个数是偶数，返回中间两个结点中的前一个结点
{
	assert(phead);
	Node *fast = phead;
	Node *slow = phead;
	while (fast&&fast->next )
	{
		fast = fast->next->next ;
		if (fast)
		{
			slow = slow->next;
		}
	}
	return slow;
}
Node * FindMidNodeF2(Node*phead)// 方法2：如果结点个数是偶数，返回中间两个结点中的前一个结点
{
	assert(phead);
	Node *fast = phead;
	Node *slow = phead;
	while (fast&&fast->next&&(fast->next ->next) )
	{
		fast = fast->next->next;
			slow = slow->next;
	}
	return slow;
}
Node * FindMidNodeL(Node*phead)//如果结点个数是偶数，返回中间两个结点中的后一个结点
{
	assert(phead);
	Node *fast = phead;
	Node *slow = phead;
	while (fast&&fast->next)
	{
		fast = fast->next->next;
		slow = slow->next;
	}
	return slow;
}
//7.查找单链表的倒数第k个结点
Node * FindLastk(Node *phead, int k)
{
	assert(phead);
	Node* fast = phead;
	Node*slow = phead;
	while (--k)
	{
		fast = fast->next;
	}
	while (fast->next !=NULL)
	{
		fast = fast->next;
		slow = slow->next;
	}

	return slow;
}
//8.合并两个有序链表
Node *MergeList(Node*list1, Node*list2)
{
	Node*list,*tail;
	if (list1 == NULL)
	{
		return list2;
	}
	else if (list2 == NULL)
	{
		return list1;
	}
	if ((list1->Data) < (list2->Data))
	{
		list = list1;
		list1 = list1->next;
	}
	else
	{
		list = list2;
		list2 = list2->next;
	}
	tail = list;
	while (list1&&list2)
	{
		if ((list1->Data) < (list2->Data))
		{
			tail->next = list1;
			list1 = list1->next;
		}
		else
		{
			tail->next = list2;
			list2 = list2->next;
		}
		tail = tail->next;
	}
	
	if (list1)
	{
		tail->next =list1;
	}
	if (list2)
	{
		tail->next =list2;
	}
	return list;
}
//9.单链表排序
void Sortlist(Node*phead)
{
	if (phead == NULL)//不能用断言  空链表也是有序的
	{
		return;
	}
	
	Node *tail = NULL;
	int tmp;
	while (tail != phead)//排几趟
	{
		Node* Next = phead->next;
		Node* cur = phead;
		while (Next != tail)//每趟排序
		{

			if ((cur->Data )> (Next->Data))
			{
				tmp = cur->Data;
				cur->Data = Next->Data;
				Next->Data = tmp;

			}
			cur = cur->next;
			Next = Next->next;
		}
		tail = cur;
	}
}

test.c 

#include"Seqlist.h"
void fun1()//测试PrintTailToHeadR  PrintTailToHead
{  
	Node *list;
	Init(&list);
	PushBack(&list, 1);
	PushBack(&list, 2);
	PushBack(&list, 3);
	PushBack(&list, 4);
	PushBack(&list, 5);
	PrintSeqlist(list);
	PrintTailToHeadR(list);
	PrintTailToHead(list);
}

void fun2()//测试EraseNotTail  InsertFront2    InsertFront1  Reverse
{
	Node *list;
	Init(&list);
	PushBack(&list, 1);
	PushBack(&list, 2);
	PushBack(&list, 3);
	PushBack(&list, 4);
	PushBack(&list, 5);
	PrintSeqlist(list);
	EraseNotTail(list->next );
	PrintSeqlist(list);
	InsertFront2(list->next, 2);
	PrintSeqlist(list);
	InsertFront1(list->next, 2);
	PrintSeqlist(list);
	Revese(&list);
	PrintSeqlist(list);

}
void fun3()//测试Josephus
{
	Node *list;
	Init(&list);
	PushBack(&list, 1);
	PushBack(&list, 2);
	PushBack(&list, 3);
	PushBack(&list, 4);
	PushBack(&list, 5);
	Node * tmp = Find(list, 5);
		tmp->next = list;
		Node * man=Josephus2(list, 3);
		printf("%d", man->Data);
}
void fun4()//FindMidNode系列   FindLastk
{
	Node *list;
	Init(&list);
	PushBack(&list, 1);
	PushBack(&list, 2);
	PushBack(&list, 3);
	PushBack(&list, 4);
	PushBack(&list, 5);
        PushBack(&list, 6);
        Node* cur = FindMidNodeL(list);
	printf("%d\n", cur->Data);
	Node *tmp = FindLastk(list, 3);
	printf("%d\n", tmp->Data);
}
void fun5()//测试MergeList
{
	Node*list1;
	Node*list2;
	Init(&list1);
	PushBack(&list1, 3);
	PushBack(&list1, 5);
	PushBack(&list1, 9);
	Init(&list2);
	PushBack(&list2, 3);
	PushBack(&list2, 4);
	PushBack(&list2, 7);
	Node *list=MergeList(list1, list2);
	PrintSeqlist(list);
}
void fun6()//测试Sortlist
{
	Node *list;
	Init(&list);
	PushBack(&list, 1);
	PushBack(&list, 4);
	PushBack(&list, 3);
	PushBack(&list, 2);
	PushBack(&list, 9);
	PushBack(&list, 6);
	Sortlist(list);
	PrintSeqlist(list);
}
int main()
{
	//fun1();
	//fun2();
	//fun3();
	//fun4();
	//fun5();
	fun6();
	system("pause");
	return 0;

}

daidaihaha
关注
专栏目录
c语言实现链表面试题
dove1202ly的博客
11-18 2850
   以前实现过链表的简单函数，详细见http://blog.csdn.net/dove1202ly/article/details/77168657       今天我们来看看链表涉及的面试题相信大家都知道单链表面试题的重要性，既然知道，我们就应该把思路捋清楚，然后多敲几遍多敲几遍多敲几遍（重要的事情说三遍），在我身边好多编程好的把这几个函数敲了不下十遍，而我太菜，这才是第一次下定决心把这个整...
C语言实现单链表面试题汇总
ljx_5489464的博客
03-20 2927
这篇博客只有针对单链表的不同面试题的不同函数，没有对单链表的具体实现方法的介绍。 单链表的具体实现方法（创建，初始化，前插，后插，删除，插入，销毁等），可以参考我的另一边博客： http://blog.csdn.net/ljx_5489464/article/details/50893430以下是单链表面试题的具体实现：1、从尾到头打印单链表void PrintListTailToHead(PS
【数据结构】7道经典链表面试题
最新发布
2302_81312180的博客
10-10 1048
题目描述： 给你一个链表的头节点head，判断链表中是否有环。 如果链表中有某个节点，可以通过连续跟踪next指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数pos来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos不作为参数进行传递。仅仅是为了标识链表的实际情况。 如果链表中存在环，则返回true。 否则，返回false。 题目描述： 给定一个链表的头节点 head，返回链表开始入环的第一个节点。如果链表无环，则返回null
c语言链表的面试题,C语言实现单链表面试题（进阶篇）
weixin_39629679的博客
05-19 191
首先给出单链表的结构，下面实现具体代码typedef int datatype;typedef struct node{datatype data;struct node*next;}node,*pnode,*plist;//结点typedef struct complexnode{datatype d;struct complexnode*next;struct complexnode*rand...
C语言 链表面试题
Coder's Blog
06-28 638
链表是c语言中颇为重要的简单数据结构，在面试中常常被面试官所考到，接下来我就为大家提供一些经常面试中常常被问到面试题的源码。 函数声明： typedef int DataType; typedef struct Node { DataType data; struct Node* next; }Node,*pNode,*pList; void InitList...
C语言链表相关面试题.zip
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
C语言链表面试题(增强版)
zhaoxaun666的博客
02-07 2779
C语言诸多面试题，这里有常用的经典面试题，应用有多种算法，如替换法，快慢指针等等。 注：含有的有关头文件引用上一篇博客单链表的插与删，本篇文章不在写出。 面试题 一：从尾到头打印单链表。 /////// 1.从尾到头打印单链表 ////////// void SLitsPrintTailToHead(SListNode* pHead)//非递归算法(利用俩个指针一个定义到尾部p1，另一个
链表面试题——C语言
JenaeLi的博客
04-12 587
最近总结了一些有关用C语言实现单链表的面试题。代码如下： list.h文件——主要是条件编译以及各个函数的声明。 #ifndef __LIST__ #define __LIST__#include<stdio.h> #include<windows.h> #include<assert.h>typedef int DataType; typedef struct list { struc
C语言链表在笔试面试中常考问题总结
m0_60104735的博客
03-05 906
二、如果两个链表相交，那么两个链表从相交点到链表结束都是相同的节点，我们可以先遍历一个链表，直到尾部，再遍历另外一个链表，如果也可以走到同样的结尾点，则两个链表相交。(L – a – x)为相遇点到环入口点的距离，由此可知，从链表头到环入口点等于(n-1)循环内环+相遇点到环入口点，于是我们从链表头、与相遇点分别设一个指针，每次各走一步，两个指针必定相遇，且相遇第一点为环入口点。一、将其中一个链表首尾相连，检测另外一个链表是否存在环，如果存在，则两个链表相交，而检测出来的依赖环入口即为相交的第一个点。
c语言链表以及面试题
turn__back的博客
12-07 1904
#ifndef __PNODE_H__ //不带头结点的链表 #define __PNODE_H__ #include #include #include typedef int DataType; typedef struct Node { DataType data; struct Node *next; }Node, *PNode; void InitList(P
链表常见面试题-c语言实现,单链表相关面试题（C语言实现）
weixin_31739613的博客
05-19 417
在这里给出一些关于单链表常见的面试题。一、 给定单链表，检测是否有环。1.题目分析仔细读题目发现还是有难度的，很多人刚开始会理解成就是判断一个单链表是否为循环链表，这样的理解是错的。题目的意思是指给出一条单链表，判断其中是否含有环，如“6”字型单链表就含有环。明白题目意思以后我们来说明解题思路，假设给定的单链表中有n个节点，我们可以利用两个指针fast和slow来求解问题。fast指针每次走两步，...
C语言单链表面试题详解
Sxy_wspsby的博客
11-11 701
第一题：力扣移除链表元素：力扣链接：力扣 我解此题的思路是碰见要移除的链表元素就释放然后让前一个节点链接后一个节点。代码如图所示： /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * }; */ struct ListNode* removeElements(struct ListNode* head, int val)
链表笔试题
weixin_34151004的博客
11-10 168
链表： 1、注意是否有带头结点。 2、单链表的建立：顺序建表（尾插法）、逆序建表（头插法）。单链表插入、删除操作需要寻找前驱结点。 3、双向链表和单向链表相比，多了一个前驱指针，单向链表在删除结点时候要遍历链表，双向链表在删除不需要遍历。 一、判断两个链表是否相交：（假设两个链表都没有环）  1、判断第一个链表的每个节点是否在第二个链表中  2、把第二个链表连接到第一个后面，判断得到的链...
【链表】链表常见笔试题和面试题(C语言)
热门推荐
HongKnight的博客
06-15 1万+
本文为链表常见的笔试题和面试题，包含链表反转、判断链表是否有环、查找环形入口、查找公共结点、合并两个有序链表、查找倒数第K个结点、查找中间结点、删除有序链表重复结点
C语言链表类面试题.docx
08-17
C语言链表类面试题.docx struct node { int data; struct node* next; }; 创建单链表的程序为： struct node* create(unsigned int n) { //创建长度为n的单链表 assert(n > 0); node* head; head = new node; head->next = NULL; cout << "请输入head节点的值(int型)："; cin >> head->data; if (n == 1) { return head; } node* p = head; for (unsigned int i = 1; i < n; i++) { node* tmp = new node; tmp->next = 0; cout << "请输入第" << i+1 << "个节点的值(int)："; cin >> tmp->data; p->next = tmp; p = tmp; } return head; } 问题1：链表逆置 思想为：head指针不断后移，指针反向即可，代码为： void reverse(node*& head) { if (head != NULL && head->next != NULL) { node* p = head; node* q = head->next; p->next = NULL; while (q->next != NULL) { head = q->next; q->next = p; p = q; q = head; } head->next = p; } return; }
链表c实现——附相关面试题
漫鱼
04-16 503
链表c实现——附相关面试题 写链表全部需要注意的点 typedef 把链表结点指针类型重命名，pNode是结构体指针类型 在每一个方法里首先要处理非法数据，传入指针为空就可能造成崩溃 删除结点相关的方法里，要提前保存要删除的结点，防止内存泄漏，防止野指针 如果牵扯到可能改变头结点指向，就得传入二级指针pNode*，或者返回值为pNode 写方法时首先考虑空链表，其次是一般情况，还要考虑只有头...
c语言面试题 链表相关,【C语言】单链表相关面试题（一）
weixin_39651816的博客
05-20 206
先前已经写过一些单链表的基本操作：这次链表相关的面试题是建立在这个之上写的，测试的时候会调用的其中的一些函数。今天主要说以下几个常见的链表面试题1.查询链表中间结点2.只给出一个位置，删除非尾结点3.逆序链表查询链表的中间结点，我们知道，单链表只能顺序访问，那么怎么查找中间结点呢？你可能会想到，先遍历一遍求出链表长度，然后再遍历一遍找出中间结点就可以了啊。没错，这样做能产生结果，但是相对的时间复杂...
C语言链表面试题(增强版)（转）
u013077314的博客
01-01 273
转自：https://blog.csdn.net/zhaoxaun666/article/details/79277774    C语言诸多面试题，这里有常用的经典面试题，应用有多种算法，如替换法，快慢指针等等。 注：含有的有关头文件引用上一篇博客单链表的插与删，本篇文章不在写出。 面试题 一：从尾到头打印单链表。 ///////  1.从尾到头打印单链表 //////////   vo...
面试中常见---链表题,C/C++
07-30
数据结构， 链表，笔试，很多次碰到，数据结构， 链表，笔试，很多次碰到。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值