线性数据结构（线性表）

最新推荐文章于 2023-03-24 18:00:00 发布

Whowhom

最新推荐文章于 2023-03-24 18:00:00 发布

阅读量380

点赞数

文章标签：数据结构链表

本文链接：https://blog.csdn.net/Whowhom/article/details/127853204

版权

线性数据结构（线性表）

线性数据结构主要是指线性表。线性表，类似于“手牵手”的游戏。线性表利于我们处理“点对点”、“一对一”的数据关系，在程序中可以通过多种方式来实现线性表。

1.数组实现线性表

数组、字符串都可以看作是线性表。

优点：方便快捷；

缺点：不好进行删除、插入操作。

2.静态链式存储实现线性表

实现形式

struct Node
{
	int value;			//或者 char value; 用来存储节点值
	int prev,next;		//用来存储前驱、后继节点的数组下标值，注意是下标值！
}node[size];
int head,tail,tot;

初始化操作

void initialize()
{
	tot=2;				//默认已有两个节点head、tail
	head=1,tail=2;
	node[head].next=tail;
	node[tail].prev=head;//建立前驱、后继关系
}

插入操作

void insert(int p,int val)	//在p位置（指数组下标值为p的位置）右边插入值为val的节点
							//即若原来p位置的值为链表中的第x位（不是数组中），则插入操作后链表中						    //的第x+1位的值变为val,原来链表中p位置以后的值在链表中的次序依次向							  //后移一位
{
	int q=++tot;
	node[q].value=val;
	node[node[p].next].prev=q;
	node[q].next=node[p].next;
	node[q].prev=p;
	node[p].next=q;
}

删除操作

void remove(int p)		//删除p节点（指数组下标值为p的节点）
{
	node[node[p].prev].next=node[p].next;
	node[node[p].next].prev=node[p].prev;
}

做题时这一步骤要根据题目进行修改添加，可能开始定义的结构体中要添加一个判断是否已删去的变量标志，等等。

清空操作

void clear()
{
	memset(node,0,sizeof(node));
	tot=head=tail=0;
}

3.不定长存储——vector实现线性表

头文件

#include  <vector>

vector可以理解为不定长的数组。其支持随机访问，如同数组操作，可以直接设a[i]访问下标i的位置，但是它不支持任意位置插入，这点也如同数组，不如链表插入方便，所以我们一般在vector末尾插入。

声明

vector <int> a;//相当于一个长度不定的int数组a[]
vector <int> b[100];//相当于第一维长100，第二维不定的二维数组b[100][]
vector <stru> c;//相当于一个长度不定的结构体stru的数组c

size/empty

size()返回vector的实际长度，0代表空；而empty()返回一布尔值，判断vector是否为空。对于元素引用一定要记住是左闭右开区间，即for(int i=0;i<a.size();i++)来引用。

clear

clear()清空vector。

迭代器

可被理解成STL容器的“指针”，可以用“*”操作。使用方法如下：

vector <int> a;
vector <int>::iterator it;
for(it=a.begin();it!=a.end();it++)
	cout<<*it<<endl;
以上两行代码等同于：
for(int i=0;i<a.size();i++)
	cout<<a[i]<<endl;

front/back

front()返回vector的第一个元素，等价于*a.begin()、a[0];

back() 返回vector的最后一个元素，等价于*–a.end()、a[a.size()-1]（注意减一）。

push_back/pop_back

a.push_back(x)把元素x插入到vector a的末尾。

a.pop_back()删除vector a的最后一个元素，无返回值。

4.特殊线性表——队列

队列在线性表两端处理数据，一端进入队列，一段出队列，具有“先进先出”的特性。一般规定进入队列在线性表尾部，而出队列在线性表头部。

头文件

#include  <queue>

声明

queue <int> q;//一个循环队列q
queue <stru> c;//循环队列q是一个结构体stru

push/pop

q.push(x);元素x进入队列q的尾部

q.pop();队列头元素出队列（删除）。

front/back

x=q.front();取队首元素，不删除。

x=q.back();取队尾元素，不删除。

size/empty

size()返回queue的实际长度；而empty()返回一布尔值，值为真为空，否则不为真。

5.特殊线性表——栈

如果我们对线性表节点的操作只允许在一端进行，这种特殊的线性表就是栈。栈具有“先进后出”，“后进先出”的特性。

STL中也可实现栈（stack）,此处主要介绍如何用数组来实现。

（1）初始化（清空）

void clear()
{
	top=0;
}

（2）判定

bool empty()
{
	if(top==0)
		return true;
	else
		return false;
}

（3）求栈中元素的个数

int size()
{
	return top;
}

（4）进栈

void push(int x)
{
	if(top!=MAXSIZE)
		S[++top]=x;
	else
		cout<<"stack is full!";
}

（5）出栈

void pop()
{
	if(top!=0)
		top--;
	else
		cout<<"stack is empty!";
}

（6）取栈顶元素

int get_pop()
{
	if(!empty())
		return S[top];
}

下面看几道题

括号序列

题目描述

定义如下规则：

空串是「平衡括号序列」
若字符串 $S$ 是「平衡括号序列」，那么 ${[}S\texttt]$ 和 ${(}S\texttt)$ 也都是「平衡括号序列」
若字符串 $A$ 和 $B$ 都是「平衡括号序列」，那么 $A B$ （两字符串拼接起来）也是「平衡括号序列」。

例如，下面的字符串都是平衡括号序列：

()，[]，(())，([])，()[]，()[()]

而以下几个则不是：

(，[，]，)(，())，([()

现在，给定一个仅由 (，)，[，]构成的字符串 $s$ ，请你按照如下的方式给字符串中每个字符配对：

从左到右扫描整个字符串。
对于当前的字符，如果它是一个右括号，考察它与它左侧离它最近的未匹配的的左括号。如果该括号与之对应（即小括号匹配小括号，中括号匹配中括号），则将二者配对。如果左侧未匹配的左括号不存在或与之不对应，则其配对失败。

配对结束后，对于 $s$ 中全部未配对的括号，请你在其旁边添加一个字符，使得该括号和新加的括号匹配。

输入格式

输入只有一行一个字符串，表示 $s$ 。

输出格式

输出一行一个字符串表示你的答案。

样例 #1

样例输入 #1

([()

样例输出 #1

()[]()

样例 #2

样例输入 #2

([)

样例输出 #2

()[]()

提示

数据规模与约定

对于全部的测试点，保证 $s$ 的长度不超过 100，且只含 (，)，[，] 四个字符。

代码

验证括号匹配是应用栈的典型，左括号先进栈，遇右括号再将左括号出栈进行对比。
但这题还要求补上未配对的括号，且最后顺序输出，这里就要用到链表了。

#include <bits/stdc++.h>
using namespace std;
struct Node
{
	int prev,next;
	char value;
}node[205];
int tot,head,tail;
void initialize()
{
	tot=2,head=2,tail=1;
	node[head].next=tail;
	node[tail].prev=head; 
}
void insert(int p,char val)
{
	int q=++tot;
	node[q].value=val;
	node[node[p].next].prev=q;
	node[q].next=node[p].next;
	node[p].next=q;
	node[q].prev=p;
}
int num;
struct judge
{
	char value;
	int p;
}jud[205];
int top=0;
void push(char ch,int x)
{
	jud[++top].value=ch;
	jud[top].p=x;
}

int main()
{
	initialize();
	num=2;
	string s;
	cin>>s;
	int len=s.length();
	for(int i=0;i<len;i++)
	{
		if(s[i]=='('||s[i]=='[')
		{
			insert(num,s[i]);
			num=node[num].next;
			push(s[i],num);
		}
		else if(s[i]==')')
		{
			insert(num,s[i]);
			num=node[num].next;
			if(jud[top].value=='(')top--;
			else 
			{
				insert(node[num].prev,'(' );
			}
		}
		else if(s[i]==']')
		{
			insert(num,s[i]);
			num=node[num].next;
			if(jud[top].value=='[')top--;
			else 
			{
				insert(node[num].prev,'[');
			}
		}
	}
	for(int i=1;i<=top;i++)
	{
		if(jud[i].value=='(')
			insert(jud[i].p,')');
		if(jud[i].value=='[')
			insert(jud[i].p,']');
	}
	int z=head;
	while(node[z].next!=tail)
	{
		z=node[z].next;
		cout<<node[z].value;
	}
	return 0;
}

后缀表达式

题目描述

所谓后缀表达式是指这样的一个表达式：式中不再引用括号，运算符号放在两个运算对象之后，所有计算按运算符号出现的顺序，严格地由左而右新进行（不用考虑运算符的优先级）。

如： $\texttt{3*(5-2)+7}$ 对应的后缀表达式为： $\texttt{3.5.2.-*7.+@}$ 。在该式中，@ 为表达式的结束符号。. 为操作数的结束符号。

输入格式

输入一行一个字符串 $s$ ，表示后缀表达式。

输出格式

输出一个整数，表示表达式的值。

样例 #1

样例输入 #1

3.5.2.-*7.+@

样例输出 #1

提示

数据保证， $\leq |s| \leq 50$ ，答案和计算过程中的每一个值的绝对值不超过 $10^9$ 。

代码

与验证括号匹配类似。因为是后缀，也要用的栈，数字先入栈，遇到运算符再出栈。此题也是一个典型题。后缀表达式也与树的遍历顺序有关。

#include <bits/stdc++.h>
#define MAXSIZE 1000
using namespace std;
int S[MAXSIZE];
int top=0;
void push(int x)
{
	if(top!=MAXSIZE)
		S[++top]=x;
}
void pop()
{
	if(top!=0)
		top--;
}
bool empty()
{
	if(top==0)
		return true;
	else
		return false;
}
void clear()
{
	top=0;
}
int get_pop()
{
	if(!empty())
		return S[top];
}
int main()
{
	char c;
	int num=0,a=0,b=0;
	c=getchar();
	while(c!='@')
	{
		switch(c)
		{
			case'.':push(num),num=0;break;//,
			case'+':b=get_pop(),pop(),a=get_pop(),pop(),push(a+b);break;
			case'-':b=get_pop(),pop(),a=get_pop(),pop(),push(a-b);break;
			case'*':b=get_pop(),pop(),a=get_pop(),pop(),push(a*b);break;
			case'/':b=get_pop(),pop(),a=get_pop(),pop();if(b!=0)push(a/b);break;
			default:num=num*10+c-48;
		}
		c=getchar();
	}
	cout<<get_pop()<<endl;
	return 0;
}

队列安排

题目描述

一个学校里老师要将班上 $N$ 个同学排成一列，同学被编号为 $1\sim N$ ，他采取如下的方法：

先将 $1$ 号同学安排进队列，这时队列中只有他一个人；
$2 - N$ 号同学依次入列，编号为 $i$ 的同学入列方式为：老师指定编号为 $i$ 的同学站在编号为 $1\sim(i-1)$ 中某位同学（即之前已经入列的同学）的左边或右边；
从队列中去掉 $M (M < N)$ 个同学，其他同学位置顺序不变。

在所有同学按照上述方法队列排列完毕后，老师想知道从左到右所有同学的编号。

输入格式

第 $1$ 行为一个正整数 $N$ ，表示了有 $N$ 个同学。

第 $2\sim N$ 行，第 $i$ 行包含两个整数 $k, p$ ，其中 $k$ 为小于 $i$ 的正整数， $p$ 为 $0$ 或者 $1$ 。若 $p$ 为$ 0$，则表示将 $i$ 号同学插入到 $k$ 号同学的左边， $p$ 为 $1$ 则表示插入到右边。

第 $N + 1$ 行为一个正整数 $M$ ，表示去掉的同学数目。

接下来 $M$ 行，每行一个正整数 $x$ ，表示将 $x$ 号同学从队列中移去，如果 $x$ 号同学已经不在队列中则忽略这一条指令。

输出格式

$1$ 行，包含最多 $N$ 个空格隔开的正整数，表示了队列从左到右所有同学的编号，行末换行且无空格。

样例 #1

样例输入 #1

样例输出 #1

2 4 1

提示

样例解释：

将同学 $2$ 插入至同学 $1$ 左边，此时队列为：

2 1

将同学 $3$ 插入至同学 $2$ 右边，此时队列为：

2 3 1

将同学 $4$ 插入至同学 $1$ 左边，此时队列为：

2 3 4 1

将同学 $3$ 从队列中移出，此时队列为：

2 4 1

同学 $3$ 已经不在队列中，忽略最后一条指令

最终队列：

2 4 1

数据范围

对于 $20\%$ 的数据，有 $1\leq N\leq 10$ ；

对于 $40\%$ 的数据，有 $1\leq N\leq 1000$ ；

对于 $100\%$ 的数据，有 $1\leq N,M\leq100000$ 。

代码

虽然题目中有“队列”二字，但读完题干发现这里的“队列”并非是数据结构中的“队列”，而是生活中的队列，要求能在任意节点进行插入和删除，因此要用双向链表来解决。

#include <bits/stdc++.h>
#define SIZE 100050
using namespace std;
struct Node
{
	int prev,next;
	int  value;
	int flag;
}node[SIZE];
int tot,head,tail;
void initialize()
{
	tot=2,head=2,tail=1;
	node[head].next=tail;
	node[tail].prev=head; 
}
void insert(int p,int val)
{
	int q=++tot;
	node[q].flag=1;
	node[q].value=val;
	node[node[p].next].prev=q;
	node[q].next=node[p].next;
	node[p].next=q;
	node[q].prev=p;
}
void remove(int p)
{
	node[p].flag=0;
	node[node[p].prev].next=node[p].next;
	node[node[p].next].prev=node[p].prev;
}
void clear()
{
	memset(node,0,sizeof(node));
	head=tail=tot=0;
}
int main()
{
	int n,m;
	cin>>n;
	initialize();
	insert(head,1);
	for(int i=2;i<=n;i++)
	{
		int k,p;
		cin>>k>>p;
		if(p) insert(k+2,i);
		else insert(node[k+2].prev,i); 
	}
	cin>>m;
	for(int i=0;i<m;i++)
	{
		int k;
		cin>>k;
		if(node[k+2].flag)
			remove(k+2);
	}
	int p=head;
	p=node[p].next;
	cout<<node[p].value;
	while(node[p].next!=tail)
	{
		p=node[p].next;
		cout<<' '<<node[p].value;
	}
	cout<<'\n';
	return 0;
}