（Week 3）线性表（C++，STL）

最新推荐文章于 2024-09-15 11:40:06 发布
最新推荐文章于 2024-09-15 11:40:06 发布
阅读量608 收藏 1
点赞数
分类专栏： NEUQACM作业 文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74036684/article/details/127838859
版权

【深基15.例2】寄包柜(C++，STL)

题目描述

超市里有 n ( 1 ≤ n ≤ 1 0 5 ) n(1\le n\le10^5) n(1≤n≤105) 个寄包柜。每个寄包柜格子数量不一，第 i i i 个寄包柜有 a i ( 1 ≤ a i ≤ 1 0 5 ) a_i(1\le a_i\le10^5) ai​(1≤ai​≤105) 个格子，不过我们并不知道各个 a i a_i ai​ 的值。对于每个寄包柜，格子编号从 1 开始，一直到 a i a_i ai​。现在有 q ( 1 ≤ q ≤ 1 0 5 ) q(1 \le q\le10^5) q(1≤q≤105) 次操作：

  • 1 i j k：在第 i i i 个柜子的第 j j j 个格子存入物品 k ( 0 ≤ k ≤ 1 0 9 ) k(0\le k\le 10^9) k(0≤k≤109)。当 k = 0 k=0 k=0 时说明清空该格子。
  • 2 i j：查询第 i i i 个柜子的第 j j j 个格子中的物品是什么，保证查询的柜子有存过东西。

已知超市里共计不会超过 1 0 7 10^7 107 个寄包格子， a i a_i ai​ 是确定然而未知的，但是保证一定不小于该柜子存物品请求的格子编号的最大值。当然也有可能某些寄包柜中一个格子都没有。

输入格式

第一行 2 个整数 n n n 和 q q q，寄包柜个数和询问次数。

接下来 q q q 个整数，表示一次操作。

输出格式

对于查询操作时，输出答案，以换行隔开。

样例 #1

样例输入 #1

5 4
1 3 10000 118014
1 1 1 1
2 3 10000
2 1 1

样例输出 #1

118014
1

提示

upd 2022.7.26 \text{upd 2022.7.26} upd 2022.7.26：新增加一组 Hack 数据。

解题思路：

读完题之后，很快可以想到将柜子和格子抽象为二维数组，但又很快发现会导致MLE

这时候就会发现，本质上我们要做的就是实现两个索引确定的一个元素

可以使用STL中的map来实现

首先构建一个索引的结构体：

struct map_index
{
	int m_i;
	int m_j;
};

然后创建一个map容器：

map<map_index, int>cabinet;

最后很容易实现输入、处理和输出的操作：

int main()
{
	map<map_index, int>cabinet;
	int n, q;
	cin >> n >> q;
	int select, item;//用于读入选项、要存入的数字
	struct map_index temp_map_index;//用于读入map的索引
	for (int i = 0; i < q; i++)
	{
		cin >> select;
		if (select == 1)//存入
		{
			cin >> temp_map_index.m_i >> temp_map_index.m_j >> item;
			cabinet.insert(pair<map_index, int>(temp_map_index, item));	
        }
		else if (select == 2)//读取
		{
			cin >> temp_map_index.m_i >> temp_map_index.m_j;
			cout << cabinet.find(temp_map_index)->second << endl;
		}
	}
	return 0;
}

当然，还没有结束

直接运行会报错，因为map默认的排序规则并不能应用于我们创建的索引类型

我们就需要自己来写一个排序的函数：

class MyCompare
{
public:
	//写一个重载函数调用运算符（仿函数），实现升序排序
	bool operator()(struct map_index m_i_1, struct map_index m_i_2)const//这里如果不加const，部分编译器会报错
	{
		if (m_i_1.m_i < m_i_2.m_i)
		{
			return true;
		}
		else if (m_i_1.m_i > m_i_2.m_i)
		{
			return false;
		}
		else
		{
			if (m_i_1.m_j < m_i_2.m_j)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
	}
};

第二个错误点就是没有考虑到对同一个柜子的格子（索引）会进行更新操作

第二次插入相同的索引时，会插入失败，不会更新item的值

改正后完整的代码如下：

#include <iostream>
#include <map>
using namespace std;

struct map_index
{
	int m_i;
	int m_j;
};
class MyCompare
{
public:
	bool operator()(struct map_index m_i_1, struct map_index m_i_2)const
	{
		if (m_i_1.m_i < m_i_2.m_i)
		{
			return true;
		}
		else if (m_i_1.m_i > m_i_2.m_i)
		{
			return false;
		}
		else
		{
			if (m_i_1.m_j < m_i_2.m_j)
			{
				return true;
			}
			else
			{
				return false;
			}
		}
	}
};

int main()
{
	map<map_index, int, MyCompare>cabinet;//传入自定义的排序类
	int n, q;
	cin >> n >> q;
	int select, item;
	struct map_index temp_map_index;
	for (int i = 0; i < q; i++)
	{
		cin >> select;
		if (select == 1)
		{
			cin >> temp_map_index.m_i >> temp_map_index.m_j >> item;
			if(cabinet.find(temp_map_index) == cabinet.end())
			{
				cabinet.insert(pair<map_index, int>(temp_map_index, item));
			}
			else
			{
				cabinet.find(temp_map_index)->second = item;
			}
		}
		else if (select == 2)
		{
			cin >> temp_map_index.m_i >> temp_map_index.m_j;
			cout << cabinet.find(temp_map_index)->second << endl;
		}
	}
	return 0;
}

括号序列（C++，Stack）

题目描述

定义如下规则：

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

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

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

而以下几个则不是：

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

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

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

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

输入格式

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

输出格式

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

样例 #1

样例输入 #1

([()

样例输出 #1

()[]()

样例 #2

样例输入 #2

([)

样例输出 #2

()[]()

提示

数据规模与约定

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

解题思路：

首先解释题意：题意并不是很清晰，这里进一步解释一下

题目要求最终得到的括号序列仍然是平衡括号序列，并不是说只要有能匹配的括号即可

就是说如果括号序列为

([)]

那么得出的结果应该是

()[()]

两个小括号是不能匹配的

这样我们可以想到用栈来实现代码

首先说明匹配机制：

int main()
{
	string str;
	stack<char> char_stack;
	cin >> str;
	int len = str.size();
	for (int i = 0; i < len; i++)
	{
		switch (str[i])
		{
		case '(':
			char_stack.push(str[i]);
			break;
		case '[':
			char_stack.push(str[i]);
			break;
		case ')':
		{
			if (char_stack.top() == '(')
			{
				char_stack.pop();
			}
		}
		case ']':
			if (char_stack.top() == '[')
			{
				char_stack.pop();
			}
		default:
			break;
		}
	}
}

这里可以采用两种方式实现题中要求的输出效果

要解决的核心问题就是如何区分已经匹配的括号和未匹配的括号

方法一：引入另一个匹配字符串

int main()
{
	string str, match_str = "";
	stack<char> char_stack, index_stack;
	cin >> str;
	int len = str.size();
	for (int i = 0; i < len; i++)
	{
		switch (str[i])
		{
		case '(':
			{
				char_stack.push(str[i]);
				index_stack.push(i);//如果匹配成功匹配，通过该索引对应元素修改状态
				match_str += ')';//默认状态是未匹配
				break;
			}
		case '[':
			{
				char_stack.push(str[i]);
				index_stack.push(i);//如果匹配成功匹配，通过该索引对应元素修改状态
				match_str += ']';//默认状态是未匹配
				break;
			}
		case ')':
			{
				if (!char_stack.empty() && char_stack.top() == '(')//注意：一定要先判断栈是否为空
				{
					char_stack.pop();
					match_str[index_stack.top()] = '\0';//修改状态为已经匹配
					index_stack.pop();
					match_str += '\0';
				}
				else
				{
					match_str += '(';
				}
				break;
			}
		case ']':
			{
				if (!char_stack.empty() && char_stack.top() == '[')//注意：一定要先判断栈是否为空
				{
					char_stack.pop();
					match_str[index_stack.top()] = '\0';//修改状态为已经匹配
					index_stack.pop();
					match_str += '\0';
				}
				else
				{
					match_str += '[';
				}
				break;
			}
		default:
			break;
		}
	}
}

然后实现输出的代码如下

for (int i = 0; i < len; i++)
	{
		if (match_str[i] == '\0')//如果str[i]的状态为已匹配
		{
			cout << str[i];
		}
		else//如果str[i]的状态为未匹配
		{
			if (match_str[i] == '[' || match_str[i] == '(')
			{
				cout << match_str[i] << str[i];
			}
			else
			{
				cout << str[i] << match_str[i];
			}
		}
	}

方法一实现完成

（ps：如果超时的话可能是由于字符串的拼接操作耗费时间，可以尝试字符数组）

方法二：通过值的修改来修改括号的状态，如未匹配的括号值为1，已匹配的括号值为2

方法二的完整代码如下

#include <iostream>
#include <stack>
using namespace std;

int main()
{
	string str;
	cin >> str;
	stack<char> char_stack, index_stack;
	int len = str.size();
	for (int i = 0; i < len; i++)//共有六种状态：1-(),2-[],3-(,4-),5-[,6-]
	{
		switch (str[i])
		{
		case '(':
		{
			char_stack.push(str[i]);
			index_stack.push(i);//如果匹配成功匹配，通过该索引对应元素修改状态
			str[i] = 1;//默认状态是未匹配
			break;
		}
		case '[':
		{
			char_stack.push(str[i]);
			index_stack.push(i);//如果匹配成功匹配，通过该索引对应元素修改状态
			str[i] = 2;//默认状态是未匹配
			break;
		}
		case ')':
		{
			if (!char_stack.empty() && char_stack.top() == '(')//注意：一定要先判断栈是否为空
			{
				char_stack.pop();
				str[index_stack.top()] = 3;//修改状态为已经匹配
				index_stack.pop();
				str[i] = 4;
			}
			else
			{
				str[i] = 1;
			}
			break;
		}
		case ']':
		{
			if (!char_stack.empty() && char_stack.top() == '[')//注意：一定要先判断栈是否为空
			{
				char_stack.pop();
				str[index_stack.top()] = 5;//修改状态为已经匹配
				index_stack.pop();
				str[i] = 6;
			}
			else
			{
				str[i] = 2;
			}
			break;
		}
		default:
			break;
		}
	}
	for (int i = 0; i < len; i++)
	{
		switch (str[i])
		{
		case 1:
			cout << "()";
			break;
		case 2:
			cout << "[]";
			break;
		case 3:
			cout << '(';
			break;
		case 4:
			cout << ')';
			break;
		case 5:
			cout << '[';
			break;
		case 6:
			cout << ']';
			break;
		default:
			break;
		}
	}
}

后缀表达式（逆波兰，C++，Stack）

题目描述

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

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

输入格式

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

输出格式

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

样例 #1

样例输入 #1

3.5.2.-*7.+@

样例输出 #1

16

提示

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

解题思路：

该题的考点就是STL中的stack

这里首先通过样例讲解本题题意：首先进行5-2的操作，将结果与3进行运算

再进行3*3的操作，将结果与7运算

最后进行9+7的操作，得到结果16

采用IPO实现代码：

（1）I：

直接以字符串形式读入

（2）P：

创建一个堆栈

stack<int> num_stack;

从头开始遍历字符串

若为数字，则入栈

if ('0' <= str[i] && str[i] <= '9')//获取操作数
{
	int left = i, right = i + 1;
	while ('0' <= str[right] && str[right] <= '9')
	{
		right++;
	}
	num_stack.push(stoi(str.substr(left, right)));//将操作数截取、转换、插入
	i = right;//更新i的位置
}

若为运算符，则出栈两个操作数运算

（注：先出栈的操作数为num_2，后出栈的操作数为num_1）

然后将运算结果作为操作数入栈

else if(str[i] != '.')//获取运算符
{
	//获取到运算符，则进行操作
	int num_2 = num_stack.top();//先获取的操作数为num_2
	num_stack.pop();
	int num_1 = num_stack.top();//后获取的操作数为num_1
	num_stack.pop();
	switch (str[i])
	{
	case '+':
		num_1 += num_2;
		break;
	case '-':
		num_1 -= num_2;
		break;
	case '*':
		num_1 *= num_2;
		break;
	case '/':
		num_1 /= num_2;
		break;
	case '%':
		num_1 %= num_2;
		break;
	default:
		break;
	}
	num_stack.push(num_1);//将运算结果作为操作数入栈
	i++;
}

（3）O：

最后，堆栈中剩余的唯一一个元素即为结果

完整的代码如下

#include <iostream>
#include <string>
#include <stack>
using namespace std;

int main()
{
	string str;
	stack<int> num_stack;//存储操作数
	int num_1, num_2;//用于获取运算的两个操作数
	cin >> str;
	int i = 0;
	while (str[i] != '@')//获取运算数和操作符
	{
		if ('0' <= str[i] && str[i] <= '9')//获取操作数
		{
			int left = i, right = i + 1;
			while ('0' <= str[right] && str[right] <= '9')
			{
				right++;
			}
			num_stack.push(stoi(str.substr(left, right)));//将操作数截取、转换、插入
			i = right;//更新i的位置
		}
		else if(str[i] != '.')//获取运算符
		{
			//获取到运算符，则进行操作
			int num_2 = num_stack.top();
			num_stack.pop();
			int num_1 = num_stack.top();
			num_stack.pop();
			switch (str[i])
			{
			case '+':
				num_1 += num_2;
				break;
			case '-':
				num_1 -= num_2;
				break;
			case '*':
				num_1 *= num_2;
				break;
			case '/':
				num_1 /= num_2;
				break;
			case '%':
				num_1 %= num_2;
				break;
			default:
				break;
			}
			num_stack.push(num_1);
			i++;
		}
		else//是'.'，跳过
		{
			i++;
		}
	}
	cout << num_stack.top() << endl;
	return 0;
}

队列安排（C++，List，二分法）

题目描述

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

  1. 先将 1 1 1 号同学安排进队列，这时队列中只有他一个人；

  2. 2 − N 2-N 2−N 号同学依次入列，编号为 i i i 的同学入列方式为：老师指定编号为 i i i 的同学站在编号为 1 ∼ ( i − 1 ) 1\sim(i-1) 1∼(i−1) 中某位同学（即之前已经入列的同学）的左边或右边；

  3. 从队列中去掉 M ( M < N ) M(M<N) M(M<N) 个同学，其他同学位置顺序不变。

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

输入格式

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

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

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

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

输出格式

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

样例 #1

样例输入 #1

4
1 0
2 1
1 0
2
3
3

样例输出 #1

2 4 1

提示

样例解释：

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

2 1

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

2 3 1

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

2 3 4 1

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

2 4 1

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

最终队列：

2 4 1

数据范围

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

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

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

解题思路：

根据题意，需要进行大量的插入、删除操作以及检索操作

故为了防止TLE错误

采用链表来减少插入所需时间

采用标记来减少删除所需时间

采用二分来减少检索所需时间

首先，我们按照要求设计一个学生类

class student
{
public:
	bool is_output = true;//默认标记为输出
	int id;//学生id
	class student* left_hand = NULL;//学生左手指针
	class student* right_hand = NULL;//学生右手指针
	void insert(class student* stu_p_1, class student* stu_p_2, bool select)//成员函数，实现插入功能
	{
		if (select)//插入右手边
		{
			if (stu_p_1->right_hand == NULL)//如果右手无人
			{
				stu_p_1->right_hand = stu_p_2;//右手拉住新来的学生
				stu_p_2->left_hand = stu_p_1;//让新来的学生左手拉住自己
			}
			else//如果右手有人
			{
				stu_p_2->left_hand = stu_p_1;//新来的学生左手拉住指定的学生
				stu_p_2->right_hand = stu_p_1->right_hand;//再拉住Ta右手边的学生
				stu_p_2->left_hand->right_hand = stu_p_2;
				stu_p_2->right_hand->left_hand = stu_p_2;//让左右手的学生拉自己
			}
		}
		else//插入左手边
		{
			//同理
			if (stu_p_1->left_hand == NULL)//如果左手无人
			{
				stu_p_1->left_hand = stu_p_2;
				stu_p_2->right_hand = stu_p_1;
			}
			else
			{
				stu_p_2->right_hand = stu_p_1;
				stu_p_2->left_hand = stu_p_1->left_hand;
				stu_p_2->right_hand->left_hand = stu_p_2;
				stu_p_2->left_hand->right_hand = stu_p_2;
			}
		}
	}
	student(int id)
	{
		this->id = id;
	}
	student()
	{
		this->id = 0;
	}
};

然后，我们封装一个函数，用于逻辑上的删除

//封装一个二分搜索并标记（删除）学生的函数
void delete_student(int index)//删除学生的id
{
	//二分法（红蓝）
	int left = 0, right = 100000 + 1, middle;
	while (left + 1 != right)
	{
		middle = (left + right) / 2;
		if (middle == index)//找到指定学生
		{
			student_array[index]->is_output = false;//将输出状态更改为不输出
			break;
		}
		else if (middle < index)//如果id过小，则到middle右侧寻找
		{
			left = middle;
		}
		else//若id过大，则到middle左侧寻找
		{
			right = middle;
		}
	}
}

最后，我们封装一个用于二分搜索并插入学生的函数

//封装一个二分搜索并插入学生的函数
void insert_student(class student* stu, int index, bool select)//新来的学生指针、指定学生的id、选择左手边还是右手边
{
	//二分法（红蓝）
	int left = 0, right = 100000 + 1, middle;
	while (left + 1 != right)
	{
		middle = (left + right) / 2;
		if (middle == index)//找到指定学生
		{
			student_array[index]->insert(student_array[index], stu, select);
			break;
		}
		else if (middle < index)//若id过小，则到middle右侧寻找
		{
			left = middle;
		}
		else//若id过大，则到middle左侧寻找
		{
			right = middle;
		}
	}
}

（ps：以下可以选择观看，是不采用标记而是去删除元素的操作实现代码）

学生类成员函数实现删除功能

void del_stu(class student* stu_p)
	{
		if (stu_p->left_hand == NULL)//如果左手无人
		{
			//因为M<N，所以右手一定有人
			stu_p->right_hand->left_hand = NULL;
			stu_p->right_hand = NULL;
			delete stu_p;
			stu_p = NULL;
		}
		else//如果左手有人
		{
			if (stu_p->right_hand == NULL)//如果右手无人
			{
				stu_p->left_hand->right_hand = NULL;
				stu_p->left_hand = NULL;
				delete stu_p;
				stu_p = NULL;
			}
			else//如果右手有人
			{
				stu_p->left_hand->right_hand = stu_p->right_hand;
				stu_p->right_hand->left_hand = stu_p->left_hand;
				stu_p->left_hand = NULL;
				stu_p->right_hand = NULL;
				delete stu_p;
				stu_p = NULL;
			}
		}
	}

封装一个函数，实现搜索并删除学生的功能

void delete_student(int index)
{
	int left = 0, right = 100000, middle;
	while (left + 1 != right)
	{
		middle = (left + right) / 2;
		if (middle == index)
		{
			if (student_array[index] == NULL)//若该学生已被删除，则无视这次操作
			{
				break;
			}
			student_array[index]->del_stu(student_array[index]);//调用成员函数删除学生
			student_array[index] = NULL;//将指针置空，代表该学生已被删除
			break;
		}
		else if (middle < index)
		{
			left = middle;
		}
		else
		{
			right = middle;
		}
	}
}

注意，如果不采用标记的方式删除学生，则在删除步骤时，需要注意head是否被删除

int m;
cin >> m;
for (int i = 0; i < m; i++)
{
	cin >> k;
	if (head == student_array[k])//如果head学生被删除，则其右手边的学生成为head
	{
		head = student_array[k]->right_hand;
	}
	delete_student(k);
}

既然我们实现了主要几个功能的封装，那么main函数的可读性就大大增加了

完整的代码如下：

#include <iostream>
using namespace std;

class student
{
public:
	bool is_output = true;
	int id;
	class student* left_hand = NULL;
	class student* right_hand = NULL;
	void insert(class student* stu_p_1, class student* stu_p_2, bool select)
	{
		if (select)//插入右手边
		{
			if (stu_p_1->right_hand == NULL)//如果右手无人
			{
				stu_p_1->right_hand = stu_p_2;
				stu_p_2->left_hand = stu_p_1;
			}
			else//如果右手有人
			{
				stu_p_2->left_hand = stu_p_1;//拉住学生1
				stu_p_2->right_hand = stu_p_1->right_hand;//拉住学生1右手边的学生
				stu_p_2->left_hand->right_hand = stu_p_2;
				stu_p_2->right_hand->left_hand = stu_p_2;//让左右手的学生拉自己
			}
		}
		else//插入左手边
		{
			if (stu_p_1->left_hand == NULL)//如果左手无人
			{
				stu_p_1->left_hand = stu_p_2;
				stu_p_2->right_hand = stu_p_1;
			}
			else
			{
				stu_p_2->right_hand = stu_p_1;
				stu_p_2->left_hand = stu_p_1->left_hand;
				stu_p_2->right_hand->left_hand = stu_p_2;
				stu_p_2->left_hand->right_hand = stu_p_2;
			}
		}
	}
	student(int id)
	{
		this->id = id;
	}
	student()
	{
		this->id = 0;
	}
};

student* student_array[100000 + 1] = { NULL };

void insert_student(class student* stu, int index, bool select)
{
	int left = 0, right = 100000 + 1, middle;
	while (left + 1 != right)
	{
		middle = (left + right) / 2;
		if (middle == index)
		{
			student_array[index]->insert(student_array[index], stu, select);
			break;
		}
		else if (middle < index)
		{
			left = middle;
		}
		else
		{
			right = middle;
		}
	}
}

void delete_student(int index)
{
	int left = 0, right = 100000 + 1, middle;
	while (left + 1 != right)
	{
		middle = (left + right) / 2;
		if (middle == index)
		{
			student_array[index]->is_output = false;
			break;
		}
		else if (middle < index)
		{
			left = middle;
		}
		else
		{
			right = middle;
		}
	}
}

int main()
{
	int n;
	cin >> n;
	class student* head;
	int k, p;
	student_array[1] = new class student(1);
	head = student_array[1];
	for (int student = 2; student <= n; student++)
	{
		cin >> k >> p;
		student_array[student] = new class student(student);
		insert_student(student_array[student], k, p);
		if (head == student_array[k] && !p)
		{
			head = student_array[student];
		}
	}
	int m;
	cin >> m;
	for (int i = 0; i < m; i++)
	{
		cin >> k;
		delete_student(k);
	}
	if (head->is_output)
	{
		cout << head->id;
	}
	head = head->right_hand;
	while (head != NULL)
	{
		if (head->is_output)
		{
			cout << ' ' << head->id;
		}
		head = head->right_hand;
	}
	cout << endl;
	return 0;
}
WitheredSakura_
关注
专栏目录
数据结构与算法分析（二）--- STL简介 + 线性表容器（C++11）
流云
12-19 2197
STL是由一些可适应不同需求的集合类和一些能够在这些数据集合上运作的算法构成，STL内的所有组件都由模板构成，所以其元素可以是任意类型。STL组件包括以下部分： - 容器（container）：用来管理某类对象的集合，容器可以是array、list、set、map等； - 迭代器（iterator）：用来在一个对象集合内遍历元素，这个对象集合或许是个容器，或许是容器的一部分； - 算法（algorithm）：用来处理集合内的元素，它们可以出于不同的目的而增、删、改、查、排序、使用元素。
Problem A: STL——灵活的线性表
dizhanjing3899的博客
03-29 318
Description 数组和链表是我们熟知的两种线性结构，但是它们不够灵活（不能同时实现直接插入、删除和访问操作），给你若干种操作，你能通过一种灵活的容器，实现它们的功能吗？ 操作1：Build a b （产生一个大小为a的线性表，其值全部赋为b，每组样例仅出现一次，在起始行） 操作2：Modify a b （将线性表的第a个元素的值设为b） 操作3：Insert a b ...
C/C++ 程序设计：STL 容器——线性表 ——Queue
Mr_Fmnwon的博客
09-14 363
、queue是什么队列是一种特殊的线性表，在队列这种数据结构中，最先插入在元素将是最先被删除；反之最后插入的元素将最后被删除，因此队列又称为“先进先出”（FIFO—first in first out）的线性表。它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作。进行插入操作的端称为队尾，进行删除操作的端称为队头。
基本线性表C++ STL容器操作(vector,stack,queue)
xxcdsg的博客
10-30 195
基本线性表C++ STL容器操作(vector,stack,queue)
线性表（STL版）
qq_41818544的博客
07-21 1104
 1.STL的顺序存储结构--------------vector顺序表      vector（向量）      size()    //计算当前线性表的长度      capacity()  //计算线性表的容量    （该单词的意思是 能力 ，所以可以理解为存储能力）      reverse()   //反向排序   （该单词的意思是 反向）      clear()    //...
线性表C++源码.rar
04-09
这个名为"线性表C++源码.rar"的压缩包包含了这两种结构的C++实现，同时使用了模板类，使其具有通用性，适用于多种数据类型。 首先，我们来看顺序存储结构。顺序存储的线性表是将元素存储在一块连续的内存空间中，...
C++通过类实现线性表
08-19
3. ClearList()：用于清空线性表，设置线性表的长度为 0。 4. ListEmpty()：用于判断线性表是否为空，返回布尔值。 5. ListLength()：用于获取线性表的长度，返回整数值。 6. GetElem(int i, Elem *e)：用于获取...
链表的C++实现（线性表的链式存储C++实现）
04-05
大致实现了STL中的链表的基本功能，通过对比C语言实现线性表的链式存储可以更好的理解面向对象编程和面向过程的区别，更加深入的理解C语言和C++语言的区别。相关的文章可以在我的主页算法与数据结构专栏查看。
线性表（c++代码）
03-14
数据结构：线性表的创建、插入、查找、删除 vector的简单应用
C++STL——线性表vector
Sabre_Su的博客
03-29 1250
Problem A: STL——灵活的线性表 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 4016  Solved: 1570 [Submit][Status][Web Board] Description 数组和链表是我们熟知的两种线性结构，但是它们不够灵活（不能同时实现直接插入、删除和访问操作），给你若干种操作，你能通过
STL——灵活的线性表
qq_43511633的博客
07-05 392
vector的用法，STL中的每个类型的用法实在是太多。
c++线性表
qi_programmer的博客
02-24 1473
线性表的分类 （简单 STL）一、长度可变数组 vector二、栈 stack （稍慢，最好手写栈）三、队列 queue四、链表 list 一、长度可变数组 vector 二、栈 stack （稍慢，最好手写栈） 三、队列 queue 四、链表 list ...
[STL基础]线性表vector之用法
超越
01-06 1866
Vector 网上教程有实例的 vector的函数共有五大类：定义及初始化，增加删除元素，访问元素，返回迭代器，获取设置长度容器  #include #include #include #include using namespace std; //定义及初始化；返回void或无返回值 void test0() { vector v;//只定义了v，没有分配内存空间
STL 实现线性表,栈,队列
周杰伦
09-02 735
1、STL (Standard Template Library标准模板库) 是通用类模板和算法的集合，它提供给程序员一些标准的数据结构的实现如 queues(队列), lists(链表), 和 stacks(栈)等. 2、C++ STL 提供给程序员以下三类数据结构的实现: 1、顺序容器：存放同一类型的且按线性表存放数据的容器 C++ Vectors 向量容器：（数组） ...
C++的标准模板库STL中实现的数据结构之顺序表vector的分析与使用
ZhangPY的专栏
07-22 3625
一、摘要 本文主要借助对C++的标准模板库STL中实现的数据结构的学习和使用来加深对数据结构的理解，即联系数据结构的理论分析和具体的应用实现（STL），本文是系列总结的第一篇，主要针对线性表中的顺序表（动态数组）STL vector进行分析和总结。 二、引言 由于前段时间对台大的机器学习基石和技法课程进行了学习，发现在具体的实现中常常涉及到各种类型的数据结构，比如线性表、二叉树、图等
C++ STL
freeking101的博客
03-29 2829
基础 C++的类。请读下面一段代码: class Shape { private: int x_pos; int y_pos; int color; public: Shape() : x_pos(0), y_pos(0), color(1) {} Shape(int x, int y, int c = 1) : x_pos(x), ...
C++ STL中sort函数
最新发布
weixin_43349440的博客
09-15 135
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
C++与QML的数据交互
qq_50679120的博客
09-11 479
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 450
继续学习头文件的数学函数。
STL与线性表：C++泛型编程基石
标准模板库（Standard Template Library, STL）是C++语言中实现泛型编程的一个核心组件，由Alex Stepanov在1990年代初发起并发展，于1998年正式成为C++标准的一部分。 STL包含了一系列基础的数据结构和算法模板，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

WitheredSakura_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值