给定一个查找表L（递增整数序列）以及一个整数k，求采用二分查找算法在L中查找k的关键字比较次数。
输入要求：
第一行输入一个整数n（0<n<20），表示查找表中元素的个数。
第二行输入n个查找表中的元素。
第三行输入一个整数m，表示查找次数
接下来输入m行，每行为一个要查找的整数k
输出要求：
输出每次查找时关键字比较次数
数据示例1：
输入：
11
5 13 19 21 37 56 64 75 82 88 92
2
21
70
输出：
3
4
#include<stdio.h>
int main() {
int n,m,k;
scanf("%d", &n);
int a[n];
for(int i = 0; i < n; i++) {
scanf("%d",&a[i]);
}
scanf("%d", &m);
for(int j = 0; j < m; j++) {
scanf("%d", &k);
int q = 0;
int A = 0, B = n-1;
while(A <= B) {
int C = (A+B) / 2;
if(k > a[C]) {
A = C+1;
q++;
} else if(k < a[C]) {
B = C-1;
q++;
} else if(k == a[C]) {
q++;
break;
}
}
printf("%d\n",q);
}
}
在一个小型图书馆系统的读者管理分系统中，一个读者的信息包括读者的id，姓名(name)和所借阅的图书(book)。假设每个读者只允许借阅一本图书（用书号表示），即一个读者借了一本书后，就不能借另一本书。
读者列表可以用一个顺序表来实现。请按要求完成相应的函数。
输入要求：
首先输入读者个数n（0<=n<=10），并输入n个读者的信息，包括id，姓名和所借阅书籍（以书号表示），数据之间以空格分隔。
然后，输入命令编码及所需信息。详见代码及样例输入。
输出要求：
见样例输出。空表不输出。
数据示例1：
输入：
5
1000 aaa 1002
2000 bbb -1
3000 ccc 0
4000 ddd 4001
5000 eee 5001
2 0 6000 fff -1
2 6 6000 fff -1
3 7
3 1
4 1000 1000
4 2000 2000
4 3000 3000
5 6000
5 5000
1
-1
输出：
Failed
Succeed
Failed
Succeed
Failed
Succeed
Failed
Failed
Succeed
2000|bbb|2000
3000|ccc|0
4000|ddd|4001
5000|eee|
6000|fff|
#include <stdio.h>
#include <stdlib.h>
#define NAMELEN 20 // 名字数组长度限制
#define MREADER 10 // 读者数量限制
typedef struct { // 代表一个读者的结构体
int id; // 读者id
char name[NAMELEN]; // 读者姓名
int book; // 读者所借阅的图书，以书的编号表示
// 假设每个读者只能借阅一本图书
} Reader;
typedef struct { // 读者顺序表
Reader *readers; // 读者记录
int length; // 当前读者数量
} ReaderList;
// 根据用户输入，初始化n个读者的列表readers
// 如果一个读者没有借阅任何图书，其编号用-1表示
// 该函数假设用户输入的数据是正确的
void init(ReaderList &rlist, int n);
// 依次显示所有读者的信息。
// 如果某读者的id为1000，姓名为abc，借阅了编号为1001的图书，
// 则该读者的输出信息为：1000|abc|1001(分行符)
// 如果某读者的id为1000，姓名为abc，没有借阅图书，
// 则该读者的输出信息为：1000|abc|(分行符)
void displayall(ReaderList &rlist);
// 将读者r插入读者列表rlist中的第i个位置（从1开始）
// 成功返回1，失败返回0
int insert(ReaderList &rlist, int i, Reader r);
// 删除读者列表rlist中的第i个读者（从1开始）
// 成功返回1，失败返回0
int del(ReaderList &rlist, int i);
// id为 "id" 的读者借阅书号为 "book" 的图书
// 成功返回1，失败返回0
int borrow(ReaderList &rlist, int id, int book);
// id为 "id" 的读者归还图书
// 成功返回1，失败返回0
int returnB(ReaderList &rlist, int id);
int main()
{
// 变量声明
ReaderList rlist; // 读者列表
// 临时变量
int n; // 初始用户个数
int cmd = 0; // 操作命令，-1表示退出
int result = 0; // 操作结果
int i = -1; // 位置（序号）
int book, id;
Reader r;
// 初始化读者列表
scanf("%d", &n);
init(rlist, n);
while (scanf("%d", &cmd) && cmd!=-1) { // 选择操作
switch (cmd) {
case 1: // 显示所有读者
displayall(rlist);
break;
case 2: // 插入
//printf("Inserting a reader...");
scanf("%d", &i); // 序号
// 读者的id、姓名和所借阅的图书（-1表示没有借阅图书）。
scanf("%d%s%d", &r.id, r.name, &r.book);
result = insert(rlist, i, r);
if (result) printf("Succeed\n");
else printf("Failed\n");
break;
case 3: // 删除
//printf("Deleting a reader ...");
scanf("%d", &i); // 序号
result = del(rlist, i);
if (result) printf("Succeed\n");
else printf("Failed\n");
break;
case 4: // 借书
//printf("Borrow a book ...");
scanf("%d%d", &id, &book); // 读者id和借阅的图书书号
result = borrow(rlist, id, book);
if (result) printf("Succeed\n");
else printf("Failed\n");
break;
case 5: // 还书
//printf("Return a book ...");
scanf("%d", &id); // 读者id
result = returnB(rlist, id);
if (result) printf("Succeed\n");
else printf("Failed\n");
break;
default:
printf("Unknow Command.\n");
break;
}
}
return 0;
}
/***## 3069be526b9865da ##***/
void init(ReaderList &rlist, int n){
rlist.readers = new Reader[MREADER];
for(int i = 0; i < n; i++){
scanf("%d %s %d",&rlist.readers[i].id,&rlist.readers[i].name,&rlist.readers[i].book);
}
rlist.length = n;
}
void displayall(ReaderList &rlist){
for(int i = 0; i < rlist.length; i++){
if(rlist.readers[i].book == -1){
printf("%d|%s|\n",rlist.readers[i].id,rlist.readers[i].name);
}
else
printf("%d|%s|%d\n",rlist.readers[i].id,rlist.readers[i].name,rlist.readers[i].book);
}
}
int insert(ReaderList &rlist, int i, Reader r){
if(i < 1 || i > rlist.length + 1)
return 0;
if(rlist.length == MREADER)
return 0;
for(int j = rlist.length-1 ; j >= i-1; j--){
rlist.readers[j+1] = rlist.readers[j];
}
rlist.readers[i-1] = r;
++rlist.length;
return 1;
}
int del(ReaderList &rlist, int i){
if(i<1 || i > rlist.length)
return 0;
for(int j=i;j<=rlist.length-1;j++){
rlist.readers[j-1] = rlist.readers[j];
}
rlist.length--;
return 1;
}
int borrow(ReaderList &rlist, int id, int book){
for(int i=0;i<rlist.length;i++){
if(rlist.readers[i].id == id ){
if(rlist.readers[i].book == -1){
rlist.readers[i].book = book;
return 1;
}
else{
return 0;
}
}
}
return 0;
}
int returnB(ReaderList &rlist, int id){
for(int i = 0;i<rlist.length;i++){
if(rlist.readers[i].id == id ){
if(rlist.readers[i].book ==-1 )
return 0;
else{
rlist.readers[i].book = -1;
return 1;
}
}
}
return 0;
}
一个小型图书馆系统的图书管理分系统中，一本图书的信息包括图书的编号(code)，书名(title)和借阅人(reader)。假设系统中每本书只有一册，即某本书被一个读者借阅后，就不能被其他读者借阅。
图书列表可以用一个链表来实现。请按要求完成相应的函数。
注意：链表头结点的位置为0，第一个数据结点的位置为1
输入要求：
首先输入图书数量n，并输入n本图书的信息，包括书籍编号，书名和借阅人（以id表示），数据之间以空格分隔。
然后，输入命令编码及所需信息。详见代码及样例输入。
输出要求：
见样例输出。空表不输出任何信息。
数据示例1：
输入：
5
1000 aaa 1002
2000 bbb -1
3000 ccc 0
4000 ddd 4001
5000 eee 5001
2 0 6000 fff -1
2 6 6000 fff -1
3 7
3 1
4 1000 1000
4 2000 2000
4 3000 3000
5 6000
5 5000
1
-1
输出：
Failed
Succeed
Failed
Succeed
Failed
Succeed
Failed
Failed
Succeed
2000|bbb|2000
3000|ccc|0
4000|ddd|4001
5000|eee|
6000|fff|
#include <stdio.h>
#include <stdlib.h>
#define NAMELEN 20 // 名字最长字符数
typedef struct { // 代表一本书的结构体
int code; // 编号
char title[NAMELEN]; // 书名
int reader; // 借阅人，以读者的id表示
}Book;
typedef struct BNode { // 图书结点
Book book;
struct BNode *next;
}BNode, *BookList;
// 根据用户输入，初始化n个图书的列表readers
// 如果一本没有被借阅，其借阅人以-1表示
// 该函数假设用户输入的数据是正确的
void init(BookList &blist, int n);
// 依次显示所有图书的信息。
// 如果某图书的编号为1000，书名为abc，被id为1001的读者借阅，
// 则该图书的输出信息为：1000|abc|1001(分行符)
// 如果某读者的编号为1000，书名为abc，没有被借阅，
// 则该图书的输出信息为：1000|abc|(分行符)
void displayall(BookList &blist);
// 将图书b插入图书列表blist中的第i个位置（从1开始）
// 成功返回1，失败返回0
int insert(BookList &blist, int i, Book b);
// 删除图书列表blist中的第i本书（从1开始）
// 成功返回1，失败返回0
int del(BookList &blist, int i);
// 编号为code的图书被id为 "id" 的读者借阅
// 成功返回1，失败返回0
int borrow(BookList &blist, int code, int id);
// 编号为code的图书被归还
// 成功返回1，失败返回0
int returnB(BookList &blist, int code);
int main()
{
// 变量声明
BookList blist; // 读者列表
// 临时变量
int n; // 初始图书个数
int cmd = 0; // 操作命令，-1表示退出
int result = 0; // 操作结果
int i = -1; // 位置（序号）
int code, id;
Book b;
// 初始化读者列表
scanf("%d", &n);
init(blist, n);
while (scanf("%d", &cmd) && cmd!=-1) { // 选择操作
switch (cmd) {
case 1: // 显示所有读者
displayall(blist);
break;
case 2: // 插入
scanf("%d", &i); // 序号
// 图书的编码、书名和借阅人（-1表示没有被借阅）。
scanf("%d%s%d", &b.code, b.title, &b.reader);
result = insert(blist, i, b);
if (result) printf("Succeed\n");
else printf("Failed\n");
break;
case 3: // 删除
scanf("%d", &i); // 序号
result = del(blist, i);
if (result) printf("Succeed\n");
else printf("Failed\n");
break;
case 4: // 借出
scanf("%d%d", &code, &id); // 书籍编码和借阅人id
result = borrow(blist, code, id);
if (result) printf("Succeed\n");
else printf("Failed\n");
break;
case 5: // 归还
scanf("%d", &code); // 书籍编码
result = returnB(blist, code);
if (result) printf("Succeed\n");
else printf("Failed\n");
break;
default:
printf("Unknown Command.\n");
break;
}
}
return 0;
}
/***## af98740188b914e0 ##***/
void init(BookList &blist, int n){
blist = new BNode;
blist->next = NULL;
BNode *r = blist;
for(int i=0;i<n;i++){
BNode *p= new BNode;
scanf("%d %s %d",&p->book.code,&p->book.title,&p->book.reader);
p->next = NULL;
r->next = p;
r = p;
}
}
void displayall(BookList &blist){
BNode *p = blist->next;
while(p){
printf("%d|%s|",p->book.code,p->book.title);
if(p->book.reader != -1)
{
printf("%d\n",p->book.reader);
}
else{
printf("\n");
}
p = p->next;
}
}
int insert(BookList &blist, int i, Book b){
BNode *p = blist;
int j = 0 ;
while(p && (j<i-1))
{
p = p->next;
j++;
}
if(!p || j >i -1)
return 0;
BNode *s = new BNode;
s->book = b;
s->next = p->next;
p->next = s;
return 1;
}
int del(BookList &blist, int i){
BNode *p=blist;
int j = 0;
while((p->next) && (j<i - 1)){
p = p->next;
j++;
}
if(!(p->next) || (j>i-1))
return 0;
BNode *q = new BNode;
q = p->next;
p ->next = q->next;
delete q;
return 1;
}
int borrow(BookList &blist, int code, int id){
BNode *p = blist;
p = p->next;
while(p){
if(p->book.code == code && p->book.reader == -1){
p->book.reader = id;
return 1;
}
p = p->next;
}
return 0;
}
int returnB(BookList &blist, int code){
BNode *blist1 = blist;
blist1 = blist1->next;
while(blist1){
if(blist1->book.code == code){
if(blist1->book.reader != -1){
blist1->book.reader = -1;
return 1;
}
}
blist1 = blist1->next;
}
return 0;
}
根据如下所示二叉树的顺序存储（数组s），创建二叉链表，并输出其先序、中序和后序遍历结果。
算法如下：
-
声明一个临时数组p，用于存储二叉链表结点地址，并将p初始化为NULL
-
为每个非空结点创建二叉链表结点如下：
p[i] = new BTNode;
p[i]->data = s[i];
p[i]->left = p[i]->right = NULL;
-
根据数组p的下标，确定每个非叶子结点左右孩子指针的值
-
根结点地址T=p[1]
输入要求：
第一行为一个整数n，表示测试用例个数。
每个测试用例为一个字符串，代表一棵顺序存储的二叉树。
测试用例之间用换行符间隔。
输出要求：
对于每颗二叉树，打印其先序、中序和后序遍历结果。
数据示例1：
输入：
2
abcde####fg
123456
输出：
abdefgc
dbfegac
dfgebca
124536
425163
452631
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXSIZE 20 //最大输入字符个数
typedef struct BTNode {
char data;
struct BTNode *lchild, *rchild;
} BTNode, *BTree;
void preorder(BTree T ) {
if (T !=NULL){
printf("%c",T->data);
preorder(T->lchild);
preorder (T->rchild);
}
}
void inorder(BTree T ) {
if (T !=NULL){
inorder(T->lchild);
printf("%c",T->data);
inorder (T->rchild);
}
}
void postorder(BTree T ) {
if (T !=NULL){
postorder(T->lchild);
postorder (T->rchild);
printf("%c",T->data);
}
}
// 根据二叉树的顺序存储（数组），创建并返回二叉链表
void create(BTree &T, char s[]);
int main(){
int n;
scanf("%d", &n);
while(n--){
char s[MAXSIZE+5];
scanf("%s", s+1);
BTree T;
create(T, s);
preorder(T); printf("\n");
inorder(T); printf("\n");
postorder(T); printf("\n");
}
}
void create(BTree &T, char s[]){
BTNode *p[MAXSIZE + 10];
memset(p, 0, sizeof(p));
int l = strlen(s + 1);
for(int i = 1; i <= l; i++){
if(s[i] == '#') T = NULL;
else
{
p[i] = new BTNode;
p[i]->data = s[i];
p[i]->lchild = NULL;
p[i]->rchild = NULL;
}
}
for(int i = 1; i <= l/2; i++){
p[i]->lchild = p[2*i];
p[i]->rchild = p[2*i+1];
}
T = p[1];
}
对一个无向图进行BFS。
算法如下：
-
从图中某个位置为v的顶点出发，访问（打印）这个顶点，并置visited[v]的值为1，然后将v入队
-
只要队列不空
2.1 队头元素u出队
2.2 按临界矩阵第u行的顺序，依次检查位置为u的顶点的所有邻接点（位置为w），如果visited[w]的值为0，则访问位置为w的顶点，并置visited[w]的值为1，然后将w入队
输入要求：
输入有三部分组成
第一部分是2个整数n和m，表示图的定点数和边数
第二部分是由空格分割n个字符，表示n个顶点的信息。
第三部分由m行数据组成，每行数据是空格分割的2个字符，表示图中一条边的两个顶点
输入示例：
4 3
A B C D
A B
A C
C D
输出要求：
该图的BFS序列，每个字符后有一个空格，输出结束后换行。
输出示例：
A B C D
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
#define MVNum 10 //最大顶点数
typedef struct{
char vexs[MVNum]; //顶点表
int arcs[MVNum][MVNum]; //邻接矩阵
int vexnum,arcnum;
}AMGraph;
int visited[MVNum];
void create(AMGraph &g);
void bfs(AMGraph &g, int v);
int main(){
AMGraph g;
create(g);
memset(visited, 0, sizeof(visited));
bfs(g, 0);
}
void create(AMGraph &g){
scanf("%d %d",&g.vexnum,&g.arcnum);
for(int i = 0; i < g.vexnum; i++){
getchar();
scanf("%c",&g.vexs[i]);
}
for(int i = 0; i<g.vexnum; i++){
for(int j = 0; j < g.vexnum; j++){
g.arcs[i][j]=0;
}
}
for(int i = 0; i < g.arcnum; i++){
char u,v;
int q,p;
getchar();
scanf("%c %c",&u,&v);
for(int i = 0; i < g.vexnum; i++){
if(g.vexs[i] == u)
{
q = i;
}
if(g.vexs[i] == v)
{
p = i;
}
}
g.arcs[q][p] = 1;
g.arcs[p][q] = g.arcs[q][p];
}
}
void bfs(AMGraph &g, int v){
queue<int>q;
printf("%c ", g.vexs[v]);
visited[v] = 1;
q.push(v);
if(!q.empty())
{
int u = q.front();
q.pop();
for(int w = u; w < g.vexnum; w++){
if(visited[w] == 0) bfs(g, w);
}
}
}
对一个无向图进行BFS。
算法如下：
-
从图中某个位置为v的顶点出发，访问（打印）这个顶点，并置visited[v]的值为1，然后将v入队
-
只要队列不空
2.1 队头元素u出队
2.2 按位置为u的顶点的邻接表顺序，依次检查这个顶点的所有邻接点（位置为w），如果visited[w]的值为0，则访问位置为w的顶点，并置visited[w]的值为1，然后将w入队
输入要求：
输入有三部分组成
第一部分是2个整数n和m，表示图的定点数和边数
第二部分是由空格分割n个字符，表示n个顶点的信息。
第三部分由m行数据组成，每行数据是空格分割的2个字符，表示图中一条边的两个顶点
输入示例：
4 3
A B C D
A B
A C
C D
输出要求：
该图的DFS序列，每个字符后有一个空格，输出结束后换行
输出示例：
A C B D
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
#define MVNum 10
typedef struct ArcNode {
int adjvex; // 位置(下标)
struct ArcNode *nextarc; // 指向下一条边的指针
}ArcNode; // 边结点
typedef struct {
char data; // 顶点信息
ArcNode *firstarc; // 指向第一条依附该顶点的边
}VNode; // 表头结点
typedef struct
{ VNode vexs[MVNum]; // 顶点数组
int vexnum, arcnum;
}ALGraph;
int visited[MVNum];
void create(ALGraph &g); // 临界表中的表结点采用头插法
void bfs(ALGraph &g, int v);
int main(){
ALGraph g;
create(g);
memset(visited, 0, sizeof(visited));
bfs(g, 0);
}
void create(ALGraph &g){
scanf("%d %d",&g.vexnum,&g.arcnum);
for(int i = 0; i < g.vexnum; i++){
getchar();
scanf("%c",&g.vexs[i].data);
g.vexs[i].firstarc = NULL;
}
for(int j = 0; j < g.arcnum; j++){
char u,v;
int q , p;
getchar();
scanf("%c %c",&u,&v);
for(int i = 0; i < g.vexnum; i++){
if(g.vexs[i].data == u)
{
q = i;
}
if(g.vexs[i].data == v)
{
p = i;
}
}
ArcNode *pu = new ArcNode;
pu->adjvex = q;
pu->nextarc = g.vexs[p].firstarc;
g.vexs[p].firstarc = pu;
ArcNode *pv = new ArcNode;
pv->adjvex = p;
pv->nextarc = g.vexs[q].firstarc;
g.vexs[q].firstarc = pv;
}
}
void bfs(ALGraph &g, int v){
queue<int>q;
printf("%c ", g.vexs[v].data);
visited[v] = 1;
q.push(v);
while(!q.empty())
{
int u = q.front();
q.pop();
ArcNode *p = new ArcNode;
p = g.vexs[u].firstarc;
while(p != NULL){
if(visited[p->adjvex] == 0){
printf("%c ", g.vexs[p->adjvex].data);
visited[p->adjvex] = 1;
q.push(p->adjvex);
}
p = p->nextarc;
}
}
}
计算使用KMP算法进行字符串匹配时，字符比较次数
输入要求：
输入2行。第1行输入主串，第二行输入模式串，长度均不超过80。
输出要求：
使用KMP算法进行模式匹配时，字符比较次数。不用换行
数据示例1：
输入：
aabbabaabaaaa
aabaaa
输出：
14
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAXS 80
typedef struct{
char *ch;
int length;
} HString; // 堆式顺序存储
void createString(HString &S){
S.ch = new char[MAXS];
gets(S.ch+1);
S.length = strlen(S.ch+1);
}
// 使用 KMP 算法进行模式匹配，字符比较次数
int charCompKMP(HString S, HString T);
int main(){
HString S, T;
createString(S);
createString(T);
int num = charCompKMP(S, T);
printf("%d", num);
}
int charCompKMP(HString S, HString T){
int next[T.length+1];
next[1]=0;
int i = 1 ,j = 0;
while(i < T.length+1){
if(j==0 || T.ch[i] == T.ch[j]){
j++;
i++;
next[i]=j;
}
else{
j=next[j];
}
}
i=1;
j=1;
int p=0;
while(j <= T.length && i <= S.length){
if(j==0 || S.ch[i] == T.ch[j]){
if(j==0)p--;
i++;
j++;
p++;
}
else{
j = next[j];
p++;
}
}
return p;
}
将中缀表达式转换成后缀表达式
输入要求：
多组输入，每组输入一行长度不大于20的字符串（无空格），代表一个中缀表达式。
其中操作数是1-9的个位数字，操作符包括加（+）、减（-）、乘（*）、除（/）和括号并且保证除数不为0。
示例：
2*(4+6)
2+9/3-5
输出要求：
每组输出一个转换后的后缀表达式，并换行。
示例：
246+*
293/+5-
数据示例1：
输入：
2*(4+6)
2+9/3-5
输出：
246+*
293/+5-
#include<stdio.h>
#include<stack>
using namespace std;
void match(char *exp){
char a[25];
int i = 0, j = 0, q = 0;
stack<char> s;
while(exp[i] != '\0'){
if((exp[i] > '0' && exp[i] <= '9'))
{
a[j] = exp[i];
j++;
}
else if(exp[i] == '(')
{
s.push(exp[i]);
q = 1;
}
else if(exp[i] == ')')
{
while(s.top() != '('){
a[j] = s.top();
s.pop();
j++;
}
s.pop();
q = 0;
}
else if(exp[i] == '*' || exp[i] == '/')
{
if(q == 1)
{
s.push(exp[i]);
i++;
continue;
}
if(s.empty() || s.top() == '+' || s.top() == '-')
{
s.push(exp[i]);
}
else if(s.top() == '*' || s.top() == '/')
{
while(!s.empty() && s.top() != '+' && s.top() != '-')
{
a[j] = s.top();
s.pop();
j++;
}
s.push(exp[i]);
}
}
else if(exp[i] == '+' || exp[i] == '-')
{
if(q == 1)
{
s.push(exp[i]);
i++;
continue;
}
if(s.empty())
{
s.push(exp[i]);
}
else if(s.top() == '*' || s.top() == '/' || s.top() == '+' || s.top() == '-')
{
while(!s.empty())
{
a[j] = s.top();
s.pop();
j++;
}
s.push(exp[i]);
}
}
i++;
}
while(!s.empty())
{
a[j] = s.top();
s.pop();
j++;
}
for(int w = 0; w < j; w++)
{
printf("%c",a[w]);
}
}
int main(){
char exp[25];
while(~scanf("%s", exp)){
match(exp);
printf("\n");
}
}
后缀表达式求值
输入要求：
多组输入，每组输入一行长度不大于20的字符串（无空格），代表一个后缀表达式。
其中操作数是1-9的个位数字，操作符包括加（+）、减（-）、乘（*）、除（/）并且保证除数不为0。
示例：
246+*
293/+5-
输出要求：
每组数据输出表达式计算的结果，并换行。
示例：
20
0
数据示例1：
输入：
246+*
293/+5-
输出：
20
0
#include<stdio.h>
#include<stack>
using namespace std;
int match(char *exp){
int i = 0;
stack<int> s;
while(exp[i] != '\0'){
if(exp[i] > '0' && exp[i] <= '9')
{
switch(exp[i])
{
case '1':
s.push(1);
break;
case '2':
s.push(2);
break;
case '3':
s.push(3);
break;
case '4':
s.push(4);
break;
case '5':
s.push(5);
break;
case '6':
s.push(6);
break;
case '7':
s.push(7);
break;
case '8':
s.push(8);
break;
case '9':
s.push(9);
}
}
else if(exp[i] == '+')
{
int a = s.top();
s.pop();
int b = s.top();
s.pop();
int all = b + a;
s.push(all);
}
else if(exp[i] == '-')
{
int a = s.top();
s.pop();
int b = s.top();
s.pop();
int all = b - a;
s.push(all);
}
else if(exp[i] == '*')
{
int a = s.top();
s.pop();
int b = s.top();
s.pop();
int all = b * a;
s.push(all);
}
else if(exp[i] == '/')
{
int a = s.top();
s.pop();
int b = s.top();
s.pop();
int all = b / a;
s.push(all);
}
i++;
}
return s.top();
}
int main(){
char exp[28];
while(~scanf("%s",&exp))
{
printf("%d\n",match(exp));
}
}
判断一个表达式中的圆括号()和方括号[]是否匹配。
输入要求：
多组输入，每组输入一个长度不大于20的字符串（无空格），占一行。
输出要求：
括号匹配输出yes，否则输出no。每组输出后换行
数据示例1：
输入：
()
[([][])]
[(])
([())
输出：
yes
yes
no
no
思路提示：
可以使用C++中的stack类
#include<stdio.h>
#include<stack>
using namespace std;
int match(char *exp){
int i = 0;
stack<char> s;
while(exp[i] != '\0'){
if(exp[i] == '(' || exp[i] == '[')
{
s.push(exp[i]);
}
else if(exp[i] == ')' || exp[i] == ']')
{
if(s.empty()) return 0;
else{
char tem = s.top();
if((tem == '(' && exp[i] == ')') || (tem == '[' && exp[i] == ']'))
{
s.pop();
}
else
{
return 0;
}
}
}
i++;
}
if(s.empty()) return 1;
else return 0;
}
int main(){
char exp[24];
while(~scanf("%s",&exp)){
if(match(exp))
{
printf("yes\n");
}
else
{
printf("no\n");
}
}
}