栈和中缀表达式计算的算法与实现

前端

2023-01-15 06:05:26

栈：深入理解和使用

什么是栈？

在计算机科学领域，栈是一种重要的数据结构，它遵循“先进后出”（LIFO）原则。这意味着，最后进入栈的元素将首先被移除。栈通常被用来暂时存储数据或在函数调用时传递参数。

栈的应用场景

栈在计算机科学中有着广泛的应用，包括：

后缀表达式（逆波兰表示法）的求值
中缀表达式（常规数学表示法）的求值
函数调用的参数传递
内存管理
编译器和解释器的实现

使用栈计算中缀表达式

要使用栈计算中缀表达式，我们可以遵循以下步骤：

将中缀表达式转换为后缀表达式。
将后缀表达式压入栈中。
依次弹出栈顶的两个元素，进行运算，并将结果压入栈中。
重复步骤 3，直到栈中只剩下一个元素，该元素即为中缀表达式的值。

在不同编程语言中实现栈

我们可以使用不同的编程语言来实现栈。以下是几种主流编程语言的实现示例：

Java

import java.util.Stack;

public class StackExample {

    public static void main(String[] args) {
        Stack<Integer> stack = new Stack<>();

        // 压入元素
        stack.push(1);
        stack.push(2);
        stack.push(3);

        // 弹出元素
        int poppedElement = stack.pop();

        // 查看栈顶元素
        int topElement = stack.peek();

        // 检查栈是否为空
        boolean isEmpty = stack.isEmpty();

        System.out.println("Popped element: " + poppedElement);
        System.out.println("Top element: " + topElement);
        System.out.println("Is stack empty: " + isEmpty);
    }
}

Python

class Stack:

    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def peek(self):
        return self.items[-1]

    def is_empty(self):
        return not self.items

stack = Stack()

# 压入元素
stack.push(1)
stack.push(2)
stack.push(3)

# 弹出元素
popped_element = stack.pop()

# 查看栈顶元素
top_element = stack.peek()

# 检查栈是否为空
is_empty = stack.is_empty()

print("Popped element:", popped_element)
print("Top element:", top_element)
print("Is stack empty:", is_empty)

C

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

struct StackNode {
    int data;
    struct StackNode *next;
};

struct Stack {
    struct StackNode *top;
};

void push(struct Stack *stack, int data) {
    struct StackNode *new_node = (struct StackNode *)malloc(sizeof(struct StackNode));
    new_node->data = data;
    new_node->next = stack->top;
    stack->top = new_node;
}

int pop(struct Stack *stack) {
    if (stack->top == NULL) {
        return -1;
    }
    struct StackNode *temp = stack->top;
    int popped_element = temp->data;
    stack->top = stack->top->next;
    free(temp);
    return popped_element;
}

int peek(struct Stack *stack) {
    if (stack->top == NULL) {
        return -1;
    }
    return stack->top->data;
}

int is_empty(struct Stack *stack) {
    return stack->top == NULL;
}

int main() {
    struct Stack stack;
    stack.top = NULL;

    // 压入元素
    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);

    // 弹出元素
    int popped_element = pop(&stack);

    // 查看栈顶元素
    int top_element = peek(&stack);

    // 检查栈是否为空
    int is_empty = is_empty(&stack);

    printf("Popped element: %d\n", popped_element);
    printf("Top element: %d\n", top_element);
    printf("Is stack empty: %d\n", is_empty);

    return 0;
}

JavaScript

class Stack {
    constructor() {
        this.items = [];
    }

    push(item) {
        this.items.push(item);
    }

    pop() {
        return this.items.pop();
    }

    peek() {
        return this.items[this.items.length - 1];
    }

    isEmpty() {
        return this.items.length === 0;
    }
}

const stack = new Stack();

// 压入元素
stack.push(1);
stack.push(2);
stack.push(3);

// 弹出元素
const poppedElement = stack.pop();

// 查看栈顶元素
const topElement = stack.peek();

// 检查栈是否为空
const isEmpty = stack.isEmpty();

console.log("Popped element:", poppedElement);
console.log("Top element:", topElement);
console.log("Is stack empty:", isEmpty);