数据结构--无头单向非循环链表接口的实现

最新推荐文章于 2022-09-21 12:09:23 发布
最新推荐文章于 2022-09-21 12:09:23 发布
阅读量129 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35297945/article/details/111308041
版权

1 无头单向非循环链表结构

无头单向非循环链表的示意图如下：
在这里插入图片描述
它的定义如下：

//无头单向非循环链表的定义
typedef int LDataType;
typedef struct ListNode {
LDataType data;
struct ListNode* next;
}ListNode;


typedef struct List {
ListNode* head;
}List;

2 无头单向非循环链表接口的实现

2.1 头文件及链表的定义

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

typedef int LDataType;
typedef struct ListNode {
	LDataType data;         //存储的数据
	struct ListNode* next;   //指向下一个节点
}ListNode;

typedef struct List {
	ListNode* head;    //指向链表节点的指针
}List;

2.2 链表的初始化

//链表的初始化
void listInit(list* lst) {
	//链表的初始化就是使head的指向为空
	if (lst == NULL)
		return;       //判断参数是否有效
	lst->head = NULL;
}

2.3 创建一个新节点

//创建一个新节点
listNode* creatNode(LDataType val) {
	//创建一个链表节点，使节点的数据值为val，next指向空
	//返回创建节点的地址
	listNode* node = (listNode*)malloc(sizeof(listNode));
	//申请一个大小为listNode类型的空间，并返回该空间的地址
	node->data = val;
	node->next = NULL;
	return node;
}

2.4 尾插一个数据

//尾插一个数据
void ListPushBack(list* lst, LDataType val) {
	/*1、先判断链表是否为空链表，空链表直接进行尾插，非空则进行如下操作
	  2、得到链表的最后一个节点，地址保存在end中
	* 3、创建一个新的节点，地址保存在node中
	* 4、进行尾插
	*/
	if (lst == NULL)
		return;
	//1、先判断链表是否为空链表
	if (lst->head == NULL) {
		lst->head = creatNode(val);
		return;
	}
	//2、得到最后的节点end
	listNode * end;
	end = lst->head;
	while (end->next != NULL) {
		end = end->next;
	}                     

	//3、创建一个新的节点
	listNode* node = creatNode(val);

	//4、进行尾插
		end->next = node;
}

2.5 尾删一个数据

//尾删一个数据
void ListPopBack(list* lst) {
	/*
	* 1、首先判断链表是否为空链表，若为空，则直接返回，若不为空，进行如下操作
	* 2、找到最后一个节点，记录在end中，并记录上一个节点的位置，记录在perv中
	* 3、释放最后一个节点，使prev->next=NULL
	*/
	//1、若链表为空，则直接返回
	if (lst == NULL || lst->head == NULL)
		return;
	//2、找到最后一个节点并记录前一个节点
	listNode* prev, * end;
	prev = NULL;
	end = lst->head;
	while (end->next != NULL) {
		prev = end;
		end = end->next;
	}
	//prev可能为NULL，也可能不为NULL

	//3、释放最后一个节点
	free(end);
	if (prev == NULL) {
		lst->head = NULL;
	}else
		prev->next = NULL;
}

2.6 头插一个数据

//头插一个数据
void listPushFront(list* lst, LDataType val) {
	/*1、判断是否为空链表，空链表直接插入，非空则进行如下操作
	* 2、创建一个新的节点node
	* 3、node->next = lst->head , lst->head = node ;
	* 4、可以观察出，空链表和非空链表的插入过程相同，可以进行一个合并
	*/
	if (lst == NULL)
		return;
	listNode* node = creatNode(val);
	node->next = lst->head;
	lst->head = node;     
	//注意：上面两条语句的顺序不能发生变化，否则会使链表后面的语句丢失
	/*若不考虑两者的顺序，也可以写成
	* listNode* next = lst->head ;
	* lst->head = node ;
	* node->next = next ;
	*/
}

2.7 头删一个数据

void listPopFront(list* lst) {
	/*1、首先判断链表是否为空，空链表直接返回
	* 2、记录第二个节点的位置next和第一个节点的位置node
	* 3、释放node
	* 4、lst->head = next 
	*/
	//1、空链表直接返回
	if (lst == NULL || lst->head == NULL) {
		return;
	}
	//2、记录节点位置
	listNode* next, * node;
	node = lst->head;
	next = node->next;
	//3、删除节点
	free(node);
	lst->head = next;

}

2.8 在给定节点后插入一个数据

//在给定节点之后删除一个数据
void listEraseAfter(listNode* cur) {
	/*1、记录下一个节点的位置next和下下个节点的位置nextnext
	* 2、释放next；cur->next = nextnext
	*/
	listNode* next = cur->next;
	if (next == NULL)
		return;
	listNode* nextnext = next->next;
	free(next);
	cur->next = nextnext;
}

2.9 在给定节点之后删除一个数据

//在给定节点之后删除一个数据
void listEraseAfter(listNode* cur) {
	/*1、记录下一个节点的位置next和下下个节点的位置nextnext
	* 2、释放next；cur->next = nextnext
	*/
	listNode* next = cur->next;
	listNode* nextnext = next->next;
	free(next);
	cur->next = nextnext;
}

2.10 查找某个节点

listNode* listFind(list* lst, LDataType val) {
	/*1、若为空链表，则直接返回
	* 2、遍历整个链表，查找data==val的节点
	*/
	if (lst == NULL || lst->head == NULL)
		return;
	listNode* cur = lst->head;
	while (cur) {
		if (cur->data == val) {
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

2.11 求链表的长度

//求链表的长度
int listSize(list* lst) {
	/*1、若为空链表，则直接返回0
	* 2、遍历整个链表，计算链表的长度
	*/
	if (lst == NULL || lst->head == NULL)
		return;
	listNode* cur = lst->head;
	int len = 0;
	while (cur) {
		len++;
		cur = cur->next;
	}
	return len;
}

2.12 打印链表

void printList(list* lst) {
	//遍历整个链表依次进行打印
	if (lst == NULL)
		return;
	listNode* cur = lst->head;
	while (cur) {
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

2.13 查找第n个位置的节点

//查找某个节点
listNode* listFindByIdx(list* lst, int n) {
	/*1、若为空链表，则直接返回
	* 2、遍历整个链表，查找第n个节点
	*/
	if (lst == NULL || lst->head == NULL)
		return;
	listNode* cur = lst->head;
	int len = 0;
	while (len < n && cur != NULL) {
		cur = cur->next;
		len++;
	}
	if (len >= n)
		return cur;
	if (cur == NULL)
		return NULL;
}

2.14 销毁一个链表

//销毁一个链表
void listDestroy(list* lst) {
	/*1、若为空链表则直接返回
	* 2、进行头删操作，直至链表清空
	*/
	if (lst == NULL || lst->head == NULL)
		return;
	listNode* cur = lst->head;
	while (cur) {
		lst->head = cur->next;
		free(cur);
		cur = lst->head;
	}
}

注意：
1、进行操作前，一般先考虑链表为空的情况，在考虑链表非空的情况；
2、若程序无法识别list类型，则写全类型名：struct list；

3 验证链表的接口

int main() {
	list lst;
	listInit(&lst);//初始化链表
	listPushBack(&lst, 1);//尾插1
	//链表为1
	printList(&lst); //打印链表
	listPushBack(&lst, 2);//尾插2
	//链表为1->2
	printList(&lst); //打印链表
	listPushFront(&lst, 0);//头插0
	//链表为0->1->2
	printList(&lst); //打印链表
	
	listNode* cur = listFind(&lst ,0);//查找值为0的节点
	listInsertAfter(cur, 11);//在值为0的节点的后方插入11
	//链表为0->11->1->2
	printList(&lst); //打印链表
	cur = listFindByIdx(&lst, listSize(&lst) - 1);
	listInsertAfter(cur, 13);//尾插13
	//链表为0->11->1->2->13
	printList(&lst); //打印链表

	listPopBack(&lst);//尾删
	//链表为0->11->1->2
	printList(&lst); //打印链表
	listPopFront(&lst);//头删
	//链表为11->1->2
	printList(&lst); //打印链表
	cur = listFindByIdx(&lst, 0);
	listEraseAfter(cur);//删除位置0之后的节点
	//链表为11->2
	printList(&lst); //打印链表
	cur = listFindByIdx(&lst, listSize(&lst) - 2);
	listEraseAfter( cur);//尾删
	//链表为11
	printList(&lst); //打印链表
	listDestroy(&lst);//销毁链表
	printList(&lst); //打印链表
	system("pause");
	return 0;
}

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

  • 一个小技巧
    可以将所有的全局变量及函数声明均定义在一个头文件中，这样，就不用考虑.c文件中函数的先后顺序了。
    这里头文件内容如下：
typedef int LDataType;
typedef struct listNode {
	LDataType data;         //存储的数据
	struct ListNode* next;   //指向下一个节点
}listNode;

typedef struct list {
	listNode* head;    //指向链表节点的指针
}list;

void listInit(list* lst);
listNode* creatNode(LDataType val);
void listPushBack(list* lst, LDataType val);
void listPopBack(list* lst);
void listPushFront(list* lst, LDataType val);
void listPopFront(list* lst);
void listInsertAfter(listNode* cur, LDataType val);
void listEraseAfter(listNode* cur);
void printList(list* lst);
listNode* listFind(list* lst, LDataType val);
listNode* listFindByIdx(list* lst, int n);
int listSize(list* lst);
void listDestroy(list* lst);

.c文件中所要声明的头文件如下：

#include<stdio.h>
#include<stdlib.h>
#include"list.h"
晴晴学语言
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Leetcode02-两数相加-基于python
weixin_41444880的博客
10-31 132
1题目描述 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 2审题与思路 1：本题主要考察了链表，链表是数据结构中一种非常重要的结构。关于python中链表的相关知识可以参考此篇文章 https://www.cnblogs.com/king-ding/p/pythonchaintable.
LeetCode02-两数相加（Python3）
倔强的贝吉塔
06-28 180
文章目录题目示例解法 题目 给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。 如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。 您可以假设除了数字 0 之外，这两个数都不会以 0 开头。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/...
c语言之————无头非循环单链表
long123bin的专栏
07-16 473
实现流程： 1.无头链表需要传
【LeetCode】算法刷题之路：2. 两数相加
欢迎来到三十七度的博客
03-31 504
一、题目： 给你两个非空 的链表，表示两个非负的整数。它们每位数字都是按照逆序的方式存储的，并且每个节点只能存储一位数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0开头。 二、示例： 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 三、思路： 标签：链表 1、将两个链表看成是相同长度的进行遍历，如果一个链表较短则在前面补 00，比...
【数据结构】无头单向非循环链表
卑微楽的开发之路
09-28 134
链表 首先我们来思考一个问题: 为什么要有链表这种结构呢? 上次我们写了顺序表, 其实本质上也就是一个数组, 它已经可以完成数据的存储和访问了, 但是它还存在一些不可避免的问题 1. 顺序表的中间和头部的插入删除的时间复杂度都是O(n), 复杂度太高 2. 增容的时候需要申请新的空间, 还要完成数据从旧空间到新空间的数据拷贝过程, 再释放旧空间, 消耗非常大 3. ...
Python实现-无头单向非循环链表
12-22
无头单向非循环链表链表 无头单向非循环链表结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等 无头单向非循环链表 对于任意一个数据元素a(i)来说，储存本身的...
比特数据结构课件-Lesson3-顺序表-链表.pdf
07-07
- **链表分类**：在实际应用中，最常见的链表类型是无头单向非循环链表（常作为其他数据结构的子结构）和带头双向循环链表（用于独立存储数据）。 - **链表的实现**：链表节点通常包含数据和指向下一个节点的指针...
Java之单链表篇！！！ （无头单向非循环链表实现打印、头插、尾插、任意插入、查找、删除某一关键字、删除所有所选关键字、清空单链表等基本操作）
12-21
首先对单链表的结构进行介绍，单链表是由很多个节点一个接一个串接起来的，每个节点包含两部分，数据部分和地址部分，我们这里讲的是无头的单链表，所以没有头节点，每个节点存储的是本身的数据和下一个节点的地址。...
数据结构：单向循环链表源码
07-04
单向循环链表是计算机科学中一种基本的数据结构，它在数据存储和处理中起着重要作用。本资源提供了单向循环链表的源码实现，旨在帮助读者更好地理解和掌握这一概念。下面，我们将深入探讨单向循环链表的定义、特性、...
无头单向非循环链表的实现
Hb_key的博客
08-25 300
简介 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域，由于不必按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。 分...
数据结构之无头单向非循环链表
Python_programer的博客
04-05 223
链表在数据结构中相当的重要，在以后的实际工作中使用率也很高，所以今天分享一些关于链表的基本操作： 1.链表的概念以及定义： 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的，形式如下图所示： typedef struct Node //链表的定义 { int value; //结点的数据域 str...
单链表算法
bobi的博客
03-08 339
链表在内存中结构如下： 单链表插入末尾 package main import "fmt" type Node struct { num int name string next *Node } func insertNode(head *Node, newNode *Node) { tmp := head for { if tmp.next == nil { t...
数据结构：单链表的操作
碧瑶的博客呀
07-05 406
单链表要实现增删改查，反转，置空等功能 分为三部分test.c ,SList.c, SList.h 以下为源代码： test.c #define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include "Slist.h" #include <stdlib.h> void menu() { printf("** 1....
建立带头结点的单链表
兔子王
09-21 1995
【问题描述】 设有头结点单链表，实现单链表建立算法。 【输入形式】 第一行输入一个N（N大于等于1，小于1000）； 第二行输入N个整数，以空格作为分隔，创建长度为N的单链表。 【输出形式】 输出建立的单链表。
数据结构链表的操作
TY113322的博客
03-16 1341
一.链表 1.单链表逆置 解题思路： 使用递归函数，一直递归到链表的最后一个结点，该结点就是反转后的头结点，记作 ret 此后，每次函数在返回的过程中，让当前结点的下一个结点的 next 指针指向当前节点。 同时让当前结点的 next 指针指向 NULL ，从而实现从链表尾部开始的局部反转 当递归函数全部出栈后，链表反转完成。 递归实现版: 非递归实现版本解题思路： 定义两个指针： pre 和 cur ；pre 在前 cur 在后。 每次让 pre 的 next 指向 cur ，实现一次局部反转 局部反转
C 数据结构实验之链表一：顺序建立链表 SDUT
zhangzhaolin12的博客
01-12 3793
Description 输入N个整数，按照输入的顺序建立单链表存储，并遍历所建立的单链表，输出这些数据。 Input 第一行输入整数的个数N； 第二行依次输入每个整数。 Output 输出这组整数。 Sample Input 8 12 56 4 6 55 15 33 62 Output 12 56 4 6 55 15 33 62 Hint 不得使用数组！ 一定要知道链表是怎样连接的，...
单链表的基本操作
代码改变世界，keep coding。
10-12 3212
1、定义单链表节点类； 2、定义单链表类，并实现单链表的创建、插入、删除、取元素操作和将单链表中的最小元素移到最前面的操作； 3、从键盘上依次输入21、75、30、18、42、56，顺序或逆序创建单链表，并输出单链表中的各元素值； 4、分别在单链表的第3个位置和第9个位置插入67和10，给出插入成功或失败的信息，并输出单链表中的各元素值； 5、删除单链表中的第6个数据元素和第8个数据元素，
【单链表经典面试题解析三】在无头单链表的一个非头节点前插入一个节点（要求不能遍历单链表）
sofia_m的博客
10-18 904
每次再遇到单链表的题时，别慌，先好好审题，抓住重点。这道题其实很简单，只要注意到题目的重点，首先是非头结点，然后是前差一个新节点，再就是要求不能遍历单链表。    我们可以先给单链表的一个非头结点后插一个新节点，这个很简单，很容易完成吧，但是好像和题目有点不一样，没关系，我们再把这个非头结点和新节点值给换一换，这样就符合题目要求了，是不是很机智呢！不过感觉文字描述的不太好，看得云里雾里的，接下来
hrbust 基础数据结构——单链表（1）
weixin_30588675的博客
11-12 410
Description 输入n个整数，先按照数据输入的顺序建立一个带头结点的单链表，再输入一个数据m,将单链表中的值为m的结点全部删除。分别输出建立的初始单链表和完成删除后的单链表。 Input 第一行输入数据个数n； 第二行依次输入n个整数； 第三行输入欲删除数据m。 Output 第一行输出原...
数据结构----单向链表
最新发布
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的指针。每个节点只知道下一个节点的位置，而不知道前一个节点的位置。 单向链表的特点是插入和删除操作的效率较高，但是查找某个节点的效率较低。链表的头节点是链表的入口，尾节点的指针指向空。 以下是单向链表的基本操作： 1. 插入操作：在链表的任意位置插入一个新节点。需要修改前一个节点的指针，使其指向新节点，同时新节点的指针指向原来的下一个节点。 2. 删除操作：删除链表中的某个节点。需要修改前一个节点的指针，使其指向下一个节点，同时释放被删除节点的内存空间。 3. 查找操作：遍历链表，逐个比较节点的值，直到找到目标节点或者到达链表末尾。 4. 遍历操作：按顺序访问链表中的每个节点，可以用来打印链表或者进行其他操作。 单向链表常用于需要频繁插入和删除操作的场景，比如实现栈、队列等数据结构，也可以用于实现其他高级数据结构，如图、树等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值