数据结构与算法学习笔记03

最新推荐文章于 2025-05-01 16:54:33 发布
最新推荐文章于 2025-05-01 16:54:33 发布
阅读量317 收藏
点赞数
文章标签： 学习 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_48010588/article/details/126591437
版权
本文详细介绍了单链表、静态链表、循环链表和双向链表的封装实现，并提供了具体的代码示例，包括节点操作、遍历、增删改查等功能。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

目录

封装链表：

1、单链表

单链表封装代码：

 2、静态链表

3、循环链表

4、双向链表

封装双向循环链表代码：

封装链表：

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 val)
{
	Node* node = malloc(sizeof(Node));
	node->data = val;
	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;
	list->size = 0;
	return list;
}

//	头添加
void add_head_list(List* list,TYPE val)
{
	Node* node = create_node(val);
	if(0 == list->size)
	{
		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 val)
{
	Node* node = create_node(val);
	if(0 == list->size)
	{
		list->head->next = node;
		list->tail = node;
	}
	else
	{
		list->tail->next = node;
		list->tail = node;
	}
	list->size++;
}

//	遍历
void show_list(List* list)
{
	for(Node* n=list->head->next; n; n=n->next)
	{
		printf("%d ",n->data);	
	}
	printf("\n");
}

//	头删除
bool del_head_list(List* list)
{
	if(0 == list->size) return false;
	Node* temp = list->head->next;
	list->head->next = temp->next;
	if(1 == list->size) list->tail = NULL;
	list->size--;
	free(temp);
	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* prev = list->head->next;
		while(prev->next != list->tail) prev = prev->next;
		prev->next = NULL;
		list->tail = prev;
	}
	list->size--;
	return true;
}

//	插入
bool insert_list(List* list,size_t index,TYPE val)
{
	if(0 >= index || index >= list->size) return false;

	Node* node = create_node(val);
	Node* prev = list->head->next;
	for(int i=1; i<index; i++) prev = prev->next;

	node->next = prev->next;
	prev->next = node;
	list->size++;
	return true;
}

//	按值删除
bool del_value_list(List* list,TYPE val)
{
	if(val == list->head->next->data)
		return del_head_list(list);
	if(val == list->tail->data)
		return del_tail_list(list);

	for(Node* n=list->head->next; n->next; n=n->next)
	{
		if(val == n->next->data)
		{
			Node* temp = n->next;
			n->next = temp->next;
			free(temp);
			list->size--;
			return true;
		}
	}
	return false;
}

//	按位置删除
bool del_index_list(List* list,size_t index)
{
	if(index >= list->size) return false;
	if(0 == index) 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* temp = prev->next;
	prev->next = temp->next;
	free(temp);
	list->size--;
	return true;
}

//	按位置修改
bool modify_index_list(List* list,size_t index,TYPE val)
{
	if(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;
}

//	按值修改 全部改
size_t modify_value_list(List* list,TYPE old,TYPE val)
{
	size_t cnt = 0;
	for(Node* n=list->head->next; n; n=n->next)
	{
		if(n->data == old)
		{
			n->data = val;
			cnt++;
		}
	}
	return cnt;
}

//	查询
int query_list(List* list,TYPE val)
{
	Node* n = list->head->next;
	for(int i=0; n; i++)
	{
		if(n->data == val) return i;
		n = n->next;
	}
	return -1;
}

//	访问
bool access_list(List* list,size_t index,TYPE* val)
{
	if(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 sort_list(List* list)
{
	for(Node* i=list->head->next; i->next; i=i->next)
	{
		for(Node* j=i->next; j; j=j->next)
		{
			if(j->data > i->data)
			{
				TYPE temp = j->data;
				j->data = i->data;
				i->data = temp;
			}
		}
	}
}

//	清空
void clear_list(List* list)
{
	//while(list->size) del_head_list(list);	耦合度高
	while(list->head->next)
	{
		Node* temp = list->head->next;
		list->head->next = temp->next;
		free(temp);
	}
	list->tail = NULL;
	list->size = 0;
}
//	销毁
void destory_list(List* list)
{
	clear_list(list);
	free(list->head);
	free(list);
}

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);
	del_head_list(list);
	del_tail_list(list);
	del_tail_list(list);
	show_list(list);
	insert_list(list,6,88);
	insert_list(list,6,88);
	del_value_list(list,8);
	show_list(list);
	del_index_list(list,1);
	show_list(list);
	modify_value_list(list,88,22);
	sort_list(list);
	show_list(list);
	TYPE num = -100;
	access_list(list,1,&num);
	printf("num=%d\n",num);
}

 2、静态链表

        结点：

            数据域

            游标

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

        这种链表在插入删除时时需要修改游标的值，而不用申请、释放结点内存就可以达到类似链式结构的效果

        牺牲了随机访问的功能、也没达到链表动态申请内存的效果，只是给没有指针的编程语言实现链表的一种方式，适用范围不大

3、循环链表

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

4、双向链表

        结点：

            前驱指针    prev

            数据域

            后继指针    next

封装双向循环链表代码：

#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->data = data;
	node->prev = node;
	node->next = node;
	return node;
}

//	双向链表
typedef struct DoubleList
{
	Node* head;
	size_t size;
}DoubleList;

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

//	在前驱和后继之间添加一个新结点
static void _add_list(Node* p,Node* n,TYPE val)
{
	Node* node = create_node(val);
	p->next = node;
	n->prev = node;
	node->next = n;
	node->prev = p;
}

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

//	返回指定位置的结点
static Node* _index_list(DoubleList* list,size_t index)
{
	if(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;
	}
}

//	返回指定值的结点
static Node* _value_list(DoubleList* list,TYPE data)
{
	for(Node* n=list->head->next; list->head!=n; n=n->next)
	{
		if(data == n->data) return n;	
	}
	return NULL;
}

//	头添加
void add_head_list(DoubleList* list,TYPE val)
{
	_add_list(list->head,list->head->next,val);
	list->size++;
}

//	尾添加
void add_tail_list(DoubleList* list,TYPE val)
{
	_add_list(list->head->prev,list->head,val);
	list->size++;
}

//	插入
bool insert_list(DoubleList* list,size_t index,TYPE val)
{
	Node* n = _index_list(list,index);	
	if(NULL == n) return false;

	_add_list(n->prev,n,val);
	list->size++;
	return true;
}

//	按位置修改
bool modify_index_list(DoubleList* list,size_t index,TYPE val)
{
	Node* node = _index_list(list,index);
	if(NULL == node) return false;

	node->data = val;
	return true;
}

//	按值修改 更新
size_t modify_value_list(DoubleList* list,TYPE old,TYPE val)
{
	size_t cnt = 0;
	for(Node* n=list->head->next; list->head!=n; n=n->next)
	{
		if(old == n->data)
		{
			n->data = val;
			cnt++;
		}	
	}
	return cnt;
}

//	访问
bool access_list(DoubleList* list,size_t index,TYPE* val)
{
	Node* node = _index_list(list,index);
	if(NULL == node) return false;
	
	*val = node->data;
	return true;
}

//	查询
int query_list(DoubleList* list,TYPE val)
{	
	Node* n = list->head->next;
	for(int i=0; i<list->size; i++)
	{
		if(val == n->data) return i;
		n = n->next;
	}
	return -1;
}

//	按位置删除
bool del_index_list(DoubleList* list,size_t index)
{
	Node* node = _index_list(list,index);
	if(NULL == node) return false;

	_del_list(node);
	list->size--;
	return true;
}

//	按值删除
bool del_value_list(DoubleList* list,TYPE val)
{
	Node* node = _value_list(list,val);
	if(NULL == node) return false;

	_del_list(node);
	list->size--;
	return true;
}

//	遍历
void show_list(DoubleList* list)
{
	for(Node* n=list->head->next; list->head!=n; n=n->next)
	{
		printf("%d ",n->data);	
	}
	printf("\n");
}

//	清空
void clear_list(DoubleList* list)
{
	Node* n = list->head->next;
	while(list->head!=n)
	{
		Node* temp = n;
		n = n->next;
		free(temp);
	}
	list->head->next = list->head;
	list->head->prev = list->head;
	list->size = 0;
}

//	销毁
void destory_list(DoubleList* list)
{
	clear_list(list);
	free(list->head);
	free(list);
}

int main()
{
	DoubleList* list = create_double_list();
	for(int i=0; i<10; i++)
	{
		add_tail_list(list,i);	
	}
	show_list(list);
	insert_list(list,6,88);
	insert_list(list,6,88);
	insert_list(list,6,88);
	insert_list(list,6,88);
	show_list(list);
	TYPE num = -100;
	access_list(list,1,&num);
	printf("num=%d\n",num);
	modify_index_list(list,6,77);
	show_list(list);
	del_index_list(list,1);
	show_list(list);
	del_value_list(list,99);
	modify_value_list(list,88,22);
	show_list(list);
	printf("index=%d\n",query_list(list,90));
	destory_list(list);
}

wyk@sjn
关注
双向循环链表的模板封装
freex64的专栏
03-09 221
程序员对双向循环链表的熟悉程度，那就像周星扮演的唐伯虎说《椿树秋香图》一样——“画了几百次啦，熟得很”！。所以直接进入正题模板封装，封装之后模板名称是rubbish::structlist。
数据结构-双向循环链表及其封装
xiaoyu1381的博客
08-09 159
双向循环链表
双向链表的封装
qq_36963007的博客
03-21 147
function DoublyLinkedList(){ function Node(data){ this.data = data this.prev = null this.next = null } this.head = null this.tail = null this.length = 0 //append方法 DoublyLinkedList.prototype.append = func
C#代码创建双链表以及增删改查
qq_45071375的博客
01-07 913
昨天分享了一篇单链表的博客，今天分享一篇用C#代码创建双链表以及双链表的增删改查的脚本，里面具体的重要代码块我已经标明了详细的注释，推荐了解双链表数据结构的伙伴们可以直接上手，不太了解的话个人建议先去看一下双链表的数据结构，单双链表的代码构成都差不多就是需要注意里面的区别，在这里我先说一下单双链表的区别！ 区别： 单链表：只有一个指向下一个结点的指针，只有一个next 双链表：双链表除了有一个指向...
双向链表
yanghope的专栏
06-05 469
<br />最近时间比较宽裕，所以就封装了一个双向链表，其中包含了栈，和队列的机制，对链表的删除，查找，添加操作都以函数定位，和数字序号定位两种定位方式实现，所有的函数都经过我的测试(估计还会用不妥的地方)，分享给大家，以后用到链式存储的数据结构时，拿来就用就行啦，下面是数据类型，函数声明，定义的代码，（测试函数不再提供）：<br />函数头文件dlist.h<br />#ifndef _LIST_H_<br />#define _LIST_H_<br />/*定义bool型变量*/<br />typede
数据结构与算法学习笔记.docx
11-28
数据结构与算法学习笔记 本文档概括了数据结构和算法的学习笔记，涵盖了堆、线索化二叉树、赫夫曼树等重要概念。下面是详细的知识点解释： 一、堆 1.1 什么是堆？ 堆是一种特殊的二叉树结构，它可以看作是一个...
数据结构与算法Python版学习笔记一
12-21
此外，还需要注意不同数据结构（如数组、链表、栈、队列、树等）以及算法（如排序、搜索、图论等）的应用，这些将在后续的学习笔记中逐步展开。在实践中不断练习和应用，才能真正掌握数据结构与算法的知识。
数据结构与算法学习笔记.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构与算法笔记.pdf
11-20
数据结构与算法笔记.pdf 数据结构与算法是计算机科学中两个紧密相关的概念。数据结构是指计算机中存储、组织和管理数据的方式，而算法是指解决问题的步骤和方法。在这份笔记中，我们将详细介绍算法的五个特性、算法...
Data Structures and Algorithms 数据结构与算法学习笔记.zip
01-14
算法与数据结构涵盖了以下主要内容： 数据结构（Data Structures）： 逻辑结构：描述数据元素之间...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
C# 单链表 | 双链表 | 循环链表的原理和代码实现
Liyager的博客
02-04 2424
C#用代码实现一个单向链表，纯手搓。
将多项式的系数cof，项deg,放进node,然后将node放进list里
jasscical's blog
05-27 575
收获： 1.引入库： #include 使用list容器 #include<iostream> 使用cout\cin #include<fstream> 操作文件 #include<sstream> 字符串流（格式转换） #include <cmath> 使用数学函数 #include <string> string操作 2.自己...
结构体定义 typedef struct LNode 用法说明
qq_41148224的博客
06-10 2万+
最近复习数据结构，对链表的定义进行下说明： 将typedef和结构体的定义和结构体指针的定义连在一起写，精简为如下代码： typedef struct LNode{ ElemType data; struct LNode *next; }LNode,*LinkList; 将精简代码还原： struct LNode { ElemType data; str...
一元多项式的基本操作
qq_41678405的博客
04-28 882
#include &lt;stdio.h&gt;#include &lt;malloc.h&gt;typedef struct lnode{ float cof; int exp; struct lnode *next;}lnode;void creat(lnode *h,int n){ lnode *t,*p; t=h; for(int i=0;i&lt;n;i++) { p=(lnode*)...
typedef struct lnode(结构体及结构体指针)解惑
dhuqsh的博客
07-29 7308
/* 数据结构解惑01  在数据结构中会看到 typedef struct QNode { QElemType data; //数据域  struct QNode *next; //指针域  }QNode,*QueuePtr; typedef struct { QueuePtr front; //队头指针 QueuePtr rear; //队尾指针  };
数据结构之一元多项式相加
热门推荐
学无止境
03-06 3万+
问题 采用链式存储结构，将两个线性链表表示的一元多项式相加，并输出。 算法设计 1、程序结构设计 1）数据结构 typedef struct node { floatcoef; //序数 intexpn; //指数 struct node *next; //指向下一个结点的指针 }......
第四周项目六（1）
lihao66886的博客
09-23 494
/*问题及代码 *Copyright(c)2015,烟台大学计算机学院 *All right reserved. *文件名称：存储多项式的数据结构.cpp *作者：李浩 *完成日期；2015年9月23日 *版本号；v1.0 * *问题描述：　　存储多项式的数据结构 　　多项式的通式是p n (x)=a n x n +a n?1 x n?1 +...+a 1 x+
将多项式的系数cof，项deg,放进node,然后将node放进map里
jasscical's blog
05-27 379
1.map用法 2.跟使用list方式不一样的地方： map<int,double> maptest 迭代器定义：map<int,double> :: iterator iter = maptest.begin(); 除了前面类型 map<int,double> 跟list不一样，定义的其他跟list一样 2.1 取值方式。 iter->first,ite...
OpenGL-ES 学习(15) ----纹理
最新发布
小猪佩奇的博客
05-01 1482
现实生活中，纹理(Texture) 类似于游戏中皮肤的概念，最通常的作用是装饰3D物体，它像贴纸一样贴在物体的表面，丰富物体的表面和细节在OpenGL-ES开发中，纹理除了用于装饰物体表面，还可以用来作为存储数据的容器所以在OpenGL-ES中，纹理实际上是一个可以被采样的复杂数据集合，是GPU的图像数据结构，纹理分为 2D纹理、立方图纹理和 3D纹理2D纹理是OpenGL-ES中最常见和最常用的纹理形式，是一个表示图像数据的二维数组，纹理中一个单独的数据单元被称为纹素或者纹理像素立方图纹理(
C++学习：数据结构与算法分析笔记
在这份"C++数据结构与算法学习笔记"中，重点讲解了以下几个关键知识点： 1. **数据结构和算法的基础**：数据结构和算法是计算机科学的基础，它们构成了解决问题的关键工具。数据结构包括数组、链表、栈、队列、树、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值