【数据结构】链表(单链表实现+测试+原码)

news2024/12/23 0:40:01

1.链表

1.1 链表的概念及结构

概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的 。

现实中：链表就像是一列动车，一节连着一节
数据结构中的链表

 注意:
1.从上图可看出，链式结构在逻辑上是连续的。但是在物理上不一定连续

2.现实中的结点一般都是从堆上申请出来的

3.从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续

2  链表的实现

SList.h(头文件引用)

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <malloc.h>
#include <assert.h>

typedef int SLTDataType;

typedef struct SListNode
{
	SLTDataType data;
	struct SListNode* next;
}SLTNode;

void SLTPrint(SLTNode* phead);
 
SLTNode* BuySListNode(SLTDataType x);
void SLTPushBack(SLTNode ** pphead,SLTDataType x);
void SLTPushFront(SLTNode** pphead, SLTDataType x);
void SLTPopBack(SLTNode** pphead);
void SLTPopFront(SLTNode** pphead);

//作业
SLTNode* SLTFind(SLTNode* pphead,SLTDataType x);

//在pos之前插入x
void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x);
//在之后插入x
void SLTInsertAfter( SLTNode* pos, SLTDataType x);
//删除pos位置
void SLTErase(SLTNode** pphead, SLTNode* pos);
//删除pos后一个位置
void SLTEraseAfter(SLTNode* phead,SLTNode* pos);

SList.c(函数功能的实现)

#include "SList.h"

void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	while (cur != NULL)
	{
		printf("%d->", cur->data);
		cur = cur->next;
	}
	printf("NULL\n");
}
  

SLTNode* BuySListNode(SLTDataType x)
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	return newnode;
}

void SLTPushBack(SLTNode** pphead,SLTDataType x) //尾插
	//需要用二级指针，结构体指针（地址），传递实参
{
	assert(pphead);	//空地址不正确
	//assert(*pphead);//空链表可以尾插

	SLTNode* newnode = BuySListNode(x);
	if (*pphead == NULL)	//如果为空，则指向新创建元素
	{
		  *pphead = newnode;
	}
	else	//不为空则遍历到尾部插入数据
	{
		//需要用指针结构体指针，改变结构体，传递形参
		SLTNode* tail = *pphead;
		while (tail->next != 0)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

void SLTPushFront(SLTNode** pphead, SLTDataType x)//头插
{
	assert(pphead);	//空地址不正确
	assert(*pphead);//空链表不可以前删

	SLTNode* newnode = BuySListNode(x);

	newnode->next = *pphead;
	*pphead = newnode;
}

void SLTPopBack(SLTNode** pphead)	//尾删
{
	// 1.空
	assert(*pphead != NULL);
	//	2.一个节点
	if ((*pphead)->next == NULL)
	{
		free(*pphead);
		*pphead = NULL;
	}
	//	3.多个节点
	else
	{
		SLTNode* tail = *pphead;
		while (tail->next->next)
		{
			tail = tail->next;
		} 
		free(tail->next);
		tail->next = NULL;
	}
}

void SLTPopFront(SLTNode** pphead)	//头删
{
	assert(pphead);
	assert(*pphead);

	SLTNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}

SLTNode* SLTFind(SLTNode*phead, SLTDataType x)
{
	assert(phead);
	SLTNode* tail = phead;
	while (tail)
	{
		if (tail->data == x)
		{
			return tail;
		}
		tail = tail->next;
	}
	return NULL;
	while (tail->data != x)
	{
		tail = tail->next;
		if (tail->next==NULL&&tail->data!=x)
//下一个元素的值指向NULL并且数据值不等于要查找的数，既已遍历查找完毕并且没有找到数据
		{
			printf(" 输入错误，找不到输入值\n");
			return 0;
		}
	}
	printf("已找到：%d\n", x);
	return tail;
}

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x)
{
	//有错误版本 ，地址近似一样(bug)find函数调试就好了

	assert(pos);    
	assert(*pphead);
	if (pos == *pphead)
	{
		SLTPushFront(pphead, x); 
	}
	else
	{
		SLTNode* tail = *pphead;
		//在pos之前插入x
		while (tail->next != pos)
		{
			tail =  tail->next;
		}
		SLTNode* newnode = BuySListNode(x);
		tail->next = newnode;
		newnode->next = pos;
	}

} 

void SLTInsertAfter(SLTNode* pos, SLTDataType x)
{
	assert(pos);
	assert(pos->next);

	SLTNode* newnode = BuySListNode(x);
	//注意顺序，不然会照成死循环（画图）
	newnode->next = pos->next;
	pos->next = newnode;

}

void SLTErase(SLTNode** pphead, SLTNode* pos)
{
	assert(pos);

	if (pos == *pphead)
	{
		SLTPopFront(pphead);
	}
	else
	{
		SLTNode* prev = *pphead;
		while (prev->next != pos)
		{
			prev = prev->next;
		}

		prev->next = pos->next;
		free(pos);
	}

}

void SLTEraseAfter(SLTNode* phead,SLTNode* pos)
{
	//assert(pos);
	//检查是否为尾节点
	//assert(pos->next);
	SLTNode* posNext;	//纪录要删除的节点
	//避免丢失无法Free
	posNext = pos->next;
	//pos->next = pos->next->next;
	pos->next = posNext->next;
	free(posNext);
	posNext = NULL;
}

Test_1_16(各种功能的调试、函数、以及面试OJ题的接口实现)

#include "SList.h"

void TestSList1()
{
	int n;
	printf("请输入链表长度：");
	scanf("%d", &n);
	printf("\n请依次输入每个节点的值：");
	SLTNode* plist = NULL;	//第一个元素的地址 
	for (size_t i = 0; i < n; i++)
	{
		int val;
		scanf("%d", &val);
		SLTNode* newnode = BuySListNode(val);

		//头插
		newnode->next = plist;
		plist = newnode;
	}
	SLTPrint(plist);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);
}

void TestSList()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);

	SLTPushFront(&plist, 10);
	SLTPushFront(&plist, 20);
	SLTPushFront(&plist, 30);
	SLTPushFront(&plist, 40);
	SLTPrint(plist);

}

void TestSList3()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);

	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);
	SLTPopBack(&plist);
	SLTPrint(plist);

}

void TestSList4()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);
	//SLTPopFront(&plist);
	//SLTPopFront(&plist);
	//SLTPrint(plist);
	SLTFind(plist, 1);
	SLTFind(plist, 2);
	SLTFind(plist, 3);
	SLTFind(plist, 4);
	SLTFind(plist, 5);
	SLTFind(plist, 0);
}

void TestSlist5()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);


	SLTNode* pos = SLTFind(plist,4);
	if (pos)
		pos->data = 20;
	//在pos之前插入x
	//SLTInsert(&plist, pos, 5);
	SLTPrint(plist);

}

void TestSlist6()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);


	SLTNode* pos = SLTFind(plist, 4);
	SLTInsert(&plist, pos, 90);
	SLTPrint(plist);
}

void TestSlist7()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);

	SLTNode* pos = SLTFind(plist, 4);
	SLTInsertAfter(pos, 90);
	SLTPrint(plist);
}

void TestSlist8()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);

	SLTNode* pos = SLTFind(plist, 4);
	SLTErase(&plist,pos);
	SLTPrint(plist);
}

void TestSlist9()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	SLTPushBack(&plist, 5);
	SLTPrint(plist);

	SLTNode* pos = SLTFind(plist, 4);
	SLTEraseAfter(&plist, pos);
	SLTPrint(plist);
}

struct SListNode* removeElement()
{
	;
}

struct ListNode {
	int val;
	struct ListNode* next;
	
};

//
//struct ListNode* FindKthToTail(struct ListNode* pListHead, int k)
//{
//	struct ListNode* first = pListHead;
//	struct ListNode* tail = pListHead;
//
//	while (first->next)
//	{
//		while (k>0&&first->next)
//		{
//			k--;
//			first = first->next;
//		}
//		if (first->next==NULL)
//		{
//			return tail;
//		}
//		tail = tail->next;
//		first = first->next;
//	}
//	//tail=tail->next;
//	return tail->next;
//}

struct ListNode* FindKthToTail(struct ListNode* pListHead, int k)
{
	if (pListHead == NULL)
	{
		return pListHead;
	}
	struct ListNode* first = pListHead;
	struct ListNode* tail = pListHead;

	while (first->next)
	{
		while (k > 0 && first->next)
		{
			k--;
			first = first->next;
			//if (first->next == NULL && k > 0)
			//{
			//	return NULL;
			//}
		}
		if (first->next == NULL&&k==1)
		{
			return tail;
		}
		else
		{
			return NULL;
		}
		tail = tail->next;
		first = first->next;
	}
	//tail=tail->next;
	return tail->next;
}

int main()
{
	struct SListNode* n1 = (struct ListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* n2 = (struct ListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* n3 = (struct ListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* n4 = (struct ListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* n5 = (struct ListNode*)malloc(sizeof(struct SListNode));

	n1->data = 1;
	n2->data = 2;
	n3->data = 3;
	n4->data = 4;
	n5->data = 5;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = n5;
	n5->next = NULL;

	FindKthToTail(n1, 6);
	//TestSList1();
	//TestSList3();
	//TestSlist5();
	//TestSlist7();
	//TestSlist8();
	//TestSlist9();

	/*struct SListNode* n1 = (struct ListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* n2 = (struct ListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* n3 = (struct ListNode*)malloc(sizeof(struct SListNode));
	struct SListNode* n4 = (struct ListNode*)malloc(sizeof(struct SListNode));

	n1->data = 7;
	n2->data = 7;
	n3->data = 7;
	n4->data = 7;

	n1->next = n2;
	n2->next = n3;
	n3->next = n4;
	n4->next = NULL;

	struct SListNode* head = removeElement(n1, 7);
	return 0;*/

}

// 
// 
// 
// 
//int nums1[6] = { 1,2,3,0,0,0 };
//int nums1Size = 6;
//int m = 3;
//int nums2[3] = { 2,5,6 };
//int nums2Size = 3;
//int n = 3;

int nums1[1];
int m = 0;
int nums2[1] = {1};
int n = 1;
//	int p1 = m - 1, p2 = n - 1;
//	int tail = m + n - 1;
//	int cur;
//	while (p1 > -1 || p2 > -1)
//	{
//		if (p1 == -1)
//		{
//			cur = nums2[p2--];
//		}
//		else if (p2 == -1)
//		{
//			cur = nums1[p1--];
//		}
//		else if (nums1[p1] > nums2[p2])
//		{
//			cur = nums1[p1--];
//		}
//		else
//		{
//			cur = nums2[p2--];
//		}
//		nums1[tail--] = cur;
//	}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1422411.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

微信小程序（二十五）条件判断语句与结构隐藏

微信小程序（二十五）条件判断语句与结构隐藏

注释很详细&#xff0c;直接上代码 上一篇 新增内容&#xff1a; 1.条件判断语句的演示 2.隐藏结构的演示 源码&#xff1a; index.wxml <view><!-- wx:if和wx:else为条件判断语句 --><text wx:if"{{isLogin}}">已登入的用户</text><tex…
阅读更多...
Maven基本使用

Maven基本使用

Maven简介: Apache Maven 是一个项目管理和构建工具&#xff0c;它基于项目模型(POM)的概念&#xff0c;通过一小段描述信息来管理项目的构建&#xff0c;报告和文档 Maven的作用: (1&#xff09;项目搭建&#xff1b; &#xff08;2&#xff09;依赖管理&#xff1b; &#xf…
阅读更多...
7000字详解Spring Boot项目集成RabbitMQ实战以及坑点分析

7000字详解Spring Boot项目集成RabbitMQ实战以及坑点分析

本文给大家介绍一下在 Spring Boot 项目中如何集成消息队列 RabbitMQ&#xff0c;包含对 RibbitMQ 的架构介绍、应用场景、坑点解析以及代码实战。 我将使用 waynboot-mall 项目作为代码讲解&#xff0c;项目地址&#xff1a;https://github.com/wayn111/waynboot-mall。本文大…
阅读更多...
Unity之做一个最简单的FPS游戏demo

Unity之做一个最简单的FPS游戏demo

目录 &#x1f60b;FPS游戏Demo &#x1f4a4;1.新建FPS模板项目 ⚒️2.装备枪 &#x1f4a3;3.设置射击功能 &#x1f4fa;4.制造一个子弹预制体 &#x1f3ae;5.发射子弹 说起来小编学Unity差不多一个月了&#xff0c;都是利用上班摸鱼时间学的&#xff08;doge.jpg&…
阅读更多...
【3万块指令免费送】Evol-Instruct 应用：扩充大模型数据多样性

【3万块指令免费送】Evol-Instruct 应用：扩充大模型数据多样性

Evol-Instruct 应用&#xff1a;扩充大模型数据多样性 提出背景流程步骤总结Evol-Instruct 代码复现Evol-Instruct 应用&#xff1a;扩充大模型数据多样性 提出背景 论文&#xff1a;https://arxiv.org/pdf/2304.12244.pdf 代码&#xff1a;https://github.com/nlpxucan/Wiza…
阅读更多...
如何提高思维能力，洞悉事物本质？（二）

如何提高思维能力，洞悉事物本质？（二）

在上一篇文章里&#xff0c;我们分享了几个简单、有效的思维模型。 这一篇&#xff0c;会继续探讨这个话题&#xff0c;向大家介绍几个常用的思维模型。 今天的主题是「找本质」。 大多数问题&#xff0c;当我们思考和讨论的时候&#xff0c;许多人常犯的错误&#xff0c;其实是…
阅读更多...
【Redis】实现购物秒杀及分布式锁

【Redis】实现购物秒杀及分布式锁

Redis实现购物秒杀及分布式锁 全局唯一ID Redis自增ID策略 ID构造是：时间戳 + 计数器 每天一个key，方便统计订单量 业务实现 获取指定时间的秒数 LocalDateTime timeBegin = LocalDateTime.of(2024, 1, 1, 0, 0, 0); long second = timeBegin.toEpochSecond(ZoneOffset…
阅读更多...
鸿蒙（HarmonyOS）项目方舟框架（ArkUI）之DatePicker组件

鸿蒙（HarmonyOS）项目方舟框架（ArkUI）之DatePicker组件

鸿蒙&#xff08;HarmonyOS&#xff09;项目方舟框架&#xff08;ArkUI&#xff09;之DatePicker组件 一、操作环境 操作系统: Windows 10 专业版、IDE:DevEco Studio 3.1、SDK:HarmonyOS 3.1 二、DatePicker组件 日期选择器组件&#xff0c;用于根据指定日期范围创建日期滑…
阅读更多...
前端工程\模块化

前端工程\模块化

前端工程\模块化&#x1f3ed; 本篇文章&#xff0c;学习记录于&#xff1a;尚硅谷&#x1f3a2;&#xff0c;紧接前文&#xff1a;邂逅Node.JS的那一夜→博客 无论是前端、后端、甚至非编程领域都有模块化的概念&#xff0c;只是不同的领域叫法不同&#xff0c;不过&#xf…
阅读更多...
n-皇后-dfs

n-皇后-dfs

import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.OutputStreamWriter; import java.util.Scanner;public class Main {static int n,N 20; //这里只会用到2 * n - 1的格子,开大点保险static char[][] g new c…
阅读更多...
编曲学习：功能和声 歌曲结构 和弦编配（上）

编曲学习：功能和声 歌曲结构 和弦编配（上）

34届三和弦 功能和声 歌曲结构 和弦编配&#xff08;上&#xff09;https://app8epdhy0u9502.pc.xiaoe-tech.com/live_pc/l_65b4e014e4b064a83b8f44fd?course_idcourse_2XLKtQnQx9GrQHac7OPmHD9tqbv 34届独立音乐人编曲训练营https://app8epdhy0u9502.pc.xiaoe-tech.com/p/t_…
阅读更多...
【Java程序设计】【C00219】基于SSM的大学生课程管理系统（论文+PPT）

【Java程序设计】【C00219】基于SSM的大学生课程管理系统（论文+PPT）

基于SSM的大学生课程管理系统&#xff08;论文PPT&#xff09; 项目简介项目获取开发环境项目技术运行截图 项目简介 这个一个基于SSM的大学生课程管理系统&#xff0c;本系统共分为三种权限&#xff1a;管理员、教师和学生 管理员&#xff1a;查看个人中心、学生管理、公告信…
阅读更多...
CTF-WEB的知识体系

CTF-WEB的知识体系

CTF概念 CTF是Capture The Flag的缩写&#xff0c;中文一般译作夺旗赛 CTF起源于1996年DEFCON全球黑客大会 DEFCONCTF是全球技术水平和影响力最高的CTF竞赛 竞赛模式 解题模式:解决网络安全技术挑战(即找到flag)&#xff0c;提交后获取相应分值。 攻防赛模式:要求找到其他队…
阅读更多...
计算机基础知识讲解（原码反码补码）（以及在C语言里面是如何计算和运用的）

计算机基础知识讲解（原码反码补码）（以及在C语言里面是如何计算和运用的）

补码反码掩码以及原理 补码、反码和掩码是计算机科学中用于表示和处理数值的三种编码方式。 原码 原码是最直观的数值表示方法&#xff0c;它将数值的二进制表示与其符号位结合起来。在原码表示中&#xff0c;正数的符号位为0&#xff0c;而负数的符号位为1。原码的缺点在于…
阅读更多...
Django实例_后台管理及分页器

Django实例_后台管理及分页器

原理步骤参考: Django开发_14_后台管理及分页器-CSDN博客 一、创建Django项目 二、创建page_app python manage.py startapp page_app三、修改settings.py文件 (一)添加app (二)设置每页显示数据个数 (三)设置中文显示 四、总路由添加子路由路径 from django.contrib impo…
阅读更多...
MD5算法：高效安全的数据完整性保障

MD5算法：高效安全的数据完整性保障

摘要&#xff1a;在数字世界中&#xff0c;确保数据完整性和安全性至关重要。消息摘要算法就是一种用于实现这一目标的常用技术。其中&#xff0c;Message Digest Algorithm 5&#xff08;MD5&#xff09;算法因其高效性和安全性而受到广泛关注。本文将详细介绍MD5算法的优缺点…
阅读更多...
C++初阶：入门泛型编程（函数模板和类模板）

C++初阶：入门泛型编程（函数模板和类模板）

大致介绍了一下C/C内存管理、new与delete后&#xff1a;C初阶&#xff1a;C/C内存管理、new与delete详解 我们接下来终于进入了模版的学习了&#xff0c;今天就先来入门泛型编程 文章目录 1.泛型编程2.函数模版2.1概念2.2格式2.3函数模版的原理2.4函数模版的实例化2.4.1隐式实例…
阅读更多...
leetcode 27.移除元素（python版）

leetcode 27.移除元素（python版）

需求 给你一个数组 nums 和一个值 val&#xff0c;你需要 原地 移除所有数值等于 val 的元素&#xff0c;并返回移除后数组的新长度。 不要使用额外的数组空间&#xff0c;你必须仅使用 O(1) 额外空间并 原地 修改输入数组。 元素的顺序可以改变。你不需要考虑数组中超出新长度…
阅读更多...
Cocos creator 动作系统

Cocos creator 动作系统

动作系统简介 是用于控制物体运动的一套系统&#xff0c;完全依赖代码进行实现&#xff0c;动态调节节点的移动。 移动 cc.moveTo 移动到某个坐标&#xff08;x,y&#xff09; //1秒时间内&#xff0c;移动到0,0let action1 cc.moveTo(1,0,0)this.node.runAction(action1)c…
阅读更多...
LeetCode.2670. 找出不同元素数目差数组

LeetCode.2670. 找出不同元素数目差数组

题目 题目链接 分析 一种暴力的方法&#xff0c;枚举数组所有数字&#xff0c;分别计算当前元素前面不同的元素和后面不同的元素&#xff0c;然后相减即可。这样的话太暴力&#xff0c;前缀和后缀也需要分别遍历&#xff1a;O(N*2)了。 我们来优化一下&#xff1a; 根据这种…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023