单链表及笔试题

已于 2024-09-23 18:27:35 修改
阅读量165 收藏
点赞数 3
分类专栏： 数据结构 文章标签： 数据结构
于 2024-09-12 16:31:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73284013/article/details/142152989
版权

目录

SList.h

SList.c

Text.c

练习：

链表的中间结点

移除链表元素

思路一：

思路二：

链表分割

反转链表

思路一：

倒数第k个结点

思路：

原理：

相交链表

思路一：

思路二：

环形链表

思路：

plus:

思路一：

结论：

思路二：

SList.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>


typedef int SLNDataType;
//Single List
typedef struct SListNode {
	SLNDataType val;
	struct SListNode* next;//指向下一个结点的指针
}SLNode;

//打印
void SLPrint(SLNode* phead);

//尾插
void SLPushBack(SLNode** pphead, SLNDataType);

//头插
void SLPushFront(SLNode** pphead, SLNDataType);

//尾删
void SLPopBack(SLNode** pphead);

//头删
void SLPopFront(SLNode** pphead);

//查找
SLNode* SLFind(SLNode* phead, SLNDataType x);

//在pos前插入
void SLInsert(SLNode** pphead,SLNode* pos, SLNDataType x);
//pos可以通过SLFind找到，或者写成int pos

//删除pos位置
void SLErase(SLNode** pphead, SLNode* pos);

//清空单链表
void SLDestory(SLNode** pphead);

//在pos后插入
void SLAfterInsert(SLNode* pos, SLNDataType x);
//不用pphead，因为是在后面操作plist不会发生变动

//删除pos位置
void SLAfterErase(SLNode* pos);

SList.c

#define  _CRT_SECURE_NO_WARNINGS
#include"SList.h"

void SLPrint(SLNode* phead) {

	SLNode* cur = phead;
	while (cur != NULL) {
		printf("%d->", cur->val);
		cur = cur->next;
	}
	printf("NULL");
	printf("\n");
}

SLNode* CreateNode(SLNDataType x) {
	SLNode* newnode = (SLNode*)malloc(sizeof(SLNode));
	if (newnode == NULL) {
		perror("malloc fail");
		exit(-1);
		//要是发生错误直接结束程序
		//0才是正常终止
	}
	newnode->val = x;
	newnode->next = NULL;
	return newnode;
}

但是phead newnode都是临时变量，出了函数就会被销毁
主函数上是SLPushBack(plist, 1);
相当于phead是plist的拷贝，没有被修改的权利
空间还在，但是找不到，也使用不了
//void SLPushBack(SLNode* phead, SLNDataType x) {
//	SLNode* newnode = CreateNode(x);
//	if (phead == NULL) {
//		phead = newnode;
//	}
//	else {
//		SLNode* tail = phead;
//		while (tail->next != NULL) {
//			tail = tail->next;//循环
//		}
//		//SLNode* newnode = CreateNode(x);
//		tail->next = newnode;
//	}
//}

//此处传进来的是SLPushBack(&plist, 1);也就是plist的地址
//用SLNode**接收，pphead就是plist的地址，*pphead就是根据地址找到plist
//此时就可以使用对指针进行修改
void SLPushBack(SLNode** pphead, SLNDataType x) {
	assert(pphead);
	SLNode* newnode = CreateNode(x);
	//这里用的是二级指针
	if (*pphead == NULL) {
		*pphead = newnode;
	}
	else {
		SLNode* tail = *pphead;
		while (tail->next != NULL) {
			tail = tail->next;//循环
		}
		//SLNode* newnode = CreateNode(x);
		tail->next = newnode;
		//这里用的是一级指针
			//改变指向结构体的指针Node*，要用二级指针
			// 也就是改变结构体指针的位置
			//改变结构体内部的东西Node，比如指针，要用一级指针
			// 也就是改变指针的内容
	}
}

void SLPushFront(SLNode** pphead, SLNDataType x) {
	//此处不用管链表是否为空，并无影响
	assert(pphead);

	SLNode* newnode = CreateNode(x);
	newnode->next = *pphead;
	*pphead = newnode;
	newnode->val = x;
}

void SLPopBack(SLNode** pphead) {
	assert(pphead);

	温柔检查
	//if (*pphead == NULL)
	//	return;
	// 
	//暴力检查
	assert(*pphead);

	//如果删除完链表为空，就要将指针置为空，否则就成为野指针
	//free掉一个结点之后，要将上一个节点的next指针置为空
	//所以此处可以采用两个指针完成
	//一个结点
	SLNode* tail = *pphead;
	if (tail->next == NULL) {
		free(tail);
		tail = NULL;
		*pphead = NULL;
	}
	//多个结点
	else {
		SLNode* prev = NULL;
		while (tail->next != NULL) {
			prev = tail;
			tail = tail->next;
		}
		free(tail);
		tail = NULL;
		//其实此处tail可以不置空，因为出了作用域也销毁了
		prev->next = NULL;
	}
}

void SLPopFront(SLNode** pphead) {
	assert(pphead);

	assert(*pphead);
	//一个结点
	if ((*pphead)->next == NULL) {
		free(*pphead);
		*pphead = NULL;
	}
	//多个结点
	else {
		SLNode* tail = *pphead;
		*pphead = (*pphead)->next;
		free(tail);
		tail = NULL;
	}
}

SLNode* SLFind(SLNode* phead, SLNDataType x) {
	SLNode* cur = phead;
	while (cur) {
		if (cur->val == x) {
			return cur;
		}
		else {
			cur = cur->next;
		}
	}
	printf("未找到\n");
	return NULL;
}

void SLInsert(SLNode** pphead, SLNode* pos, SLNDataType x) {
	assert(pphead);
	//pphead是一个指向plist的指针。万一是头插，则需要改plist，就需要pphead
	//需要断言

	//assert(*pphead);
	//*pphead相当于是plist
	//可以不断言，链表为空，相当于空链表的尾插，此时pos也为空


	assert((pos== NULL && *pphead == NULL)||(pos && *pphead));
	//前者是都为空
	//后者是都不为空

	//使用assert是为了把以下这种情况检查出来
	//SLNode* pos = SLFind(plist, 1000);
	//SLInsert(&plist, pos, 100);

	if (*pphead == pos) {
		//头插
		SLPushFront(pphead, x);
	}
	else {
		//找前一个
		SLNode* prev = *pphead;
		while (prev->next != pos) {
			prev = prev->next;
		}
		//插入
		SLNode* newnode = CreateNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}
}

void SLErase(SLNode** pphead, SLNode* pos) {
	assert(pphead);
	assert(*pphead);
	assert(pos);
	//找前一个
	SLNode* prev = *pphead;

	//pos在首结点
	if (*pphead == pos) {
		//头删
		SLPopFront(pphead);
	}
	else {
		//pos不在首结点
		while (prev->next != pos) {
			prev = prev->next;
		}
		prev->next = pos->next;
		free(pos);
		pos = NULL;
	}
}

void SLDestory(SLNode** pphead) {
	assert(pphead);
	SLNode* cur = *pphead;
	while (cur) {
		SLNode* tmp = (*pphead)->next;
		*pphead = tmp;
		free(cur);
		cur = *pphead;
	}
}

void SLAfterInsert(SLNode* pos, SLNDataType x) {
	assert(pos);
	SLNode* newnode = CreateNode(x);
	newnode->next = pos->next;
	pos->next = newnode->next;
}

void SLAfterErase(SLNode* pos) {
	assert(pos);
	assert(pos->next);
	SLNode* cur = NULL;
	cur = pos->next;
	pos->next = pos->next->next;
	free(cur);
	//free空不会报错
	cur = NULL;
}

Text.c

#define  _CRT_SECURE_NO_WARNINGS
#include"SList.h"
void Text1() {
	SLNode* plist = NULL;

	//SLPushBack(plist, 1);
	//SLPushBack(plist, 2);
	//SLPushBack(plist, 3);

	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);
	SLPushBack(&plist, 5);

	SLPrint(plist);

	SLPopBack(&plist);
	SLPrint(plist);

	SLPopFront(&plist);
	SLPrint(plist);

	SLFind(plist, 3);
}

void Text2() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);
	SLPushBack(&plist, 5);
	SLPrint(plist);

	SLNode* pos = SLFind(plist, 2);
	SLInsert(&plist, pos, 100);
	SLPrint(plist);

	SLErase(&plist, pos);
	SLPrint(plist);

}

void Text3() {
	SLNode* plist = NULL;
	SLPushBack(&plist, 1);
	SLPushBack(&plist, 2);
	SLPushBack(&plist, 3);
	SLPushBack(&plist, 4);
	SLPushBack(&plist, 5);
	SLPrint(plist);

	SLDestory(&plist);
	SLPrint(plist);

}

int main() {
	//Text1();
	//Text2();
	Text3();
	return 0;
}

练习：

链表的中间结点

移除链表元素

思路一：

删除结点

思路二：

组成新的单链表，但并不是复制到新的结点，只是使用新的指针

tail用来指向新的单链表的当前节点

最后一个if语句的作用是在遍历链表的过程中，当最后一个元素是需要移除的val时，防止tail->next指向空导致后续访问出错。如果链表的尾部元素是需要删除的val，那么在删除之后，tail的next应该设置为NULL，表示链表已经结束。这样做是为了保持链表结构的完整性，并在返回新的头节点newhead时，确保链表的尾部状态被正确更新

链表分割

eg：3 6 1 8 4 6 9   x=5

结果为：3 1 4 6 8 6 9

思路：新建两个链表，一个存放小于x的值，另一个存放大于x的值，然后拼接

要是两个链表其中一个为空，拼接的时候要考虑两个链表谁为空，然后返回不为空的，有点麻烦，所以最好选择带哨兵位（首元结点）的链表，使得都不为空

反转链表

思路一：

改变箭头方向

思路二：

头插

倒数第k个结点

思路：

相对距离：fast先走k步，然后fast和slow同时走，直到fast为空

原理：

slow和fast之间相差k-1步，之间距离就是k

当fast走到尾了，说明slow走到了倒数第k个

相交链表

思路一：

把a链表的所有节点地址和b去比对

思路二：

分别找到尾节点，要是地址相同，就说明相交

如果a、b依次走再判断结点是否为同一个，就有可能完美错过

所以先算出a、b长度，长的先走长度差，然后再a、b同时走

环形链表

也有可能自己指向自己

思路：

快慢指针的追及问题

plus:

思路一：

结论：

一个指针从相遇点开始走，一个指针从头开始走，他们会在环入口点相遇，以此可以求出环入口点

思路二：

合并两个有序链表

不建议把list2插入到list1的合适位置，很难控制，涉及头插尾插以及头指针的变化等等，吃力不讨好

链表的回文结构

思路：

找到中间结点，逆制后半段链表，和前半段比较看是否相同

随机链表的复制

思路一：

找random是原装链表的第i个，然后定义copy链表里的第i个为random，此时合计为O(N^2)

思路二：

要求优化到O(N)：

1、复制一个结点在原节点的后面

2、复制结点的random就等于前一个节点的random所在结点（原结点）的后一个结点（复制结点）

3、然后拆下来复制节点，再尾插

么耶咩_515
关注
专栏目录
C++笔试题之实现单链表反转
草上爬的博客
02-01 2467
链表反转在面试中经常容易被问及，比如： 输入 1 2 3 4 5 6 7 8 9 10 输出 10 9 8 7 6 5 4 3 2 1 #include using namespace std; struct Node{ int data; Node* next; }; void Display(Node *head)// 打印链表 { if (head == NULL)
单链表常见笔试面试题
qq_40425540的博客
03-29 199
定义一个结构体，用来表示链表上的每个节点的类型typedef char LinkType typedef struct LinkNode { LinkType data; struct LinkNode* next; } LinkNode;1)逆序打印单链表使用低轨思想，递归出口 head == NULLvoid LinkListReversePrint(LinkNode* he...
单链表常见笔试面试题总结
wendy_keeping的博客
07-18 619
1.单链表逆置#include <iostream> using namespace std;typedef int KeyType; typedef struct Node { KeyType value; Node *next; }Node, *List;void Reserver(List plist) { //链表尾NULL /只有一个头节点/链表只有一个头节点和数据
数据结构之单链表常见笔试题
mignatian的博客
04-07 525
头文件以及定义的节点都在上一篇的单链表功能实现里面有写 逆序打印单链表 递归方式简洁明了 void linklist_reverseprintf(linklist *head) { if(head == NULL) { return;//空链表 } linklist_reverseprint(head-&gt;next); pr...
单链表相关面试笔试题
Grok coding
08-09 839
1.链表节点结构定义
群硕java开发笔试题_群硕笔试题
weixin_39756416的博客
02-25 443
群硕的笔试只有五个大题，两个编程题，比较简单，一个字符串方面的，一个是循环链表方面的，然后一个是智力题，一个是应用WEB方面的，这个当时不会做，最后一个就是英语阅读题，回答问题了。。。面试感觉也比较容 易，首先是英文自我介绍，然后英文问一两个问题，接下来转为技术中文面试，都问些简历上做的，只要做过一般都没问题。。。一概念1.过程化编程和面向对象编程的区别字串92.(a-1)xora==0和条件 字...
python实现单链表反转（经典笔试题）
热门推荐
su_bao的博客
07-16 1万+
0、说在前面的话      链表结构，说难不难，说易不易，一定要亲自编程实现一下。其次就是一定要耐心，慢慢去体会其中的道道，博主一开始也是有点懵逼的，后来仔细琢磨了一下终于搞明白了，相信聪明的你也一定可以，有问题可以留言交流。 1、单链表结构 2、反转的想法       建立三个变量，L、M、R互相赋值迭代，并建立指向关系，从而实现单链表的反转。 3、python代码实现 cla...
单链表图解及模板总结
timerring的博客
11-24 3054
静态链表 如果说用结构体+指针的方式实现链表和栈的话，每次需要new一个新节点，非常慢。笔试题链表大小在10万级别，因此笔试题一般不会采用这种动态链表的方式。通常采用数组模拟链表的方式，这种方式更快。 struct Node { int val; Node *next; }; new Node(); 链表与邻接表 邻接表 邻接表的head[i]存储的是节点i所有的临边。实际上就是一个单链表。 用数组模拟单链表 单链表里常用的是邻接表。邻接表主要用来存储图和数。 双链表常用来优化某些问题。 链表的
4399测试工程师笔试题
ShuoCham的博客
09-30 6491
1、假设现在比特币挖矿的条件是：通过SHA-256算法生成的hash值，前面要带18个0，则满足条件的hash值有多少种？注：SHA-256算法产生的结果是以十六进制表示的，总共256bit的数字 A ,2^64 &amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp; &amp;amp;nbsp; B ,2^72 &amp;amp;nbsp; &
技术岗笔试题汇总
weixin_44500533的博客
09-17 935
总结的都是基础知识点，关于计算机基础的。 1，操作系统是对计算机资源进行管理的软件。 2，进程 进程是动态的概念，进程的执行需要CPU，进程具有生命周期，进程是对指令的描述。 3，数据存储和数据流都是数据，仅仅是所处的状态不同。 4，进程之间通信的途径：共享内存、消息队列、管道。（操作系统） 5，存储区域的字节是做加法。 32位编译器 char ：1个字节 char*（即指针变量）: 4个字节（3...
（2022）CVTE嵌入式笔试题.pdf
09-24
CVTE嵌入式笔试题 本资源为CVTE嵌入式笔试题，共27题，涵盖了嵌入式系统、操作系统、计算机网络、数据结构、算法等多个领域。 1.N个顶点的强连通图至少有多少条边？答：至少有N条边。强连通图是指任意两点之间存在...
4399游戏2015校园招聘游戏开发类笔试题.pdf
08-30
"4399游戏2015校园招聘游戏开发类笔试题.pdf" 本资源是一个游戏开发类笔试题，涵盖了数据结构、算法、计算机网络、编程语言等多个方面的知识点。 1. 散列存储和查找长度：问题1考查散列存储的基本概念和查找长度的...
2022年yahoo在线笔试题c语言及部分答案.doc
11-11
【知识点详解】 1. **二分查找算法**：在有序数组中查找元素，通过不断将查找区间减半来快速定位目标...以上是针对2022年Yahoo在线笔试题C语言部分的解析，涵盖了数据结构、操作系统、程序设计等多个方面的知识点。
2022年java笔试题.doc
11-11
"java笔试题知识点总结" 本文总结了java笔试题中的重要知识点，涵盖了软件基础测试题、java语言基础、数据结构、面向对象技术、线程控制、String处理、队列和链表操作等方面。 一、软件基础测试题 1. 使用JAVA...
前端常用算法和数据结构
renqq001的博客
10-17 281
前端常用算法和数据结构
#数据结构（一）
2302_79847831的博客
10-17 178
2 创造顺序表3 判断是否为空4遍历输出5 查找索引位置6 删除7 在固定位置插入。
优先级队列和PriorityQueue
2301_79985750的博客
10-17 336
优先级队列是一种特殊的队列，每个元素都有一个优先级或者权重，与普通队列的先进先出不同，它按照优先级的大小从高到低进行排序，优先级最高的优先出队列。在任务调度，事件模拟中发挥着重要的作用。Java中的优先级队列是一种利用堆这种数据结构进行实现，按照数据的优先级顺序进行排序，可以任意的顺序插入，但是取出时按照规定好的优先级进行操作。
数据结构(8.2_1)——插入排序
最新发布
m0_65240792的博客
10-17 175
算法思想：每次将一个待排序的记录按其关键字大小插入到前面已排序好的子序列中，直到全部记录插入完成。 代码实现 (带哨兵) 空间复杂度：O(1)时间复杂度:主要来自对比关键字，移动元素，若有n个元素，则需要n-1趟处理最好情况：共n-1趟处理，每一趟只需要对比关键字1次，不用移动元素———O(n)最坏情况：第1趟：对比关键字2次，移动元素3次第2趟：对比关键字3次，移动元素4次...第i趟：对比关键字i+1次，移动元素i+2次———O(n^2)平均时间复杂度：O(n^2) 思路：先用折半查找
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值