链表的一些常用函数

于 2024-08-22 14:28:16 发布
阅读量1.1k 收藏 2
点赞数 38
CC 4.0 BY-SA版权
文章标签： 链表 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_hard_August/article/details/141427163

本文用一个相同的主函数和结构体来讲述链表的14种常见函数

主函数和结构体

#include<stdio.h>
#include<stdlib.h>
typedef struct node 
{
	int num;
	struct node* p_next;
}node;
typedef struct 
{
	node head;
	node tail;
}link;


int main()
{
	link lnk = { 0 };
	link_init(&lnk);
	link_add_head(&lnk, 20);
	link_add_head(&lnk, 10);
	link_append(&lnk, 90);
	link_append(&lnk, 100);
	link_insert(&lnk, 70);
	link_insert(&lnk, 40);
	link_insert(&lnk, 60);
	link_insert(&lnk, 30);
	link_insert(&lnk, 50);
	link_insert(&lnk, 80);
	link_remove_head(&lnk);
	link_remove_tail(&lnk);
	int val = 0;
	link_get_head(&lnk, &val);
	printf("最前面数字是%d\n", val);
	link_get_tail(&lnk, &val);
	printf("最后面数字是%d\n", val);
	int size = link_size(&lnk);
	for (int num = 0; num < size; num++) 
	{
		link_get(&lnk, &val, num);
		printf("%d ", val);
	}
	link_deinit(&lnk);
	return 0;
}

链表的初始化函数



//链表的初始化函数
void link_init(link* p_link) 
{
	p_link->head.p_next = &(p_link->tail);
	p_link->tail.p_next = NULL;
}

链表的清理函数

//链表的清理函数
void link_deinit(link* p_link) 
{
	while (p_link->head.p_next != &(p_link->tail)) 
	{
		node* p_first = &(p_link->head);
		node* p_mid = p_first->p_next;
		node* p_last = p_mid->p_next;
		p_first->p_next = p_last;
		free(p_mid);
		p_mid = NULL;
	}
}

统计有效数字个数的函数

//统计有效数字个数的函数
int link_size(const link* p_link)
{
	int cnt = 0;
	const node* p_node = NULL;
	for (p_node = &(p_link->head); p_node != &(p_link->tail); p_node =p_node->p_next) 
	{
		const node* p_first = p_node;
		const node* p_mid = p_first->p_next;
		const node* p_last = p_mid->p_next;
		if (p_mid != &(p_link->tail)) 
		{
			cnt++;
		}
	}
	return cnt;
	// }
	// return cnt-1;
}

判断链表是否为空的函数

//判断链表是否为空的函数
int link_empty(const link* p_link) 
{
	return p_link->head.p_next == &(p_link->tail);
}

判断链表是否为满的函数

//判断链表是否为满的函数
int link_full(const link* p_link) 
{
	return 0;
}

在最前面插入新节点的函数

//在最前面插入新节点的函数
int link_add_head(link* p_link, int num) 
{
	node* p_first = NULL, * p_mid = NULL, * p_last = NULL;
	node* p_node = (node*)malloc(sizeof(node));
	if (!p_node) 
	{
		return 0;
	}

	p_node->num = num;
	p_node->p_next = NULL;
	p_first = &(p_link->head);
	p_mid = p_first->p_next;
	p_last = p_mid->p_next;
	p_first->p_next = p_node;
	p_node->p_next = p_mid;
	return 1;
}

在最后加入新节点的函数

//在最后加入新节点的函数
int link_append(link* p_link, int num) 
{
	node* p_tmp = NULL;
	node* p_node = (node*)malloc(sizeof(node));
	if (!p_node) 
	{
		return 0;
	}
	p_node->num = num;
	p_node->p_next = NULL;
	for (p_tmp = &(p_link->head); p_tmp != &(p_link->tail); p_tmp = p_tmp->p_next)
	{
		node* p_first = p_tmp;
		node* p_mid = p_first->p_next;
		node* p_last = p_mid->p_next;
		if (p_mid == &(p_link->tail)) 
		{
			p_first->p_next = p_node;
			p_node->p_next = p_mid;
			break;
		}
	}
	return 1;
}

按照从小到大的顺序把新节点插入到链式物理结构中

//按照从小到大的顺序把新节点插入到链式物理结构中
int link_insert(link* p_link, int num) {
	node* p_tmp = NULL;
	node* p_node = (node*)malloc(sizeof(node));
	if (!p_node) {
		return 0;
	}
	p_node->num = num;
	p_node->p_next = NULL;
	for (p_tmp = &(p_link->head); p_tmp != &(p_link->tail); p_tmp = p_tmp->p_next) 
	{
		node* p_first = p_tmp;
		node* p_mid = p_first->p_next;
		node* p_last = p_mid->p_next;
		if (p_mid == &(p_link->tail) || p_mid->num > p_node->num)
		{
			p_first->p_next = p_node;
			p_node->p_next = p_mid;
			break;
		}
	}
	return 1;
}

删除第一个有效节点的函数

//删除第一个有效节点的函数
int link_remove_head(link* p_link) 
{
	node* p_first = NULL, * p_mid = NULL, * p_last = NULL;
	if (p_link->head.p_next == &(p_link->tail)) 
	{
		return 0;
	}
	p_first = &(p_link->head);
	p_mid = p_first->p_next;
	p_last = p_mid->p_next;
	p_first->p_next = p_last;
	free(p_mid);
	p_mid = NULL;
	return 1;
}

删除最后一个有效节点的函数

//删除最后一个有效节点的函数
int link_remove_tail(link* p_link) 
{
	node* p_tmp = NULL;
	for (p_tmp = &(p_link->head); p_tmp != &(p_link->tail); p_tmp = p_tmp->p_next) 
	{
		node* p_first = p_tmp;
		node* p_mid = p_first->p_next;
		node* p_last = p_mid->p_next;
		if (p_last == &(p_link->tail)) 
		{
			p_first->p_next = p_last;
			free(p_mid);
			p_mid = NULL;
			return 1;
		}
	}
	return 0;
}

删除某个数字所在节点的函数

//删除某个数字所在节点的函数
int link_remove(link* p_link, int num) 
{
	node* p_tmp = NULL;
	for (p_tmp = &(p_link->head); p_tmp != &(p_link->tail); p_tmp = p_tmp->p_next) 
	{
		node* p_first = p_tmp;
		node* p_mid = p_first->p_next;
		node* p_last = p_mid->p_next;
		if (p_mid != &(p_link->tail) && p_mid->num == num) 
		{
			p_first->p_next = p_last;
			free(p_mid);
			p_mid = NULL;
			return 1;
		}
	}
	return 0;
}

获得第一个有效数字的函数

//获得第一个有效数字的函数
int link_get_head(const link* p_link, int* p_num) 
{
	if (p_link->head.p_next == &(p_link->tail)) 
	{
		return 0;
	}
	const node* p_first = &(p_link->head);
	const node* p_mid = p_first->p_next;
	const node* p_last = p_mid->p_next;
	*p_num = p_mid->num;
	return 1;
}

获得最后一个有效数字的函数

//获得最后一个有效数字的函数
int link_get_tail(const link* p_link, int* p_num) 
{
	const node* p_tmp = NULL;
	for (p_tmp = &(p_link->head); p_tmp != &(p_link->tail); p_tmp = p_tmp->p_next) 
	{
		const node* p_first = p_tmp;
		const node* p_mid = p_first->p_next;
		const node* p_last = p_mid->p_next;
		if (p_last == &(p_link->tail)) 
		{
			*p_num = p_mid->num;
			return 1;
		}
	}
	return 0;
}

获得编号对应数字的函数

//获得编号对应数字的函数
int link_get(const link* p_link, int* p_num, int num)
{
	const node* p_tmp = NULL;
	int cnt = 0;
	for (p_tmp = &(p_link->head); p_tmp != &(p_link->tail); p_tmp = p_tmp->p_next) 
	{
		const node* p_first = p_tmp;
		const node* p_mid = p_first->p_next;
		const node* p_last = p_mid->p_next;
		if (p_mid != &(p_link->tail) && cnt == num) 
		{
			*p_num = p_mid->num;
			return 1;
		}
		cnt++;
	}
	return 0;
}

Hard_August
关注
链表的各种基本函数
白菜
06-24 4827
/* 线性表基本操作的编程实现，掌握线性表的建立、遍历、插入、删除等基本操作的编程 实现，也可以进一步编程实现查找、逆序、排序等操作，需要实现线性表的以下功能: 1、创建单链表 2、删除链表中的某个结点 3、输出单链表(遍历) 4、释放结点所占空间 5、查找第i个结点 6、插入一个结点 7、求链表的长度*/ #include&l...
链表常用操作API函数示例
04-30
在本示例中，我们将深入探讨如何使用API函数来执行链表的常见操作，这些操作在VS2005环境下实现，适用于C++编程。 首先，创建链表涉及定义链表节点的结构。一个链表节点通常包含数据元素和指向下一个节点的指针。...
链表的函数
kyriekk的博客
04-15 1306
如题所示，本文是围绕链表与函数展开的，也就是如何传进传出以及遇到的问题。 1-- 首先观察如下代码，这是之前的知识（套中套那部分），指针p指向一个int变量k，指针pp指向p， 注意他们都是一级指针，所以这里的指针pp紧紧是指向，他具有修改*p也就是k的值的能力，但是！他并没有改变p的地址的能力。 #include <stdio.h> int main() { int k=0; int* p=&k; int* pp=p; *pp=2; printf("%d",k);
LRU缓存机制
m0_49252661的博客
10-09 248
LRU缓存机制LeetCode146官方题解 struct DLinkedNode { int key, value; DLinkedNode* prev; DLinkedNode* next; DLinkedNode(): key(0), value(0), prev(nullptr), next(nullptr) {} DLinkedNode(int _key, int _value): key(_key), value(_value), prev(nullptr
链表及其相关函数（理解总结）
街角的、回忆的博客
08-04 731
链表代码链接 int InitLink(pNode *h) 函数功能：链表初始化 函数参数：头指针的地址 函数返回值：成功返回success，失败返回failure 链表初始化即为给头结点分配空间并初始化指针域。在定义头指针后它还是个野指针，给它分配空间就会得到一个新地址，所以需要传指针的指针来进行指针值修改。 int InsertLink(pNode h, int p, int num)...
链表的常用函数
KaiLoveM的博客
11-30 932
头文件：#ifndef _LINKLIST_H_ #define _LINKLIST_H_#define SUCCESS 1000001 #define FAILURE 1000002 #define TRUE 1000003 #define FALSE 1000004 typedef int ElemType;struct node { ElemType data; st
链表常用函数总结
Det10528的博客
10-28 2854
//创建单链表 PNODE creat_list() { int len; int i; int val; PNODE pHead=NULL; pHead=(PNODE)malloc(sizeof(NODE)); if(NULL==pHead) { printf("分配内存失败，请重新输入"); } PNODE pTail=pHead; pTail->Next=NULL; printf("请您输入需要链表的的个数%d",len); scanf("%d",&.
链表是常用数据结构之一 ，总体分为单向 ，双向
06-06
为了方便操作，还可以定义一些辅助函数，如创建新节点、插入节点到指定位置、删除特定节点以及打印链表内容等。 总结，链表是计算机科学中不可或缺的数据结构，理解其工作原理和操作方法对编程至关重要。无论是单向...
C语言常用函数速查手册.pdf
04-17
但是，根据标题“C语言常用函数速查手册.pdf”以及描述中的信息，我们可以推断该文档很可能包含关于C语言编程中常用函数的信息。下面，我将从C语言常见的函数类型、函数库及使用场景等方面进行介绍，帮助你了解C语言...
双向链表的14个基本操作函数C语言
03-02
其中，链表是一种常用的数据结构，而双向链表是链表的一种变体，它比单链表提供了更多的灵活性。本篇文章将深入讲解双向链表及其14个基本操作函数的C语言实现。 双向链表与单链表不同，每个节点不仅包含数据，还...
关于链表的几个函数
08-22
一段有关链表的代码，链表的创建，插入节点，删除节点。
链表的主函数
11-08
链表的主函数即实现
链表的各种函数
weixin_30838921的博客
06-17 143
# include <stdio.h> # include <stdlib.h> struct node { int data; struct node *next; } ; struct node *creat1(int n) //顺序建立链表 { struct node *head, *tail, *p; ...
链表常用函数
xupeng1644的博客
09-27 656
链表的常用操作包括: 1. 插入（依序插入链尾） 2. 查找 3. 删除 4. 打印输出 5. 判空 源代码如下: MyList.h #include struct ListNode { int nData; ListNode* pNext; }; class MyList { public: MyList() : m_pHead(NULL) {}
链表的相关函数
Bonjour_ming的博客
09-19 909
链表为一种基本的存储方式，对链表的掌握有助于更加理解数据的存储
链表常用函数实现
Luyaooooo0的博客
05-13 385
数据结构-线性结构-单向链表常规函数 #include<stdio.h> #include<stdlib.h> #include<stdbool.h> #define Elemtype int //所有列表均含头节点,单向链表 //节点定义 struct node{ Elemtype val; struct node* next; }; ...
C语言链表相关函数（VS2019）
Hellofeng_的博客
04-21 2657
以下链表函数均为不含虚拟头结点的链表 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdbool.h> #include<stdlib.h> typedef struct Node { int data; struct Node* pnext; }N, * P; //尾插法：在链表末尾插入一个值为newval的新结点 void input(P ph, in...
实现链表的基本函数
Synchro 明净翼 的博客
03-18 406
头文件(linklist.h)#pragma once #include &lt;stdio.h&gt; #include &lt;windows.h&gt; #include &lt;stddef.h&gt; #include &lt;assert.h&gt; typedef int listtype; typedef struct linklist { listtype data; st...
C++链表的常用函数
最新发布
03-18
### C++ 中链表相关的常用函数 在 C++ 编程中，链表是一种常见的动态数据结构。标准模板库 (STL) 提供了一个名为 `std::list` 的容器来实现双向链表功能[^3]。以下是关于链表的一些常见操作及其对应的函数： #### 1. 构造与初始化 - **默认构造函数**: 创建一个空的链表。 ```cpp std::list<int> myList; ``` - **指定大小的构造函数**: 初始化具有特定数量元素的链表。 ```cpp std::list<int> myList(5, 0); // 初始有五个值为0的元素 ``` #### 2. 插入操作 - **push_back()**: 向链表尾部添加一个新元素。 ```cpp myList.push_back(10); ``` - **push_front()**: 向链表头部添加一个新元素。 ```cpp myList.push_front(20); ``` - **insert()**: 在指定位置插入一个或多个元素。 ```cpp auto it = myList.begin(); ++it; // 移动迭代器指向第二个元素的位置 myList.insert(it, 15); // 在第二个元素前插入15 ``` #### 3. 删除操作 - **pop_back()**: 删除链表中的最后一个元素。 ```cpp myList.pop_back(); ``` - **pop_front()**: 删除链表的第一个元素。 ```cpp myList.pop_front(); ``` - **erase()**: 删除由迭代器指定的一个或多个元素。 ```cpp myList.erase(myList.begin()); // 删除第一个元素 ``` #### 4. 访问元素 由于链表不支持随机访问，因此主要依赖于迭代器来进行元素的遍历。 - **begin()/end()**: 返回指向链表起始和结束位置的迭代器。 ```cpp for(auto it = myList.begin(); it != myList.end(); ++it){ cout << *it << " "; } ``` #### 5. 大小与容量 - **size()**: 获取当前链表中存储的有效元素数目。 ```cpp size_t sz = myList.size(); ``` - **empty()**: 检查链表是否为空。 ```cpp if(myList.empty()) { /* ... */ } ``` #### 6. 反转与排序 - **reverse()**: 将链表内的顺序反转。 ```cpp myList.reverse(); ``` - **sort()**: 对链表进行排序，默认升序排列。 ```cpp myList.sort(); ``` 以上列举的是基于 STL 容器 `std::list` 的一些基本方法，在实际开发过程中非常实用。如果需要手动实现链表，则需自行设计节点结构以及上述类似的接口逻辑[^2]。 ```cpp struct Node { int data; Node* next; Node(int val): data(val), next(nullptr){} }; class LinkedList{ private: Node* head; public: void pushFront(int value){/*...*/} void popFront(){/*...*/} }; ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值