jmu-ds-栈与队列-stack、queue与string小综合

栈(stack)、队列(queue)和字符串(string)都是数据结构中比较基础的组成部分。栈是一种只能在栈顶进行插入、删除的线性结构，类似于一摞盘子。队列是一种先进先出的数据结构，类似于排队等待的人群。字符串是一个由字符组成的序列，常用于存储和处理文本信息。在编程中，这三种数据结构都有各自的应用场景，例如栈常用于程序调用的运行时栈、表达式求值、括号匹配等场景，队列常用于消息队列、任务队列、广度优先搜索等场景，字符串则广泛应用于文本处理、数据表示等方面。因此，学习和掌握好这三种数据结构对于编程人员而言是非常重要的。

相关问题

PTA中7-1 jmu-ds-栈与队列-stack、queue与string小综合代码

在PTE（Problem Translation Exercise，翻译题）的编程题目中，特别是涉及到7-1级别的JMU-DS（Java Methodology and Data Structures）部分，可能会让你编写涉及栈（Stack）和队列（Queue）数据结构以及字符串操作的小规模程序。栈是一种后进先出（LIFO，Last In First Out）的数据结构，而队列则是先进先出（FIFO，First In First Out）。

例如，一道简单的题目可能是创建一个功能，可以接受用户的输入，比如数字或特定命令（如"push"入栈，"pop"出栈，"enqueue"入队，"dequeue"出队），然后对这些元素按照相应的操作处理，最后可能还会有一个查看栈顶或队首元素的功能。同时，你还需要处理字符串操作，比如搜索、替换等。

代码可能如下所示（这是一个简化的示例，并非完整的解题代码）：

import java.util.Scanner;
import java.util.Stack;
import java.util.Queue;

public class StackAndQueue {
    private Stack<String> stack;
    private Queue<String> queue;

    public StackAndQueue() {
        stack = new Stack<>();
        queue = new LinkedList<>(); // 使用LinkedList作为队列实现
    }

    // 推入栈
    public void push(String item) {
        stack.push(item);
    }

    // 弹出栈顶
    public String pop() {
        return stack.pop();
    }

    // 入队
    public void enqueue(String item) {
        queue.offer(item);
    }

    // 出队
    public String dequeue() {
        return queue.poll();
    }

    // 查看栈顶元素
    public String peekStack() {
        return stack.peek();
    }

    // 查看队首元素
    public String peekQueue() {
        return queue.peek();
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        StackAndQueue instance = new StackAndQueue();

        while (true) {
            System.out.println("Enter command (push/pop/enqueue/dequeue/peek_stack/peek_queue/exit):");
            String command = scanner.nextLine();

            if (command.equalsIgnoreCase("exit")) break;

            switch (command) {
                case "push":
                    instance.push(scanner.next());
                    break;
                // ... 对其他命令进行类似处理
            }
        }
        scanner.close();
    }
}

PTA中7-1 jmu-ds-栈与队列-stack、queue与string小综合C语言代码

在程序设计（Programming Technology Assessment, PTA）中，题目通常涉及对基本数据结构如栈（stack）和队列（queue）的理解以及它们在C语言中的实现。这两个数据结构在处理序列元素时非常有用，尤其是当需要按照特定顺序添加和删除元素时。

对于7-1题目的描述不够明确，但我可以给你一个简单的C语言代码示例，展示如何用数组模拟栈和队列，并附上一个字符串操作的小例子：

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

#define MAX_SIZE 10

// 定义栈
typedef struct {
    char* items;
    int top;
    int size;
} Stack;

Stack* create_stack() {
    Stack* s = (Stack*)malloc(sizeof(Stack));
    s->items = (char*)malloc(MAX_SIZE * sizeof(char));
    s->top = -1;
    s->size = 0;
    return s;
}

// 入栈操作
void push(Stack* s, char item) {
    if (s->top == MAX_SIZE - 1) {
        printf("Stack overflow.\n");
        return;
    }
    s->items[++s->top] = item;
    s->size++;
}

// 出栈操作
char pop(Stack* s) {
    if (s->top == -1) {
        printf("Stack underflow.\n");
        return '\0';
    }
    char item = s->items[s->top];
    s->items[s->top] = '\0'; // 清空字符以便下次入栈
    s->top--;
    return item;
}

// 队列
typedef struct {
    char* front;
    char* rear;
    int count;
} Queue;

Queue* create_queue() {
    Queue* q = (Queue*)malloc(sizeof(Queue));
    q->front = q->rear = (char*)malloc(MAX_SIZE * sizeof(char));
    q->count = 0;
    return q;
}

// 入队
void enqueue(Queue* q, char item) {
    if (q->rear == q->front + MAX_SIZE - 1) {
        printf("Queue is full.\n");
        return;
    }
    *(q->rear++) = item; // 增加指针并保存元素
    q->count++;
}

// 出队
char dequeue(Queue* q) {
    if (q->count == 0) {
        printf("Queue is empty.\n");
        return '\0';
    }
    char item = *(q->front++);
    q->count--;
    return item;
}

int main() {
    Stack* stack = create_stack();
    char str[] = "Hello";
    for (int i = 0; i < strlen(str); i++) {
        push(stack, str[i]);
        printf("Pushed '%c'\n", str[i]);
    }

    Queue* queue = create_queue();
    for (int i = strlen(str) - 1; i >= 0; i--) {
        enqueue(queue, str[i]);
        printf("Enqueued '%c'\n", str[i]);
    }

    while (!isempty(stack)) {
        char popped = pop(stack);
        printf("Popped from stack: '%c'\n", popped);
    }

    while (!isempty(queue)) {
        char dequeued = dequeue(queue);
        printf("Dequeued from queue: '%c'\n", dequeued);
    }

    free(stack);
    free(queue);
    return 0;
}

// 用于检查是否栈或队列为空的辅助函数
int isempty(struct _Stack* s) { return s->top == -1; }
int isempty(Queue* q) { return q->count == 0; }