#include<iostream>

using namespace std;

// 定义双向链表节点
class ListNode
{
public:
	int val;
	ListNode* next, *pre;
public:
	ListNode() {};
	ListNode(int v) : val(v), next(nullptr), pre(nullptr){}
};

// 定义双向链表
class LinkList
{
private:
	// 头节点和尾节点
	ListNode* head, * tail;
	int len;
public:
	// 构造函数，初始化链表
	// 传入数组
	LinkList(int len, int* arr)
	{
		this->len = len;
		// 先构造头节点
		head = new ListNode(arr[0]);
		ListNode* node = head->next;
		ListNode* pre = head;
		// 遍历数组，和单链表过程差不多，但是需要加一个加节点前置指针指向pre
		for (int i = 1; i < len; ++i)
		{
			node = new ListNode(arr[i]);
			pre->next = node;
			node->pre = pre;
			node = node->next;
			pre = pre->next;
		}
		// 尾节点
		tail = node;
	}
	// 找到Key节点，然后输出前置和后置
	void getKey(int key)
	{
		ListNode* node = head;
		// 这里其实可以使用双指针去遍历，降低到O(n/2)
		for (int i = 0; i < len; ++i)
		{
			if (node->val == key)
			{
				break;
			}
			node = node->next;
		}
		if (node != nullptr)
		{
			// 先判断是不是前置和后置指针都有
			if (node->pre != nullptr && node->next != nullptr)
			{
				cout << node->pre->val << " " << node->next->val;
			}
			else if (node->pre != nullptr)
			{
				cout << node->pre->val;
			}
			else
			{
				cout << node->next->val;
			}
			cout << endl;
		}
	}
};

int main(int argc, char** argv)
{
	int n;
	cin >> n;
	int m;
	cin >> m;
	int* arr = new int[n];
	for (int i = 0; i < n; ++i)
	{
		cin >> arr[i];
	}
	LinkList* list = new LinkList(n, arr);
	for (int i = 0; i < m; ++i)
	{
		int key;
		cin >> key;
		list->getKey(key);
	}

	return 0;
}

#include<iostream>
#include<stack>
#include<string>

using namespace std;

int main(int argc, char** argv)
{
	int t;
	cin >> t;
	while (t--)
	{
		string str;
		cin >> str;
		stack<char> chstk;
		// 直接遍历字符串
		for (char& ch : str)
		{
			// 压栈
			chstk.push(ch);
		}
		// 然后不断出栈
		while (!chstk.empty())
		{
			cout << chstk.top();
			chstk.pop();
		}
		cout << endl;
	}

	return 0;
}

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

/// <summary>
/// 行编辑函数
/// </summary>
/// <param name="s"></param>
void lineEdit(string s)
{
	// 使用两个栈，一个用于存储，一个用于输出
	stack<char> stk1, stk2;
	for (char& ch : s)
	{
		// 识别到不是 # 则压栈 
		if (ch != '#')
		{
			stk1.push(ch);
		}
		// 判断栈是否空，不空则出栈
		else if (!stk1.empty())
		{
			stk1.pop();
		}
	}
	// 如果遍历完，栈1为空，则直接输出，并跳出
	if (stk1.empty())
	{
		cout << "NULL" << endl;
		return;
	}
	// 否则，则需要使用另外一个栈将原栈的元素顺序倒置，然后才输出
	while (!stk1.empty())
	{
		stk2.push(stk1.top());
		stk1.pop();
	}
	while (!stk2.empty())
	{
		cout << stk2.top();
		stk2.pop();
	}
	cout << endl;
}

int main(int argc, char** argv)
{
	int t;
	cin >> t;
	while (t--)
	{
		string s;
		cin >> s;
		lineEdit(s);
	}

	return 0;
}

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

// 括号匹配函数
void ParMatch(string s)
{
	stack<char> stk;
	// 用于记录最终是否成功匹配
	bool flag = true;
	for (char& ch : s)
	{
		// 左括号入栈
		if (ch == '(' || ch == '[' || ch == '{')
		{
			stk.push(ch);
		}
		// 右括号出栈，匹配
		else if (!stk.empty() && 
				(ch == '}'  && stk.top() == '{' 
				|| ch == ']' && stk.top() == '[' 
				|| ch == ')' && stk.top() == '('))
		{
			stk.pop();
		}
		// 匹配不成功 直接退出
		else if (ch == '}' || ch == ')' || ch == ']')
		{
			flag = false;
			break;
		}
	}
	// 判断栈是否为空，以及是否匹配成功
	if (!stk.empty() || flag == false)
	{
		cout << "error" << endl;
	}
	else
	{
		cout << "ok" << endl;
	}
}

int main(int argc, char** argv)
{
	int t;
	cin >> t;
	while (t--)
	{
		string s;
		cin >> s;
		ParMatch(s);
	}
	return 0;
}

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

class Solution
{
public:
	// 路径栈，存储路径的坐标
	stack<pair<int, int>> path;
	const int dx[4] = { 0, 1, 0, -1 };
	const int dy[4] = { 1, 0, -1, 0 };

	// 寻找路径函数
	stack<pair<int, int>> findpath(int n,int** arr)
	{
		// 先判断起始点是否可以通过
		if (arr[0][0] == 1)
		{
			return {};
		}
		bool flag = true;
		// 调用dfs函数搜索路径
		dfs(arr, 0, 0, n, flag);
		return path;
	}
	/// <summary>
	/// DFS搜索路径
	/// </summary>
	/// <param name="arr">迷宫</param>
	/// <param name="x">当前x坐标</param>
	/// <param name="y">当前y坐标</param>
	/// <param name="n">迷宫尺寸</param>
	/// <param name="flag">是否到达终点标识符</param>
	void dfs(int** arr, int x, int y, int n, bool& flag)
	{
		// 如果到达终点
		if (x == n - 1 && y == n - 1)
		{
			// 压栈
			path.push({x, y});
			// 标识符
			flag = false;
			return;
		}
		// 避免出现下一个位置直接回退，造成不必要的时间浪费
		arr[x][y] = -1;
		for (int i = 0; i < 4 && flag; ++i)
		{
			// 下一坐标计算
			int nx = x + dx[i];
			int ny = y + dy[i];
			// 判断下一坐标是否可走
			if (nx >= 0 && nx < n && ny >= 0 && ny < n && arr[nx][ny] == 0)
			{
				dfs(arr, nx, ny, n, flag);
			}
		}
		// 找到路径，递归回来直接压栈
		if (!flag)
		{
			path.push({ x, y });
		}

	}
};

void display(stack<pair<int, int>> path)
{
	if (!path.empty())	//找到路径
	{	
		int i = 0;
		while (!path.empty())
		{
			auto cops = path.top();
			cout << '[' << cops.first << "," << cops.second << "]--";
			if ((++i) % 4 == 0)
			{
				cout << endl;
			}
			path.pop();
		}
		cout << "END" << endl;
	}
	else
	{
		cout << "no path" << endl; //找不到路径输出no path
	}
}


int main(int argc, char** argv)
{
	int t;
	cin >> t;
	while (t--)
	{
		int n;
		cin >> n;
		int** arr = new int*[n];
		for (int i = 0; i < n; ++i)
		{
			arr[i] = new int[n];
			for (int j = 0; j < n; ++j)
			{
				cin >> arr[i][j];
			}
		}
		Solution sol;
		auto path = sol.findpath(n, arr);
		display(path);
	}


	return 0;
}

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

class Solution
{
private:
	stack<string> nums;		// 存储操作数, 实际上会存储操作符的
	stack<char> op;			// 存储操作符

	// 逆向遍历时判断操作符优先级
	bool opcmpRight(char op1, char op2)
	{
		// + - 的时候，只需要判断栈顶是否同级，逆序，同级新的优先级更高
		if (op1 == '+' || op1 == '-')
		{
			return op2 == '+' || op2 == '-';
		}
		// * / 直接入栈
		return true;
	}

	// 正向遍历时判断操作符优先级
	bool opcmpLeft(char op1, char op2)
	{
		// 正向的时候，同级新的优先级会低
		if (op1 == '*' || op1 == '/')
		{
			return op2 != '*' && op2 != '/';
		}
		return false;
	}
public:
	// 求解波兰式
	string poland(string s)
	{
		int len = s.length();
		// 逆序遍历字符串
		for (int i = len - 1; i >= 0; --i)
		{
			// 数字存栈
			if (s[i] >= '0' && s[i] <= '9')
			{
				// 字符串拼接
				string num = "";
				num += s[i];
				// 判断前置是否是数字
				while (i - 1 >= 0 && s[i - 1] >= '0' && s[i - 1] <= '9')
				{
					num = s[--i] + num;
				}
				// 将数字入栈
				nums.push(num);
			}
			// 操作符
			// 判断栈是否空，或者有右括号
			else if (op.empty() || s[i] == ')' || op.top() == ')')
			{
				op.push(s[i]);
			}
			// 识别到左括号，此时需要将括号内的操作符输出
			else if (s[i] == '(')
			{
				// 操作数栈存储括号内的操作符
				while (!op.empty() && op.top() != ')')
				{
					string ops = "";
					ops += op.top();
					nums.push(ops);
					op.pop();
				}
				// 右括号出栈
				op.pop();
			}
			// 优先级高于栈顶，无脑入栈
			else if (opcmpRight(s[i], op.top()))
			{
				op.push(s[i]);
			}
			// 优先级低于栈顶
			else
			{
				// 操作符出栈并存入操作数栈
				while (!op.empty() && !opcmpRight(s[i], op.top()))
				{
					string ops = "";
					ops += op.top();
					nums.push(ops);
					op.pop();
				}
				// 压栈
				op.push(s[i]);
			}
		}
		// 将最终操作符栈压入操作数栈中
		while (!op.empty())
		{
			string ops = "";
			ops += op.top();
			nums.push(ops);
			op.pop();
		}
		// 得出答案
		string ans = "";
		while (!nums.empty())
		{
			ans += nums.top() + (nums.size() > 1 ? " " : "");
			nums.pop();
		}
		return ans;
	}

	// 求解逆波兰式
	string antiPoland(string s)
	{
		int len = s.size();
		string ans = "";
		// 正向遍历
		for (int i = 0; i < len; ++i)
		{
			// 数字直接加入答案
			if (s[i] >= '0' && s[i] <= '9')
			{
				ans += s[i];
				while (i + 1 < len && s[i + 1] >= '0' && s[i + 1] <= '9')
				{
					ans += s[++i];
				}
				ans += " ";
			}
			// 操作符的情况则需要和波兰式类似存栈
			// 栈空，左括号
			else if (op.empty() || s[i] == '(' || op.top() == '(')
			{
				op.push(s[i]);
			}
			// 右括号则需要输出括号内的操作符
			else if (s[i] == ')')
			{
				while (!op.empty() && op.top() != '(')
				{
					ans += op.top();
					ans += " ";
					op.pop();
				}
				op.pop();
			}
			// 判断优先级
			else if (opcmpLeft(s[i], op.top()))
			{
				op.push(s[i]);
			}
			else
			{
				while (!op.empty() && !opcmpLeft(s[i], op.top()))
				{
					ans += op.top();
					ans += " ";
					op.pop();
				}
				op.push(s[i]);
			}
		}
		// 将栈中输出到答案中
		while (!op.empty())
		{
			ans += op.top();
			ans += op.size() > 1 ? " " : "";
			op.pop();
		}
		return ans;
	}
};

int main(int argc, char** argv)
{
	int t;
	cin >> t;
	while (t--)
	{
		Solution sol;
		string s;
		cin >> s;
		cout << sol.poland(s) << endl;
		cout << sol.antiPoland(s) << endl << endl;
	}

	return 0;
}