数据结构：线性表

已于 2024-03-31 22:32:37 修改
阅读量65 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构 线性表 链表 c语言
于 2023-11-20 23:40:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79277083/article/details/134520477
版权

p.s.个人收录用

p.ss.本文所有代码均使用c语言

目录

存储结构

顺序存储

顺序表

链式储存

单向链表

双向链表

循环单链表

循环双链表

如果一个数据元素序列满足以下要求：
1.第一个数据前没有数据，最后一个数据后面没有数据
2.除去最前面和最后面两个数据，其他数据都有唯一的前驱数据 和唯一的后继数据
称 这些数据组成的结构是线性结构，其构成了线性表
也说 这些数据之间的逻辑关系是线性的

存储结构

顺序存储

组成：数组=>顺序表
优点：随机存取
缺点：插入&删除需要大量操作，可能会空间浪费
应用场景：随机查看的操作较多，且修改操作较少

顺序表

结构体组成：数组(存储数据) +  理论容量 + 实际容量

typedef struct arraylist
{
	int* data;//指针模拟开数组
	int length;//理论容量
	int size;//实际容量
}MyArr;
//初始化
MyArr initArray(int n)
{
	MyArr ar;
	ar.data = (int*)malloc(sizeof(int) * n);
	if (ar.data == NULL)
		printf("空间分配失败\n");
	ar.length = n;
	ar.size = 0;
	return ar;
}

 操作：增 插 删 改 查

 1) 增加：在末尾添加一个元素 （p.s. 首先判断是否超限）

//增加
void add(MyArr* a, int k)
{
	if (a->size < a->length)//判断是否超限
	{
		a->data[a->size] = k;
		a->size++;
	}
	else
		printf("空间已满\n");
}

2) 插入：在指定位置插入一个元素

//插入
void insert(MyArr* a, int i, int k)
{
	if (a->size < a->length)//判断是否超限
	{
		for (int j = a->size - 1; j >= i; j--)//移动位置(倒着移)
			a->data[j + 1] = a->data[j];
		a->data[i] = k;//插入赋值
		a->size++;
	}
	else
		printf("空间已满\n");
}

3) 删除：删除指定数据k
                首先，查找
                其次，删除

//查找
int find(MyArr a, int k)
{
	for (int i = 0; i < a.size; i++)
		if (a.data[i] == k)
			return i;
	return -1;
}

//删除
void del(MyArr* a, int k)
{
	int i = find(*a, k);
	if (i == -1)
		printf("不存在该数据\n");
	else
	{
		for (int j = i; j < a->size - 1; j++)
			a->data[j] = a->data[j + 1];
		a->size--;
	}
}

4) 修改：把指定位置的元素改成另一个元素 

//修改
void change(MyArr* a, int i, int k)
{
	a->data[i] = k;
}
链式储存

组成：链表（由若干个结点组成）
分类：单向链表 双向链表 循环链表 空链表
相关概念：
        结点 / 节点：数据 + 下一个数据的地址（指向下一个数据的指针）
        头指针：存储第一个结点的地址的指针，可标记一个链表
        首元结点：第一个存储真实数据的结点（非空链表一定有）
        头结点：链表中第一个没有存储真实数据的结点（可有可无）
作用： 1）当不带头结点时，对首元结点的操作需要涉及头指针，非常特殊
                 带头结点时，首元结点与其他结点无异
            2）对空链表：带头结点，空链表和非空链表都有结点
声明链表 = 声明结点
应用场景：1）可以实现各种各样的数据结构，灵活
缺点：不能随机访问

单向链表

 结构体组成：数据域data + 指针域next（下一个数据的地址）

typedef struct ListNode {
	int data;//数据
	struct ListNode* next;//保存下一个结点的地址
}Node, * linklist;

p.s.声明头指针 => 增强可读性 

//初始化
linklist initlist()
{
	linklist l = (Node*)malloc(sizeof(Node));
	if (l == NULL)
		printf("分配失败\n");
	else
		l->next = NULL;
	return l;
}

 操作：增 插 删 改 查

1) 增加：
            不带头结点的链表：在首元节点前插入一个结点——动头指针；在其他结点前插入结点；
            带头结点的链表：不分类

接下来以带头结点的链表为例：

步骤：1) 把数据放到一个链表中；2) 再把结点插入到链表中；

①头插

//头插
linklist head_insert(linklist head, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("分配失败\n");
	else
	{
		s->data = k;
		s->next = head->next;
		head->next = s;
	}
	return head;
}

②尾插

//尾插
linklist tail_insert(linklist head, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("分配失败\n");
	else
	{
		s->data = k;
		s->next = NULL;
		//先找到最后一个结点
		Node* t = head;
		while (t != NULL)
		{
			if (t->next == NULL)
				break;
			else
				t = t->next;
		}
		//插入
		t->next = s;
	}
	return head;
}

 ③中间插

//中间插
linklist mid_insert(linklist head, int x, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("分配失败\n");
	else
	{
		s->data = k;
		//先找到x所在的结点
		Node* t = head->next;//比较数据，故从首元节点开始比较
		while (t->data != x)
			t = t->next;
		//插入
		s->next = t->next;
		t->next = s;
	}
	return head;
}

2) 删除：删除指定数据k
                首先，查找
                其次，删除

//删除：删除数据k
linklist del(linklist head, int k)
{
	Node* t = head->next;
	Node* p = head;
	while (t->data != k)
	{
		t = t->next;
		p = p->next;
	}
	p->next = t->next;
	t->next = NULL;//可有可无
	free(t);//把t的空间回收；释放空间
	t = NULL;
	return head;
}

 3) 修改：把指定位置的元素改成另一个元素

//修改
linklist change(linklist head, int k, int x)
{
	Node* t = head->next;
	while (t->data != k)
		t = t->next;
	t->data = x;
}
双向链表

 结构体组成：数据域data + 指针域pre（上一个数据的地址）+  指针域next（下一个数据的地址）

typedef struct ListNode {
	struct ListNode* pre;//上一个结点的地址
	int data;
	struct ListNode* next;
}Node, * linklist;
//初始化
linklist initlist()
{
	linklist l = (Node*)malloc(sizeof(Node));
	if (l == NULL)
		printf("分配失败\n");
	else
	{
		l->pre = NULL;
		l->next = NULL;
	}
	return l;
}

 操作：增 插 删 改 查

1) 增加：

接下来以带头结点的链表为例：

①头插

//头插
linklist head_insert(linklist head, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("分配失败\n");
	else
	{
		s->data = k;
		s->next = head->next;
		s->pre = head;
		if (s->next!=NULL)
			head->next->pre = s;
		head->next = s;
	}
	return head;
}

②尾插

//尾插
linklist tail_insert(linklist head, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("分配失败\n");
	else
	{
		s->data = k;
		s->next = NULL;
		Node* t = head;
		while (t != NULL)
		{
			if (t->next == NULL)
				break;
			t = t->next;
		}
		t->next = s;
		s->pre = t;
	}
	return head;
}

 ③中间插

//中间插
linklist mid_insert(linklist head, int x, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("分配失败\n");
	else
	{
		s->data = k;
		Node* t = head;
		while (t != NULL && t->data != x)
			t = t->next;
		s->next = t->next;
		s->pre = t;
		t->next->pre = s;
		t->next = s;
	}
	return head;
}

2) 删除：删除指定数据k
                首先，查找
                其次，删除

//删
linklist del(linklist head, int x)
{
	Node* t = head->next;
	while (t != NULL && t->data != x)
		t = t->next;
	t->pre->next = t->next;
	if (t->next != NULL)
		t->next->pre = t->pre;
	t->pre = NULL;
	t->next = NULL;
	free(t);
	t = NULL;
	return head;
}

 3) 修改：把指定位置的元素改成另一个元素

//改
linklist change(linklist head, int x, int x0)
{
	Node* s = head->next;
	while (s != NULL && s->data != x)
		s = s->next;
	s->data = x0;
}
循环单链表

 结构体组成：数据域data + 指针域next（下一个数据的地址）

typedef struct NodeList {
	int data;
	struct NodeList* next;
}Node, * linklist;
//初始化
linklist init()
{
	linklist l = (Node*)malloc(sizeof(Node));
	if (l == NULL)
		printf("分配失败\n");
	else
		l->next = l;
	return l;
}

 操作：增 插 删 改 查

1）增加

//头插
linklist insert_head(linklist head, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("分配失败\n");
	else
	{
		s->data = k;
		s->next = head->next;
		head->next = s;
	}
	return head;
}

//尾插
linklist insert_tail(linklist head, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("失败\n");
	else
	{
		s->data = k;
		s->next = head;
		Node* t = head;
		while (t != NULL)
		{
			if (t->next == head)
				break;
			t = t->next;
		}
		t->next = s;
	}
	return head;
}

//中间插
linklist insert_mid(linklist head, int x, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("失败\n");
	else
	{
		s->data = k;
		Node* t = head;
		while (t != NULL)
		{
			if (t->data == x)
				break;
			t = t->next;
		}
		s->next = t->next;
		t->next = s;
	}
	return head;
}

2）删除

//删除
linklist del(linklist head, int k)
{
	Node* t = head->next;
	Node* p = head;
	while (t != NULL)
	{
		if (t->data == k)
			break;
		t = t->next;
		p = p->next;
	}
	p->next = t->next;
	t->next = NULL;
	free(t);
	t = NULL;
	return head;
}

3）改变

//改变
linklist change(linklist head, int x, int k)
{
	Node* t = head->next;
	while (t != NULL)
	{
		if (t->data == x)
			break;
	}
	t->data = k;
	return head;
}
循环双链表

  结构体组成：数据域data + 指针域pre（上一个数据的地址）+  指针域next（下一个数据的地址）

typedef struct NodeList {
	struct NodeList* pre;
	int data;
	struct NodeList* next;
}Node, * linklist;
//初始化
linklist init()
{
	linklist l = (Node*)malloc(sizeof(Node));
	if (l == NULL)
		printf("失败\n");
	else
	{
		l->pre = l;
		l->next = l;
	}
	return l;
}

  操作：增 插 删 改 查

1）增加

//头插
linklist insert_head(linklist head, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("失败\n");
	else
	{
		s->data = k;
		s->next = head->next;
		s->pre = head;
		head->next->pre = s;
		head->next = s;
	}
	return head;
}
//尾插
linklist insert_tail(linklist head, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("失败\n");
	else
	{
		s->data = k;
		s->next = head;
		s->pre = head->pre;
		head->pre->next = s;
		head->pre = s;
	}
	return head;
}
//中间插
linklist insert_mid(linklist head, int x, int k)
{
	Node* s = (Node*)malloc(sizeof(Node));
	if (s == NULL)
		printf("失败\n");
	else
	{
		s->data = k;
		Node* t = head;
		while (t != NULL)
		{
			if (t->data == x)
				break;
			t = t->next;
		}
		s->pre = t;
		s->next = t->next;
		t->next->pre = s;
		t->next = s;
	}
	return head;
}

2）删除

//删除
linklist del(linklist head, int x)
{
	Node* t = head->next;
	while (t != NULL)
	{
		if (t->data == x)
			break;
		t = t->next;
	}
	t->pre->next = t->next;
	t->next->pre = t->pre;
	t->next = NULL;
	t->pre = NULL;
	free(t);
	t = NULL;
	return head;
}

3）改变

//改变
linklist change(linklist head, int x, int k)
{
	Node* t = head->next;
	while (t != NULL)
	{
		if (t->data == x)
			break;
	}
	t->data = k;
	return head;
}

Jessica0706
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构：线性表讲解
dabing113的博客
11-20 651
1.1线性表的基本概念 数据元素之间具有的逻辑关系为线性关系的数据元素结合，称为线性表，n为线性表的长度，长度为0的线性表称为空表 线性表的基本操作 创建一个新的线性表 求线性表的长度 检索线性表中第i个数据元素（1<=i<=n） 根据数据元素的某数据项（通常称为关键字）的值求该数据元素在线性表的位置 在线性表第i个位置上存入一个新的的数据元素 在线性表第i个位置上...
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
数据结构：线性表(List)【详解】
热门推荐
UniqueUnit的博客
02-18 11万+
线性表 一、线性表的定义 线性表（List）：零个或多个数据元素的有限序列。 线性表的数据集合为{a1,a2,…,an}，假设每个元素的类型均为DataType。其中，除第一个元素a1外，每一个元素有且只有一个直接前驱元素，除了最后一个元素an外，每一个元素有且只有一个直接后继元素。数据元素之间的关系是一对一的关系。 在较复杂的线性表中，一个数据元素可以由若干个数据项组成。在这种情况下，常把数据元素称为记录，含有大量记录的线性表又称为文件 二、线性表的顺序标识和实现 概念：用一组地址连续的存储单元依次存储
C语言数据结构：线性表！
qq_42319810的博客
06-12 3832
线性表是具有相同(每个元素所占空间一样大)数据类型的 n（n>=0）个数据元素的有限序列（有次序），其中 n 为表长，当 n = 0 时，线性表是一个空表。若用 L 命名线性表。则一般表示为相关概念：1、ai 是线性表中的 “第 i 个” 元素线性表中的位序注意：位序从 1 开始，但是数组下标从 0 开始。2、a1 是表头元素；an 是表尾元素。3、除了第一个元素外，每个元素有且仅有一个直接前驱；4、除去最后一个元素外，每个元素有且仅有一个直接后继。顺序表。
c语言数据结构：线性表
qq_51813155的博客
11-25 1575
线性表1.什么是线性表？2.线性表的基本运算： 1.什么是线性表？ 线性表是最基本、最简单、也是最常用的一种数据结构。 线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的 它的逻辑结构： 它的：存储结构： 线性表的顺序存储结构——————顺序表 把线性表的所有元素按照逻辑顺序依次存储在 存储位置开始的一块连续的存储空间中 2.线性表的基本运算： 建立线性
数据结构：线性表类型
weixin_55047064的博客
12-12 916
线性表（linear list）是逻辑概念，只要所有的数据在逻辑上是一维的，即每个元素（第一个和最后一个除外）都有一个唯一的前驱（predecessor）和后继（successor），都可以认为是线性表。跟线性表相对的概念应该是树（tree）或者堆（heap）。 线性表根据底层存储空间的类型，分为顺序表（contiguous list）和链表（linked list）。 顺序表：底层存储空间是连续的，插入或删除需要搬运大量元素O(n)，访问方便O(1)。当扩容时需要开辟新空间，把已有元素拷贝，释放旧空间。
数据结构：线性表的实现
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
07-10 1176
增删元素的话，线性结构要保证元素的连续性 动态数组是顺序存储结构具体实现的核心思想 因为线性结构可以有顺序存储结构和链式存储结构实现，那么我i吗就可以把对线性结构的共同操作进行抽取，定义出线性结构的接口 ArrayList及其方法的实现 属性 扩容 缩容 获取元素的值 获取线性表元素个数 获取线性表中数组容量 获取元素在线性表下标 判断是否包含某个元素 判断线性表是否为空 清空线性表 返回子线性表 判断两个线性表是否相等 测试.........
【实验一】数据结构：线性表
weixin_49003900的博客
11-06 2718
数据结构，实验一，线性表，内容：递增有序顺序表的插入、两个有序链表序列的交集、简单计算器、银行业务队列简单模拟
C语言数据结构：线性表
最新发布
Caoshuang_的博客
05-12 1387
线性表的顺序存储结构称为顺序表，之所以是顺序存储，是因为其逻辑地址上相邻的元素在物理地址上也相邻。由于其物理地址与逻辑地址相对应，所以每个元素上只用存储元素的值，查找元素可以通过索引*数据占用内存空间大小计算得到。可以用数组来表示。由于int 类型一般情况下占用内存为 4 字节，在内存地址中它们的分配空间是相临的，所以上面的3个物理地址(16进制)每个相差为4。// sizeof 是一个运算符，它用于计算其操作数的大小（以字节为单位）
数据结构：线性表的操作
aa543928678的博客
07-13 1765
一、要求 1.顺序表的操作 （1）输入一组整型元素序列，建立线性表的顺序存储结构。 （2）实现该线性表的遍历。 （3）在该顺序表中查找某一元素,查找成功显示查找元素，否则显示查找失败。 （4）在该顺序表中插入指定元素。 （5）在该顺序表中删除指定元素。 （6）建立两个按值非递减有序排列的顺序表，将他们合并成一个按值非递减有序排列的顺序表。 2.单链表的操作 （1）输入一组整型元素序列，使用尾插法建立一个带有头结点的单链表。 （2）实现该单链表的遍历。 （3）在该单链表的第i个元素前..
数据结构：线性表(链接存储).ppt
06-19
数据结构：线性表（链接存储） 一、线性表的链接存储 线性表的链接存储是一种存储方式，它可以克服顺序存储的缺点。顺序存储需要一块连续的存储空间，但是当顺序表很大时，系统可能无法分配这么大的一块连续存储...
数据结构：线性表(顺序存储).ppt
06-19
数据结构：线性表（顺序存储） 线性表是具有相同属性的数据元素的一个有限序列。线性表中的各元素都具有同种数据类型，表的长度可用 n（n>=0）表示，表中所含元素个数即为线性表的长度。特殊情况 n=0，且线性表的...
C++数据结构实验一：线性表的应用
03-29
1．熟练掌握线性表的基本运算。 2．掌握顺序表和单链表...4. 掌握线性表的逻辑结构特点、顺序存储结构、链式存储结构、顺序表的结构体类型定义、单链表的结构体类型定义、在两种存储结构上的各种基本操作的实现算法。
数据结构： 线性表讲解实例
11-03
数据结构： 线性表讲解实例。针对线性表的深入讲解。
算法与数据结构：线性表的实现
12-02
线性表是计算机科学中一种基础且重要的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在本主题中，我们将深入探讨四种不同的线性表实现方式：单链表、双链表、静态链表以及如何使用链表来实现多项式的...
《数据结构C++版》实验一：线性表的顺序存储结构实验报告
04-25
《数据结构C++版》实验一的目的是让学生深入理解线性表的顺序存储结构，并熟练掌握C++程序设计的基本技巧。在这个实验中，学生需要通过类的定义来实现线性表，数据对象的类型可以自定义。以下是实验涉及的主要知识点...
数据结构：线性表求一元多项式的值
12-06
考虑到C++标准库中的`std::vector`是一个高效且灵活的动态数组，我们可以选择它来实现线性表： ```cpp #include class Polynomial { private: std::vector<Term> terms; public: // 添加项 void addTerm(int ...
利用C++实现以下经典数据结构算法：线性表、栈、队列、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法）、树.zip
12-28
利用C++实现以下经典数据结构与算法：线性表（顺序表、链表、静态链表、三元组）、栈（双栈、共享栈）、队列（任务调度、循环队列、双向队列、链队列）、数组（特殊矩阵、稀疏矩阵压缩）、串（朴素模式匹配、KMP算法...
数据结构：线性表操作实现
"这是一份来自数据结构教材的算法实现，主要涉及线性表操作，包括顺序表的初始化、判断是否为空、获取长度、追加元素、插入元素、删除元素和查找元素等基本操作。" 在计算机科学中，数据结构是组织和存储数据的方式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值