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

最新推荐文章于 2023-09-25 21:40:23 发布

WitheredSakura_

最新推荐文章于 2023-09-25 21:40:23 发布

阅读量546

点赞数

分类专栏：线性表文章标签： c++ 数据结构算法

本文链接：https://blog.csdn.net/m0_74036684/article/details/127838771

版权

线性表专栏收录该内容

5 篇文章 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$ 。

解题思路：

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

故为了防止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;
}