【大一下】栈和队列实验代码总结

最新推荐文章于 2022-11-23 15:34:59 发布
最新推荐文章于 2022-11-23 15:34:59 发布
阅读量903 收藏 2
点赞数 5
分类专栏： 小知识点 数据结构 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nathanqian123/article/details/124182010
版权

目录

栈

括号匹配问题

指针做法

STL做法

顺序共用栈问题

类与对象做法

指针做法

迷宫

队列

轮船问题

指针做法

STL做法

单指针队列

杨辉三角形

栈模拟队列

 

栈

括号匹配问题

指针做法

//Author:NathanQian
#include<iostream>
#include<stack>
#include<string>
using namespace std;
const int N = 1e5 + 10;
struct Stack
{
	char* base;
	int top;
	int stacksize;
};
void Initstack(Stack &st)
{
	st.base = new char[N];
	st.top = -1;
	st.stacksize = N;
}
void push(Stack& st,char e)
{
	st.top++;
	st.base[st.top] = e;
}
void pop(Stack& st)
{
	if (st.top == -1)
		return;
	else
		st.top--;
}
char top(Stack& st)
{
	if (st.top != -1)
	return st.base[st.top];
}
bool empty(Stack& st)
{
	if(st.top == -1)return true;
	else return false;
}
int main()
{
	cout << "请输入表达式:" << endl;
	Stack st;
	Initstack(st);
	string s;
	cin >> s;
	for (int i = 0; i < s.size(); i++)
	{
		auto c = s[i];
		if (c == '('|| c == '[')push(st,c);
		else if (c == ')')
		{
			if (!empty(st)&&top(st) == '(')
			{
				pop(st);
				continue;
			}
			else
			{
				puts("不匹配");
				return 0;
			}
		}
		else if(!empty(st)&&c==']')
		{
			if (top(st) == '[')
			{
				pop(st);
				continue;
			}
			else
			{
				puts("不匹配");
				return 0;
			}
		}
	}
	if (empty(st))
		puts("匹配！");
	else
		puts("不匹配");

}

STL做法

//Author:NathanQian
#include<iostream>
#include<stack>
#include<string>
using namespace std;

int main()
{
	cout << "请输入表达式：" << endl;
	stack<char>st;
	string s;
	cin >> s;
	for (int i = 0; i < s.size(); i++)
	{
		auto c = s[i];
		if (c == '(' || c == '[')st.push(c);
		else if (c == ')')
		{
			if (!st.empty() && st.top() == '(')
			{
				st.pop();
				continue;
			}
			else
			{
				puts("不匹配");
				return 0;
			}
		}
		else if (!st.empty() && c == ']')
		{
			if (st.top() == '[')
			{
				st.pop();
				continue;
			}
			else
			{
				puts("不匹配");
				return 0;
			}
		}
	}
	if (st.empty())
		puts("匹配！");
	else
		puts("不匹配");

}

顺序共用栈问题

类与对象做法

#include<iostream>
#include<string>
using namespace std;
int n;class mergeStack
{
private:
	int top1;
	int top2;
	int stacksize;
	int* base = new int[stacksize];
public:
	mergeStack(int n)
	{
		stacksize = n;
		top1 = -1;
		top2 = stacksize;
	}
	void push1()
	{
		if (top1 + 1 == top2)
		{
			cout << "栈满，无法入栈" << endl;
			return;
		}
		top1++;
		cout << "成功入栈，栈顶指针增1" << endl;
		return;
	}
	void push2()
	{
		if (top2 -1 == top1)
		cout << "栈满，无法入栈" << endl;
		else
		{
			top2--;
			cout << "成功入栈，栈顶指针减1" << endl;
		}
		return;
	}
	void pop1()
	{
		if (top1 == -1)
			cout << "栈空，无法出栈" << endl;
		else
		{
			top1--;
			cout << "成功出栈，栈顶指针减1" << endl;
		}
	}
	void pop2()
	{
		if (top2 == stacksize)
			cout << "栈空，无法出栈" << endl;
		else
		{
			top2++;
			cout << "成功出栈，栈顶指针增1" << endl;
		}
	}

};
int main()
{
	int n;
	puts("请输入共用栈的容量:");
	cin >> n;
	mergeStack St(n);
	int type;
	string op;
	puts("请输入栈序号（1，2）和对应操作（in，out）:");
	while (cin >> type >> op)
	{
		if (type == 1)
		{
			if (op == "in")
				St.push1();
			else if (op == "out")
				St.pop1();
			else
				cout << "op操作输入非法！" << endl;
		}
		else if (type == 2)
		{
			if (op == "in")
				St.push2();
			else if (op == "out")
				St.pop2();
			else
				cout << "op操作输入非法！" << endl;
		}
		else
			cout << "输入序号非法！" << endl;
	}
	return 0;

}

指针做法

#include<iostream>
#include<string>
using namespace std;
int n;class mergeStack
{
private:
	int top1;
	int top2;
	int stacksize;
	int* base = new int[stacksize];
public:
	mergeStack(int n)
	{
		stacksize = n;
		top1 = -1;
		top2 = stacksize;
	}
	void push1()
	{
		if (top1 + 1 == top2)
		{
			cout << "栈满，无法入栈" << endl;
			return;
		}
		top1++;
		cout << "成功入栈，栈顶指针增1" << endl;
		return;
	}
	void push2()
	{
		if (top2 -1 == top1)
		cout << "栈满，无法入栈" << endl;
		else
		{
			top2--;
			cout << "成功入栈，栈顶指针减1" << endl;
		}
		return;
	}
	void pop1()
	{
		if (top1 == -1)
			cout << "栈空，无法出栈" << endl;
		else
		{
			top1--;
			cout << "成功出栈，栈顶指针减1" << endl;
		}
	}
	void pop2()
	{
		if (top2 == stacksize)
			cout << "栈空，无法出栈" << endl;
		else
		{
			top2++;
			cout << "成功出栈，栈顶指针增1" << endl;
		}
	}

};
int main()
{
	int n;
	puts("请输入共用栈的容量:");
	cin >> n;
	mergeStack St(n);
	int type;
	string op;
	puts("请输入栈序号（1，2）和对应操作（in，out）:");
	while (cin >> type >> op)
	{
		if (type == 1)
		{
			if (op == "in")
				St.push1();
			else if (op == "out")
				St.pop1();
			else
				cout << "op操作输入非法！" << endl;
		}
		else if (type == 2)
		{
			if (op == "in")
				St.push2();
			else if (op == "out")
				St.pop2();
			else
				cout << "op操作输入非法！" << endl;
		}
		else
			cout << "输入序号非法！" << endl;
	}
	return 0;

}

迷宫

这里实际上最终会考察BFS和DFS就用vector来模拟下吧！

//Author:NathanQian
#include<iostream>
#include<queue>
#include<vector>
#include<cstring>
using namespace std;
const int N = 550;
struct co
{
	int x;
	int y;
};
char g[N][N];
bool st[N][N];
int d[N][N];
int n, m;
vector<co>ans1;
vector<co>ans;
int dx[4] = { -1,0,1,0 }, dy[4] = { 0,1,0,-1 };
void dfs(int x,int y)
{
	if (x == n && y == m)
	{
		for (int i = 0; i < ans.size(); i++)
			cout << "(" << ans[i].x << "," << ans[i].y << ")"<<' ';
		cout << endl;
	}
	else
	{
		for (int i = 0; i < 4; i++)
		{
			int x0 = x + dx[i], y0 = y + dy[i];
			if (!st[x0][y0] && g[x0][y0]=='0')
			{
				ans.push_back({ x0,y0 });
				st[x0][y0] = true;
				dfs(x0, y0);
				st[x0][y0] = false;
				ans.pop_back();
			}
		}
	}
}
void bfs()
{
	queue<co>q;
	memset(d, -1, sizeof d);
	q.push({ 1,1 });
	ans1.push_back({ 1,1 });
	d[1][1] = 0;
	int cnt = 0;
	while (q.size())
	{
		auto p = q.front(); q.pop();
		for (int i = 0; i < 4; i++)
		{
			int x = p.x + dx[i], y = p.y + dy[i];
			if (d[x][y]==-1 && g[x][y] == '0')
			{
				d[x][y] = d[p.x][p.y] + 1;
				q.push({ x,y });
				if (d[x][y] > cnt)
				{
					cnt = d[x][y];
					ans1.push_back({ x,y });
				}
			}
			if (x == n && y == m)
			{
				for (int i = 0; i < ans1.size(); i++)
					cout << "(" << ans1[i].x << "," << ans1[i].y << ")" << ' ';
				cout << endl;
				return;
			}
		}
	}
}
int main()
{
	puts("请输入地图的长度和宽度：");
	cin >> n >> m;
	memset(g, -1, sizeof g);
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
			cin >> g[i][j];
	puts("1.DFS求所有可能的路径");
	ans.push_back({ 1,1 });
	st[1][1] = 1;
	dfs(1, 1);
              puts("2.BFS求最短路径");
	bfs();
	return 0;
}

队列

轮船问题

指针做法

//Author:NATHANQIAN
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
const int N = 1e5 + 10;
int cnt = 1;
struct Car
{
	char type;
	int id;
};
struct Sqqueue
{
	Car* base;
	int front;
	int rear;
	int queuesize;
};
struct Node
{
	Car* p;
	int id;
	Node* next;
};

//轮船的存储结构
void InitNode(Node *&p)
{
	Node* s = new Node;
	s->p = new Car[10];
	s->id = cnt++;
	p = s;
}//轮船结点的初始化

void push_back(Node*& ship)
{
	Node* s;
	InitNode(s);
	s->next = ship->next;
	ship->next = s;
	ship = s;
}//将这个轮船放入链表


//队列的初始化和操作
void Initqueue(Sqqueue &Q)
{
	Q.base = new Car[N];
	Q.front = Q.rear = 0;
	Q.queuesize = N;
}
void push(Sqqueue& Q, Car e)
{
	Q.base[Q.rear] = e;
	Q.rear++;
}
void pop(Sqqueue& Q)
{
	Q.front++;
}
Car front(Sqqueue& Q)
{
	return Q.base[Q.front];
}
bool empty(Sqqueue& Q)
{
	if (Q.rear == Q.front)
		return true;
	else
		return false;

}

int main()
{
	Sqqueue car1, car2;
	Initqueue(car1), Initqueue(car2);
	int n, m, cnt1 = 0, cnt2 = 0, cnt = 0;
	Node* L;//头结点方便后期遍历整个链表
	L = new Node;
	Node* ship;
	InitNode(ship);
	ship->next = NULL;
	L->next = ship;
	int j = 0;
	puts("请依次输入进入队列的客车和货车的数量");
		while (cin >> n >> m && (n || m))
		{
			system("cls");
			for (int i = 1; i <= n; i++)
				push(car1,{ 'K',i + cnt1});
			cnt1 += n;
			for (int j = 1; j <= m; j++)
				push(car2, { 'H',j + cnt2 });
			cnt2 += m;
			while (!empty(car1) || !empty(car2))
			{
				if ((cnt >= 4 && !empty(car2)) || empty(car1))
				{
					auto now = front(car2); pop(car2);
					ship->p[j++]=now;
					cnt = 0;
				}
				else
				{
					auto now = front(car1); pop(car1);
					ship->p[j++]=now;
					cnt++;
				}
				if (j == 10)
				{
					push_back(ship);
					j = 0;
				}
			}
			int st;
			puts("是否查看当前船的载车情况 1.查看 2.继续输入");
			cin >> st;
			if (st == 1)
			{
				for (auto it = L->next; it != NULL; it = it->next)
				{
					
					for (int j = 0; j < 10; j++)
						if (it->p[j].type =='H'||it->p[j].type=='K')
						cout << it->p[j].type << it->p[j].id << ' ';
					cout << "ship" << it->id << endl;
				}
				
			}
			cout << endl;

			puts("请依次输入进入队列的客车和货车的数量,输入 0 0 结束装载");
		}
		puts("运载结束");
		





}

STL做法

#include<iostream>
#include<queue>
#include<vector>

using namespace std;
struct Car
{
	char type;
	int id;
};
vector<vector<Car>>ship;
int main()
{
	queue<Car>car1, car2;
	int n, m, cnt1 = 0, cnt2 = 0, cnt = 0;
	ship.push_back(vector<Car>(10));
	int i = 0, j = 0;
	puts("请依次输入进入队列的客车和货车的数量");
		while (cin >> n >> m && (n || m))
		{
			system("cls");
			for (int i = 1; i <= n; i++)
				car1.push({ 'K',i + cnt1});
			cnt1 += n;
			for (int j = 1; j <= m; j++)
				car2.push({ 'H',j + cnt2});
			cnt2 += m;
			while (!car1.empty() || !car2.empty())
			{
				if ((cnt >= 4 && !car2.empty()) || car1.empty())
				{
					auto now = car2.front(); car2.pop();
					ship[i][j++]=now;
					cnt = 0;
				}
				else
				{
					auto now = car1.front(); car1.pop();
					ship[i][j++]=now;
					cnt++;
				}
				if (j == 10)
				{
					ship.push_back(vector<Car>(10));
					i++;
					j = 0;
				}
			}
			int st;
			puts("是否查看当前船的载车情况 1.查看 2.继续输入");
			cin >> st;
			if (st == 1)
			{
				for (auto iter = ship.begin(); iter != ship.end(); iter++)
				{
					auto tmp = *iter;
					for (auto it = tmp.begin(); it != tmp.end(); it++)
						if (it->id)
						{
							cout << it->type << it->id << ' ';
						}
					cout << "ship" << iter - ship.begin()+1<< endl;
				}
			}
			puts("请依次输入进入队列的客车和货车的数量,输入 0 0 结束装载");
		}
		puts("运载结束");
		





}

单指针队列

这个就是一个手写队列

#include<iostream>
using namespace std;
struct queue
{
	int* base;
	int front;
	int rear;
	int queuesize;
};
void Initqueue(queue& Q, int m)
{
	Q.base = new int[m];
	Q.front = Q.rear = 0;
	Q.queuesize = m + 1;
}
void push(queue& Q, int e)
{
	if ((Q.rear +1)% Q.queuesize == Q.front)
	{
		cout << "队满，无法入队啦！" << endl;
		return;
	}
	Q.base[Q.rear] = e;
	Q.rear = (Q.rear + 1) % Q.queuesize;
	cout << "入队成功！" << endl;
}
void pop(queue& Q)
{
	if (Q.front == Q.rear)
	{
		cout << "队空，没东西出队啦！" << endl;
		return;
	}
	Q.front = (Q.front + 1) % Q.queuesize;
	cout << "出队成功！" << endl;
}
bool empty(queue& Q)
{
	return Q.rear == Q.front;
}

void show(queue& Q)
{
	if (Q.front == Q.rear)
	{
		cout << "队空，没东西看啦！" << endl;
		return;
	}

	for (int i = Q.front; i < Q.rear; i++)
		cout << Q.base[i] << ' ';
	cout << endl;
}
int main()
{
	cout << "请输入队长:" << endl;
	queue q; int m; cin >> m;
	cout << "功能表：\n1.测队空\n2.入队\n3.出队\n4.显示队长\n5.显示队元素" << endl;
	int op;
	Initqueue(q,m);
	while (cin >> op)
	{
		switch(op)
		{
		case 1:
			if (empty(q))
				cout << "队空" << endl;
			else
				cout << "队不空" << endl;
			break;
		case 2:
			cout << "请输入入队个数和元素值" << endl;
			int i; cin >> i;
			while (i--)
			{
				int x; cin >> x;
				push(q, x);
			}
			break;
		case 3:
			pop(q);
			break;
		case 4:
			if (q.rear > q.front)
				cout << q.rear - q.front << endl;
			else
				cout << q.queuesize - (q.front - q.rear);
			break;
		case 5:
			show(q);
		}
	}
	return 0;
}

杨辉三角形

队列来模拟

用作一个新的思维角度去考虑这个三角形问题挺不错

#include<iostream>
#include<queue>
using namespace std;
int main()
{
	queue<int>q;
	int rmax; cin >> rmax;
	int cnt = 1;
	int a[4] = { 0,1,0,0 };
	for (int i = 0; i < 4; i++)
		q.push(a[i]);
	while (cnt <= rmax)
	{
		for (int i = 1; i <= cnt + 2; i++)
		{
			auto p = q.front(); q.pop();
			q.push(p + q.front());
			cout << p << ' ';
		}
		cout << endl;
		q.push(0);
		cnt++;
	}
}

栈模拟队列

#include<iostream>
using namespace std;
const int N = 4;
struct Stack
{
	int* base;
	int top;
	int stacksize;
};
void InitStack(Stack& st)
{
	st.stacksize = N;
	st.base = new int[N];
	st.top = -1;
}
int pop(Stack& st)
{
	return st.base[st.top--];
}
void push(Stack& st,int e)
{
	st.top++;
	st.base[st.top] = e;

}
bool full(Stack& st)
{
	if (st.top + 1 == st.stacksize)
		return true;
	else
		return false;
}
bool empty(Stack& st)
{
	if (st.top == -1)
		return true;
	else
		return false;
}
void show(Stack &st)
{
	if (!empty(st))
		for (int i = 0; i <= st.top; i++)
			cout << st.base[st.top] << ' ';

}
int main()
{
	Stack s1, s2;
	InitStack(s1), InitStack(s2);
	int op;
	puts("请输入操作：\n1.测队空\n2.入队\n3.显示队列元素\n4.出队");
	while (cin >> op)
	{
		if (op == 1)
		{
			if (empty(s1) && empty(s2))
				cout << "队空！" << endl;
			else
				cout << "队不空哦！" << endl;
		}
		else if (op == 2)
		{
			puts("请输入元素:");
			int e; cin >> e;
			if (!full(s1))
			{
				push(s1, e);
				cout << "入队成功！" << endl;
			}
			else if (full(s1) && empty(s2))
			{
				while (!empty(s1))
				{
					int m = pop(s1);
					push(s2, m);
				}
				push(s1, e);
				cout << "入队成功！" << endl;
			}
			else if (full(s1) && !empty(s2))
				cout << "不能入队哦！" << endl;
		}
		else if (op == 3)
		{
			if (empty(s1) && empty(s2))
				cout << "队空！" << endl;
			else 
				{
				for (int i = s2.top; i >= 0; i--)
					cout << s2.base[i] << ' ';
				for (int i = 0; i <= s1.top; i++)
					cout << s1.base[i] << ' ';
				cout << endl;
				}
		}
		else if (op == 4)
		{
			if (!empty(s2))
				pop(s2);
			else if (empty(s1))
			{
				while (!empty(s1))
					push(s2, pop(s1));
			}
			else
				cout << "不能出队哦！" << endl;
		}
	}
	return 0;

}

Nathan Qian
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
实验报告栈和队列的操作实验报告
04-25
栈，队列，循环队列； 数据结构实验报告，循环队列打印杨辉三角
数据结构与算法——队列
qq_38670588的博客
10-19 289
目录什么是队列队列的实现基于数组的队列实现基于链表的队列实现循环链表阻塞队列和并发队列问题 什么是队列 队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。先进者先出，这就是典型的“队列”。 队列的实现 基于数组的队列实现 跟栈一样，队列可以用数组来实现，也可以用链表来实现。用数组实现的栈叫作顺序栈，用链表实现的栈叫作链式栈。同样，用数组实现的队列
栈和队列的总结
weixin_46772722的博客
07-17 874
栈和队列
数据结构：栈和队列的总结回顾
weixin_33947521的博客
02-10 66
栈和队列都是线性表： 栈和队列，它们都是特殊的线性表，只不过对插入和删除操作做了限制。 栈：限定仅在表尾进行插入和删除操作的线性表。 队列：只允许在一端进行插入操作，而在另一端进行删除操作的线性表。 栈和队列的顺序存储结构： 它们都可以用线性表的顺序存储结构实现，但都存在着顺序存储的一些弊端，因此它们各自有一些技巧解决这个问题。 对于栈来说，如果两个相同数据类型的栈，则可...
数据结构实验栈和队列详细实验报告
04-15
实验三 栈和队列 3.1实验目的： （1） 熟悉栈的特点（先进后出）及栈的基本操作，如入栈、出栈等，掌握栈的基本操作在栈的顺序存储结构和链式存储结构上的实现； （2） 熟悉队列的特点（先进先出）及队列的基本操作，如入队、出队等，掌握队列的基本操作在队列的顺序存储结构和链式存储结构上的实现。 3.2 实验要求： （1） 复习课本中有关栈和队列的知识； （2） 用C语言完成算法和程序设计并上机调试通过； （3） 撰写实验报告，给出算法思路或流程图和具体实现（源程序）、算法分析结果（包括时间复杂度、空间复杂度以及算法优化设想）、输入数据及程序运行结果（必要时给出多种可能的输入数据和运行结果）。
数据结构栈和队列（参考代码）
06-18
数据结构栈和队列的课程指导上几实验代码 相抵部分
数据结构试验2-栈和队列实验报告含源码
03-08
数据结构栈和队列实验报告，请放心下载
栈和队列 实验报告
11-03
栈和队列 实验报告 亲测可以运行 C++代码 其中数据位int类型
东北大学 数据结构实验2 栈和队列
06-19
东北大学数据结构课程实验2栈和队列，实验报告，有代码。
栈和队列总结
风铃的博客
07-20 1813
一、栈（先进后出） 1、定义：栈作为一种数据结构，是一种只能在一端进行插入和删除操作的特殊线性表。 2、栈的存取方式和数组一样，不过有三个约束：1. 只能在末尾插入数据 2.只能读取末尾的数据 ...
栈和队列的基本操作实现及其应用实验报告
12-20
栈和队列的基本操作实验报告 一、实验目的 1、熟练掌握栈和队列的基本操作在两种存储结构上的实现。 2、会用栈和队列解决简单的实际问题。 二、实验内容 题目：试写一个算法，判断依次读入的一个以@为结束符的字符序列，是否为回文。所谓“回文“是指正向读和反向读都一样的一字符串,如“321123”或“ableelba”。
栈的实现和应用（实验报告+代码）
04-28
实现了以下三个问题 1、 实现自己的顺序栈类； 2、 判断输入的字符串中的括号是否配对； 3、 输入一个后缀表达式，并进行求值。
栈实验报告
03-31
1.了解栈和队列的特性。 2. 掌握栈的顺序表示和实现。 3. 掌握栈的链式表示和实现。 4. 掌握队列的顺序表示和实现。 5. 掌握队列的链式表示和实现。 6. 掌握栈和队列在实际问题中的应用。
数据结构栈实验的代码
10-30
包括数据结构实验课要求的整个程序，且绝对可获得优异成绩
栈和队列的实现和总结
m0_72873854的博客
11-23 1126
栈和队列的总结
【数据结构与算法】实验三 栈和队列
兔子王
10-08 1560
【实验内容】1. 编写程序实现顺序栈的相关操作。2. 编写程序实现循环队列的相关操作。3. 实现栈的应用——数制转换（十进制转换为二进制）。4. 实现栈的应用——判断表达式括号是否匹配。5. 栈和递归。6. 设计程序实现简单的四则运算。
【无标题】
kobe5152的博客
02-22 134
用队列实现栈和用栈实现队列 用队列实现栈 typedef int QDataType; typedef struct QListNode { struct QListNode* next; QDataType data; }QNode; // 队列的结构 typedef struct Queue { QNode* front; QNode* rear; }Queue; void QueueInit(Queue* q) { assert(q); q->front = NULL; q-&
《数据结构》实验三：栈和队列实验报告
热门推荐
hslynn的专栏
11-09 3万+
一．.实验目的      巩固栈和队列数据结构，学会运用栈和队列。 1.回顾栈和队列的逻辑结构和受限操作特点，栈和队列的物理存储结构和常见操作。 2.学习运用栈和队列的知识来解决实际问题。 3.进一步巩固程序调试方法。 4.进一步巩固模板程序设计。 二．实验时间    准备时间为第5周到第6周，具体集中实验时间为6周第2次课。2个学时。 三．.实验内容 1.自己选择顺序或链式存储
sdut数据结构实验3栈和队列pta
最新发布
10-03
sdut数据结构实验3栈和队列pta是一个涉及栈和队列的实验题目。根据提供的引用内容中的代码，这个实验中包含了三个题目，分别是队列模拟、银行业务队列简单模拟和行编辑器。其中，队列模拟题目涉及到使用队列进行数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Nathan Qian

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

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

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

打赏作者

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

抵扣说明：

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

余额充值