栈

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

template<typename T = int,int siz = maxn>
struct mystack{
    T sta[siz+5];
    int head = 0;

    void clear() { head = 0;}

    void push(T a) { sta[head++] = a;}

    void pop(){head--;}

    T top() { return sta[head-1];}

    bool empty() { return head == 0;}

    int size() { return head;}
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# 直接使用 list 模拟栈
stack = []

stack.append(1)   # 入栈 push
top = stack[-1]   # 查看栈顶 peek → 3
item = stack.pop()  # 出栈 pop → 3

is_empty = not stack          # 判空
size = len(stack)             # 大小

## 方法2 : 继承 list,改名
class Stack(list):
   push = list.append
   empty = lambda self: not self
   size = lambda self: len(self)


#  使用 class 封装，便于扩展和加保护 

class Stack:
   def __init__(self):
       self._items = []

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

   def pop(self):
       if self.is_empty():
           raise IndexError("pop from empty stack")
       return self._items.pop()

   def peek(self):
       if self.is_empty():
           raise IndexError("peek from empty stack")
       return self._items[-1]

   def is_empty(self) -> bool:
       return not self._items

   def __len__(self) -> int:
       return len(self._items)

   def __repr__(self):
       return f"Stack({self._items})"


s = Stack()
s.push(1); s.push(2)
print(s.peek())   # 2
print(s.pop())    # 2
print(len(s))     # 1