SDUT OJ----数据结构----栈与队列习题

最新推荐文章于 2023-02-20 17:11:54 发布
最新推荐文章于 2023-02-20 17:11:54 发布
阅读量824 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_55812984/article/details/119101056
版权

A - 数据结构实验之栈与队列一：进制转换

Description

输入一个十进制非负整数，将其转换成对应的 R (2 <= R <= 9) 进制数，并输出。

Input

第一行输入需要转换的十进制非负整数；
第二行输入 R。

Output

输出转换所得的 R 进制数。

Sample

Input 

1279
8

Output 

2377

顺序栈方法

#include<stdio.h>
#include<stdlib.h>
#define N 100

typedef struct 
{
	int *base;
	int *top;
	int len;
}stack;

stack initstack()
{
	stack s;
	s.top=(int *)malloc(N * sizeof(int));
	s.base=s.top;
	s.len=0;
	return s;
}

int pop(stack *s)
{
	int e;
	e=*(s->top-1);
	s->top--;
	s->len--;
	return e;
}

void push(stack *s,int x)
{
	*(s->top)=x;
	s->top++;
	s->len++;
}

int main()
{
	int n,m;
	stack s;
	scanf("%d %d",&n,&m);
	s=initstack();
	if(n==0)
	{
		push(&s,n);
	}
	while(n)
	{
		push(&s,n%m);
		n/=m;
	}
	while(s.len)
	{
		printf("%d",pop(&s));
	}
	return 0;
}

链栈方法

#include<stdio.h>
#include<stdlib.h>

typedef struct Node
{
	int data;
	Node *next;
}node;

typedef struct Stack 
{
	node *top;
	node *base;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	return p;
}

int pop(stack *p)
{
	int n;
	node *t;
	n=p->top->next->data;
	t=p->top->next;
	p->top->next=p->top->next->next;
	free(t);
	return n;
}

void push(stack *p,int n)
{
	node *t;
	t=creatnode();
	t->data=n;
	t->next=p->top->next;
	p->top->next=t;
}

void print(stack *p)
{
	while(p->top->next)
	{
		printf("%d",pop(p));
	}
}
int main()
{
	int n,m;
	stack *t;
	t =creatstack();
	scanf("%d %d",&n,&m);
	if(n==0)
	{
		push(t,n);
	}
	while(n)
	{
		push(t,n%m);
		n/=m;
	}
	print(t);
	return 0;
}

B - 数据结构实验之栈与队列二：一般算术表达式转换成后缀式

Description

对于一个基于二元运算符的算术表达式，转换为对应的后缀式，并输出之。

Input

输入一个算术表达式，以‘#’字符作为结束标志。

Output

输出该表达式转换所得到的后缀式。

Sample

Input 

a*b+(c-d/e)*f#

Output 

ab*cde/-f*+

 链栈

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Node
{
	char data;
	Node *next;
}node;

typedef struct Stack
{
    node *top;
    node *base;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *s;
	s=(stack *)malloc(sizeof(stack));
	s->top=creatnode();
	s->base=s->top;
	return s;
}

void pop(stack *p)
{
	node *t;
    t=p->top->next;
    p->top->next=p->top->next->next;
    free(t);
}

char top(stack *p)
{
	char t;
	t=p->top->next->data;
	return t;
}

void push(stack *p,char n)
{
	node *t;
	t=creatnode();
	t->data=n;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
}

int empty(Stack *t)
{
    if(t->top->next==NULL)
    {
        return 0;
    }
    return 1;
}

void print(stack *p)
{
	while(empty(p))
    {
    	printf("%c",top(p));
    	pop(p);
	}
}

int main()
{
    stack *t;
    char s[1000];
    scanf("%s",s);
    t = creatstack();
    for(int i=0;s[i]!='#';i++)
    {
        if(s[i]=='(')
            push(t,s[i]);
        else if(s[i]==')')
        {
            while(top(t)!='(')
            {
                printf("%c",top(t));
                pop(t);
            }
            pop(t);
        }
		else if(s[i] == '+' || s[i] == '-')
        {
           
            if(!empty(t) || top(t) == '(')
            {
            	push(t,s[i]);
            }
            else
            {
        	    printf("%c",top(t));
         	    pop(t);
         	    push(t,s[i]);
            }
        }
        else if(s[i] == '*' || s[i] == '/')
        {
            
      		if(!empty(t)|| top(t) == '(' || top(t) == '+' || top(t) == '-')
       	    {
       		    push(t,s[i]);
           	}
           	else
           	{
            	printf("%c",top(t));
            	pop(t);
            }
        }
        else
        {
            printf("%c",s[i]);
        }
    }
    print(t);
    return 0;
}

顺序栈

#include<stdio.h>
#include<stdlib.h>

typedef struct Stack
{
    char *top;
    char *base;
	char len;
}stack;

stack creatstack()
{
	stack s;
	s.top=(char *)malloc(100000 * sizeof(char));
	s.base=s.top;
	s.len=0;
	return s;
}

void pop(stack *p)
{
	p->top--;
	p->len--;
}

char top(stack p)
{
	return *(p.top-1);
}

void push(stack *p,char n)
{
	*(p->top)=n;
	p->top++;
	p->len++;
}

int empty(stack t)
{
    if(!t.len)
    {
        return 0;
    }
    else
    {
        return 1;
    }
}

void print(stack p)
{
	while(empty(p))
    {
    	printf("%c",top(p));
    	pop(&p);
	}
}

int main()
{
    stack t;
    char s[1000];
    scanf("%s",s);
    t = creatstack();
    for(int i=0;s[i]!='#';i++)
    {
        if(s[i]=='(')
            push(&t,s[i]);
        else if(s[i]==')')
        {
            while(top(t)!='(')
            {
                printf("%c",top(t));
                pop(&t);
            }
            pop(&t);
        }
		else if(s[i] == '+' || s[i] == '-')
        {
           
            if(!empty(t) || top(t) == '(')
            {
            	push(&t,s[i]);
            }
            else
            {
        	    printf("%c",top(t));
         	    pop(&t);
         	    push(&t,s[i]);
            }
        }
        else if(s[i] == '*' || s[i] == '/')
        {
            
      		if(!empty(t)|| top(t) == '(' || top(t) == '+' || top(t) == '-')
       	    {
       		    push(&t,s[i]);
           	}
           	else
           	{
            	printf("%c",top(t));
            	pop(&t);
            }
        }
        else
        {
            printf("%c",s[i]);
        }
    }
    print(t);
    return 0;
}

C - 数据结构实验之栈与队列三：后缀式求值

Description

对于一个基于二元运算符的后缀表示式（基本操作数都是一位正整数），求其代表的算术表达式的值。

Input

输入一个算术表达式的后缀式字符串，以‘#’作为结束标志。

Output

求该后缀式所对应的算术表达式的值，并输出之。

Sample

Input 

59*684/-3*+#

Output 

57

Hint

基本操作数都是一位正整数!

链栈

#include<stdio.h>
#include<stdlib.h>

typedef struct Node
{
	int data;
	Node *next;
}node;

typedef struct Stack
{
	node *top;
	node *base;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	return p;
}

int top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *s;
	s=p->top->next;
	p->top->next=p->top->next->next;
	free(s);
}

void push(stack *p,int c)
{
	node *t;
	t=creatnode();
	t->data=c;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
}

int main()
{
	stack *p;
	p=creatstack();
	char str[1000];
	scanf("%s",str);
	for(int i=0;str[i]!='#';i++)
	{
		if(str[i]>='0' && str[i]<='9')
		{
			push(p,str[i]-'0');
		}
		else
		{
			int c1=top(p);
			pop(p);
			int c2=top(p);
			pop(p);
			if(str[i]=='+')
			{
				push(p,c2+c1);
			}
			else if(str[i]=='-')
			{
				push(p,c2-c1);
			}
			else if(str[i]=='*')
			{
				push(p,c2*c1);
			}
			else if(str[i]=='/')
			{
				push(p,c2/c1);
			}
		}
	} 
	printf("%d",top(p));
	return 0;
}

顺序栈

#include<stdio.h>
#include<stdlib.h>

typedef struct Stack
{
	int *top;
	int *base;
	int len;
}stack;

stack creatstack()
{
	stack p;
    p.top=(int *)malloc(10001 * sizeof(int));
    p.base=p.top;
    p.len=0;
    return p;
}

int top(stack p)
{
	return *(p.top-1);
}

void pop(stack *p)
{
	p->top--;
	p->len--;
}

void push(stack *p,int c)
{
	*(p->top)=c;
	p->top++;
	p->len++;
}

int main()
{
	stack p;
	p=creatstack();
	char str[1000];
	scanf("%s",str);
	for(int i=0;str[i]!='#';i++)
	{
		if(str[i]>='0' && str[i]<='9')
		{
			push(&p,str[i]-'0');
		}
		else
		{
			int c1=top(p);
			pop(&p);
			int c2=top(p);
			pop(&p);
			if(str[i]=='+')
			{
				push(&p,c2+c1);
			}
			else if(str[i]=='-')
			{
				push(&p,c2-c1);
			}
			else if(str[i]=='*')
			{
				push(&p,c2*c1);
			}
			else if(str[i]=='/')
			{
				push(&p,c2/c1);
			}
		}
	} 
	printf("%d",top(p));
	return 0;
}

数据结构实验之栈与队列四：括号匹配

Description

 给你一串字符，不超过50个字符，可能包括括号、数字、字母、标点符号、空格，你的任务是检查这一串字符中的( ) ,[ ],{ }是否匹配。

Input

 输入数据有多组，处理到文件结束。

Output

 如果匹配就输出“yes”，不匹配输出“no”

Sample

Input 

sin(20+10)
{[}]

Output 

yes
no

链栈

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct Node
{
	char data;
	Node *next;
}node;

typedef struct Stack
{
	node *top;
	node *base;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	return p;
}

char top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	free(t);
}

void push(stack *p,char c)
{
	node *t;
	t=creatnode();
	t->data=c;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
}

int isempty(stack *p)
{
	if(p->top->next)
	{
		return 1;
	}
	else 
	{
		return 0;
	}
}

void del(stack *p)
{
	while(p->top->next)
	{
		pop(p);
	}
}
int main()
{
	char str[100];
	stack *p;
	p=creatstack();
	while(fgets(str,100,stdin))
	{
		int n=strlen(str);
		int i=0;
		for(i=0;i<n;i++)
		{
			if(str[i]=='[' || str[i]=='{' || str[i]=='(')
			{
				push(p,str[i]);
			}
			else if(str[i]==']' || str[i]=='}' || str[i]==')')
			{
				if(!isempty(p))
				{
					break;
				}
				else if(str[i]==']' && top(p)!='[')
				{
					break;
				}
				else if(str[i]=='}' && top(p)!='{')
				{
					break;
				}
				else if(str[i]=='(' && top(p)!=')')
				{
					break;
				}
				else
				{
					pop(p);
				}
			}
	    }
		if(i==n)
		{
			if(!isempty(p))
			{
		    	printf("yes\n");
			}
			else
			{
				printf("no\n");
			}
		}
		else
		{
			printf("no\n");
		}
		del(p);
	}
	return 0;
}

顺序栈

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct stack
{
    char *top,*base;
    int len;
}stack;

stack creatstack()
{
    stack t;
    t.top = (char *)malloc(100050*sizeof(char));
    t.base = t.top;
    t.len=0;
    return t;
}

void push(stack *t,char x)
{
    *(t->top) = x;
    t->top++;
    t->len++;
}

char top(stack t)
{
    return *(t.top-1);
}

void pop(stack *t)
{
    t->top--;
    t->len--;
}

int isempty(stack t)
{
    if(t.top==t.base)
    {
		return 0;
	}
	else
	{
 	    return 1;
 	}
}

void del(stack t)
{
    while(isempty(t))
    {
        pop(&t);
    }
}

int main()
{
    char str[55];
    stack p;
    int n,i;
    p = creatstack();
    while(fgets(str,100,stdin))
	{
		int n=strlen(str);
		int i=0;
		for(i=0;i<n;i++)
		{
			if(str[i]=='[' || str[i]=='{' || str[i]=='(')
			{
				push(&p,str[i]);
			}
			else if(str[i]==']' || str[i]=='}' || str[i]==')')
			{
				if(!isempty(p))
				{
					break;
				}
				else if(str[i]==']' && top(p)!='[')
				{
					break;
				}
				else if(str[i]=='}' && top(p)!='{')
				{
					break;
				}
				else if(str[i]=='(' && top(p)!=')')
				{
					break;
				}
				else
				{
					pop(&p);
				}
			}
	    }
    	if(i==n)
		{
			if(!isempty(p))
			{
		    	printf("yes\n");
			}
			else
			{
				printf("no\n");
			}
		}
		else
		{
			printf("no\n");
		}
		del(p);
    }
    return 0;
}

E - 数据结构实验之栈与队列五：下一较大值（一）

Description

对于包含n（1<=n<=1000）个整数的序列，对于序列中的每一元素，在序列中查找其位置之后第一个大于它的值，如果找到，输出所找到的值，否则，输出-1。

Input

 输入有多组，第一行输入t（1<=t<=10），表示输入的组数；

以后是 t 组输入：每组先输入n，表示本组序列的元素个数，之后依次输入本组的n个元素。

Output

 输出有多组，每组之间输出一个空行（最后一组之后没有）；

每组输出按照本序列元素的顺序，依次逐行输出当前元素及其查找结果，两者之间以-->间隔。

Sample

Input 

2
4 12 20 15 18
5 20 15 25 30 6

Output 

12-->20
20-->-1
15-->18
18-->-1

20-->25
15-->25
25-->30
30-->-1
6-->-1

链栈

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct Node
{
	int data;
	Node *next;
}node;

typedef struct Stack
{
	node *top;
	node *base;
}stack;

struct S
{
	int data;
	int next;
}number[20000];

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	return p;
}

int top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	free(t);
}

void push(stack *p,int n)
{
	node *t;
	t=creatnode();
	t->data=n;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
}

int isempty(stack *p)
{
	if(p->top->next)
	{
		return 1; 
	} 
	else 
	{
		return 0;
	}
}

void del(stack *p)
{
	while(isempty(p))
	{
		pop(p);
	}
}

int main()
{
	int n,m;
	stack *p;
	p=creatstack();
	scanf("%d",&n);
	while(n--)
	{
		scanf("%d",&m);
		for(int i=0;i<m;i++)
		{
			scanf("%d",&number[i].data);
			number[i].next=-1;
		}
		for(int i=0;i<m;i++)
		{
			if(!isempty(p))
			{
				push(p,i);
			}
			else
			{
				while(isempty(p) && number[i].data>number[top(p)].data)
				{
					number[top(p)].next=number[i].data;
					pop(p);
				}
				push(p,i);
			}
		}
		for(int i=0;i<m;i++)
		{
			printf("%d-->%d\n",number[i].data,number[i].next);
		}
		del(p);
		if(n)
		{
			printf("\n");
		}
	}
	return 0;
}

顺序栈

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct Stack
{
	int *top;
	int *base;
	int len;
}stack;

struct S
{
	int data;
	int next;
}number[10001];

stack creatstack()
{
	stack p;
	p.top=(int *)malloc(10000 * sizeof(int));
	p.base=p.top;
	p.len=0;
	return p;
}
int top(stack t)
{
    return *(t.top-1);
}
void pop(stack *t)
{
    t->top--;
    t->len--;
}
void push(stack *t,int x)
{
    *(t->top) = x;
    t->top++;
    t->len++;
}
int isempty(stack t)
{
    if(t.base==t.top)
    {
    	return 0;
	}
    else
    {
    	return 1;
	}
}
void del(stack *t)
{
    while(isempty(*t))
    {
        pop(t);
    }
}

int main()
{
	int n,m;
	stack p;
	p=creatstack();
	scanf("%d",&n);
	while(n--)
	{
		scanf("%d",&m);
		for(int i=0;i<m;i++)
		{
			scanf("%d",&number[i].data);
			number[i].next=-1;
		}
		for(int i=0;i<m;i++)
		{
			if(!isempty(p))
			{
				push(&p,i);
			}
			else
			{
				while(isempty(p) && number[i].data>number[top(p)].data)
				{
					number[top(p)].next=number[i].data;
					pop(&p);
				}
				push(&p,i);
			}
		}
		for(int i=0;i<m;i++)
		{
			printf("%d-->%d\n",number[i].data,number[i].next);
		}
		del(&p);
		if(n)
		{
			printf("\n");
		}
	}
	return 0;
}

G - 数据结构实验之栈与队列七：出栈序列判定

Description

给一个初始的入栈序列，其次序即为元素的入栈次序，栈顶元素可以随时出栈，每个元素只能入栈依次。输入一个入栈序列，后面依次输入多个序列，请判断这些序列是否为所给入栈序列合法的出栈序列。

例如序列1，2，3，4，5是某栈的压入顺序，序列4，5，3，2，1是该压栈序列对应的一个出栈序列，但4，3，5，1，2就不可能是该序列的出栈序列。假设压入栈的所有数字均不相等。

Input

第一行输入整数n(1<=n<=10000)，表示序列的长度。

第二行输入n个整数，表示栈的压入顺序。

第三行输入整数t（1<=t<=10）。

后面依次输入t行，每行n个整数，表示要判断的每一个出栈序列。

Output

对应每个测试案例输出一行，如果由初始入栈序列可以得到该出栈序列，则输出yes，否则输出no。

Sample

Input 

5
1 2 3 4 5
2
4 5 3 2 1
4 3 5 1 2

Output 

yes
no

Hint

链栈

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct Node
{
	int data;
	Node *next;
}node;

typedef struct Stack
{
	node *top;
	node *base;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	return p; 
}

int top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	free(t);
}

void push(stack *p,int n)
{
	node *t;
	t=creatnode();
	t->data=n;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
}

int isempty(stack *p)
{
	if(p->top->next)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

void clear(stack *p)
{
	while(isempty(p))
	{
		pop(p);
	}
}

int main()
{
	int n,m,a[10000],b[10000];
	stack *p;
	p=creatstack();
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	scanf("%d",&m);
	while(m--)
	{
		for(int i=0;i<n;i++)
		{
			scanf("%d",&b[i]);
		}
		int i,j;
		i=j=0;
		while(j<n)
		{
			if(i<n && b[j]==a[i])
			{
				i++;
				j++;
			}
			else
			{
				if(isempty(p) && b[j]==top(p))
				{
					pop(p);
					j++;
				}
				else if(i<n)
				{
					push(p,a[i]);
					i++;
				}
				else
				{
					break;
				}
			}
		}
		if(!isempty(p))
		{
			printf("yes\n");
		}
		else
		{
			printf("no\n");
		}
		clear(p);
	}
	return 0;
}

顺序栈

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct  Stack
{
	int *top;
	int *base;
	int len;
}stack;

stack creatstack()
{
	stack p;
	p.top=(int *)malloc(10000 * sizeof(int));
	p.base=p.top;
	p.len=0;
	return p;
}

int top(stack p)
{
	return *(p.top-1);
}

void pop(stack *p)
{
	p->top--;
	p->len--;
}

void push(stack *p,int n)
{
	*(p->top)=n;
	p->top++;
	p->len++;
}

int isempty(stack p)
{
	if(p.base==p.top)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

void clear(stack *p)
{
	while(isempty(*p))
	{
		pop(p);
	}
}

int main()
{
	int n,m,a[10000],b[10000];
	stack p;
	p=creatstack();
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		scanf("%d",&a[i]);
	}
	scanf("%d",&m);
	while(m--)
	{
		for(int i=0;i<n;i++)
		{
			scanf("%d",&b[i]);
		}
		int i,j;
		i=j=0;
		while(j<n)
		{
			if(i<n && b[j]==a[i])
			{
				i++;
				j++;
			}
			else
			{
				if(isempty(p) && b[j]==top(p))
				{
					pop(&p);
					j++;
				}
				else if(i<n)
				{
					push(&p,a[i]);
					i++;
				}
				else
				{
					break;
				}
			}
		}
		if(!isempty(p))
		{
			printf("yes\n");
		}
		else
		{
			printf("no\n");
		}
		clear(&p);
	}
	return 0;
}

H - 数据结构实验之栈与队列八：栈的基本操作

Description

堆栈是一种基本的数据结构。堆栈具有两种基本操作方式，push 和 pop。push一个值会将其压入栈顶，而 pop 则会将栈顶的值弹出。现在我们就来验证一下堆栈的使用。

Input

首先输入整数t（1 <= t <= 10），代表测试的组数，以后是 t 组输入。
 对于每组测试数据，第一行输入两个正整数 m（1 <= m <= 100)、n（1 <= n <= 1000)，其中m代表当前栈的最大长度，n代表本组测试下面要输入的操作数。 而后的 n 行，每行的第一个字符可能是'P’或者'O’或者'A’；如果是'P’，后面还会跟着一个整数，表示把这个数据压入堆栈；如果是'O’，表示栈顶元素出栈；如果是'A'，表示询问当前栈顶的值'。

Output

 对于每组测试数据，根据其中的命令字符来处理堆栈；
（1）对所有的'P'操作，如果栈满输出'F'，否则完成压栈操作；
（2）对所有的'A'操作，如果栈空，则输出'E'，否则输出当时栈顶的值；
（3）对所有的'O'操作，如果栈空，则输出'E'，否则输出栈顶元素的值，并让其出栈；
每个输出占据一行，每组测试数据（最后一组除外）完成后，输出一个空行。

Sample

Input 

2
5 10
A
P 9
A
P 6
P 3
P 10
P 8
A
P 2
O
2 5
P 1
P 3
O
P 5
A

Output 

E
9
8
F
8

3
5

Hint

建议： 用串的方式（%s）读入操作字符。

链栈


#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct Node
{
	int data;
	Node *next;
}node;

typedef struct Stack
{
	node *top;
	node *base;
	int len;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	p->len=0;
	return p; 
}

int top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	p->len--;
	free(t);
}

void push(stack *p,int n)
{
	node *t;
	t=creatnode();
	t->data=n;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
	p->len++;
}

int isempty(stack *p)
{
	if(p->top->next)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}


void clear(stack *p)
{
	while(isempty(p))
	{
		pop(p);
	}
	p->len=0;
}

int main()
{
	int n;
	stack *p;
	p=creatstack();
	scanf("%d",&n);
	while(n--)
	{
		int maxlen,m,num;
		char str[100];
		scanf("%d %d",&maxlen,&m);
		for(int i=0;i<m;i++)
		{
			scanf("%s",str);
			if(str[0]=='P')
			{
				scanf("%d",&num);
				if(p->len==maxlen)
				{
					printf("F\n");
				}
				else
				{
					push(p,num);
				}
			}
			else if(str[0]=='A')
			{
				if(!isempty(p))
				{
					printf("E\n");
				}
				else
				{
					printf("%d\n",top(p));
				}
			}
			else if(str[0]=='O')
			{
				if(!isempty(p))
				{
					printf("E\n");
				}
				else
				{
					printf("%d\n",top(p));
					pop(p);
				}
			}
		}
		printf("\n");
		clear(p);
	}
	return 0;
}

顺序栈


#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct Stack
{
	int *top;
	int *base;
	int len;
}stack;

stack creatstack()
{
	stack p;
	p.top=(int *)malloc(10000 * sizeof(int));
	p.base=p.top;
	p.len=0;
	return p;
}

int top(stack p)
{
	return *(p.top-1);
}

void pop(stack *p)
{
    p->top--;
    p->len--;
}

void push(stack *p,int n)
{
	*(p->top)=n;
	p->top++;
	p->len++;
}

int isempty(stack p)
{
	if(p.base==p.top)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}


void clear(stack *p)
{
	while(isempty(*p))
	{
		pop(p);
	}
	p->len=0;
}

int main()
{
	int n;
	stack p;
	p=creatstack();
	scanf("%d",&n);
	while(n--)
	{
		int maxlen,m,num;
		char str[100];
		scanf("%d %d",&maxlen,&m);
		for(int i=0;i<m;i++)
		{
			scanf("%s",str);
			if(str[0]=='P')
			{
				scanf("%d",&num);
				if(p.len==maxlen)
				{
					printf("F\n");
				}
				else
				{
					push(&p,num);
				}
			}
			else if(str[0]=='A')
			{
				if(!isempty(p))
				{
					printf("E\n");
				}
				else
				{
					printf("%d\n",top(p));
				}
			}
			else if(str[0]=='O')
			{
				if(!isempty(p))
				{
					printf("E\n");
				}
				else
				{
					printf("%d\n",top(p));
					pop(&p);
				}
			}
		}
		printf("\n");
		clear(&p);
	}
	return 0;
}

I - 数据结构实验之栈与队列九：行编辑器

Description

 一个简单的行编辑程序的功能是：接受用户从终端输入的程序或数据，并存入用户的数据区。 

由于用户在终端上进行输入时，不能保证不出差错，因此，若在编辑程序中，“每接受一个字符即存入用户数据区”的做法显然不是最恰当的。较好的做法是，设立一个输入缓冲区，用以接受用户输入的一行字符，然后逐行存入用户数据区。允许用户输入出差错，并在发现有误时可以及时更正。例如，当用户发现刚刚键入的一个字符是错的时，可补进一个退格符"#"，以表示前一个字符无效； 

如果发现当前键入的行内差错较多或难以补救，则可以键入一个退行符"@"，以表示当前行中的字符均无效。 

如果已经在行首继续输入'#'符号无效。 

Input

 输入多行字符序列，行字符总数（包含退格符和退行符）不大于250。 

Output

 按照上述说明得到的输出。 

Sample

Input 

whli##ilr#e(s#*s)
outcha@putchar(*s=#++);

Output 

while(*s)
putchar(*s++);

链栈

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct Node
{
	char data;
	Node *next;
}node;

typedef struct Stack
{
	node *top;
	node *base;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	return p; 
}

char top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	free(t);
}

void push(stack *p,char n)
{
	node *t;
	t=creatnode();
	t->data=n;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
}

int isempty(stack *p)
{
	if(p->top->next)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}


void clear(stack *p)
{
	while(isempty(p))
	{
		pop(p);
	}
}

void print(node *p)
{
	if(p==NULL)
	{
		return;
	}
	else
	{
		print(p->next);
	}
	if(p)
	{
		printf("%c",p->data);
	}
}

int main()
{
    char str[300];
    stack *p;
    p = creatstack();
    while(scanf("%s",str)!=EOF)
    {
        int n = strlen(str);
        for(int i=0;i<n;i++)
        {
            if(str[i]=='@')
            {
            	clear(p);
			}
            else if(str[i]=='#')
            {
                if(isempty(p))
                {
                   pop(p);
                }
            }
            else
            {
			    push(p,str[i]);
			}
        }
        print(p->top->next);
        clear(p);
        printf("\n");
    }
    return 0;
}

顺序栈

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char s[300];
int r=0;
typedef struct Stack
{
	char *top;
	char *base;
	int len;
}stack;

stack creatstack()
{
	stack p;
	p.top=(char *)malloc(10000 * sizeof(int));
	p.base=p.top;
	p.len=0;
	return p;
}
char top(stack p)
{
	return *(p.top-1);
}
void pop(stack *p)
{
	p->top--;
	p->len--;
}

void push(stack *p,char c)
{
	*(p->top)=c;
	p->top++;
	p->len++;
}

int isempty(stack p)
{
	if(p.top==p.base)
	{
		return 0;
	}
	else
	{
		return 1;
	}
}

void clear(stack *p)
{
	while(isempty(*p))
	{
		pop(p);
	}
}

void print(stack *p)
{
	while(p->top!=p->base)
	{
		s[r++]=top(*p);
		pop(p);
	}
	for(int i=r-1;i>=0;i--)
	{
		printf("%c",s[i]);
	}
	r=0;
	printf("\n");
}
int main()
{
    char str[300];
    stack p;
    p = creatstack();
    while(scanf("%s",str)!=EOF)
    {
        int n = strlen(str);
        for(int i=0;i<n;i++)
        {
            if(str[i]=='@')
            {
            	clear(&p);
			}
            else if(str[i]=='#')
            {
                if(isempty(p))
                {
                   pop(&p);
                }
            }
            else
            {
			    push(&p,str[i]);
			}
        }
        print(&p);
        clear(&p);
        memset(s,0,sizeof(s));
        memset(str,0,sizeof(str));
    }
    return 0;
}

J - 数据结构实验之栈与队列十：走迷宫

Description

一个由n * m 个格子组成的迷宫，起点是(1, 1)， 终点是(n, m)，每次可以向上下左右四个方向任意走一步，并且有些格子是不能走动，求从起点到终点经过每个格子至多一次的走法数。

Input

       第一行一个整数T 表示有T 组测试数据。(T <= 110)

对于每组测试数据:

第一行两个整数n, m，表示迷宫有n * m 个格子。(1 <= n, m <= 6, (n, m) !=(1, 1) ) 接下来n 行，每行m 个数。其中第i 行第j 个数是0 表示第i 行第j 个格子可以走，否则是1 表示这个格子不能走，输入保证起点和终点都是都是可以走的。

任意两组测试数据间用一个空行分开。

Output

 对于每组测试数据，输出一个整数R，表示有R 种走法。

Sample

Input 

3
2 2
0 1
0 0
2 2
0 1
1 0
2 3
0 0 0
0 0 0

Output 

1
0
4
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

int path[110][110];
int sign[110][110];
int ways;
int n,m;

void DFS(int x,int y)
{
    if(x<1 || y<1 || x>n || y>m || path[x][y]==1)
	{
		return;	
	}
	if(x==n && y==m)
	{
		ways++;
		return;
	}
	if(sign[x][y]==0)
	{
		sign[x][y]=1;
		DFS(x+1,y);
		DFS(x,y+1);
		DFS(x-1,y);
		DFS(x,y-1);
		sign[x][y]=0;
	}
} 

int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=m;j++)
			{
				scanf("%d",&path[i][j]);
			}
		}
		ways=0;
		DFS(1,1);
		printf("%d\n",ways);
		memset(path,0,sizeof(path));
		memset(sign,0,sizeof(sign));
	}
}

数据结构实验之栈与队列十一：refresh的停车场

Description

 refresh最近发了一笔横财，开了一家停车场。由于土地有限，停车场内停车数量有限，但是要求进停车场的车辆过多。当停车场满时，要进入的车辆会进入便道等待，最先进入便道的车辆会优先

进入停车场，而且停车场的结构要求只出去的车辆必须是停车场中最后进去的车辆。现告诉你停车场容量N以及命令数M，以及一些命令（Add num 表示车牌号为num的车辆要进入停车场或便道，

Del 表示停车场中出去了一辆车，Out 表示便道最前面的车辆不再等待，放弃进入停车场）。假设便道内的车辆不超过1000000.

Input

 输入为多组数据，每组数据首先输入N和M（0＜　ｎ，ｍ　＜200000），接下来输入M条命令。

Output

 输入结束后，如果出现停车场内无车辆而出现Del或者便道内无车辆而出现Out,则输出Error,否则输出停车场内的车辆，最后进入的最先输出，无车辆不输出。

Sample

Input 

2 6
Add 18353364208
Add 18353365550
Add 18353365558
Add 18353365559
Del
Out

Output 

18353365558
18353364208
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct Node
{
	char str[50];
	Node *next;
}node;

typedef struct Stack
{
	node *top;
	node *base;
	int len;
}stack;

typedef struct Queue
{
	node *front;
	node *rear;
	int len;
}queue;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	p->len=0;
	return p;
}

void popstack(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	p->len--;
	free(t);
}

void pushstack(stack *p,char s[])
{
	node *t;
	t=creatnode();
	strcpy(t->str,s);
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
	p->len++;
}

int emptystack(stack *p)
{
	if(p->top->next)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

void clearstack(stack *p)
{
	while(emptystack(p))
	{
		popstack(p);
	}
} 

queue *creatqueue()
{
	queue *p;
	p=(queue *)malloc(sizeof(queue));
	p->front=creatnode();
	p->rear=p->front;
	p->len=0;
	return p;
}

void popqueue(queue *p)
{
	node *t;
	t=p->front->next;
	p->front->next=p->front->next->next;
	p->len--;
	free(t);
}

void pushqueue(queue *p,char s[])
{
	node *t;
	t=creatnode();
	strcpy(t->str,s);
	t->next=p->rear->next;
	p->rear->next=t;
	p->rear=t;
	p->len++;
}

int emptyqueue(queue *p)
{
	if(p->front->next)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

void clearqueue(queue *p)
{
	while(emptyqueue(p))
	{
		popqueue(p);
	}
}

void print(node *p)
{
	while(p->next)
	{
		printf("%s\n",p->next->str);
		p->next=p->next->next;
	}
}

int main()
{
	int maxnum,num;
	char s[10],s1[100];
	stack *p1;
	queue *p2;
	p1=creatstack();
	p2=creatqueue();
	while(scanf("%d%d",&maxnum,&num)!=EOF)
	{
		clearstack(p1);
		clearqueue(p2);
		int flag=1;
		while(num--)
		{
			scanf("%s",s);
			if(strcmp(s,"Add")==0)
			{
				scanf("%s",s1);
			    if(p1->len<maxnum)
			    {
			    	pushstack(p1,s1);
				}
				else
				{
					pushqueue(p2,s1);
				}
			}
			else if(strcmp(s,"Del")==0)
			{
				if(!emptystack(p1))
				{
					flag=0;
				}
				else
				{
					popstack(p1);
					if(emptyqueue(p2))
					{
						strcpy(s1,p2->front->next->str);
						popqueue(p2);
						pushstack(p1,s1);
					}
				}
			}
			else if(strcmp(s,"Out")==0)
			{
				if(!emptyqueue(p2))
				{
					flag=0;
				}
				else
				{
					popqueue(p2);
				}
			}
		}
		if(!flag)
		{
			printf("Error\n");
		}
		else
		{
			print(p1->top);
		}
	}
}

L - Special Judge Ⅲ（就是和上面栈的出序列操作判断题目几乎一样）

Description

Q：什么是 Special Judge，Special Judge 的题目有什么不同?

A：一个题目可以接受多种正确方案，即有多组解的时候,题目就必须被 Special Judge。Special Judge 程序使用输入数据和一些其他信息来判答你程序的输出，并将判答结果返回。

不抽黑贞与咸鱼有什么区别？

3921

5月3日 FGO(Fate/Grand Order) 赝作活动来袭，MLE 开始了他的玄学抽卡：

他在 n 个小方块上写上数字，并按照先后顺序往上堆，在堆的过程中他会随机性的把上面的小方块抽走，堆完以后再依次从上往下把剩余没抽完的小方块抽走。按照小方块抽走的先后顺序排列开来（先拿走的小方块放最前面），之后再随机选择一个小方块，这个小方块上面的数字就表示活动开始以后的若干秒后开始抽卡。

不幸的是由于过于激动把小方块抽走的先后顺序给忘了，MLE 向闲来无事的 keke 求助，让他给出一个序列看自己能不能想起来，但为了避免浪费时间，MLE 希望 keke 给出的序列符合小方块抽走后排列的顺序，现在问题留给你，由你来判断这个序列是否合法。

Input

输入数据有多组（数据组数不超过 1000），到 EOF 结束。

对于每组数据：

  • 第一行先输入一个数 n (0 <= n <= 1000) 表示小方块的个数
  • 第二行输入 n 个数表示小方块上的数字，均为正整数
  • 第三行输入 keke 给出的序列，长度与小方块个数一致

所有数据范围均为 [0, 1000]。

Output

Keke 的答案正确输出 "Accepted"，否则输出 "Wrong Answer"（不包括引号）。

Sample

Input 

5
1 2 3 4 5
5 4 3 2 1

Output 

Accepted

Hint

当 n 为 0 时认为是 "Accepted"。

 链栈

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct Node
{
	int data;
	Node *next;
}node;

typedef struct Stack
{
	node *top;
	node *base;
	int len;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	p->len=0;
	return p;
}

int top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	free(t);
}

void push(stack *p,int n)
{
	node *t;
	t=creatnode();
	t->data=n;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
}

int emptystack(stack *p)
{
	if(p->top->next)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

void clearstack(stack *p)
{
	while(emptystack(p))
	{
		pop(p);
	}
}

int main()
{
	int n;
	stack *p;
	p=creatstack();
	while(scanf("%d",&n)!=EOF)
	{
		int s1[1001],s2[1001];
		for(int i=0;i<n;i++)
		{
			scanf("%d",&s1[i]);
		}
		for(int i=0;i<n;i++)
		{
			scanf("%d",&s2[i]);
		}
		int i,j;
		i=j=0;
		while(j<n)
		{
			if(i<n && s1[i]==s2[j])
			{
				i++;
				j++;
			}
			else
			{
				if(emptystack(p) && s2[j]==top(p))
				{
					j++;
					pop(p);
				}
				else if(i<n)
				{
					push(p,s1[i]);
					i++;
				}
				else
				{
					break;
				}
			}
		}
		if(n==0 || !emptystack(p))
		{
			printf("Accepted\n");
		}
		else
		{
			printf("Wrong Answer\n");
		}
	}
	return 0;
}

M - 我成了瘸腿鹅

Description

智 (hei) 慧 (bang) 长 (yi) 者 (ge) 阿福虽说是智勇双全，却无奈老是被该 (zheng) 死 (yi) 的成龙欺负。既然武斗不行，那么今天阿福决定靠他的智慧为自己找回些面子。所以他今天打算和成龙来比纸牌接龙游戏，输的人将会接受惩罚。游戏是这样的阿福先出牌，然后成龙出牌，出的牌按出牌顺序排成一列，如果当前出的牌在出牌序列中，那么那个人可以取走两张相同牌之间的所有牌并加上相应于牌数的分。比如原牌的排列为 5 4 3 6 9 8 现在成龙出牌 9 那么他可以取走 9 8 9 得到 3 分，然后牌的序列就变成 5 4 3 6 了。

最后看他们两个人的得分谁比较高，分数低的人将会接受惩罚，由于阿福长的比较丑，所以得分相同的情况下算阿福输（长得丑怪我咯）。

智 (hei) 慧 (bang) 长 (yi) 者 (ge) 阿福相信自己智勇双全一定会赢的，所以他打算赌得大一点：”谁输了就把他打成瘸腿鹅！”。由于没有人见证了他们的比赛过程，只知道他们的总出牌序列，想在好奇得到 UMR 想知道最后谁成了瘸腿鹅，但是 UMR 智商令人着急所以只能聪明的你求助了，你能告诉他谁被打成瘸腿鹅了吗？如果你说对了 UMR 将会将给你一个大大的 AC 作为回报。

Input

第一行输入一个 nn，代表总共出了 nn 张牌 (2 \leqslant n \leqslant 100000)(2⩽n⩽100000)。

接下来 nn 个数 a_{i}ai​，代表他们出的牌 (1 \leqslant a_{i} \leqslant 10)(1⩽ai​⩽10)。

Output

​如果阿福输了输出 ON!。

否则输出 HaHa!（不存在的）。

Sample

Input 

9
1 2 5 8 7 1 8 7 8

Output 

ON!

Hint

阿福先出牌。

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct Node
{
	int data;
	Node *next;
}node;

typedef struct  Stack
{
	node *top;
	node *base;
	int len;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	return p;
}

int top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	free(t);
	p->len--; 
}

void push(stack *p,int n)
{
	node *t;
	t=creatnode();
	t->data=n;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
}

int emptystack(stack *p)
{
	if(p->top->next)
	{
		return 1;
	}
	else
    {
    	return 0;
	}
}

int main()
{
	int n;
	int num1,num2,num;
	int s[100001],a[10]={0};
	stack *p;
	scanf("%d",&n);
	p=creatstack();
	num1=num2=0;
	for(int i=1;i<=n;i++)
	{
		num=0;
		scanf("%d",&s[i]);
		a[s[i]]++;
		if(a[s[i]]==1)
		{
			push(p,s[i]);
		}
		else if(a[s[i]]==2)
		{
			while(emptystack(p) && top(p)!=s[i])
			{
				a[top(p)]=0;
				pop(p);
				num++;
			}
			pop(p);
			num+=2;
			a[s[i]]=0;
			if(i%2==0)
			{
				num1+=num;
			}
			else
			{
				num2+=num;
			}
		}
	}
	if(num1>num2 || num1==num2)
	{
		printf("ON!");
	}
	else
	{
		printf("HaHa!");
	}
	return 0;
}

N - 蚂蚁花呗

Description

众所周知，蚂蚁是一种十分神奇的生物，在算法设计中，我们往往能从它身上得到启发，例如在求解TSP问题中，就有一种模仿蚂蚁行为方式而设计出的蚁群算法。 z这种算法是由Marco Dorigo等人在1991年研究新型算法的过程中，发现蚁群在寻找食物时，通过蚂蚁分泌一种称为信息素的生物激素交流觅食信息从而能快速的找到目标，据此提出来的一种十分神奇的算法。

今天，我们也来从蚂蚁身上寻找一些灵感。

水平线上有 N 只蚂蚁，每只蚂蚁的位置及大小均不同。他们沿着 X 轴爬行，有的向左，有的向右，爬行的速度是一样的，两只蚂蚁相遇大一点的会吃掉小的。

现在从左到右给出每只蚂蚁的大小和爬行的方向（0 表示向左，1 表示向右）。问足够长的时间之后，能剩下多少只蚂蚁？

Input

首先输入测试数据的组数t，后面是t组测试数据。

对于每组测试数据：

第 1 行：一个整数 N，表示蚂蚁的数量 (1≤N≤100000)。

第 2 到 N+1 行：每行两个数 Ai,Bi (1≤Ai≤1e9，Bi∈{0,1})，中间用空格分隔，分别表示蚂蚁的大小及爬 行的方向，Bi=0 表示向左，Bi=1 表示向右。

Output

输出最终剩下的蚂蚁的数量。

Sample

Input 

1
5
4 0
3 1
2 0
1 0
5 0

Output 

2
#include<stdio.h>
#include<string.h>
#include<stdlib.h> 
#define ll long long
const int N = 1e5;
typedef struct Node
{
	int data;
	Node *next;
}node;

typedef struct  Stack
{
	node *top;
	node *base;
	int len;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	return p;
}

int top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	free(t);
	p->len--; 
}

void push(stack *p,int n)
{
	node *t;
	t=creatnode();
	t->data=n;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
}

int emptystack(stack *p)
{
	if(p->top->next)
	{
		return 1;
	}
	else
    {
    	return 0;
	}
}

void clearstack(stack *p)
{
	while(emptystack(p))
	{
		pop(p);
	}
}
int main()
{
    int T,num,n;
    stack *p;
    p=creatstack();
    scanf("%d",&T);
    while(T--)
    {
        num = 0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            int size,dir;
            scanf("%d%d",&size,&dir);
            if(!dir)
            {
                while(emptystack(p) && top(p)<size)
                {
                    num++;
                    pop(p);
                }
                if(emptystack(p))
                {
                    num++;
                }
            }
            else
            {
            	push(p,size);
            }
        }
        printf("%d\n",n-num);
        clearstack(p);
    }
    return 0;
}

算术表达式的转换

Description

小明在学习了数据结构之后，突然想起了以前没有解决的算术表达式转化成后缀式的问题，今天他想解决一下。

   因为有了数据结构的基础小明很快就解出了这个问题，但是他突然想到怎么求出算术表达式的前缀式和中缀式呢？小明很困惑。聪明的你帮他解决吧。

Input

 输入一算术表达式，以\'#\'字符作为结束标志。（数据保证无空格,只有一组输入）

Output

 输出该表达式转换所得到的前缀式 中缀式 后缀式。分三行输出，顺序是前缀式 中缀式 后缀式。

Sample

Input 

a*b+(c-d/e)*f#

Output 

+*ab*-c/def
a*b+c-d/e*f
ab*cde/-f*+

Hint

#include<stdio.h>
#include<string.h>
#include<stdlib.h>

typedef struct Node
{
	char data;
	Node *next;
}node;

typedef struct Stack
{
	node *top;
	node *base;
	int len;
}stack;

node *creatnode()
{
	node *p;
	p=(node *)malloc(sizeof(node));
	p->next=NULL;
	return p;
}

stack *creatstack()
{
	stack *p;
	p=(stack *)malloc(sizeof(stack));
	p->top=creatnode();
	p->base=p->top;
	p->len=0;
	return p;
}

char top(stack *p)
{
	return p->top->next->data;
}

void pop(stack *p)
{
	node *t;
	t=p->top->next;
	p->top->next=p->top->next->next;
	p->len--;
	free(t);
}

void push(stack *p,char c)
{
	node *t;
	t=creatnode();
	t->data=c;
	t->next=p->top->next;
	p->top->next=t;
	p->base=t;
	p->len++;
}

int  emptystack(stack *p)
{
	if(p->top->next)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

void clearstack(stack *p)
{
	while(emptystack(p))
	{
		pop(p);
	}
}

void print(node *p)
{
	while(p)
	{
		printf("%c",p->data);
		p=p->next;
	}
	printf("\n");
}
int main()
{
	char str[10001];
	stack *p1,*p2;
	scanf("%s",str);
	p1=creatstack();
	p2=creatstack();
	for(int i=strlen(str)-2;i>=0;i--)
	{
		if(str[i]>='a' && str[i]<='z')
		{
			push(p1,str[i]);
		}
		else if(str[i]=='+' || str[i]=='-')
		{
			if(!emptystack(p2) || top(p2)==')')
			{
				push(p2,str[i]);
			}
			else if(top(p2)=='*' || top(p2)=='/')
			{
				while(top(p2)=='*' || top(p2)=='/')
				{
					push(p1,top(p2));
					pop(p2);
					push(p2,str[i]);
				}
			}
			else
			{
				push(p2,str[i]);
			}
		}
		else if(str[i]=='*' || str[i]=='/' || str[i]==')')
		{
			push(p2,str[i]);
		}
		else if(str[i]=='(')
		{
			while(top(p2)!=')')
			{
				push(p1,top(p2));
				pop(p2);
			}
			pop(p2);
		}
	}
	while(emptystack(p2))
	{
		push(p1,top(p2));
		pop(p2);
	}
	print(p1->top->next);
	clearstack(p1);
	for(int i=0;str[i]!='#';i++)
	{
		if(str[i]!='(' && str[i]!=')')
		{
			printf("%c",str[i]);
		}
	} 
	printf("\n");
	for(int i=0;str[i]!='#';i++)
	{
		if(str[i]>='a' && str[i]<='z')
		{
			push(p2,str[i]);
		}
		else if(str[i]=='(')
		{
			push(p1,str[i]);
		}
	    else if(str[i]==')')
	    {
	    	while(top(p1)!='(')
	    	{
	    		push(p2,top(p1));
	    		pop(p1);
			}
			pop(p1);
		}
		else if(str[i]=='*' || str[i]=='/')
		{
			if(!emptystack(p1) || top(p1)=='(' || top(p1)=='+' || top(p1)=='-')
			{
				push(p1,str[i]);
			}
			else
			{
				push(p2,top(p1));
				pop(p1);
				push(p1,str[i]);
			}
		}
		else if(str[i]=='+' || str[i]=='-')
		{
			if(!emptystack(p1) || top(p1)=='(')
			{
				push(p1,str[i]);
			}
			else
			{
				push(p2,top(p1));
				pop(p1);
				push(p1,str[i]);
			}
		}
	}
	while(emptystack(p2))
	{
		push(p1,top(p2));
		pop(p2);
	}
    print(p1->top->next);
	return 0;
}

M - 双向队列

Description

      想想双向链表……双向队列的定义差不多，也就是说一个队列的队尾同时也是队首；两头都可以做出队，入队的操作。
现在给你一系列的操作，请输出最后队列的状态；
命令格式：
LIN X  X表示一个整数，命令代表左边进队操作；
RIN X  表示右边进队操作；
ROUT
LOUT   表示出队操作；

Input

第一行包含一个整数M(M<=10000)，表示有M个操作；
以下M行每行包含一条命令；
命令可能不合法，对于不合法的命令，请在输出中处理；

Output

输出的第一行包含队列进行了M次操作后的状态，从左往右输出，每两个之间用空格隔开；
以下若干行处理不合法的命令（如果存在）；
对于不合法的命令，请输出一行X ERROR
其中X表示是第几条命令；

Sample

Input 

8
LIN 5
RIN 6
LIN 3
LOUT
ROUT
ROUT
ROUT
LIN 3

Output 

3
7 ERROR

Hint


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef int type;
typedef struct node
{
    type data;
    struct node *next;
}node,*nodeptr;
typedef struct
{
    nodeptr fron;
    nodeptr rear;
    int length;
}linkq;
int creat(linkq &Q)
{
    Q.fron=Q.rear=(nodeptr)malloc(sizeof(node));
    if(!Q.fron) exit(0);
    Q.fron->next=NULL;
    Q.rear=Q.fron;
    Q.length=0;
    return 1;
}
int lenter(linkq &Q,type e)
{
    nodeptr m;
    nodeptr p=(nodeptr)malloc(sizeof(node));
    if(!p) exit(0);
    p->data=e;
    p->next=Q.fron->next;
    Q.fron->next=p;
    m=Q.fron;
    while(m->next!=NULL)
        m=m->next;
    Q.rear=m;
    Q.length++;
    return 1;
}
int renter(linkq &Q,type e)
{
    nodeptr p=(nodeptr)malloc(sizeof(node));
    if(!p) exit(0);
    p->data=e;
    p->next=NULL;
    Q.rear->next=p;
    Q.rear=p;
    Q.length++;
    return 1;
}
int lleave(linkq &Q,type &e)
{
    if(Q.length==0) return 0;
    nodeptr p;
    p=Q.fron->next;
    e=p->data;
    Q.fron->next=p->next;
    if(Q.rear==p) Q.rear=Q.fron;
    free(p);
    Q.length--;
    return 1;
}
int rleave(linkq &Q,type &e)
{
    if(Q.length==0) return 0;
    nodeptr p,b;
    p=Q.rear;
    e=p->data;
    b=Q.fron;
    while(b->next!=Q.rear)
        b=b->next;
    b->next=NULL;
    Q.rear=b;
    free(p);
    Q.length--;
    return 1;
}
int main()
{
    linkq Q;
    nodeptr q;
    creat(Q);
    int i,n,key,k=0;
    int wrong[10000]={0};
    char order[10];
    scanf("%d",&n);
    for(i=1;i<=n;i++)
    {
        scanf("%s",order);
        if(strcmp(order,"LIN")==0)
        {
            scanf("%d",&key);
            lenter(Q,key);
        }
        else if(strcmp(order,"RIN")==0)
        {
            scanf("%d",&key);
            renter(Q,key);
        }
        else if(strcmp(order,"LOUT")==0)
        {
            if(Q.fron==Q.rear)
                wrong[k++]=i;
            else
                lleave(Q,key);
        }
        else if(strcmp(order,"ROUT")==0)
        {
            if(Q.fron==Q.rear)
                wrong[k++]=i;
            else
                rleave(Q,key);
        }
    }
    q=Q.fron->next;
    while(q)
    {
        printf("%d",q->data);
        q=q->next;
        if(q)
            printf(" ");
        else
            printf("\n");
    }
    for(i=0;i<k;i++)
        printf("%d ERROR\n",wrong[i]);
    return 0;
}

天行九歌。
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SDUT-OJ偏序关系
加油鸭
02-25 296
#include <stdio.h> #include <stdlib.h> int main() { int i, n; while(~scanf("%d", &n)) { int flag = 1; int a[110]; int b[110]; for(i=0; i<n; i++) { scanf("%d", &a[i]); .
数据结构---栈和队列OJ习题
qq_35297945的博客
01-19 371
1 括号匹配问题 1.1 题目介绍 给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。 有效字符串需满足：     左括号必须用相同类型的右括号闭合。     左括号必须以正确的顺序闭合。 注意:空字符串可被认为是有效字符串。 示例 1: 输入: “([])” 输出: true 示例 3: 输入: “(][)” 输出: false 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/valid-paren
SDUT 1519 数据结构实验之链表八：Farey序列
became_a_wolf的专栏
09-29 637
数据结构实验之链表八：Farey序列 Time Limit: 10MS Memory limit: 600K 题目描述 Farey序列是一个这样的序列：其第一级序列定义为（0/1，1/1），这一序列扩展到第二级形成序列（0/1，1/2，1/1），扩展到第三极形成序列（0/1，1/3，1/2，2/3，1/1），扩展到第四级则形成序列（0/1，1/4，1/3，1/2，2/3，
SDUT OJ2551
weixin_43849113的博客
02-26 189
未经允许禁止转载. 问题： 题目原链接：http://acm.sdut.edu.cn/onlinejudge2/index.php/Home/Contest/contestproblem/cid/2783/pid/2551 代码： #include&lt;stdio.h&gt; int main() { int i,j,n,m,a,b,c,d,e; while(scanf("%d",&amp;n...
SDUT OJ 《程序设计基础（B）I》 150题 答案
热门推荐
qq_45830025的博客
10-21 3万+
实验一：【腾讯文档】实验一 https://docs.qq.com/doc/DTmZsbkVMUlhVYk9J 实验二：【腾讯文档】实验二 https://docs.qq.com/doc/DTkVVUWFaUEVKUUNG 实验三：【腾讯文档】实验三 https://docs.qq.com/doc/DTlV3UnZSc05RVGdj 实验四：【腾讯文档】实验四 https://docs.qq.com/doc/DTkZ2dm5JUW1Sc2tN 实验五：【腾讯文档】实验五 https://docs.qq.co
SDUT OJ 免费馅饼
随便写写
05-03 485
免费馅饼Time Limit: 1000 ms Memory Limit: 32768 KiBSubmit StatisticProblem Description都说天上不会掉馅饼，但有一天gameboy正走在回家的小径上，忽然天上掉下大把大把的馅饼。说来gameboy的人品实在是太好了，这馅饼别处都不掉，就掉落在他身旁的10米范围内。馅饼如果掉在了地上当然就不能吃了，所以gameboy马上卸下...
SDUT---OJ《数据结构与算法》实践能力专题训练3 栈与队列
m0_46062697的博客
11-13 434
A - 数据结构实验之栈与队列一：进制转换 Description 输入一个十进制非负整数，将其转换成对应的 R (2 <= R <= 9) 进制数，并输出。 Input 第一行输入需要转换的十进制非负整数； 第二行输入 R。 Output 输出转换所得的 R 进制数。 Sample Input 1279 8 Output 2377 #include <iostream> #include <bits/stdc++.h> using na..
SDUTOJ-回文串鉴别
加油鸭
02-21 419
三年前代码： #include<cstdio> #include<cstring> int main() { int n, i; char s[100]; scanf("%s", s); n= strlen(s); for(i = 0; i < n; i++) { int j = n - 1 - i; if(s[i] != s[j]) break; } if.
SDUTOJ 数据结构-顺序表部分题目
ccccvvvvvcv的博客
03-19 274
#include <bits/stdc++.h> using namespace std; const int manx=1e5+10; class yyh { public: int data[manx]; int len; void create(class yyh*); void change(class yyh*); void print(class yyh*); }; void create(struct yyh* head) { fo
SDUT-OJ-C/C++程序训练6---歌德巴赫猜想的证明
加油鸭
03-13 1442
#include <stdio.h> #include <math.h> void display(int n); int main() { int n; scanf("%d", &n); display(n); return 0; } void display(int n) { int i, j, x, y; for(i = 3;i < n;i++) { x = 1; for(j.
sdut-oj-最小生成树c
最新发布
06-17
SDUT-OJ（Software Development University of Tsinghua Online Judge）是一个在线编程平台，提供给清华大学软件学院的学生和爱好者练习和解决算法问题的环境，其中包括各种计算机科学题目，包括数据结构、算法、...
SDUT OJ 完美网络
CHEN_ZAN_YU的博客
08-15 283
完美网络 Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Discuss Problem Description 完美网络是连通网络的基础上要求去掉网络上任意一条线路，网络仍然是连通网络。求一个连通网络要至少增加多少条边可以成为完美网络。 Input 第一行输入一个数T代表测试数据个数（T&lt;=20）。每个测...
SDUT OJ 打字练习
CHEN_ZAN_YU的博客
07-24 303
推荐一个不错的打字练习网站，并没有收人家广告费，纯良心推荐，哈哈 http://dazi.kukuw.com/
SDUT OJ Period
CHEN_ZAN_YU的博客
08-07 250
Period Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Problem Description For each prefix of a given string S with N characters (each character has an ASCII code between 97 and 126,...
SDUT-OJ共用体练习
加油鸭
03-18 448
# include<stdio.h> # include<string.h> union node { int a; double b; char c[20]; }q[100001]; int main() { int n, m, i, t; char s[100001][20]; scanf("%d %d", &n, &m); for(i = 0; i < n; i++) { s.
SDUT OJ 约瑟夫问题
随便写写
02-26 1841
约瑟夫问题Time Limit: 1000 ms Memory Limit: 65536 KiBSubmit Statistic DiscussProblem Descriptionn个人想玩残酷的死亡游戏，游戏规则如下： n个人进行编号，分别从1到n，排成一个圈，顺时针从1开始数到m，数到m的人被杀，剩下的人继续游戏，活到最后的一个人是胜利者。请输出最后一个人的编号。Input输入n和m值。Ou...
sdut算法分析oj题目整合
qq_52169234的博客
02-20 1011
sdutoj算法分析
栈的应用 -内容：输入一个十进制数，利用栈操作，将该数转换成n进制数。
南风知我意
10-11 1941
#include<stdio.h> #include<stdlib.h> #define stackinitsize 100 #define stackincrement 10 typedef struct{ int *base; int top; int stacksize; }sqstack; void initstack(sqstack &S){ /...
栈的应用：输入一个十进制数，利用栈操作，将该数转换成n进制数
weixin_43893363的博客
02-15 4032
代码 #include<stdio.h> #include<stdlib.h> #define StackInitSize 100 #define StackIncrease 10 typedef struct{ char *base; int top; int stacksize; }SqStack; //初始化 void CInitStack(SqStack &...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

天行九歌。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值