实验03 栈应用2022

最新推荐文章于 2022-10-15 14:54:45 发布
最新推荐文章于 2022-10-15 14:54:45 发布
阅读量377 收藏 1
点赞数
分类专栏： 数据结构实验 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_62431082/article/details/127233544
版权

A. DS堆栈--逆序输出（STL栈使用）

C++中已经自带堆栈对象stack，无需编写堆栈操作的具体实现代码。

本题目主要帮助大家熟悉stack对象的使用，然后实现字符串的逆序输出

输入一个字符串，按字符按输入顺序压入堆栈，然后根据堆栈后进先出的特点，做逆序输出

stack类使用的参考代码

n包含头文件<stack>：#include <stack>

n创建一个堆栈对象s（注意stack是模板类）：stack <char>  s;//堆栈的数据类型是字符型

n把一个字符ct压入堆栈：s.push(ct);

n把栈顶元素弹出：s.pop();

n获取栈顶元素，放入变量c2：c2 =s.top();

n判断堆栈是否空：s.empty()，如果为空则函数返回true，如果不空则返回false

输入

第一行输入t，表示有t个测试实例
第二起，每一行输入一个字符串，注意字符串不要包含空格

字符串的输入可以考虑一下代码：

#include <string>

int main()

{ string str;

Int len;

cin>>str; //把输入的字符串保存在变量str中

len = str.length()  //获取输入字符串的长度

}

输出

每行逆序输出每一个字符串

输入：
2
abcdef
aabbcc
输出：
fedcba
ccbbaa
#include<iostream>
using namespace std;
#include<stack>
#include<string>
int main() {
	string s;
	int n;
	cin >> n;
	while (n--) {
		cin >> s;
		stack<char> ss;
		for (int i = 0; i < s.length(); i++)
			ss.push(s[i]);
		while (!ss.empty()) {
			cout << ss.top();
			ss.pop();
		}
		cout << endl;
	}
}

B. DS堆栈--行编辑

题目描述

使用C++的STL堆栈对象，编写程序实现行编辑功能。行编辑功能是：当输入#字符，则执行退格操作；如果无字符可退就不操作，不会报错

本程序默认不会显示#字符，所以连续输入多个#表示连续执行多次退格操作

每输入一行字符打回车则表示字符串结束

注意：必须使用堆栈实现，而且结果必须是正序输出

输入

第一行输入一个整数t，表示有t行字符串要输入
第二行起输入一行字符串，共输入t行

输出

每行输出最终处理后的结果，如果一行输入的字符串经过处理后没有字符输出，则直接输出NULL

输入：
4
chinaa#
sb#zb#u
##shen###zhen###
chi##a#####
输出：
china
szu
sz
NULL
输入：
1
###############################################################################################

输出：
NULL
#include<iostream>
using namespace std;
#include<stack>
#include<string>
int main() {
	int n;
	cin >> n;
	while (n--) {
		string s;
		stack<char> c;
		cin >> s;
		int num = 0;
		for (int i = 0; i < s.length(); i++) {
			if (s[i] != '#') c.push(s[i]);
			else if(!c.empty()) c.pop();
		}
		if (c.empty()) cout << "NULL" << endl;
		else {
			stack<char>cc;
			while (!c.empty()) {
				cc.push(c.top());
				c.pop();
			}
			while (!cc.empty()) {
				cout << cc.top();
				cc.pop();
			}
			cout << endl;
		}
	}
}

C. DS堆栈--括号匹配

题目描述

处理表达式过程中需要对括号匹配进行检验，括号匹配包括三种：“(”和“)”，“[”和“]”，“{”和“}”。例如表达式中包含括号如下：

(	)	[	(	)	(	[	]	)	]	{	}
1	2	3	4	5	6	7	8	9	10	11	12

从上例可以看出第1和第2个括号匹配，第3和第10个括号匹配，4和5匹配，6和9匹配，7和8匹配，11和12匹配。从中可以看到括号嵌套的的情况是比较复杂的，使用堆栈可以很方便的处理这种括号匹配检验，可以遵循以下规则：

1、 当接收第1个左括号，表示新的一组匹配检查开始；随后如果连续接收到左括号，则不断进堆栈。

2、 当接受第1个右括号，则和最新进栈的左括号进行匹配，表示嵌套中1组括号已经匹配消除

3、 若到最后，括号不能完全匹配，则说明输入的表达式有错

建议使用C++自带的stack对象来实现

stack类使用的参考代码

n包含头文件<stack>：#include <stack>

n创建一个堆栈对象s（注意stack是模板类）：stack <char>  s;//堆栈的数据类型是字符型

n把一个字符ct压入堆栈：s.push(ct);

n把栈顶元素弹出：s.pop();

n获取栈顶元素，放入变量c2：c2 =s.top();

n判断堆栈是否空：s.empty()，如果为空则函数返回true，如果不空则返回false

提示

算法流程

1、初始化，i=0，建立堆栈，栈为空
2、输入表达式，建立指针指向表达式的头部
3、读入表达式的第i个字符
4、如果第i个字符是左括号，入栈
5、如果第i个字符是右括号，检查栈顶元素是否匹配
A.如果匹配，弹出栈顶元素
B.如果不匹配，报错退出
6、i++，指向下一个字符，是否已经表达式末尾
A. 未到末尾，重复步骤3
B. 已到达末尾
a. 堆栈为空，输出ok
b. 堆栈不为空，输出error

输入：
2
(a+b)[4*5+(-6)]
[5*8]/{(a+b)-6
输出：
ok
error
输入：
4
{1+1}[3+3](5+5)
((({{{}}})))
((({{{}}})))([[]])
((({{{5+5}}})))([[]])(1+1)
输出：
ok
ok
ok
ok
#include <iostream>
using namespace std;
#include<stack>
#include<string>

int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        stack<char> s;
        string str;
        cin >> str;
        int len = str.length(), flag = 1;

        for (int i = 0; i < len; i++)
        {
            if ((str[i] == ')' || str[i] == ']' || str[i] == '}') && s.empty())
            {
                flag = 0;
                break;
            }

            if (str[i] == '(' || str[i] == '[' || str[i] == '{')
                s.push(str[i]);

            if (str[i] == ')' && s.top() == '(' || str[i] == ']' && s.top() == '[' || str[i] == '}' && s.top() == '{')
            {
                s.pop();
            }
            else if (str[i] == ')' && s.top() != '(' || str[i] == ']' && s.top() != '[' || str[i] == '}' && s.top() != '{')
            {
                flag = 0;
                break;
            }
        }
        if (s.empty() && flag)
            cout << "ok" << endl;
        else
            cout << "error" << endl;

    }
}

D. DS堆栈--迷宫求解

题目描述

给出一个N*N的迷宫矩阵示意图，从起点[0,0]出发，寻找路径到达终点[N-1, N-1]

要求使用堆栈对象来实现，具体算法参考课本3.2.4节51页

输入

第一行输入t，表示有t个迷宫

第二行输入n，表示第一个迷宫有n行n列

第三行起，输入迷宫每一行的每个方格的状态，0表示可通过，1表示不可通过

输入n行

以此类推输入下一个迷宫

输出

逐个输出迷宫的路径

如果迷宫不存在路径，则输出no path并回车

如果迷宫存在路径，将路径中每个方格的x和y坐标输出，从起点到终点，每输出四个方格就换行，最终以单词END结尾，具体格式参考示范数据

输出的代码参考如下：

//path是保存路径的堆栈，堆栈中每个元素都包含x坐标和y坐标，用属性xp和yp表示

//path1是一个临时堆栈，把path的数据倒序输出到path1，使得路径按正序输出

if (!path.empty())//找到路径

{//......若干代码，实现path的数据导入path1

i=0;  //以下是输出路径的代码

while (!path1.empty())

{cpos = path1.top();

if ( (++i)%4 == 0 )

cout<<'['<<cpos.xp<<','<<cpos.yp<<']'<<"--"<<endl;

else

cout<<'['<<cpos.xp<<','<<cpos.yp<<']'<<"--";

path1.pop();

}

cout<<"END"<<endl;

}

else

cout<<"no path"<<endl; //找不到路径输出no path

输入：
2
8
0 0 0 1 1 1 1 1
1 0 0 0 1 0 0 1
1 0 0 0 1 0 0 0
1 1 0 0 0 0 0 1
0 0 1 1 0 1 1 0
0 0 0 0 0 0 1 1
1 1 1 1 1 0 0 1
0 0 0 0 1 0 0 0
7
0 0 0 1 1 1 1
1 0 0 1 0 0 1
1 0 0 1 0 0 0
1 1 0 0 0 0 1
0 0 1 1 0 1 0
1 0 0 0 0 1 0
0 0 0 0 1 1 0
输出：
[0,0]--[0,1]--[0,2]--[1,2]--
[1,3]--[2,3]--[3,3]--[3,4]--
[4,4]--[5,4]--[5,5]--[6,5]--
[6,6]--[7,6]--[7,7]--END
no path
输入：
2
12
0 1 1 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 1
0 1 1 1 1 0 1 1 1 1 0 1
1 0 0 0 0 0 0 0 0 0 0 1
0 0 1 1 1 1 0 1 0 1 1 0
0 1 1 1 1 1 1 1 1 1 0 0
0 0 0 0 0 0 0 0 0 0 0 1
1 1 1 1 0 1 1 1 1 1 0 1
1 1 1 1 1 0 1 1 1 1 0 1
1 1 1 1 1 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 0 1 1 1
0 1 0 1 0 1 0 1 0 0 0 0
12
0 1 1 1 1 1 1 1 1 1 1 0
0 0 0 0 0 0 0 0 0 0 0 1
0 1 1 1 1 0 1 1 1 1 0 1
1 0 0 0 0 0 0 0 0 0 0 1
0 0 1 1 1 1 0 1 0 1 1 0
0 1 1 1 1 1 1 1 1 1 0 0
0 0 0 0 0 0 0 0 0 0 1 1
1 1 1 1 0 1 1 1 1 1 0 1
1 1 1 1 1 0 1 1 1 1 0 1
1 1 1 1 1 0 0 0 0 0 0 0
1 1 1 1 1 1 1 1 0 1 1 1
0 1 0 1 0 1 0 1 0 0 0 0
输出：
[0,0]--[1,0]--[1,1]--[1,2]--
[1,3]--[1,4]--[1,5]--[1,6]--
[1,7]--[1,8]--[1,9]--[1,10]--
[2,10]--[3,10]--[3,9]--[3,8]--
[3,7]--[3,6]--[3,5]--[3,4]--
[3,3]--[3,2]--[3,1]--[4,1]--
[4,0]--[5,0]--[6,0]--[6,1]--
[6,2]--[6,3]--[6,4]--[6,5]--
[6,6]--[6,7]--[6,8]--[6,9]--
[6,10]--[7,10]--[8,10]--[9,10]--
[9,9]--[9,8]--[10,8]--[11,8]--
[11,9]--[11,10]--[11,11]--END
no path

 

#include <string>
#include<stack>
#include<map>
#include<iostream>
using namespace std;
int m[100][100];
int way[4][2] = { {1,0},{0,1},{-1,0},{0,-1} };
int sign = 0;
struct sta
{
 int xp, yp;
};
stack<sta> path, path1;

void dfs(int x, int y, int n)
{
 if (x == n  && y == n )
 {
  sign = 1;
  sta te;
  te.xp = n;
  te.yp = n;
  path.push(te);
  while (!path.empty())
  {
   path1.push(path.top());
   path.pop();
  }
  return;
 }
 for (int i = 0; i < 4; i++)
 {
  sta temp;
  temp.xp = x + way[i][0];
  temp.yp = y + way[i][1];
  if ((m[temp.yp][temp.xp]==0))
  {
   sta t;
   t.xp = temp.xp - way[i][0];
   t.yp = temp.yp - way[i][1];
   m[temp.yp][temp.xp] = 1;
   path.push(t);
   dfs(temp.xp, temp.yp, n);
   if (sign)
    return;
   m[temp.yp][temp.xp] = 0;
   path.pop();
  }
 }
}
int main()

{
 int t;
 cin >> t;
 while (t--)
 {
  int n;
  cin >> n;
  for (int i = 0; i <= n+1; i++)
  {
   for (int j = 0; j <= n+1; j++)
   {
     m[i][j]=1;
   }
  }
  for (int i = 1; i <= n; i++)
  {
   for (int j = 1; j <=n; j++)
   {
    cin>>m[i][j] ;
   }
  }
  sta cpos;
  int i;
  sign = 0;
  dfs(1, 1, n);
  if (sign)//找到路径

  {//......若干代码，实现path的数据导入path1

   i = 0;  //以下是输出路径的代码

   while (!path1.empty())

   {
    cpos = path1.top();

    if ((++i) % 4 == 0)

     cout << '[' << cpos.yp-1 << ',' << cpos.xp-1 << ']' << "--" << endl;

    else

     cout << '[' << cpos.yp -1<< ',' << cpos.xp -1<< ']' << "--";

    path1.pop();

   }

   cout << "END" << endl;

  }

  else

   cout << "no path" << endl; //找不到路径输出no path
 }
}

E. 堆栈操作合法性

题目描述

假设以S和X分别表示入栈和出栈操作。如果根据一个仅由S和X构成的序列，对一个空堆栈进行操作，相应操作均可行（如没有出现删除时栈空）且最后状态也是栈空，则称该序列是合法的堆栈操作序列。请编写程序，输入S和X序列，判断该序列是否合法。

输入

输入第一行给出两个正整数N和M，其中N是待测序列的个数，M（≤50）是堆栈的最大容量。随后N行，每行中给出一个仅由S和X构成的序列。序列保证不为空，且长度不超过100。

输出

对每个序列，在一行中输出YES如果该序列是合法的堆栈操作序列，或NO如果不是。

输入：
4 10
SSSXXSXXSX
SSSXXSXXS
SSSSSSSSSSXSSXXXXXXXXXXX
SSSXXSXXX
输出：
YES
NO
NO
NO
#include <iostream>
using namespace std;
#include<stack>
#include<string>

int main()
{
 int t,n;
 cin >> t>>n;
 while (t--)
 {
  stack<char> s;
  string str;
  cin >> str;
  int len = str.length(),flag=1;
  int size=0;
  for (int i = 0; i < len; i++)
  {
   if (s.empty() && str[i] == 'X'||size>n)
   {
    flag = 0;
    break;
   }
   if (str[i] == 'S')
   {
    s.push(str[i]);
    size++;
   }
   if (str[i] == 'X')
   {
    s.pop();
    size--;
   }
  }
  if (s.empty() && flag)
   cout << "YES" << endl;
  else
   cout << "NO" << endl;
 }
}

F. 【程序填空】表达式计算（栈应用）

题目描述

使用C++自带的stack栈模板来实现四则运算表达式求值

算法描述参考第3.2.5节

算法伪代码参考P53-54的算法3.4

例如

1. Push (OPTR, '#');表示把字符#压入堆栈OPTR中，转换成c++代码就是OPTR.push('#');

2. Pop(OPND, a); 表示弹出栈OPND的栈顶元素，并把栈顶元素放入变量a中。因此改成c++代码是两个操作：a = OPND.top();   OPND.pop();

3. a = GetTop(OPND)表示获取栈OPND的栈顶元素，转成c++代码就是： a = OPND.top();

大家主要是改造表达式求值函数EvaluateExpression的代码

输入

第一个输入t，表示有t个实例

第二行起，每行输入一个表达式，每个表达式末尾带#表示结束

输入t行

输出

每行输出一个表达式的计算结果，计算结果用浮点数（含2位小数）的格式表示

参考代码如下：

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

int main()

{ double temp = 12.345678

  cout<<fixed<<setprecision(2)<<temp<<endl;

}

输出结果为12.35

样例查看模式 

正常显示查看格式

提示

本题需要把一个字符串转成浮点数，例如字符串"1.234"转成浮点数1.234

因为C++11开始取消atof函数，所以C++要用sscanf函数来实现该转换，参考代码如下

#include <iostream>

#include <cstdio>

using namespace std;

int  main()

{ char TempData[]="1.23456";

double dd;

sscanf(TempData, "%lf", &dd);

cout<<dd<<endl;

return 0;

}

输入：
2
1+2*3-4/5#
(66+(((11+22)*2-33)/3+6)*2)-45.6789#
输出：
6.20
54.32
#include <iostream>
#include <string>
#include <cstring>
#include <stack>
#include <iomanip>
using namespace std;

#define OPSETSIZE 7
unsigned char Prior[7][7] = { //运算符间的优先关系
	  '>','>','<','<','<','>','>',
	  '>','>','<','<','<','>','>',
	  '>','>','>','>','<','>','>',
	  '>','>','>','>','<','>','>',
	  '<','<','<','<','<','=',' ',
	  '>','>','>','>',' ','>','>',
	  '<','<','<','<','<',' ','='
};
char OPSET[OPSETSIZE] = { '+' , '-' , '*' , '/' ,'(' , ')' , '#' }; //运算符集合

double Operate(double a, unsigned char theta, double b);	//计算类似a+b的表达式结果
bool In(char Test, char* TestOp); //判断字符Test是否是运算符，是则返回true
char precede(char Aop, char Bop); //返回两个运算符优先级的比较结果 

//以下完成算术表达式求值函数EvaluateExpression(string MyExp)的填空
double EvaluateExpression(string MyExp) //算术表达式求值算法
//设OPTR和OPND分别为运算符栈和运算数栈
//参数MyExp是表达式字符串
{
	stack<char> OPTR;		//运算符栈，字符元素
	stack<double> OPND;	//运算数栈，实数元素
	char TempData[20];
	double Data, a, b, r;
	char theta, c, x, Dr[2];
	OPTR.push('#');
	strcpy(TempData, "\0");
	int i = 0;		//表达式字符串的当前字符位置
	c = MyExp[i];	//表达式字符串的当前字符

	//逐个读入表达式字符串的字符到变量c，并识别为数值或运算符，做相应处理
/********** Write your code here! **********/
	//以下完成算术表达式求值函数EvaluateExpression(string MyExp)的填空
		//逐个读入表达式字符串的字符到变量c，并识别为数值或运算符，做相应处理
		strcpy(TempData, "\0");
		while (c != '#' || OPTR.top() != '#')
		{
			if (!In(c, OPSET)) //读入的字符if是一个数字
			{
				Dr[0] = c;
				Dr[1] = '\0';

				strcat(TempData, Dr);
				c = MyExp[++i];  //读下一个字符

				if (In(c, OPSET)) //if c是运算符，表示前面读入了一个完整操作
				{
					Data = (double)atof(TempData);
					OPND.push(Data);
					strcpy(TempData, "\0");
				}
			}
			else //是运算符->开始计算
			{
				switch (precede(OPTR.top(), c))
				{
					//栈顶元素优先权低
				case'<':OPTR.push(c);
					c = MyExp[++i];
					break;
					//脱括号并接收下一个字符
				case'=':OPTR.pop();
					c = MyExp[++i];
					break;
					//退栈并将运算符结果入栈
				case'>':
					theta = OPTR.top(); OPTR.pop();
					//等价于c—> pop(OPTR,theta);
					b = OPND.top(); OPND.pop();
					//->pop(opnd,b);
					a = OPND.top(); OPND.pop();
					//->pop(opnd,a);
					OPND.push(Operate(a, theta, b));
					break;
				}

			}
		}

		return OPND.top();



/*******************************************/
} //这是函数EvaluateExpression的右花括号
//函数EvaluateExpression的代码到此结束


//以下填空完成其他函数的定义，包括函数Operate\函数In\函数precede
//可以参考教材光盘中文件夹CHAP03的源代码ALGO0304.cpp，几乎照抄
/********** Write your code here! **********/


double Operate(double a, unsigned char theta, double b) //theta：运算符，a&b：数字->用于两个数字间的计算
{
	if (theta == '+')
		return a + b;
	else if (theta == '-')
		return a - b;
	else if (theta == '*')
		return a * b;
	else if (theta == '/')
		return a / b;
}


bool In(char test, char* testop) //test：字符->判断是否为运算符
{
	for (int i = 0; i < 7; i++)
		if (test == testop[i])
			return 1;
	return 0;
}

char precede(char aop, char bop)//判断两个运算符之间的大小关系
{
	int i, j;

	for (i = 0; i < 7; i++)
		if (OPSET[i] == aop)
			break;

	for (j = 0; j < 7; j++)
		if (OPSET[j] == bop)
			break;

	return Prior[i][j];//这是一个大于/小于/等于号
}

/*******************************************/
//主函数
int main()
{
	string Exp;
	int t;
	double result;
	cin >> t;
	while (t--)
	{
		cin >> Exp;
		result = EvaluateExpression(Exp);
		cout << fixed << setprecision(2) << result << endl;
	}

	return 0;
}

要被ddl噶辣
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构实验】栈的应用
06-15
实验三 栈的应用 1.实验目的： 熟悉栈的定义，栈的特点以及栈的基本操作。能够根据实际情况选择合适的存储结构，解决实际问题。 2.实验内容： 对任意给定的一个中缀算术表达式,输出等价的后缀形式。
数据结构实验之栈与队列八：栈的基本操作
baiqiaoxiang的博客
10-13 388
Description 堆栈是一种基本的数据结构。堆栈具有两种基本操作方式，push 和 pop。push一个值会将其压入栈顶，而 pop 则会将栈顶的值弹出。现在我们就来验证一下堆栈的使用。 Input 首先输入整数t（1 <= t <= 10），代表测试的组数，以后是 t 组输入。 对于每组测试数据，第一行输入两个正整数 m（1 <= m <= 100)、n（1 <= n <= 1000)，其中m代表当前栈的最大长度，n代表本组测试下面要输入的操作数。 而后的 n 行
多校联合集训 字符串“水”题
so_so_y的博客
05-03 658
题目描述 给出一个长度为 n 的字符串(1<=n<=100000)，求有多少个连续字串中所有的字母都出现了偶数次。 输入 第一行一个正整数 T，表示数据组数(1 <= T <= 10)。 接下来 T 行，每行有一个只包含小写字母的字符串。 输出 每个答案输出满足要求字符串个数。每个答案占一行。 样例输入 3 a aabbcc abcabc 样例输出 0
C++ string 类详解
顺其自然~专栏
12-27 1万+
　　字符串是存储在内存的连续字节中的一系列字符。C++ 处理字符串的方式有两种，一种来自 C 语言，常被称为 C-风格字符串，另一种是基于 string 类库的字符串处理方式。C 风格字符串的处理可以参考C语言 -- 字符串详解 - tongye - 博客园，本文着重介绍 string 类库的使用。 一、string 类简介 　　C++ 中提供了专门的头文件 string（注意不是 string.h，这个是 C 风格字符串相关函数的头文件），来支持 string 类型。string 类定义隐藏了字符..
python多组输入第一行第一组t组表示有t组数据_python3的输入方式及多组输入方法...
weixin_39844525的博客
02-10 1643
python3的输入方式1. 读取键盘输入内置函数 input()接收键盘标准输入str = input("请输入")print(str)默认返回的是字符串类型，通过强制转换可以变成其他类型num = int(input("请输入"))print(num, type(num))//type(变量)，返回变量类型2. raw_input()(只适用python2)input() 函数和raw_inp...
【程序填空】表达式计算（栈应用）
weixin_62438655的博客
10-15 321
表达式计算（栈应用），栈的经典应用。
C++中empty()函数的使用
qq_37140815的博客
04-13 5万+
C++中empty()作为判断容器是否为空的函数；string s； if (s.empty()) { cout &lt;&lt; “字符串为空”； } else { cout &lt;&lt; "字符串不为空"； }
ZCMU--1134: 青蛙约会(C语言)
小小小Why的博客
05-03 2002
Description 两只青蛙在一个点，但是他们想要来个久别胜新婚的约会，于是他们出发，朝同一个方向绕圈跳，我们求出他们相遇的时间 Input 输入数据的第一行为一个正整数T, 表示测试数据的组数. 然后是T组测试数据. 每组测试数据包含两组正整数，用空格隔开。每组包含两个正整数，表示跳n圈需要的秒数(1/2，表示跳2圈要1秒)，用'/'隔开。 Output 对于每组测试数据, 输出它们的下次相遇时间，如果相遇周期是整数则用整数表示，否则用最简分数表示。 Sample Input 2 1/
山科大第四届校赛 字符串“水”题
yxmGo
04-25 674
Description 给出一个长度为n的字符串(1 Input 第一行一个正整数T，表示数据组数(1 接下来T行，每行有一个只包含小写字母的字符串。 Output 每个答案输出满足要求字符串个数。每个答案占一行。 Sample Input 3 a aabbcc abcabc Sample
c 语言 多实例测试
qq_39345244的博客
02-24 4843
/*****题目描述： 求n个整数的和。 输入： 输入第一行是一个整数T，表示有T组测试实例； 每组输入包括两行： 第一行一个数n表示接下来会有n个整数； 第二行空格隔开的n个数。 输出： 对于每组输入，在一行输出n个数的和（保证和不会超出int类型的范围）！ 样例输入 ： 2 3 1 2 3 4 -1 0 -19 22 样例输出 ： 6 2 ******/ #include <stdio....
7-6-1 stack 括号匹配
XXX
07-19 423
给定仅包含“()[]{}”六种括号的字符串，请你判断该字符串中，括号的匹配是否是合法的，也就是对应括号的数量、嵌套顺序完全正确。 输入格式: 第一行一个整数T（T<=10） 其后T行每行一个字符串只包含[{()}]六种字符（字符串长度2e5以内） 输出格式: 对于每个字符串，匹配输出Yes,否则输出No 输入样例: 2 {()[]} ([)] 输出样例: Yes No 报段错误代码段 原因：这一段会出现访问非法内存的情况，char a = st.top();赋值时有可能栈空，没有栈.
数据结构实验代码（C++）栈的应用
05-10
实验内容： 设计一个算法，将一般算术表达式转化为逆波兰表达式，并求逆波兰表达式的值。
栈及其应用实验作业.
11-19
不错的作业，大家有空可以做做，很基本的，可以试试看
C++数据结构实验二：栈与队列的应用
03-31
1．熟练掌握栈和队列的基本运算。 2．掌握在两种存储结构上对栈和队列所施加的入栈、出栈、入队和出队的实现。 3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列...
北京邮电大学 2008 上机题目
followingturing 追随图灵的路上...
08-26 1553
都说前几年北邮的上机题像是谭浩强版c语言的课后习题。 呵呵，今日看了看，一语中的啊！（除了个别一两个以外）  ----------------------------------------------------忧伤的分割线-------------------------
输入第一行是一个整数T，表示有T组测试实例； 每组输入包括两行： 第一行一个数n表示接下来会有n个整数； 第二行空格隔开的n个数。 输出 对于每组输入，在一行输出n个数的和
热门推荐
qq_43728862的博客
07-14 8万+
#include<stdio.h> int main() { /*求n个整数的和。 输入 输入第一行是一个整数T，表示有T组测试实例； 每组输入包括两行： 第一行一个数n表示接下来会有n个整数； 第二行空格隔开的n个数。 输出 对于每组输入，在一行输出n个数的和（保证和不会超出int类型的范围）！ 样例输入 Copy 2 3 1 2 3 4 -1 0 -19 22 样例输出 Copy ...
哈夫曼编码（贪心）
晚安(￣o￣) . z Z
11-09 518
题目描述 给定一只含有小写字母的字符串；输出其哈夫曼编码的长度 输入 第一行一个整数T，代表样例的个数，接下来T行，每行一个字符串，0<T<=2000,字符串长度0<L<=1500. 输出 对于每个字符串，输出其哈夫曼编码长度 样例输入 3 hrvsh lcxeasexdphiopd mntflolfbtbpplahqolqykrqdnwdoq 样例输出 10 51 115 每次取频率最小的两个合并，新的结果放入 #include<bits/stdc++.h> using
问题 E: 动态数组
elapse_的博客
03-02 2593
问题 E: 动态数组 时间限制: 1 Sec 内存限制: 128 MB 题目描述 一开始未知数组长度，根据要求创建不同类型的指针，并且使用指针创建相应长度的数组，然后再完成不同的要求 若要求创建整数数组，计算数组内所有数据的平均值 若要求创建字符数组，找出数组内的最大字母 若要求创建浮点数数组，找出数组的最小值 要求程序整个过程不能使用数组下标，从数组创建、输入到搜索、比较、计算，到输出都必须使用指针 提示：使用new关键字 输入 第一行输入t表示有t个测试实例 第二行先输入一个大写字母表示数组类型，I表
9-3栈的应用 括号匹配 (15 分)
GitHub：https://github.com/myp020301
07-25 331
9-3栈的应用 括号匹配 (15 分) 给定仅包含“()[]{}”六种括号的字符串，请你判断该字符串中，括号的匹配是否是合法的，也就是对应括号的数量、嵌套顺序完全正确。 输入格式: 第一行一个整数T（T<=10） 其后T行每行一个字符串只包含[{()}]六种字符（字符串长度2e5以内） 输出格式: 对于每个字符串，匹配输出Yes,否则输出No 输入样例: 2 {()[]} ([)] 输出样例: Yes No 代码： #include <iostream> #include <st
栈、队列的应用实验原理
最新发布
05-27
通过实验，我深入理解了栈和队列的原理和应用场景，并掌握了相应的编程技巧。同时，我也认识到了数据结构在实际应用中的重要性，需要在编写程序时根据实际情况选择合适的数据结构，以提高程序的效率和可靠性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值