C语言单链表

最新推荐文章于 2024-04-24 16:09:08 发布
最新推荐文章于 2024-04-24 16:09:08 发布
阅读量1.2k 收藏 52
点赞数 60
分类专栏： 数据结构 C语言 文章标签： c语言 开发语言 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lh11223326/article/details/137055900
版权

目录

一.链表的概念及结构

1.概念：

2.结构：

二.单链表的接口声明

三.单链表实现接口:

(1).增加节点：

 1.创建新节点：

2.在头部增加节点：

3.在尾部增加节点：

4.在指定位置前面增加：

5.在指定位置后面增加：

(2).删除节点：

1.删除头部节点：

2.删除尾部节点：

3.删除指定位置的节点：

4.删除指定位置后面节点：

C语言实现顺序表(增,删,改,查)-CSDN博客icon-default.png?t=N7T8https://blog.csdn.net/lh11223326/article/details/137008884?spm=1001.2014.3001.5501

一.链表的概念及结构

1.概念：

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

现实中数据结构中

注意:

  1. 从上图可以看出，链表结构在逻辑上是连续的，但是在物理上不一定连续。
  2. 现实中的节点一般都是从堆上申请出来的。
  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续。

2.结构：

链表分为单链表和双链表，带头或不带头，循环或者非循环，实际中最常用的只有两种结构:

  1. 无头单向非循环链表：结构简单，一般不会单独用来存数据，实际中更多是作为其他数据结构的子结构，如哈希桶，图的邻接表等。
  2. 带头双向循环链表：结构最复杂，一般用在单独存储数据，实际使用的链表数据结构，都是带头双向循环链表，另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而更简单了。

二.单链表的接口声明

如下代码是各种接口(只提供功能的实现，而不需要了解其原理)的声明,文件为.h： 

创建链表之前需要一个结构体用来当做链表的节点,如，data代表数据，next代表用来把内容链接起来的指针。代码如下：

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

然后需要添加节点的函数，也就是BuySListNode，创建好的节点需要返回出去，所以函数的类型就是结构体的类型。如下

SLTNode* BuySListNode(SLTDataType x);

总所周知单链表的头插头删的速度是最快的为O(1)，但头插头删的话一般需要找到对应的地址，又因为我们使用的是指针指向的节点，所以参数列表为指针的指针，也就是二级指针所以是**，但是尾节点跟中间增加和删除的速度不是那么理想,中间的效率为O(n)这里的n是链表头距离要插入的位置，尾的效率为O(N)这里n是整个链表的长度。

头部增加节点,一个是指向链表的指针，还有一个是要添加的数据:

void SLTPushBack(SLTNode** pphead, SLTDataType x);//头增加

因为都是增加节点所以参数跟头结点并无区别。

void SLTPushFront(SLTNode** pphead, SLTDataType x);//尾增加

而头部删除和尾部删除，不用数据参数只需要一个指针参数用来找到对应的位置,所以代码如下:

void SLTPopBack(SLTNode** pphead);//头删
void SLTPopFront(SLTNode** pphead);//尾删

 在对应位置插入或删除需要一个要插入的位置，这个就是pos，插入比删除多一个数据参数，而在pos之前插入多了一个前后指针。

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

声明接口的总代码如下:

#pragma once
#include<stdio.h>
#include<stdlib.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* phead, SLTDataType x);

//在pos之前插入x
void SLTInsert(SLTNode** pphead,SLTNode*pos, SLTDataType x);

//在pos以后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x);

//在删除pos
void SLTErase(SLTNode** pphead, SLTNode* pos);

//在删除pos以后一个位置
void SLTEraseAfter( SLTNode* pos);

三.单链表实现接口:

也就是遍历整个链表如果它的下一个等于要查找的就返回指针如果一直没找到就返回NULL。查找节点：后续很多操作都需要查找节点比如指定位置插入删除。如要一组 1 2 3 4 5  要找3图如下:

SLTNode* SLTFind(SLTNode* phead, SLTDataType x) {
	SLTNode* cur = phead;
	while (cur!=NULL) {
		if (cur->data == x) {
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

(1).增加节点：

如下是单链表的结构。

 1.创建新节点：

使用malloc创建一个节点并使用一个指针来连接，此函数的类型为结构体指针，是为了返回创建好的指向节点的指针，如果内容为空则创建失败终止程序，创建成功之后放入数据，数据是传入进来的参数，然后把创建出来的节点里面的指针至为空。

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;
}

2.在头部增加节点：

在头部增加节点首先需要新节点指向头指针指向的内容，然后再用头指针指向新节点此时就增加成功。如图：

void SLTPushBack(SLTNode** pphead, SLTDataType x) {
	
	SLTNode* newnode = BuySListNode(x);//开辟一个空间然后传个数据x
	if (*pphead==NULL) {
		//改变的结构体的指针，所以要用二级指针
		*pphead = newnode;
	}
	else {
		SLTNode* tail = *pphead;
		while (tail->next != NULL) {
			tail = tail->next;
		}
		//改变的结构体，用结构体的指针即可
		tail->next = newnode;
	}
	
}

3.在尾部增加节点：

在尾部增加节点只需要用为指针指向新节点，然后再把新节点的指针置空。

void SLTPushFront(SLTNode** pphead, SLTDataType x) {
	SLTNode* newnode = BuySListNode(x);//开辟一个空间然后传个数据x
	newnode->next = *pphead;
	*pphead = newnode;
}

4.在指定位置前面增加：

在指定位置前面增加节点需要一个指定位置也就是pos，还需要一个给新节点数据x，首先用assert断言一下传入的pos是否为有效的，然后再开辟新节点，最后一路走一路判断是否是，如果是指针前面是的话就为真就不执行循环了，然后就用新节点指向它最后用此节点变为指向新的节点。如下图：

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
	assert(pos);
	if (pos == *pphead) {
		SLTPushFront(pphead, x);
	}
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos) {
			prev = prev->next;
		}
		SLTNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}

}

5.在指定位置后面增加：

其方法比上述方法更简便，只需要把要插入位置的指针传进来，先把其节点的指向的地方赋给新节点，然后再用节点指向它。

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

	SLTNode* newnode = BuySListNode(x);
	pos->next = newnode;

	newnode->next = pos->next;

}

(2).删除节点：

1.删除头部节点：

删除头部节点首先查看头指针指向的是否为空，如果为空那就结束，如果链表只有一个节点只需要直接把那个节点释放掉，然后直接用头指针指向空就可以了。

void SLTPopBack(SLTNode** pphead) {
	assert(*pphead);
	//一个节点
	if ((*pphead)->next==NULL) {
		free(*pphead);
		*pphead = NULL;
	}
	else {//一个以上节点
		//SLTNode* tailPerv = NULL;
		//SLTNode* tail = *pphead;
		//while (tail->next) {
		//	tailPerv = tail;
		//	tail = tail->next;
		//}
		//free(tail);
		tail = NULL;
		//tailPerv->next = NULL;

		SLTNode* tail = *pphead;
		while (tail->next->next) {
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;

	}
}

2.删除尾部节点：

找到尾部节点的前一个，然后保存尾部节点指向的内容，然后释放最后在赋值给其。

void SLTPopFront(SLTNode** pphead) {
	assert(*pphead);
	SLTNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}

3.删除指定位置的节点：

首先找节点时指针的next就是下一个节点这样就可以在pos前面了，然后再保存一下pos里面指向的下一个最后把pos释放再用现在指针的节点直接指向之前保存的节点就完了。

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);
		//pos = NULL;
	}

}

4.删除指定位置后面节点：

首先把pos（指定位置）后面那个节点指向的节点保存一下，然后再把其free释放，然后再用pos指向保存的那个节点。

void SLTEraseAfter(SLTNode* pos) {
	assert(pos);
	//检查pos是否是尾节点
	assert(pos->next);
	SLTNode* posNext = pos->next;
	pos->next = posNext->next;

	free(posNext);
	posNext = NULL;
}

总代码如下:

#include"SList.h"

void SLTPrint(SLTNode* phead)
{
	SLTNode* cur = phead;
	//while(cur!=NULL)
	while (cur) {
		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) {
	
	SLTNode* newnode = BuySListNode(x);//开辟一个空间然后传个数据x
	if (*pphead==NULL) {
		//改变的结构体的指针，所以要用二级指针
		*pphead = newnode;
	}
	else {
		SLTNode* tail = *pphead;
		while (tail->next != NULL) {
			tail = tail->next;
		}
		//改变的结构体，用结构体的指针即可
		tail->next = newnode;
	}
	
}
void SLTPushFront(SLTNode** pphead, SLTDataType x) {
	SLTNode* newnode = BuySListNode(x);//开辟一个空间然后传个数据x
	newnode->next = *pphead;
	*pphead = newnode;
}
void SLTPopBack(SLTNode** pphead) {
	assert(*pphead);
	//一个节点
	if ((*pphead)->next==NULL) {
		free(*pphead);
		*pphead = NULL;
	}
	else {//一个以上节点
		//SLTNode* tailPerv = NULL;
		//SLTNode* tail = *pphead;
		//while (tail->next) {
		//	tailPerv = tail;
		//	tail = tail->next;
		//}
		//free(tail);
		tail = NULL;
		//tailPerv->next = NULL;

		SLTNode* tail = *pphead;
		while (tail->next->next) {
			tail = tail->next;
		}
		free(tail->next);
		tail->next = NULL;

	}
}

void SLTPopFront(SLTNode** pphead) {
	assert(*pphead);
	SLTNode* newhead = (*pphead)->next;
	free(*pphead);
	*pphead = newhead;
}
SLTNode* SLTFind(SLTNode* phead, SLTDataType x) {
	SLTNode* cur = phead;
	while (cur!=NULL) {
		if (cur->data == x) {
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

void SLTInsert(SLTNode** pphead, SLTNode* pos, SLTDataType x) {
	assert(pos);
	if (pos == *pphead) {
		SLTPushFront(pphead, x);
	}
	else {
		SLTNode* prev = *pphead;
		while (prev->next != pos) {
			prev = prev->next;
		}
		SLTNode* newnode = BuySListNode(x);
		prev->next = newnode;
		newnode->next = pos;
	}

}

//接口
//在pos以后插入x
void SLTInsertAfter(SLTNode* pos, SLTDataType x) {
	assert(pos);

	SLTNode* newnode = BuySListNode(x);
	pos->next = newnode;

	newnode->next = pos->next;

}

//在删除pos
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);
		//pos = NULL;
	}

}

//在删除pos以后一个位置
void SLTEraseAfter(SLTNode* pos) {
	assert(pos);
	//检查pos是否是尾节点
	assert(pos->next);
	SLTNode* posNext = pos->next;
	pos->next = posNext->next;

	free(posNext);
	posNext = NULL;
}

aMereNobody
关注
  • 60
    点赞
  • 踩
  • 52
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
C语言单链表实现
01-16
c语言单链表的简单实现代码，有初学者的小伙伴可以参考一下。
C语言 单链表的实现
06-28
(1)熟悉将算法转换为程序代码的过程。 (2)了解顺序表的逻辑结构特性，熟练学握顺序表存储结构的 C 语言描述方法。 (3)熟练学握顺序表的基本运算:查找、插入、删除等，学握顺序表的随机存取特性。 (4)了解线性表的链式存储结构，熟练学握线性表的链式存储结构的 C 语言描述方法。 (5)熟练掌握线性链表(单链表)的基本运算:查找、插入、删除等，能在实际应用中灵活选择适当的链表结构。
C语言单链表实现19个功能完全详解.zip_C语言_C语言单链表_单链表
09-20
C语言单链表，实现19个不同功能的完全详细解答
C语言单链表实现多项式相加
08-29
主要为大家详细介绍了C语言单链表实现多项式相加，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c语言单链表
sunzixian998的博客
10-23 772
2.2创建单链表头结点。5.1按位置删除元素。2.1先创建指针结构。3.1按位置插入元素。4.1按位置查找元素。4.2按数值查找位置。
c语言单链表基本操作
qq_59328991的博客
08-16 484
单链表基本操作
C语言 单链表的反转
热门推荐
Genven_Liang的博客
05-18 2万+
C语言 单链表的反转 一、简述 记--简单的将单链表的数据顺序进行反转。如将原来的顺序1 2 3 4 5 6 7 反转为：7 6 5 4 3 2 1 二、方式1：头插法 2.1 头插法1--类似新建链表 2.1.1 思路：断开链表头，然后以头插法的方式将原链表的数据添加链表。 2.1.2 测.........
c语言单链表的逆置
weixin_50626842的博客
10-08 2389
单链表的逆置 方法一：头插 void Reverse(Node* plist) { assert(plist != NULL&&plist->next!=NULL); Node* p = plist->next; Node* q; plist->next = NULL; while (p != NULL) { q = p->next; p->next = plist->next; plist->next = p; p
C语言单链表删除（无备注）
04-05
数据结构典型范例，单链表删除操作（注：因实验需要，没有直接汉语注释和输入提醒）
C语言 | Leetcode C语言题解之第45题跳跃游戏II
m0_59237910的博客
04-23 361
C语言 | Leetcode C语言题解之第45题跳跃游戏II
开发语言漫谈-脚本语言
wangbing1125的博客
04-20 734
前面讲的都称之为编程语言，就是做系统用的。还有一大类称之为脚本语言的语言，这类语言数量极多，大部分程序员用不上，也不关心，这是系统维护人员专用的邻域。更准确的来讲，能直接运行的文本都可以称之为脚本语言，按这个标准，python也是。ruby是日本人松本行弘发明的一种面向对象编程的脚本语言，大量借鉴了Perl、Smalltalk、Eiffel、Ada以及Lisp语言的优点，曾经风靡一时，但现在有点没落了。N多年后，可能现在的很多编程语言消失了，但是只要linux还在，bash就在。它在游戏届那是相当的有名。
数据结构——树和二叉树的基本概念
最新发布
qq_67693066的博客
04-24 1067
数据结构——树和二叉树的基本概念
数据结构中的栈和队列（附实际案例代码）
JAZJD的博客
04-23 765
栈（Stack）和队列（Queue）
数据结构——堆
2301_76613753的博客
04-20 1561
之前我们了解到了一种非线性的数据结构——树，今天我们来学习二叉树的顺序结构——堆的实现，来了解堆这种数据结构。一、堆的概念及结构如果有一个关键码的集合K = { ， ， ，…， }，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足： <=且 <=( >=且 >= ) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。堆的性质：堆中某个节点的值总是不大于或不小于其父节点的值；堆总是一棵完全二叉树。
数据结构面试常见问题：什么是二叉树？如何进行二叉树的遍历？
万猫学社
04-21 871
二叉树是一种特殊的数据结构，它的每个元素都有零个、一个或两个子元素。这些元素被称为节点，每个节点都有一个值，以及两个指向其子节点的链接。这种结构就像一个家族树，每个节点都有一个父节点（除了顶部的根节点），以及左右两个子节点。在实际项目中，我们经常会用到二叉树这种数据结构，它在数据存储、搜索等方面都有着广泛的应用。接下来，我们将深入探讨二叉树的结构，包括节点、父节点、子节点、叶节点、根节点等概念。在本文中，我们介绍了二叉树的基本结构，以及前序遍历、中序遍历和后序遍历的实现方式。
数据结构 -- 二叉树&二叉搜索树
2301_79602614的博客
04-20 1429
这样看似prev = node.val 也就是 prev = 5,但因为你的prev是作为一个参数,是对整个方法中生效的,也就是4这个点有doValid(node.left,prev) 和 doValid(node.right,prev)这两个prev都是4这个点传入的prev并不会说因为在doValid(node.prev)中prev=5导致这个方法的所有prev都变为了5,本质也就是这个参数只是这个方法的局部变量,局部变量的修改不会影响到其他的方法。如何知道右子树处理完成呢？
学习笔记-数据结构-线性表（2024-04-18）- 单向链表选择排序
XuJiaKai的博客
04-20 450
正经的单向链表选择排序！！不是别人的那种交换值的！
学习笔记-数据结构-树与二叉树（2024-4-22）
XuJiaKai的博客
04-23 196
的访问流程：1⃣️先访问当前节点的元素，然后沿着当前节点的左孩子，将元素入栈，一直循环先访问再入栈，直到左孩子为空；2⃣️栈顶元素出栈，并且判断有没有右孩子，如果没有右孩子，继续栈顶元素出栈；2⃣️若队列非空，则队头节点出队，访问该节点，若它有左孩子，则将其左孩子入对；若它有右孩子，则将其右孩子入队。的访问流程：1⃣️沿着根的左孩子，依次将元素入栈，直到左孩子为空；2⃣️栈顶元素出栈并访问，并且判断它是否有右孩子，如果右孩子为空，继续执行2；的思路分析：1⃣️沿着根的左孩子，依次入栈，直到左孩子为空。
c语言单链表实验小结
04-10
C语言单链表实验小结： 在C语言中，单链表是一种常用的数据结构，用于存储和操作数据。在实验中，我们学习了如何使用C语言来实现单链表，并进行了相关的操作。 首先，我们需要定义一个结构体来表示链表的节点，该结构体包含两个成员：数据域和指针域。数据域用于存储节点的数据，指针域用于指向下一个节点。 接下来，我们可以编写一些函数来对链表进行操作。常见的操作包括： 1. 创建链表：通过动态内存分配来创建一个空链表。 2. 插入节点：在链表的指定位置插入一个新节点。 3. 删除节点：从链表中删除指定位置的节点。 4. 遍历链表：按顺序输出链表中的所有节点的数据。 5. 查找节点：根据给定的值，在链表中查找对应的节点。 在实验中，我们可以通过编写这些函数来完成对单链表的操作，并进行测试验证其正确性和效果。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值