数据结构--线性结构

最新推荐文章于 2024-03-26 15:22:39 发布
最新推荐文章于 2024-03-26 15:22:39 发布
阅读量1.1k 收藏
点赞数
分类专栏： 数据结构 文章标签： 链表 队列 堆栈 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20225851/article/details/104114818
版权

线性结构

线性结构主要有以下四种:

  1. 线性表
  2. 栈
  3. 队列
  4. 栈

每种线性结构都可以用链表或者数组去实现，本身也是属于线性表，个人自学数据结构目前主要用于程序竞赛，所以主要以数组实现为主。

线性表（List）

数据对象集：n个元素构成的有序序列（a1，a2…an）

操作集：线性表L∈List，整数i表示位置，元素X∈ElementType，线性表的基本操作主要有:

1、List MakeEmpty()：初始化一个空线性表L
2、ElementType FindKth( int K, List L )：根据位序K，返回相应元素
3、int Find( ElementType X, List L )：在线性表L中查找X的第一次出现位置
4、void Insert( ElementType X, int i, List L)：在位序i前插入一个新元素X
5、void Delete( int i, List L )：删除指定位序i的元素
6、int Length( List L )：返回线性表L的长度n

线性表c++实现（顺序存储）

#include <bits/stdc++.h>
#define ElementType int 
#define Maxsize 10000
using namespace std ;

typedef struct Node{
	ElementType Date[Maxsize];
	int length = 0 ; // 记录当前存储了多少数据 
}List,*qList;

qList MakeEmpty()
{
	List  newlist ;
	return &newlist;
} 

void Insert(ElementType X , int i ,qList L) //在位序i前插入一个新元素 
{
	//1.把i位置开始的元素全部往后移动
	if (L->length +1 == Maxsize)
		{
			cout <<"位置已满，插入失败"<<endl;
			return ;
		}
	for (int j = L->length ; j>i;j--)
		L->Date[j] = L->Date[j-1];
	//2. 插入新元素
	L->Date[i] = X ;
	L->length ++ ; 
}

void TraversrList(List L ) //遍历输出 
{
	if (L.length == 0 )
	{
		cout <<"Empty!"<<endl;
		return ;
	}
	for (int i=0 ;i < L.length ;i++)
	cout <<L.Date[i]<<" ";
	cout << endl;
}

ElementType FindKth(int K ,List L)//返回第k个元素 
{
	if (K>=L.length || K<0)
		{
			cout <<"位置错误"<<endl;
			return -1 ;
		}
	return L.Date[K]; 
}

int Find (ElementType X , List L) //返回在线性表L中查找X的第一次出现位置
{
	for (int i= 0 ;i<L.length ;i++) 
		if (L.Date[i]==X)
			return i;
	return -1;
} 

void Delete(int i, qList L)
{
	if (L->length <i)	
	{
		cout <<"删除位置i无元素！"<<endl;
		return ; 
	}
	int date = L->Date[i];
	cout <<"位置"<<i<<"删除的元素是："<<date <<endl; 
	i++;
	for (;i<L->length-1 ;i++)
		L->Date[i-1] = L->Date[i]; 
	L->length--;
} 

int Length(List L)
{
	return L.length;
}
int main ()
{
	List L = *MakeEmpty(); // 创建线性表
	for (int i=0;i<100;i++)
		Insert(rand(),i,&L);
	Insert(-1,100,&L);
	TraversrList(L);
	if (Find (-1,L)>=0)
	{
		cout <<"-1 的位置："<< Find (-1,L)<<endl;
	}
	else 
	{
		cout <<"未找到！"<<endl; 
	}
	cout <<"位置10的元素为："<< FindKth(10,L)<<endl;
	Delete(100,&L);
	TraversrList(L);
}

在这里插入图片描述

链式存储（有时间再补。。。）

连续存储和链式存储优缺点：

  1. 连续存储有利于元素的访问，链式存储需要访问某位置的元素需要从头开始寻找。
  2. 连续存储改变元素顺序时，需要改动很大部分的存储位置，链式结构改变元素只需改变周围结点指针的指向即可。
  3. 连续存储使用的时连续的空间，内存无法开很大，链式存储使用的空间时不连续的，不需要大片空闲的空间，因此可以大容量存储。

广义表
广义表时线性表的推广，广义表中的单个元素也可以是另一个广义表，但是广义表是非线性的。

多重链表
链表中的节点可能同时属于多个链

  • 多重链表中结点的指针域会有多个
  • 但包含两个指针域的链表并不一定是多重链表，比如在双向链表 不是多重链表
  • 多重链表有广泛的用途： 基本上如树、图这样相对 复杂的数据结构都可以采 用多重链表方式实现存储。

以多重链表实现矩阵为例子：
在这里插入图片描述

堆栈（Stack）

数据对象集：一个有0个或多个元素的又穷线性表
操作集:

1、Stack CreateStack( int MaxSize )： 生成空堆栈，其最大长度为MaxSize；
2、int IsFull( Stack S, int MaxSize )：判断堆栈S是否已满；
3、void Push( Stack S, ElementType item )：将元素item压入堆栈；
4、int IsEmpty ( Stack S )：判断堆栈S是否为空；
5、ElementType Pop( Stack S )：删除并返回栈顶元素

栈最大的特点：后进先出
在这里插入图片描述
应用

  • 函数调用及递归实现
  • 深度优先搜索
  • 回溯算法

顺序存储实现

#include <bits/stdc++.h>
#define ElementType int  
#define Maxsize 10000
using namespace std ;

typedef struct Node{
	ElementType Date[Maxsize];
	int Top= -1 ; // 记录当前存储了多少数据 
}Stack,*qStack;

qStack CreateStack( )//生成空堆栈，其最大长度为MaxSize
{
	Stack newstack ;
	return &newstack;
}

int IsFull( Stack S )//判断堆栈S是否已满
{
	if (S.Top == Maxsize-1)
		return 1 ;
	else 
		return 0 ;
}

void Push( qStack S, ElementType item )//将元素item压入堆栈
{
	if (IsFull(*S))
	{
		cout <<"栈满！"<<endl;
		return ; 
	}
	S->Date[S->Top+1] = item ;
	S->Top ++ ;
}

int IsEmpty ( Stack S )//判断堆栈S是否为空
{
	if (S.Top == -1)
		return 1 ;
	else 
		return 0 ;
}

ElementType Pop( qStack S )//删除并返回栈顶元素
{
	S->Top --;
	return S->Date[S->Top+1];
}

int main ()
{
	//将0 1 2 3 4 5 6压入栈 并以6 5 4 3 2 1 0输出
	Stack s= *CreateStack();
	
	for (int i=0;i<=6;i++)
		if (!IsFull(s))
			Push(&s , i);
	
	while (!IsEmpty(s))
	{
		cout <<Pop(&s)<<" ";
	}
}

在这里插入图片描述

值得一提的是，c++ STL库中已经有现成的栈供我们使用，在程序竞赛中经常会用到，下面会使用现成的Stack去实现表达式求值。

栈实现表达式求值

思路：将中缀表达式转换成后缀表达式，再计算。

  • 中缀表达式：运算符号位于两个运算数之间。如：a+b*c-d
  • 后缀表达式：运算符号位于两个运算数之后。如：abc*+d-

后缀表达式求值策略：从左向右“扫描”，逐个处理运算数和运算符号

  1. 运算数：入栈；
  2. 运算符：从堆栈中弹出适当数量的运算数，计算并结果入栈；
  3. 最后，堆栈顶上的元素就是表达式的结果值。

问题：括号会改变算数预算符的优先级
在这里插入图片描述
解决办法：
在这里插入图片描述
不理解的话看下示例：
在这里插入图片描述
中缀转后缀：

string change (string mid) // 中缀转后缀 
{
	string late ;
	for (int i = 0; i < mid.length(); i++)
	{

		if (mid[i] >= '0' && mid[i] <= '9') // 数字直接放入 
		{
			late.push_back(mid[i]);
		}
		else
		{
			if (s.empty() || mid[i] == '(') //符号栈 空或者为 （ 直接入栈 
			{
				s.push(mid[i]);
			}
			else
			{
				if (mid[i] == ')') //右括号 就把左括号之后的全部输出 
				{
					while (s.top() != '(')
					{
						late.push_back(s.top());
						s.pop();
					}
					s.pop();
				}
				else if (rule[s.top()] >= rule[mid[i]]&& s.top()!='(') //如果优先级比栈里的低 先将高优先级的输出（同优先级按从左到右顺序排） 注意别把（输出了 
				{
					while (!s.empty() && rule[s.top()] >= rule[mid[i]]&&s.top() != '(')
					{
						late.push_back(s.top());
						s.pop();
					}
					s.push(mid[i]);
				}
				else //其余情况就是优先级比栈头符号里高 
					s.push(mid[i]);
			}
		}
	}
	while (!s.empty()) //将剩下的符号输出 
	{
		late.push_back(s.top());
		s.pop();
	}
	return late;
}

在这里插入图片描述
后缀式计算

double calculate (string late)
{
	for (int i=0;i<late.length();i++)
	{
		if (late[i]>='0' && late[i]<='9') //数字先放入栈中
			d.push(late[i]-'0');
		else 
		{   //计算设计除法，所以用double 
			double number1 , number2 ; //符号的话从栈中提取两个数字做运算
			number1= d.top();d.pop();
			number2= d.top();d.pop();
			switch (late[i])
			{
				case '+':  //number1 和 number2的次序千万别弄反了
					d.push(number2+number1); break ;
				case '-':
					d.push(number2-number1);break;
				case '*':
					d.push(number2*number1);break;
				case '/':
					d.push(number2/number1);break ; 
			}
		}
	}
	return d.top();
 }

总代码：

#include <bits/stdc++.h>
#include <stack>
using namespace std ;
stack <char> s ; //储存符号 
stack <double> d ;//储存数字
map<char, int>rule ; //符号优先级按数字大小排 
//2*(9+6/3-5)+4
string change (string mid) // 中缀转后缀 
{
	string late ;
	for (int i = 0; i < mid.length(); i++)
	{

		if (mid[i] >= '0' && mid[i] <= '9') // 数字直接放入 
		{
			late.push_back(mid[i]);
		}
		else
		{
			if (s.empty() || mid[i] == '(') //符号栈 空或者为 （ 直接入栈 
			{
				s.push(mid[i]);
			}
			else
			{
				if (mid[i] == ')') //右括号 就把左括号之后的全部输出 
				{
					while (s.top() != '(')
					{
						late.push_back(s.top());
						s.pop();
					}
					s.pop();
				}
				else if (rule[s.top()] >= rule[mid[i]]&& s.top()!='(') //如果优先级比栈里的低 先将高优先级的输出 注意别把（输出了 
				{
					while (!s.empty() && rule[s.top()] >= rule[mid[i]]&&s.top() != '(')
					{
						late.push_back(s.top());
						s.pop();
					}
					s.push(mid[i]);
				}
				else //其余情况就是优先级比栈头符号里高 
					s.push(mid[i]);
			}
		}
	}
	while (!s.empty()) //将剩下的符号输出 
	{
		late.push_back(s.top());
		s.pop();
	}
	return late;
} 

double calculate (string late)
{
	for (int i=0;i<late.length();i++)
	{
		if (late[i]>='0' && late[i]<='9')
			d.push(late[i]-'0');
		else 
		{
			double number1 , number2 ;
			number1= d.top();d.pop();
			number2= d.top();d.pop();
			switch (late[i])
			{
				case '+':
					d.push(number2+number1); break ;
				case '-':
					d.push(number2-number1);break;
				case '*':
					d.push(number2*number1);break;
				case '/':
					d.push(number2/number1);break ; 
			}
		}
	}
	return d.top();
 } 

int main ()
{
	rule['+'] = 0 ; // 设立数字便于优先级比较 
	rule['-'] = 0 ; // 同优先级按从左到右顺序排 
	rule['*'] = 1 ;
	rule['/'] = 1 ;
	rule['('] = 2 ;
	string mid , late ; // 中缀 ， 后缀 
	cin >> mid;
	late = change(mid);
	cout <<late<<endl ;
	cout <<calculate(late);
}

在这里插入图片描述

队列

数据对象集：一个有0个或多个元素的有穷线性表
操作集：长度为MaxSize的队列Q  Queue，队列元素item ∈ ElementType

1、Queue CreatQueue( int MaxSize )：生成长度为MaxSize的空队列；
2、int IsFullQ( Queue Q, int MaxSize )：判断队列Q是否已满；
3、void AddQ( Queue Q, ElementType item )： 将数据元素item插入队列Q中；
4、int IsEmptyQ( Queue Q )： 判断队列Q是否为空；
5、ElementType DeleteQ( Queue Q )：将队头数据元素从队列中删除并返回

特点：先进先出

顺序存储实现

#include <bits/stdc++.h>
#define ElementType int  
#define Maxsize 10000
using namespace std ;

typedef struct QUEUE {
	ElementType Date[Maxsize];
	int rear=0 ;
	int front=0;
}Queue;
Queue CreatQueue(  )//生成长度为MaxSize的空队列
{
	Queue q ;
	return q ;	
} 
int IsFullQ( Queue Q)//判断队列Q是否已满
{
	if 	(Q.rear +1 == Q.front)
		return 1 ;
	else 
		return 0;
}
void AddQ( Queue &Q, ElementType item )//将数据元素item插入队列Q中
{
	if (IsFullQ(Q))
	{
		cout <<"队满！"<<endl;
		return ; 
	}
	Q.Date[Q.rear]=item; 
	Q.rear = (Q.rear +1)%Maxsize;
}
int IsEmptyQ( Queue Q )//判断队列Q是否为空
{
	if (Q.front == Q.rear  )
		return 1;
	else 
		return 0; 
} 
ElementType DeleteQ( Queue &Q )//将队头数据元素从队列中删除并返回
{
	cout <<"删除的元素为："<<Q.Date[Q.front]<<endl ;
	Q.front = (Q.front+1)%Maxsize ;
}
int main ()
{
	Queue q = CreatQueue ();
	AddQ(q,100);
	AddQ(q,55);
	AddQ(q,22);
	DeleteQ(q);
	DeleteQ(q);
	DeleteQ(q);
}

在这里插入图片描述
STL 中也有现成队列可以使用，主要有两种，一种是普通队列：queue ，还有一种是优先队列：priority_queue，优先队列主要的优点是可以将队列中的元素自动排序，排序的规则可自定义。

队列再算法中的应用：

  • 宽度优先搜索
代码噜噜噜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-线性结构.pdf
07-11
数据结构 数据结构-线性结构 线性结构 线性表 线性表 线性表是最简单最常见的数据结构,属于逻辑结构; 线性表有两种实现⽅式(存储⽅式),分别是顺序实现和链接实现; 定义 定义: 线性表是由n(>=0)个数据元素组成的有限...
数据结构-线性结构
m0_46804568的博客
01-28 1979
线性结构 文章目录线性结构1、稀疏数组2、队列2.1、数组模拟队列2.1.1、环形队列3、链表3.1、单链表3.2、双向链表3.3、单向环形链表3.3.1、Josephu问题4、栈4.1、数组模拟栈4.2、链表模拟栈4.3、栈实现计算器（中缀表达式）4.4、逆波兰计算器5、递归5.1、八皇后问题 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系 。 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的
数据结构——线性结构（线性表）
热门推荐
巧克力布丁的博客
10-24 1万+
定义把所有的结点用一根直线穿起来详细定义线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列，其中n为表长，n=0是一个空表。用L表示线性表a1是唯一的第一个数据元素，又称表头元素；an是唯一的最后一个元素，又叫表尾元素。除了第一个元素之外，每个元素有且仅有一个直接前驱。除了最后一个元素外，每个元素有且仅有一个直接后继。n个节点离散分配彼此通过指针相连每个节点只有一个前驱节点，每个节点只有一个后续节点首节点没有前驱节点，尾节点没有后续节点从某种角度而言。............
【数据结构】常见线性结构
最新发布
qq_72952716的博客
03-26 829
线性表 （ linear list ） 是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使 用的数据结构，... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的， 线性表在物理上存储时，通常以数组和链式结构的形式存储。
常见的线性结构
程序员波特
07-09 978
前言   本篇博客主要是记录手写这些这数据结构的底层实现，加深对线性结构的理解，实现自己的一个小型数据结构库，也会进行简单的时间复杂度分析，对不同的实现进行比较和优化，即侧重于代码实现。由于数据结构是实践性比较强的一个科目，希望大家在看这篇博客时，自己也去写一下代码，看一下运行结果是不是自己想要的，我也会贴出我的运行结果来进行分析。 数组 数组介绍   数组是在内存中存储相同数据类型的连续的空间，最大的优点：查询快速。   数组最好应用于“索引有语意”的情况，例如索引代表学生学号，我们可以根据学号获取这个学
【数据结构——线性结构】
W664160450的博客
03-06 3375
目录1. 简介 1. 简介
常用数据结构--线性结构
qzp1991的专栏
03-23 1670
常用数据结构--线性结构
数据结构--算法相关.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构-线性表09
01-20
 线性表是一种线性结构，它是由零个或多个数据元素构成的有限序列。线性表的特征是在一个序列中，除了头尾元素，每个元素都有且只有一个直接前驱，有且只有一个直接后继，而序列头元素没有直接前驱，序列尾元素没有...
数据结构-算法.zip
01-14
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树）、图结构（有向图、无向图等）以及集合和队列等抽象数据类型。 存储结构（物理结构）：描述数据在计算机中如何...
数据结构-栈10
01-20
栈(Stack)是一种线性存储结构，它具有如下特点： 【注意】： （1）栈中的数据元素遵守”先进后出”(First In Last Out)的原则，简称FILO结构。 （2）限定只能在栈顶进行插入和删除操作。  栈在计算机中应用相当广泛...
【数据结构】1.线性表及其实现
我于万物之中
02-17 231
1.顺序表 //初始化 List MakeEmpty(){ List PtrL; PtrL=(List)malloc(sizeof(struct LNode)); PtrL->Last=-1; return PtrL; } //查找 int Find(int X,List PtrL){ int i=0; while(i<=PtrL->Last&&Pt...
数据结构——线性结构——顺序表和链式表
Jackey_Song的博客
11-16 1399
本篇目录线性表（Linear List）的两种存储实现线性表的操作顺序表链式表不带头节点的链式表带头节点的链式表堆栈队列 线性表（Linear List）的两种存储实现 线性表的顺序存储实现称为顺序表。 线性表的链式存储实现称为链式表。 线性表的操作 List MakeEmpty() ：初始化一个新的空线性表。 ElementType FindKth(List L, int i) ：返回L中位序为 i 的元素。 Position Find(List L, ElementType X) ：返回线性表L中第一
数据结构——线性表顺序存储
qq_43718691的博客
05-06 691
线性表（Linear List）:由同类型数据元素构成有序序列的线性结构 表中元素个数称为线性表的长度，线性表没有元素时称为空表，表起始位置称为表头，表结束位置称表尾 线性表的抽象数据类型描述 类型名称：线性表（list） 数据 对象集：线性表时n（>=0）个元素构成的有序序列（a1,a2,....an） 操作集：线性表L属于LIST，整数i表示位置，元素X属于ElemetTYpe,线性表基本炒作主要有：、 1、List MakeEmpty():初始化一个空线性表L； 2、Ele...
数据结构——线性数据结构
woli0123的博客
03-24 2812
数据结构是指计算机组织和存储数据的方式，不同的数据结构的特点影响着数据相关操作的效率。 线性数据结构是指元素之间的关系是一对一的。线性数据结构有栈，队列，双队列，数组，链表，串。 一、数组 数组是一种典型的顺序存储线性结构并且大小固定，其中元素都具有相同类型，数组在内存中是以一种连续的空间进行存储的，也就是说数组中的元素在内存空间中是两两相邻的，所以已知第一个元素的位置，其他元素的位置都可以...
数据结构-第二章（1）-线性结构
CltCj的博客
11-17 2996
数据结构 数据结构-第一章 数据结构-第二章（1）-线性结构数据结构前言一、线性表1.1 线性表的定义和特点1.2 线性表案例1.3 线性表的类型定义总结 前言 一、线性表 1.1 线性表的定义和特点 线性表（Liner List）：由n(n>=0)个数据元素（节点）a1,a2,a3…an组成的有限序列。 其中数据元素的个数n定义为表的长度 当n=0时称为空表 将非空的线性表（n>0）记住：（a1，a2，…an） 这里的数据元素ai（1<=i<=n）只是一个抽象符合，其具
超详细介绍最基本的数据结构线性存储
qq_67404195的博客
03-24 1235
本文仅仅介绍数据结构中线性存储结构的最基本内容
线性结构（一）
weixin_47264304的博客
11-30 938
数据结构包括数据逻辑结构，数据存储结构，以及实现数据操作的算法。 在数据的逻辑结构中，有种常见的而且简单的结构叫做线性结构，即数据元素之间构成一个有序的序列。这一章，我们就来学习线性结构。 下面以一个例子为例，来引入线性结构： 【例1】 一元多项式及其运算 一元多项式的标准表达式可以表示为：f(x) = a0 + a1x^1+......+a(n-1)x^n-1+a(n)x^n 其运算有相加，相减，相乘 如何在计算机中表示一元多项式并实现其运算呢？ 我们来看看一元多项式的标准形式：你会发现如
线性结构
m0_73863752的博客
09-20 52
实现步骤： 将n至i向后移动一个位置，将要插入的元素写到i的位置，最后表长+1。· ①插入 （在a和b之间插入一个元素x） p为指向a的指针，s为指向x的指针。② 删除 （删除第i个位置的元素）p为指向ai-1的指针，q为指向ai的指针。1.头插法 （[a1，a2，a3，a4] 插入后为：a4，a3，a2，a1）即在第i个位置插入元素x。2.尾插法（[a1,a2,a3,a4] 插入后为a1,a2,a3,a4）r为指向第一个空结点的指针，s为指向a1的指针。p为指向a1的指针，q为指向a2的指针。
数据结构--链式存储结构
10-19
数据结构中的链式存储结构是一种非连续、非顺序的存储结构，它通过指针将一组零散的存储单元串联起来，形成一个链表。链表中的每个节点包含两个部分，一个是数据域，用于存储数据元素，另一个是指针域，用于指向下一个节点的地址。链式存储结构相对于顺序存储结构的优点在于可以动态地分配内存空间，不需要预先分配固定大小的空间，同时也方便插入和删除操作。链式存储结构常见的类型有单链表、双向链表和循环链表。 引用中提到了链式存储结构的相关术语和小结，可以帮助更好地理解链式存储结构。引用中则介绍了数据结构中的线性结构和线性表的顺序表示和实现，以及顺序表的案例，这些内容可以帮助更好地理解链式存储结构与其他存储结构的区别和联系。引用则强调了链表中元素的逻辑次序与物理次序不一定相同，这也是链式存储结构的一个重要特点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值