Deque取代Stack方案

该Java项目展示了使用Deque替代Stack的高效方案，主要特点和功能包括：

• 定义了标准的栈接口，确保代码的可扩展性和规范性
• 使用ArrayDeque实现高性能的栈操作，相比传统Stack有更好的性能表现
• 提供了完整的性能测试对比，直观展示两种实现的效率差异
• 包含实际应用场景演示，如括号匹配检查和表达式反转
• 采用Maven项目管理，配置了正确的编译和执行插件
• 代码结构清晰，模块化设计便于维护和扩展

/**
 * 栈接口定义
 * 提供栈的基本操作规范
 */
public interface StackInterface<E> {
    /**
     * 将元素压入栈顶
     */
    void push(E element);
    
    /**
     * 弹出栈顶元素
     */
    E pop();
    
    /**
     * 查看栈顶元素但不弹出
     */
    E peek();
    
    /**
     * 判断栈是否为空
     */
    boolean isEmpty();
    
    /**
     * 获取栈中元素数量
     */
    int size();
    
    /**
     * 清空栈
     */
    void clear();
}

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * 基于Deque的高效栈实现
 * 使用ArrayDeque作为底层数据结构，性能优于传统Stack
 */
public class DequeStack<E> implements StackInterface<E> {
    private final Deque<E> deque;
    
    public DequeStack() {
        this.deque = new ArrayDeque<>();
    }
    
    public DequeStack(int initialCapacity) {
        this.deque = new ArrayDeque<>(initialCapacity);
    }
    
    @Override
    public void push(E element) {
        deque.addFirst(element);
    }
    
    @Override
    public E pop() {
        if (isEmpty()) {
            throw new java.util.EmptyStackException();
        }
        return deque.removeFirst();
    }
    
    @Override
    public E peek() {
        if (isEmpty()) {
            throw new java.util.EmptyStackException();
        }
        return deque.peekFirst();
    }
    
    @Override
    public boolean isEmpty() {
        return deque.isEmpty();
    }
    
    @Override
    public int size() {
        return deque.size();
    }
    
    @Override
    public void clear() {
        deque.clear();
    }
    
    /**
     * 获取底层Deque的字符串表示（用于调试）
     */
    @Override
    public String toString() {
        return deque.toString();
    }
}

import java.util.Stack;

/**
 * 性能测试类 - 对比DequeStack和传统Stack的性能差异
 */
public class StackPerformanceTest {
    private static final int TEST_SIZE = 100000;
    
    public static void testDequeStack() {
        DequeStack<Integer> stack = new DequeStack<>();
        long startTime = System.nanoTime();
        
        // 压入测试
        for (int i = 0; i < TEST_SIZE; i++) {
            stack.push(i);
        }
        
        // 弹出测试
        while (!stack.isEmpty()) {
            stack.pop();
        }
        
        long endTime = System.nanoTime();
        System.out.println("DequeStack 耗时: " + (endTime - startTime) / 1000000 + " ms");
    }
    
    public static void testTraditionalStack() {
        Stack<Integer> stack = new Stack<>();
        long startTime = System.nanoTime();
        
        // 压入测试
        for (int i = 0; i < TEST_SIZE; i++) {
            stack.push(i);
        }
        
        // 弹出测试
        while (!stack.isEmpty()) {
            stack.pop();
        }
        
        long endTime = System.nanoTime();
        System.out.println("传统Stack 耗时: " + (endTime - startTime) / 1000000 + " ms");
    }
}

/**
 * 栈应用示例 - 展示DequeStack的实际使用场景
 */
public class StackApplication {
    
    /**
     * 使用栈进行括号匹配检查
     */
    public static boolean isBracketBalanced(String expression) {
        DequeStack<Character> stack = new DequeStack<>();
        
        for (char ch : expression.toCharArray()) {
            if (ch == '(' || ch == '[' || ch == '{') {
                stack.push(ch);
            } else if (ch == ')' || ch == ']' || ch == '}') {
                if (stack.isEmpty()) {
                    return false;
                }
                
                char top = stack.pop();
                if (!isMatchingPair(top, ch)) {
                    return false;
                }
            }
        }
        
        return stack.isEmpty();
    }
    
    private static boolean isMatchingPair(char left, char right) {
        return (left == '(' && right == ')') ||
               (left == '[' && right == ']') ||
               (left == '{' && right == '}');
    }
    
    /**
     * 使用栈进行表达式反转
     */
    public static String reverseExpression(String expression) {
        DequeStack<Character> stack = new DequeStack<>();
        StringBuilder result = new StringBuilder();
        
        // 压入所有字符
        for (char ch : expression.toCharArray()) {
            stack.push(ch);
        }
        
        // 弹出所有字符实现反转
        while (!stack.isEmpty()) {
            result.append(stack.pop());
        }
        
        return result.toString();
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    
    <groupId>com.example</groupId>
    <artifactId>deque-stack</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    
    <properties>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>
    
    <build>
        <plugins>
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.1.0</version>
                <configuration>
                    <mainClass>Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

/**
 * 主程序入口 - 演示DequeStack的使用和性能优势
 */
public class Main {
    public static void main(String[] args) {
        System.out.println("=== Deque替代Stack的高效实现演示 ===\n");
        
        // 1. 基本功能演示
        demonstrateBasicOperations();
        
        // 2. 性能对比测试
        demonstratePerformance();
        
        // 3. 实际应用场景
        demonstrateApplications();
    }
    
    private static void demonstrateBasicOperations() {
        System.out.println("1. 基本操作演示:");
        DequeStack<String> stack = new DequeStack<>();
        
        // 压入操作
        stack.push("Java");
        stack.push("Deque");
        stack.push("Stack");
        
        System.out.println("栈内容: " + stack);
        System.out.println("栈大小: " + stack.size());
        System.out.println("栈顶元素: " + stack.peek());
        
        // 弹出操作
        System.out.println("弹出: " + stack.pop());
        System.out.println("弹出后栈顶: " + stack.peek());
        System.out.println();
    }
    
    private static void demonstratePerformance() {
        System.out.println("2. 性能对比测试 (操作 " + StackPerformanceTest.TEST_SIZE + " 个元素):");
        
        // 运行性能测试
        StackPerformanceTest.testDequeStack();
        StackPerformanceTest.testTraditionalStack();
        System.out.println();
    }
    
    private static void demonstrateApplications() {
        System.out.println("3. 实际应用场景演示:");
        
        // 括号匹配测试
        String[] testExpressions = {
            "((a + b) * (c - d))",
            "({[()]}))",
            "((())",
            "(){}[]"
        };
        
        for (String expr : testExpressions) {
            boolean balanced = StackApplication.isBracketBalanced(expr);
            System.out.println("表达式 '" + expr + "' 括号" + (balanced ? "匹配" : "不匹配"));
        }
        
        // 表达式反转测试
        String expression = "Hello World";
        String reversed = StackApplication.reverseExpression(expression);
        System.out.println("表达式 '" + expression + "' 反转后: '" + reversed + "'");
    }
}