线性表

最新推荐文章于 2024-09-16 18:31:59 发布
最新推荐文章于 2024-09-16 18:31:59 发布
阅读量94 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Reggie0202/article/details/110562715
版权

线性表基本概念

  • 线性表是零个或者多个数据元素的有限序列
  • 数据元素之间是有顺序的
  • 数据元素个数是有限的
  • 数据元素的类型必须相同

线性表性质

  • a0为线性表的第一个元素，只有一个后继，没有前驱
  • an为线性表最后一个元素，只有一个前驱，没有后继
  • 除了a0和an外的其他元素ai，既有前驱，也有后继
  • 线性表能够逐项访问和顺序存取

线性表操作

  • 创建线性表
  • 销毁线性表
  • 清空线性表
  • 将元素插入线性表
  • 将元素从线性表中删除
  • 获取线性表中某个位置的元素
  • 获取线性表的长度

线性表的顺序存储

  • 用一段地址连续的存储单元依次存储线性表的数据元素

代码示例：

//.h头文件
#ifndef DENAMIC_ARRAY_H
#define DENAMIC_ARRAY_H

#define _CRT_SECURE_NO_WARNINGS

using namespace std;

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

//定义结构体
//动态增长内存，策略将存放数据的内存
//动态数组申请内存，插入和拷贝数据
//capacity表示内存一共可以存放多少元素
//size记录当前数组元素个数
typedef struct DYNAMICARRAY
{
	int* pAddr;//存放数据地址
	int size;//当前有多少个元素
	int capacity;//容量容器最大可以容纳多少元素
}Dynamic_Array;

//写一系列的相关的对结构体操作的函数

//初始化
Dynamic_Array* Dynamic_Init_Array();

//插入
bool Push_Back_Array(Dynamic_Array* arr,int value);

//根据位置删除
bool Remove_Bypos_Array(Dynamic_Array* arr, int pos);

//根据值删除
bool Remove_Byvalue_Array(Dynamic_Array* arr, int value);

//查找
bool Find_Array(Dynamic_Array* arr, int value);

//释放动态数组的内存
bool Free_Space_Array(Dynamic_Array* arr);

//打印数组
void Print_Arrar(Dynamic_Array* arr);

//清空数组
bool Clear_Array(Dynamic_Array* arr);

//返回动态数组容量
int Capacity_Array(Dynamic_Array* arr);

//返回数组元素个数
int Size_Array(Dynamic_Array* arr);

//根据位置获取元素
int Get_Array(Dynamic_Array* arr, int address);

#endif // !DENAMIC_ARRAY_H

//.cpp文件
#include"DynamicArray.h"

// 初始化
Dynamic_Array* Dynamic_Init_Array()
{
	Dynamic_Array* myArray = (Dynamic_Array*)malloc(sizeof(Dynamic_Array));
	if (myArray == NULL)
	{
		printf("内存分配不成功");
		return NULL;
	}
	//初始化数据项
	myArray->capacity = 20;
	myArray->pAddr = (int*)malloc(sizeof(int) * myArray->capacity);
	myArray->size = 0;
	return myArray;
}

//插入
bool Push_Back_Array(Dynamic_Array* arr, int value)
{
	if (arr == NULL)
	{
		return false;
	}
	//判断空间是否足够
	if (arr->size == arr->capacity)
	{
		//第一步申请一块更大空间，默认新空间是旧空间的两倍
		int* newsapce = (int*)malloc(sizeof(int) * arr->capacity * 2);
		if (newsapce == NULL)
		{
			return false;
		}
		//第二步拷贝数据到新的空间
		memcpy(newsapce, arr->pAddr, arr->capacity * sizeof(int));
		//第三步释放旧内存
		free(arr->pAddr);
		//更新容量
		arr->pAddr = newsapce;
		arr->capacity = arr->capacity * 2;	
	}
	arr->pAddr[arr->size] = value;
	arr->size++;
	return true;
}

//根据位置删除
bool Remove_Bypos_Array(Dynamic_Array* arr, int pos)
{
	if (arr == NULL)
	{
		return false;
	}
	if (pos<0 || pos>arr->size)
	{
		return false;
	}
	for (int i = pos; i < arr->size; i++)
	{
		arr->pAddr[i] = arr->pAddr[i + 1];
	}
	arr->pAddr[arr->size] = 0;
	arr->size--;
	return true;
}

//根据值删除，删除数组中所有该值
bool Remove_Byvalue_Array(Dynamic_Array* arr, int value)
{
	if (arr == NULL)
	{
		return false;
	}
	//找到值的位置
	for (int i = 0; i < arr->size; i++)
	{
		if (arr->pAddr[i] == value)
		{
			Remove_Bypos_Array(arr, i);
		}
	}
	return true;
}

//查找
bool Find_Array(Dynamic_Array* arr, int value)
{
	if (arr == NULL)
	{
		return false;
	}
	int flag = 0;
	for (int i = 0; i < arr->size; i++)
	{
		if (arr->pAddr[i] == value)
		{
			flag = 1;
			printf("%d  ", arr->pAddr[i]);
		}	
	}
	if (flag == 0)
		printf("%d找不到，不存在于数组", value);
	printf("\n");
	return true;
}

//释放动态数组的内存
bool Free_Space_Array(Dynamic_Array* arr)
{
	if (arr->pAddr != NULL)
	{
		free(arr->pAddr);
	}
	free(arr);
	return true;
}

//打印数组
void Print_Arrar(Dynamic_Array* arr)
{
	if (arr == NULL)
	{
		return;
	}
	for (int i = 0; i < arr->size; i++)
	{
		printf("%d  ", arr->pAddr[i]);
	}
	printf("\n");
	return ;
}

//清空数组
bool Clear_Array(Dynamic_Array* arr)
{
	if (arr == NULL)
	{
		return true;
	}
	arr->size = 0;
	return true;
}

//返回动态数组容量
int Capacity_Array(Dynamic_Array* arr)
{
	if (arr==NULL)
	{
		return 0;
	}
	return arr->capacity;
}

//返回数组元素个数
int Size_Array(Dynamic_Array* arr)
{
	if (arr == NULL)
	{
		return 0;
	}
	return arr->size;
}

//根据位置获取元素
int Get_Array(Dynamic_Array* arr, int address)
{
	//if (arr==NULL)
	//{
	//	return -1;//表示出错
	//}
	return arr->pAddr[address];
}

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#include"DynamicArray.h"

#define MARRAY_TRUE 1
#define MARRAY_FLASE 0

void test01()
{
	//初始化动态数组
	Dynamic_Array* myArray = Dynamic_Init_Array();
	//打印容量
	printf("数组容量:%d  ", Capacity_Array(myArray));
	printf("数组大小:%d\n", Size_Array(myArray));
	
	//插入元素
	for (int i = 0; i < 30; i++)
	{
		Push_Back_Array(myArray, i);
	}
	printf("数组容量:%d  ", Capacity_Array(myArray));
	printf("数组大小:%d\n", Size_Array(myArray));

	//打印
	Print_Arrar(myArray);

	//删除
	Remove_Bypos_Array(myArray, 0);
	Remove_Byvalue_Array(myArray, 5);

	//查找第五个位置
	printf("第5个元素是%d\n", Get_Array(myArray, 5));

	//打印
	Print_Arrar(myArray);

	//销毁
	Free_Space_Array(myArray);
}

int main(void)
{
	test01();
	system("pause");
	return 0;
}

线性表的链式存储

  • 不连续的内存空间
  • 由一系列的节点组成，每个节点包含两个域，指针域和数据域
  • 最后一个节点是NULL
//.h头文件
#ifndef _LINK_LIST_H
#define _LINK_LIST_H

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
using namespace std;

//链表结点
typedef struct LINKNODE
{
	void* data;//可以指向任何类型的数据
	struct LINKNODE* next;

}LinkNode;

//链表结构体
typedef struct LINKLIST
{
	LinkNode* head;
	int size;
	//不需要容量
}LinkList;

typedef void(*PRINTLINKNODE)(void*);


//初始化链表
LinkList* Init_LinkList();

//指定位置插入
void Insert_LinkList(LinkList* list, int pos,void* data);

//删除指定位置的值
void RemoveByPos_LinkList(LinkList* list, int pos);

//获得链表的长度
int Size_LinkList(LinkList* list);

//查找
int Find_LinkList(LinkList* list, void* data);

//返回第一个结点
void* Front_LinkList(LinkList* list);

//释放链表内存
void FreeSpace_LinkList(LinkList* list);

//打印链表结点
void Print_LinkList(LinkList* list,PRINTLINKNODE print);

#endif 
//.cpp实现文件
#include"LinkList.h"

typedef void(*PRINTLINKNODE)(void*);

//初始化链表
LinkList* Init_LinkList()
{
	LinkList* list = (LinkList*)malloc(sizeof(LinkList));
	if (list == NULL)
	{
		return NULL;
	}
	list->head = (LinkNode*)malloc(sizeof(LinkNode));
	if (list->head == NULL)
	{
		return NULL;
	}
	list->head->data = NULL;
	list->head->next = NULL;
	list->size = 0;
	return list;
}

//指定位置插入
void Insert_LinkList(LinkList* list, int pos, void* data)
{
	if (list == NULL || data == NULL)
	{
		return;
	}

	//友好处理，pos越界
	if (pos<0 || pos>list->size)
	{
		pos = list->size;
	}
	//创建新的结点
	LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));
	if (newNode == NULL)
	{
		return;
	}
	newNode->data = data;
	newNode->next = NULL;
	//找结点
	//辅助指针变量
	LinkNode* pCurrent = list->head;
	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}
	//新结点入链表
	newNode->next = pCurrent->next;
	pCurrent->next = newNode;
	//链表变长
	list->size++;
	return ;
}


//删除指定位置的值
void RemoveByPos_LinkList(LinkList* list, int pos)
{
	if (list == NULL || (pos > list->size || pos < 0))
	{
		return;
	}
	LinkNode* pCurrent = (LinkNode*)malloc(sizeof(LinkNode));
	if (pCurrent == NULL)
	{
		return;
	}
	//查找删除节点的前一个结点
	pCurrent = list->head;
	for (int i = 0; i < pos; i++)
	{
		pCurrent = pCurrent->next;
	}
	//辅助节点
	LinkNode* deleteNode = pCurrent->next;
	pCurrent->next = pCurrent->next->next;
	//释放删除结点的内存
	free(deleteNode);

	return;
}

//获得链表的长度
int Size_LinkList(LinkList* list)
{
	return list->size;
}

//查找
int Find_LinkList(LinkList* list, void* data)
{
	if (list == NULL || data == NULL)
	{
		return -1;
	}
	//遍历查找
	LinkNode* pCurrent = list->head->next;
	int i = 0;
	while (pCurrent!=NULL)
	{
		if (pCurrent->data == data)
		{
			break;
		}
		i++;
		pCurrent = pCurrent->next;
	}
	return i;
}

//返回第一个结点
void* Front_LinkList(LinkList* list)
{
	return list->head->next->data;
}

//释放链表内存
void FreeSpace_LinkList(LinkList* list)
{
	if (list == NULL)
	{
		return;
	}
	//辅助指针变量
	LinkNode* pCurrent = list->head;
	while (pCurrent != NULL)
	{
		//缓存下一个节点
		LinkNode* pNext = pCurrent->next;
		free(pCurrent);
		pCurrent = pNext;
	}
	return;
}

//打印链表结点
void Print_LinkList(LinkList* list, PRINTLINKNODE print)
{
	if (list == NULL)
	{
		return;
	}
	//辅助指针变量
	LinkNode* pCurrent = list->head->next;
	while (pCurrent!=NULL)
	{
		print(pCurrent->data);
		pCurrent = pCurrent->next;
	}
	return;
}
//main.c调用
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include"LinkList.h"
//自定义数据类型
typedef struct PERSON
{
	char name[64];
	int age;
	int score;
}Person;

//打印函数
void MyPrint(void* data)
{
	Person* p = (Person*)data;
	printf("Name:%s  Age:%d  Score:%d\n", 
		    p->name, p->age, p->score);
}

int main(void)
{
	//创建链表
	LinkList* list = Init_LinkList();

	//创建数据类型
	Person p1 = { "aaa",18,100 };
	Person p2 = { "bbb",19,90 };
	Person p3 = { "ccc",20,80 };
	Person p4 = { "ddd",21,70 };
	Person p5 = { "eee",22,60 };

	//数据插入链表
	Insert_LinkList(list, 0, &p1);
	Insert_LinkList(list, 0, &p2);
	Insert_LinkList(list, 0, &p3);
	Insert_LinkList(list, 0, &p4);
	Insert_LinkList(list, 0, &p5);
	//打印
	Print_LinkList(list,MyPrint);

	cout << "---------------------" << endl;
	//返回第一个节点
	void* ret = Front_LinkList(list);
	MyPrint(ret);

	cout << "---------------------" << endl;
	RemoveByPos_LinkList(list, 1);
	Print_LinkList(list, MyPrint);
	//销毁链表
	FreeSpace_LinkList(list);
	cout << "---------------------" << endl;	
	system("pause");
	return 0;
}
Mr_Csyn
关注
专栏目录
线性表的详解
gongjunbox的博客
12-04 9336
线性表是算法题命题的重点。这类算法题实现起来比较容易且代码量较少，但是要求具有最优的性能（时间复杂度、空间复杂度)，才能获得满分。因此，应牢固掌握线性表的各种基本操作（基于两种存储结构)，在平时的学习中多注重培养动手能力。另外，需要提醒的是，算法最重要的是思想!考场上的时间紧迫，在试卷上不一定要求代码具有实际的可执行性，因此应尽力表达出算法的思想和步骤，而不必过于拘泥每个细节。注意算法题只能用C/C++语言实现。
数据结构学习--线性表及其应用--顺序表
06-25
线性表是数据结构的基础，它是由n（n>=0）个相同类型元素构成的有限序列。线性表按照存储方式可以分为顺序表和链表。顺序表是将线性表中的元素顺序地存储在一块连续的内存空间里，通常采用数组作为其底层实现。这种...
数据结构实验报告-线性表-两个有序线性表的归并算法
04-10
具体来说，实验要求学生通过键盘输入数据来建立两个有序线性表，并最终将这两个有序线性表合并成一个新的有序线性表。 #### 实验内容与要求详解 1. **线性表的构建**： - 实验首先要求从键盘输入数据，构建两个...
C++通过类实现线性表
08-19
C++ 通过类实现线性表 本文详细介绍了 C++ 通过类实现线性表的知识点，包括线性表的基本概念、类实现线性表的思路、类成员函数的实现等。 线性表的基本概念 线性表是一种基本的数据结构，线性表是由零个或多个...
线性表通信录【c语言实现】.pdf
08-18
在本篇文档中，详细介绍了如何使用C语言实现一个基本的线性表通讯录管理系统。该系统利用顺序存储结构来组织和管理数据，适用于在校大学生学习数据结构与算法时进行实践操作。以下是文档中提及的关键知识点： 1. ...
数据结构-树（基础，分类，遍历）
nice66660的博客
09-15 1263
在计算机科学中，树是一种常用的非线性数据结构，用于表示具有层次关系的数据。与线性数据结构（如数组和链表）不同，树结构以节点（Nodes）和边（Edges）组成，通过根节点（Root Node）进行组织。每个节点可以有零个或多个子节点，形成一系列层级结构。根节点（Root）：树的最上层节点，没有父节点。节点（Node）：树中的基本单元，包含数据和指向子节点的引用。子节点（Child）：直接连接到某一节点的节点。父节点（Parent）：直接连接到子节点的节点。叶节点（Leaf）：没有子节点的节点。
数据结构之线性表（python）
最新发布
huaz_md的博客
09-16 747
线性表零个或多个数据元素的有限序列在逻辑结构上具有线性关系。将具有“一对一”关系的数据“线性”地存储到物理空间中，这种存储结构就称为线性存储结构（简称线性表线性表元素的个数nn>=0）定义为线性表的长度，当n=0时，称为空表。在较复杂的线性表中，一个数据元素可以有若干个数据项组成。线性表又可以分为顺序表顺序存储结构）和链表链式存储结构。
【数据结构-一维差分】力扣1893. 检查是否区域内所有整数都被覆盖
sjsjs11的博客
09-12 517
首先因为是差分的办法，所以i开始必须在ranges中最小的range[0]及其左边开始，但是由于可能会出现left在最小range[0]的左边，从而在遍历left到最小range[0]的时候满足了i>left而且s这时候又为0，会返回false。输入：ranges = [[1,2],[3,4],[5,6]], left = 2, right = 5。输入：ranges = [[1,10],[10,20]], left = 21, right = 21。解释：21 没有被任何一个区间覆盖。
2_foc闭环调试_ADC电流采样与滤波及pid数据结构
Pou光明的博客
09-11 616
1、ADC电流采样上次添加了编码器获取电角度的程序，将之前开环控制的角度进行了替换，这次再将电流采样添加进来，之后就可以利用这样一个有反馈的系统进行电流环PI控制器参数调试。 之前写过ADC＋DMA电流采样的stm32库函数程序，现在来看还是有很大缺陷的：首先当电机没有转动时，ADC采样已经有了一个数值，即是一个偏置，需要后面将其减去，这块采回来的电流理论上是一个正弦波数值。另外需要将...
【数据结构-一维差分】力扣1854. 人口最多的年份
sjsjs11的博客
09-12 341
在使用差分的时候要注意的是death的那一年，就不算入人口，这和覆盖类的差分不一样，覆盖类差分需要。然后我们定义一个res来记录最多人口的年份，maxNum来计入最大人口的数量，然后去遍历每一年的人口，最后返回res+offset就是人口最多的年份。给你一个二维整数数组 logs ，其中每个 logs[i] = [birthi, deathi] 表示第 i 个人的出生和死亡年份。输入：logs = [[1950,1961],[1960,1971],[1970,1981]]返回 人口最多 且 最早 的年份。
嵌入式初学-C语言-数据结构--七
MaBaB的博客
09-12 1066
根指针：指向根节点的指针变量节点：数据域 (存储的实际数据)指针域 (左，右指针)
【华为OD】2024D卷——生成哈夫曼树
weixin_45653183的博客
09-12 1397
这是通过构建一种特殊的二叉树来实现的，其中每个字符都位于树的一个叶节点上，且该叶节点到根节点的路径上的边所代表的字符（在哈夫曼编码中通常使用0和1表示）共同构成了该字符的编码。·新节点作为这两个子节点的父节点，而原来的两个节点则成为新节点的左右子节点（通常约定左子节点频率小于等于右子节点）。2、不断从堆中取出两个最小的节点作为左右子树，构造一个新的父节点，其权值为两个节点权值之和，并将新节点插入堆中。·然后，算法反复地选择两个频率最小的节点，将它们合并为一个新的节点，新节点的频率是两个子节点频率之和。
数据结构 - 栈
kaneki_lh的博客
09-13 571
/指向栈的指针int maxlen;//表示栈的最大长度int top;//栈顶元素的下标，用来指明栈顶的位置}s//数据域名//指针，指向栈下一个元素。
[数据结构]二叉搜索树
2302_80220453的博客
09-15 935
今天我们来学习一下新的数据结构，二叉搜索树，这个结构比较简单，是一个铺垫式的结构，为之后的平衡二叉树，AVL树以及红黑树做一个知识基础，我们将从概念到实现具体的介绍二叉搜索树。
堆+堆排序+topK问题
博客 | 复习知识点 + 练习 + 最终的领悟 | 全力以赴
09-13 645
交换，size--，再进行向下调整算法。
数据结构——队列
2302_80919983的博客
09-11 1209
/取数据个数assert(pq);++size;7. 检测队列是否为空，如果为空返回非零结果，如果非空返回0- 直接通过检查队列的队头指针（ pq->head ）是否为 NULL 来判断队列是否为空。如果队头指针为 NULL ，则表示队列为空，函数返回 true；否则返回 false。//判断队列是否为空assert(pq);8. 销毁队列-首先，将 cur 指针初始化为队列的头节点（ pq - > head ）。然后，通过一个 while 循环遍历队列中的每个节点。
Python 中常见的数据结构（二）
Liu_Bruce的博客
09-11 408
这些数据结构都有其特点和应用场景，在实际编程中，我们需要选择合适的数据结构来处理和组织数据。这篇文章旨在帮助您更好地理解 Python 中常见的数据结构，希望对您的编程之旅有一定的帮助。栈是一种后进先出数据结构，Python 中，可以使用。图是一种非线性数据结构，Python 中，可以使用。树是一种非线性数据结构，Python 中，可以使用。在上面的示例中，我们创建了一个名为。在上面的示例中，我们创建了一个名为。在上面的示例中，我们创建了一个名为。方法添加两个元素：字符串。方法访问栈中的元素。
C语言实现线性表操作
本文档是关于线性表的实现，使用C语言编写的。文档中包含了一个名为`XianXingBiao`的类，该类用于表示线性表，并提供了初始化、获取长度、插入元素、添加元素以及删除元素等操作。 线性表是一种基本的数据结构，它...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Mr_Csyn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值