目录
1.队列元素逆置
【问题描述】
已知Q是一个非空队列，S是一个空栈。仅使用少量工作变量以及对队列和栈的基本操作，编写一个算法，将队列Q中的所有元素逆置。
【输入形式】
输入的第一行为队列元素个数，第二行为队列从首至尾的元素
【输出形式】
输出队列的逆置
【样例输入】
3 1 2 3
【样例输出】
3 2 1
【评分标准】
需采用队列与栈的知识，否则不能得分
C语言
#include <stdio.h>
#include <stdlib.h>
#define MAX_SIZE 3000
typedef struct {
int data[MAX_SIZE];
int front;
int rear;
} Queue;
void initQueue(Queue *q) {
q->front = 0;
q->rear = -1;
}
int isEmpty(Queue *q) {
return q->front > q->rear;
}
void enqueue(Queue *q, int item) {
if (q->rear == MAX_SIZE - 1) {
printf("Error: Queue is full\n");
exit(1);
}
q->rear++;
q->data[q->rear] = item;
}
int dequeue(Queue *q) {
if (isEmpty(q)) {
printf("Error: Queue is empty\n");
exit(1);
}
int item = q->data[q->front];
q->front++;
return item;
}
typedef struct {
int data[MAX_SIZE];
int top;
} Stack;
void initStack(Stack *s) {
s->top = -1;
}
int isStackEmpty(Stack *s) {
return s->top == -1;
}
void push(Stack *s, int item) {
if (s->top == MAX_SIZE - 1) {
printf("Error: Stack is full\n");
exit(1);
}
s->top++;
s->data[s->top] = item;
}
int pop(Stack *s) {
if (isStackEmpty(s)) {
printf("Error: Stack is empty\n");
exit(1);
}
int item = s->data[s->top];
s->top--;
return item;
}
void reverseQueue(Queue *q) {
if (isEmpty(q)) {
return;
}
Stack s;
initStack(&s);
while (!isEmpty(q)) {
push(&s, dequeue(q));
}
while (!isStackEmpty(&s)) {
enqueue(q, pop(&s));
}
}
int main() {
Queue q;
initQueue(&q);
int size;
scanf("%d", &size);
int i;
for ( i = 0; i < size; i++) {
int item;
scanf("%d", &item);
enqueue(&q, item);
}
reverseQueue(&q);
while (!isEmpty(&q)) {
printf("%d ", dequeue(&q));
}
printf("\n");
return 0;
}C++
#include<stdio.h>
int main()
{
int QUEUE[1000],STACK[1000],i,n,temp,top,front,rear;
front=rear=top=-1;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d",&temp);
rear++;
QUEUE[rear]=temp;
}
for(i=0;i<n;i++)
{
temp=QUEUE[++front];
STACK[++top]=temp;
}
while(top!=-1)
{
printf("%d ",STACK[top]);
top--;
}
return 0;
}2.约瑟夫环
【问题描述】
n个人围成一个圈，按顺时针方向一次编号1、2、3、……、n，从第一个人开始顺时针方向依次报数1、2、3、……，报数m的人被淘汰，然后下一个人再从1开始报数，一直重复该过程。由于人数是有限的，因此最后一定只会剩下一个人，求这个人的编号。
【输入形式】
第一行，一个整数n，表示约瑟夫环的总人数。
第二行，一个整数m，表示报到m的人被淘汰。
【输出形式】
一行，一个整数，约瑟夫环最终剩下的人的编号。
【样例输入】
5 2
【样例输出】
3
【样例说明】
5个人围成一圈，编号1，2，3，4，5；
第一轮，2号淘汰，剩下1，3，4，5；
第二轮，从3开始报数，4号淘汰，剩下1，3，5；
第三轮，从5开始报数，1号淘汰，剩下3，5；
第四轮，从3开始报数，5号淘汰，剩下3。
【评分标准】
通过所有数据
class Queue:
#initialization
def __init__(self):
self.q = []
#入队
def enqueue(self, num):
self.q.append(num)
#出队
def dequeue(self):
if self.isEmpty():
return "The queue is EMPTY!"
else:
return self.q.pop(0)
def get_len(self):
return len(self.q)
def isEmpty(self):
return self.get_len()==0
joseph = Queue()
n = int(input())
m = int(input())
for i in range(1,n+1):
joseph.enqueue(i)
while(joseph.get_len()!=1):
count = 1
while(True):
if(count!=m):
joseph.enqueue(joseph.dequeue())
count += 1
else:
joseph.dequeue()
break
print(joseph.dequeue())3.栈实现队列
【问题描述】
请使用栈类实现队列的类。
【输入形式】
第一行一个整数n，
接下来n行，每行一个整数，依次表示已经在队列中的数。
接下来一行，一个整数m。
接下来m行，有两种情况：1. 一个整数，请将其入列。2. 字符串"D"，表示出列操作。
【输出形式】
若干行，每行一个出列的输出。
【样例输入】
3 1 2 3 2 4 D
【样例输出】
1
【样例说明】
队列中原来有1，2，3三个数，第一个操作使4入列，第二个操作出列，弹出队头的1
【评分标准】
通过所有数据
class Stack:
def __init__(self):
self.s = []
def push(self, num):
self.s.append(num)
def out(self):
return self.s.pop()
def empty(self):
return len(self.s)==0
class Queue:
def __init__(self):
self.s1 = Stack()
self.s2 = Stack()
def enq(self, num):
self.s1.push(num)
def deq(self):
while(not self.s1.empty()):
self.s2.push(self.s1.out())
temp= self.s2.out()
while(not self.s2.empty()):
self.s1.push(self.s2.out())
return temp
n = int(input())
q = Queue()
for i in range(n):
q.enq(int(input()))
m = int(input())
for i in range(m):
op = input()
if op.isdigit():
q.enq(int(op))
elif op=="D":
print(q.deq())4.用队列实现栈
【问题描述】
用队列实现一个栈。本题要求使用队列实现栈，其他实现方式不计分。
【输入形式】
第一行输入数n，接下来n行输入一些数，表示已经在栈里的数
接下来输入数m，接下来m行输入指令，A表示入栈，B表示出栈，具体看样例
【输出形式】
第一行输出弹出栈的数字们，用空格隔开
第二行弹出栈内剩余的数，并用空格隔开
【样例输入】
3 1 2 3 5 A 5 A 6 B B B
【样例输出】
6 5 3 2 1
【样例说明】
出现异常还是输出一行‘No’
【评分标准】
class SQueue(object):
def __init__(self, init_len=8):
self.__elem = [0] * init_len
self.__len = init_len
self.__head = 0
self.__num = 0
def __extend(self):
old_len = self.__len
self.__len *= 2
new_elems = [0] * self.__len
for i in range(old_len):
new_elems[i] = self.__elem[(self.__head + i) % old_len]
self.__elem, self.__head = new_elems, 0
def is_empty(self):
return self.__num == 0
def peek(self):
if self.__num == 0:
raise QueueUnderflow
return self.__elem[self.__head]
def enqueue(self, e):
if self.__num == self.__len:
self.__extend()
self.__elem[(self.__head + self.__num) % self.__len] = e
self.__num += 1
def dequeue(self):
if self.__num == 0:
raise QueueUnderflow
e = self.__elem[self.__head]
self.__head = (self.__head + 1) % self.__len
self.__num -= 1
return e
def get_elem(self):
print(self.__elem)
class Stack():
def __init__(self):
self.__stack = SQueue()
self.__temp = SQueue()
def push(self, e):
while not self.__stack.is_empty():
self.__temp.enqueue(self.__stack.dequeue())
self.__stack.enqueue(e)
while not self.__temp.is_empty():
self.__stack.enqueue(self.__temp.dequeue())
def pop(self):
return self.__stack.dequeue()
def is_empty(self):
return self.__stack.is_empty()
n = int(input())
stack = Stack()
for i in range(n):
stack.push(int(input()))
mark = 0
tmp = []
m = int(input())
for i in range(m):
o = input()
if 'A' in o:
o = int(o.strip().split()[1])
stack.push(o)
elif 'B' in o:
try:
tmp += [stack.pop()]
except:
mark = 1
break
if mark == 1:
print('No')
else:
tmp = [str(i) for i in tmp]
print(' '.join(tmp))
_ = []
while not stack.is_empty():
_ += [str(stack.pop())]
print(' '.join(_))
扫一扫
2119
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
