封装链表

最新推荐文章于 2024-01-19 15:24:50 发布
最新推荐文章于 2024-01-19 15:24:50 发布
阅读量504 收藏
点赞数 2
分类专栏： C语言 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44442895/article/details/113495061
版权

封装链表

尾添加的效率低，非法下标的判断效率也很低

1、单链表

节点：

​ 数据域

​ 指针域

数据项：

​ 头指针

​ 尾指针

​ 节点数量

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

#define TYPE int 

//	单链表的实现

//	设计节点
typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

Node* create_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

//	设计单链表结构
typedef struct List
{
	Node* head;	//	头指针
	Node* tail;	//	尾指针
	size_t size;	//	数量
}List;

//	创建带头节点单链表
List* create_list(void)
{
	List* list = malloc(sizeof(List));
	list->head = create_node(0);	//	创建一头节点，这是一个带头节点的链表,节点的数据没有意义
	list->tail = NULL;
	return list;
}

//	头添加
void add_head_list(List* list,TYPE data)
{
	Node* node = create_node(data);
	if(list->size == 0)
	{
		list->head->next = node;
		list->tail = node;
	}
	else
	{
		node->next = list->head->next;
		list->head->next = node;
	}
	list->size++;
}
//	尾添加
void add_tail_list(List* list,TYPE data)
{
	Node* node = create_node(data);
	if(list->size ==0)
	{
		list->head->next = node;
		list->tail = node;
	}
	else
	{
		list->tail->next = node;
		list->tail = node;
	}
	list->size++;
}
//	头删除
bool del_head_list(List* list)
{
	if(list->size == 0)	return false;
	Node* tmp = list->head->next;
	list->head->next = tmp->next;	//list->head->next->next
	if(1 == list->size)	list->tail = NULL;
	free(tmp);
	list->size--;
	return true;
}
//	尾删除
bool del_tail_list(List* list)
{
	if(0 == list->size) return false;

	free(list->tail);

	if(1 == list->size)
	{
		list->head->next = NULL;
		list->tail = NULL;
	}
	else
	{
		Node* n = list->head->next;
		while(n->next != list->tail) n = n->next;
		n->next = NULL;
		list->tail = n;
	}
	list->size--;
	return true;
}
//	插入
bool insert_list(List* list,int index,TYPE data)
{
	if(index < 0 || list->size <= index) return false;
	Node* node = create_node(data);
	Node* prev = list->head;	//	待插入位置的上一个位置
	for(int i=0;i<index;i++)
	{
		prev = prev->next;
	}
	node->next = prev->next;
	prev->next = node;
	list->size;
	return true;
}
//	按值删除
bool del_value_list(List* list,TYPE data)
{
	if(data == list->tail->data) return del_tail_list(list);
	if(data == list->head->next->data) return del_head_list(list);
	for(Node* n=list->head->next;n->next->next != NULL;n=n->next)
	{
		if(data == n->next->data)
		{
			Node* tmp = n->next;
			n->next = tmp->next;
			free(tmp);
			list->size--;
			return true;
		}
	}
	return false;
}
//	按位置删除
bool del_index_list(List* list,int index)
{
	if(0>index || index >= list->size) return false;
	if(index == 0)	return del_head_list(list);
	if(index == list->size-1)	return del_tail_list(list);

	Node* prev = list->head->next;
	for(int i=1;i<index;i++)
	{
		prev = prev->next;
	}
	Node* tmp = prev->next;
	prev->next = tmp->next;
	free(tmp);
	list->size--;
	return true;
}
//	值修改	全部值
bool modify_value_list(List* list,TYPE old,TYPE data)
{
	bool flag = false;
	Node* n = list->head->next;
	for(int i=0;i<list->size;i++)
	{
		if(n->data == old)
		{
			n->data = data;
			flag = true;
		}
		n=n->next;
	}
	return flag;
}
//	位置修改
bool modify_index_list(List* list,int index,TYPE val)
{
	if(0>index || index >= list->size) return false;
	Node* n = list->head->next;
	for(int i=0;i<index;i++)
	{
		n = n->next;
	}
	n->data = val;
	return true;
}
//	查询
int query_list(List* list,TYPE data)
{
	Node* n = list->head->next;
	for(int i =0;n;n=n->next,i++)
	{
		if(data == n->data) return i;
	}
	return -1;
}
//	排序
void sort_list(List* list)
{
	for(Node* i=list->head->next;i->next != NULL;i=i->next)
	{
		for(Node* j=i->next;j != NULL;j=j->next)
		{
			if(i->data > j->data)
			{
				TYPE tmp = i->data;
				i->data = j->data;
				j->data = tmp;
			}	
		}
	}
}
//	访问
bool access_list(List* list,int index,TYPE* val)
{
	if(0>index || index>=list->size)	return false;
	Node* n = list->head->next;
	while(index--) n=n->next;
	/*
	for(int i=0;i<index;i++)
	{
		n=n->next;
	}
	*/
	*val = n->data;
	return true;
}
//	清空
void clean_list(List* list)
{
	while(list->tail)	del_tail_list(list);
}

//	销毁
void destory_list(List* list)
{
	clean_list(list);
	free(head);
	//frea(tail);	可但是没必要，因为tail本来就是指向空的
	free(list);
}
//	遍历
void show_list(List* list)
{
	for(Node* n = list->head->next;n;n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}

int main(int argc,const char* argv[])
{
	List* list = create_list();
	for(int i=0;i<10;i++)
	{
		add_tail_list(list,i);
	}
	show_list(list);
	/*
	for(int i=0;i<5;i++)
	{
		del_tail_list(list);
	}
	*/
	//insert_list(list,4,59);		//插入和添加的区别，插入不能在最后的位置插入，最后的位置要增加数据叫做添加
	//del_value_list(list,0);
	//del_index_list(list,7);
	modify_index_list(list,3,59);
	//show_list(list);
	//modify_value_list(list,59,60);
	//sort_list(list);
	show_list(list);
	//printf("index:%d\n",query_list(list,7));
	int num=-1;
	access_list(list,3,&num);
	printf("num:%d\n",num);
	return 0;
}

2、静态链表

节点：

​ 数据域

​ 游标

#include <stdio.h>

typedef struct Node
{
    int data;
    int i;	//游标
}Node;

Node list[100];

int main()
{
	Node* head = list[0];
    head->i = 5;
    list[5].i = 7;
    list[3].i = 3;
}

静态链表的节点储存在连续的内存，通过游标来访问下一个节点

原因：其他的高级语言没有指针

这种链表的插入删除时只能通过修改游标的值，而不用申请、释放内存来达到链式结构的效果

牺牲了随机访问的功能，是一种给没有指针的编译实现单链表

3、循环链表

链表的最后一个节点的next不再指向NULL，而是指向头节点，这种链表叫做单项循环链表，简称循环链表，它的好处是可以通过任意节点遍历整个链表

4、双向链表

节点：

​ 前驱指针

​ 数据域

​ 后继指针

数据项：

​ 头节点

​ 节点数量

双向循环链表的特点：

​ 1、从任何节点都可以遍历整个链表

​ 2、已知节点的位置，可以选择从前到后，还是从后到前进行遍历，依次提高链表的访问效率

未封装

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

#define TYPE int

//	-----带头节点的双向循环链表----

//	设计双向节点
typedef struct Node
{
	struct Node* prev;	//前驱指针
	TYPE data;		//数据域
	struct Node* next;	//后缀指针
}Node;


//	创建节点
Node* create_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->prev = node;
	node->data = data;
	node->next = node;
	return node;
}

//	添加函数
void _add_list(Node* p,Node* n,TYPE data)
{
	Node* node = create_node(data);
	node->next = n;
	node->prev = p;
	p->next = node;
	n->prev = node;
}	

//	删除函数
void _del_list(Node* node)
{
	node->prev->next = node->next;	//	node 是当前节点
	node->next->prev = node->prev;	
	free(node);
}

//	(带头节点) 头添加
void add_head_list(Node* head,TYPE data)
{
	_add_list(head,head->next,data);
}

//	尾添加
void add_tail_list(Node* head,TYPE data)
{
	_add_list(head->prev,head,data);
}

//	插入
bool insert_list(Node* head,size_t index,TYPE data)
{
	Node* n = head->next;
	for(int i=0;i<index;i++)
	{
		n = n->next;
		if(head == n) return false;
	}
	//	n是待插入的位置
	_add_list(n->prev,n,data);
	return true;
}

//	按位置删除
bool del_index_list(Node* head ,size_t index)
{
	Node* n = head->next;
	for(int i=0;i<index;i++)
	{
		n=n->next;
		if(n == head) return false;
	}
	_del_list(n);
	return true;
}

//	按值删除
bool del_value_list(Node* head,TYPE data)
{
	bool flag = false;
	for(Node* n=head->next; n != head ;n=n->next)
	{
		if(n->data == data)
		{
			_del_list(n);
			flag = true;
		}
	}
	return flag;
}
//	遍历
void show_list(Node* head)
{
	for(Node* n=head->next;head != n;n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}
int main(int argc,const char* argv[])
{
	Node* head = create_node(0);
	for(int i=0;i<10;i++)
	{
		add_tail_list(head,i);
	}
	show_list(head);
	insert_list(head,5,98);
	del_index_list(head,4);
	show_list(head);
	del_value_list(head,7);
	show_list(head);
	return 0;
}

封装后

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

#define TYPE int

//	设计节点
typedef struct Node
{
	struct Node* prev;	//前驱指针
	TYPE data;		//数据域
	struct Node* next;	//后缀指针
}Node;

//	创建节点
Node* create_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->prev = node;
	node->data = data;
	node->next = node;
	return node;
}

//	设计双向链表结构
typedef struct DoubleList
{
	Node* head;		//	头
	size_t size;	//	数量
}DoubleList;

//	创建链表结构
DoubleList* creat_list(void)
{
	DoubleList* list = malloc(sizeof(DoubleList));
	list->head = create_node(0);
	list->size = 0;
	return list;
}

//	在前驱和后继之间添加一个节点
//	下划线开头的函数，是其他函数的依赖函数
void _add_list(Node* p,Node* n,TYPE data)
{
	Node* node = create_node(data);
	node->prev = p;
	node->next = n;
	p->next = node;
	n->prev = node;
}

//	删除当前节点
void _del_list(Node* node)
{
	node->prev->next = node->next;
	node->next->prev = node->prev;
	free(node);
}

//	访问指定位置的节点
Node* _index_list(DoubleList* list,size_t index)
{
	if(0>index || index>=list->size)	return NULL;
	if(index< list->size/2)
	{
		//	从前往后找
		Node* n = list->head->next;
		while(index--)	n = n->next;
		return n;
	}
	else
	{
		Node* n = list->head->prev;
		while(++index <list->size)	n = n->prev;
		return n;
	}
}

//	访问指定数值的节点
Node* _value_list(DoubleList* list,TYPE data)
{
	for(Node* n=list->head->next;n!=list->head;n=n->next)
	{
		if(n->data == data) return n;
	}
	return NULL;
}

//	头添加
void add_head_list(DoubleList* list,TYPE data)
{
	_add_list(list->head,list->head->next,data);
	list->size++;
}
//	尾添加
void add_tail_list(DoubleList* list,TYPE data)
{
	_add_list(list->head->prev,list->head,data);
	list->size++;
}
//	插入
bool insert_list(DoubleList* list,size_t index,TYPE data)
{
	Node* n = _index_list(list,index);
	if(n == NULL) return false;
	_add_list(n->prev,n,data);
	list->size++;
}
//	按位置修改
bool modify_index_list(DoubleList* list,size_t index,TYPE data)
{
	Node* n = _index_list(list,index);
	if(n == NULL)	return false;
	n->data = data;
	return true;
}
//	按值修改（全部）
int modify_value_list(DoubleList* list,TYPE old,TYPE data)
{
	bool flag = false;
	int cnt = 0;
	for(Node* n=list->head->next;n!=list->head;n=n->next)
	{
		if(n->data == old)
		{
			n->data = data;
			cnt++;
		}
	}
	return cnt;
}
//	访问
bool access_list(DoubleList* list,size_t index,TYPE *val)
{
	Node* n = _index_list(list,index);
	if(n == NULL) return false;
	*val = n->data;
	return true;
}
//	查询
int query_list(DoubleList* list,TYPE data)
{
	Node* node = list->head->next;
	for(int i=0;i<list->size;i++,node= node->next)
	{
		if(node->data == data)	return i;
	}
}
//	按位置删除
bool del_index_list(DoubleList* list,size_t index)
{
	Node* n = _index_list(list,index);
	if(n == NULL) return false;
	_del_list(n);
	list->size--;
	return true;
}
//	按值删除
bool del_value_list(DoubleList* list,TYPE data)
{
	Node* n = _value_list(list,data);
	if(n = NULL) return false;
	_del_list(n);
	list->size--;
	return true;
}
//	遍历
void show_list(DoubleList* list)
{
	/*
	for(int i=0;i<list->size;i++)
	{
		printf("%d ",list->head->next->data);
		list->head->next = list->head->next->next;
	}
	*/
	for(Node* n = list->head->next;n!=list->head;n=n->next)
	{
		printf("%d ",n->data);
	}
	printf("\n");
}
//	清理空	只是把位置放出啦，值并没有变
void clean_list(DoubleList* list)
{
	while(list->size--)
	{
		del_index_list(list,list->size);
	}
	list->head->next = list->head;
	list->head->prev = list->head;
}
//	销毁
void destroy_list(DoubleList* list)
{
	clean_list(list);
	free(list);
}

int main(int argc,const char* argv[])
{
	DoubleList* list = creat_list();
	for(int i=0;i<10;i++)
	{
		add_tail_list(list,i);
	}
	show_list(list);
	modify_index_list(list,4,85);
	modify_value_list(list,9,90);
	show_list(list);
	/*
	int num =0;
	num =query_list(list,0);
	printf("%d\n",num);
	*/
	clean_list(list);
	show_list(list);
	return 0;
}

5、Linux的内核通用链表

链表的节点不能包含万物，那么久让万物来包含链表

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

//	遍历
#define list_for_each(n, head) \
	for(n = head->next; n != head; n = n->next)

//	计算结构成员所处的结构体中的编号
#define offset(type,mem) ((int)&((type*)0)->mem)

//	计算返回某个结构体的节点成员所处的结构体的首地址
#define node_to_obj(node,type,mem)\
	((type*)((void*)node-offset(type,mem)))

//	第二种遍历
#define list_for_each_entry(obj,head,mem)\
	for(obj=node_to_obj(head->next,typeof(*obj),mem);\
		&obj->mem!=head;\
		obj=node_to_obj(obj->mem.next,typeof(*obj),mem))


//	链表节点
typedef struct Node
{
	struct Node* prev;
	struct Node* next;
}Node;

Node* create_list(void)
{
	Node* head = malloc(sizeof(Node));
	head->prev = head;
	head->next = head;
	return head;
}

void _add_list(Node* prev,Node* next,Node* node)
{
	next->prev = node;
	node->next = next;
	node->prev = prev;
	prev->next = node;
}

//	头添加
void add_head_list(Node* head,Node* node)
{
	_add_list(head,head->next,node);	
}

//	尾添加
void add_tail_list(Node* head,Node* node)
{
	_add_list(head->prev,head,node);	
}

//	判断链表是否为空
bool empty_list(Node* head)
{
	return head == head->next;	
}

//	删除节点
void _del_list(Node* node)
{
	node->next->prev = node->prev;
	node->prev->next = node->next;
	node->next = NULL;
	node->prev = NULL;
}

//	头删除
Node* del_head_list(Node* head)
{
	if(empty_list(head)) return NULL;
	Node* node = head->next;
	_del_list(node);
	return node;
}



//	尾删除
Node* del_tail_list(Node* head)
{
	if(empty_list(head)) return NULL;
	Node* node = head->prev;
	_del_list(node);
	return node;
}

/*----以上是库函数的内容，下面是用户编写的内容---*/

typedef struct Student
{
	char name[20];
	char sex;
	char age;
	char id;
	Node node;
}Student;

int main(int argc,const char* argv[])
{

	Student* s = malloc(sizeof(Student));
	printf("====%p===%p====\n",(Student*)0,&((Student*)0)->node);

	Node* head = create_list();
	for(int i=0; i<10; i++)
	{
		Student* stu = malloc(sizeof(Student));
		sprintf(stu->name,"hehe");
		stu->sex = i%2?'w':'m';
		stu->age = 18+i%2;
		stu->id = 100+i;
		add_tail_list(head,&stu->node);
	//	printf("%p %p\n",&stu->node,stu);
		printf("%s %c %hhd %hhd\n",stu->name,stu->sex,stu->age,stu->id);
	}

	printf("------------\n");
	
	for(int i=0;i<5;i++)
	{
		del_tail_list(head);	
	}
	
	Node* n = NULL;
	/*
	list_for_each(n,head)
	{
		//printf("%p\n",n);	
		//Student* stu = (Student*)n;
		Student* stu = node_to_obj(n,Student,node);
		printf("%s %c %hhd %hhd\n",stu->name,stu->sex,stu->age,stu->id);
	}
	*/
	Student* stu1 = NULL;
	list_for_each_entry(stu1,head,node)
	{
		printf("%s %c %hhd %hhd\n",stu1->name,stu1->sex,stu1->age,stu1->id);
	}
}
willbe-nice
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
双向循环链表的模板封装
freex64的专栏
03-09 170
程序员对双向循环链表的熟悉程度，那就像周星扮演的唐伯虎说《椿树秋香图》一样——“画了几百次啦，熟得很”！。所以直接进入正题模板封装，封装之后模板名称是rubbish::structlist。
单项链表的方法封装
qq_56607109的博客
08-23 295
我们先来认识一下, 链表中应该有哪些常见的操作。
简单的链表封装(类)
m0_61907339的博客
08-31 324
【代码】简单的链表封装(类)
封装链表类
xal87v5的博客
11-22 286
Demo(int val=0,int val1=0) : val1(val1) //使用初始化列表对成员变量val val1初始化。//right getmyval()是static方法，是类的成员。//right const对象可以调用const方法。//const成员是只读的，只能初始化，不能修改。int getval() const //const成员方法:不能修改类对象。//error obj是const对象，只能调用const方法。//static成员。
C++ 封装链表
最新发布
qq_43219334的博客
01-19 501
要注意的是添加前链表是否为空，如果链表为空，那么不存在头尾节点，则添加错误。在这里只简单写了几个关于链表的函数功能，也可以根据自己的需要，封装各种函数。并且在结构体中重载构造函数，方便新节点数据的添加。可以在链表类中封装一些与链表有关的功能。包括头尾节点，和链表长度成员属性。下面让我们来对各个函数进行测试。链表数据使用结构体进行封装。
封装链表模板类的源代码
08-26
利用标准C++的语言，实现封装链表模板类，即List模板类
C++语言封装链表类
09-11
仅供大一参考联系， 利用C++中的类实现线性链表的常见操作
C++编程实例(c++封装链表、栈、队列).pdf
02-13
封装链表、栈和队列是C++编程中的基础数据结构，它们提供了对数据的高效管理。链表是一种动态数据结构，允许在任意位置插入和删除元素。栈是一种后进先出（LIFO）的数据结构，通常用于递归和表达式求值等场景。队列...
通用链表封装
12-29
2. `LinkedList` 类：封装链表操作，如构造函数（创建空链表）、`insert()` 方法（插入节点）、`length()` 方法（计算链表长度）等。 3. 可能还包括一些辅助函数，如`display()`（打印链表），`find()`（查找节点）...
链表类模板封装链表操作
10-25
在C++中，我们可以通过类模板来封装链表的操作，实现通用性且高效的数据处理。类模板是C++中的一个强大特性，允许我们创建泛型代码，适用于多种数据类型。 首先，链表的基本元素是节点，每个节点包含两部分：数据域...
通用链表类封装
03-25
class CMyList { private: PLIST Head; PLIST Last; int iCount; public: CMyList(); ~CMyList(); }
链表封装
weixin_30764137的博客
10-03 758
// 链表 function LinkedList () { function Node(value) { this.next = null this.value = value } this.head = null this.length = 0 //在链表尾部追加元素 LinkedL...
链表及链表的常见操作和用js封装一个链表
M_emory_的博客
04-30 676
/ 封装 append 追加方法// 1、创建新的节点// 2、判断添加的是否为第一个节点if (this.length == 0) { // 2.1 是第一个节点} else { // 2.2 不是第一个节点// 找到最后一个节点while (current.next) { // 判断下一个节点是否为 null ，如果为 null 就跳出循环，如果不为 null ，就继续往后寻找，一直找到最后的节点// 最后节点的next指向新的节点。
JavaScript：封装单向链表10种常见的操作方法
零小唬的博客
12-25 428
JavaScript：封装单向链表10种常见的操作方法
自己封装的链表操作
清流弯弯
12-07 1897
链表节点定义   struct CRectTracker_Node { CRectTracker_Node() { radio_distance_x=0; radio_distance_y=0; radio_width=0; radio_height=0; next=NULL; bSelected=FALSE; };
js单向链表的基本实现
ab31ab的博客
06-13 996
单向链表 1.单向链表的封装 单链表跟双向链表一样,js里的引用类型有点不太懂，此处的this.head不知道是看做指针还是头结点来使用。 我在这里是把this.head复制了一个节点数据，同时把this.head的看做了指针指向了第一个新节点（不这样想看不下去了），按我的想法插入第一个节点的时候是 this.head.next=newNode.先记...
C++ 封装链表类、模板封装链栈、链式队列
weixin_43030270的博客
11-22 394
无
链表—— 最基础的动态数据结构
zjt980452483的博客
01-04 203
package dataStructure.chapter4; /** * @Author: zjtMeng * @Date: 2020/1/1 22:24 * @Version 1.0 */ public class LinkedList<E> { private class Node{ public E e; public Nod...
1.使用C++封装一个链表类LinkList
涂作权的博客
12-07 6724
 使用C++封装一个链表类LinkList。写出相应一个测试用例 链表需要提供 添加 修改删除 除重 合并 排序创建 销毁等接口。 不能调用库函数或者使用STL等类库 题目延伸***********逆置链表********** LinkNode.h #ifndef LINKNOD
如何用class封装链表
07-13
你可以使用类来封装链表，下面是一个示例： ```python class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None def add_node...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值