数据结构——栈

        数据结构中的栈（Stack）是一种遵循后进先出（LIFO, Last In First Out）原则的有序集合。这种数据结构只允许在栈顶进行添加（push）或删除（pop）元素的操作。栈的实现可以使用数组或链表来完成，每种实现方式都有其特点。

栈的基本操作

1. push(element): 将一个元素添加到栈的顶部。
2. pop(): 移除栈顶的元素，并返回该元素。如果栈为空，则执行此操作可能会引发错误或异常。
3. peek() 或 top(): 返回栈顶元素的值，但不从栈中移除它。如果栈为空，则执行此操作可能会引发错误或异常。
4. isEmpty(): 检查栈是否为空。
5. size(): 返回栈中的元素数量。

import java.util.Stack;

public class Test {
    public static void main(String[] args) {
        Stack<Integer> stack=new Stack<>();
        //入栈
        stack.push(1);
        stack.push(2);
        stack.push(3);
        stack.push(4);


        //出栈
        int x=stack.pop();
        System.out.println(x);

        //获取当前栈顶元素元素
        int y=stack.peek();
        System.out.println(y);

        //判空
        System.out.println(stack.empty());
        
        //元素个数
        System.out.println(stack.size());
    }
}

模拟实现

import java.util.Arrays;

public class MyStack {
    private int[] elem;
    private  int usedSize;

    public MyStack() {
        elem = new int[5];
        usedSize = 0;
    }

    public  boolean isEmpty() {
        return usedSize == 0;
    }

    public boolean isFull(){
        return usedSize==elem.length;
    }

    public void push(int val){
        if(isFull()){
            //扩容
            elem= Arrays.copyOf(elem,2*elem.length);
        }
        elem[usedSize] = val;
        usedSize++;
    }
    public int pop(){
       if(isEmpty()){
           System.out.println("Stack is empty");
        }
        usedSize--;
        return elem[usedSize];

    }

    public int peek(){
        if(isEmpty()){
            System.out.println("Stack is empty");
        }
        return elem[usedSize-1];
    }
    
    public int size(){
        return usedSize;
    }
}

• 函数调用：在计算机程序中，函数调用是通过栈来实现的。当调用一个函数时，其返回地址、参数以及局部变量被压入栈中。当函数返回时，这些信息被弹出栈，控制返回到主调函数。
• 表达式求值：在解析和计算表达式时（特别是算术表达式），栈被用来存储操作数和操作符。
• 回溯算法：在解决如迷宫搜索、棋盘上的八皇后问题等问题时，栈可用来保存中间状态，以便在需要时回溯到之前的状态。
• 页面替换算法：在计算机操作系统的内存管理中，如LRU（最近最少使用）页面替换算法，可以使用栈来模拟。

栈的实现

使用数组实现的栈

使用数组实现的栈需要维护一个表示栈顶位置的索引。当向栈中添加元素时，索引增加；当从栈中移除元素时，索引减少。但是，需要注意数组可能会满或空的情况。

class ArrayStack:  
    def __init__(self, capacity):  
        self._stack = [None] * capacity  
        self._top = -1  # 栈顶索引，初始化为-1表示空栈  
  
    def push(self, item):  
        if self._top == len(self._stack) - 1:  
            raise IndexError("Stack is full")  
        self._stack[self._top + 1] = item  
        self._top += 1  
  
    def pop(self):  
        if self._top == -1:  
            raise IndexError("Stack is empty")  
        item = self._stack[self._top]  
        self._top -= 1  
        return item  
  
    def peek(self):  
        if self._top == -1:  
            raise IndexError("Stack is empty")  
        return self._stack[self._top]  
  
    def is_empty(self):  
        return self._top == -1  
  
    def size(self):  
        return self._top + 1

使用链表实现的栈

使用链表实现的栈，通常是将新元素添加到链表的头部（即栈顶），因为链表的头部添加操作是常数时间复杂度的。链表的头部元素即为栈顶元素。

class ListNode:  
    def __init__(self, value=0, next=None):  
        self.value = value  
        self.next = next  
  
class LinkedListStack:  
    def __init__(self):  
        self._head = None  
  
    def push(self, item):  
        new_node = ListNode(item)  
        new_node.next = self._head  
        self._head = new_node  
  
    def pop(self):  
        if self._head is None:  
            raise IndexError("Stack is empty")  
        item = self._head.value  
        self._head = self._head.next  
        return item  
  
    def peek(self):  
        if self._head is None:  
            raise IndexError("Stack is empty")  
        return self._head.value  
  
    def is_empty(self):  
        return self._head is None  
  
    def size(self):  
        current = self._head  
        count = 0  
        while current:  
            count += 1  
            current = current.next  
        return count