一.栈的概念
在 Python 中，栈（Stack）是一种 “ 后进先出（LIFO）”的数据结构，仅允许在栈顶进行插入（push）和删除（pop）操作。
二.栈的抽象数据类型
1.抽象数据类型 “栈” 定义：
<1>.Stack ()：创建一个空栈，不包含任何数据项
<2>.push (item)：将 item 加入栈顶，无返回值
<3>.pop ()：将栈顶数据项移除，并返回，栈被修改
<4>.peek ()：“窥视” 栈顶数据项，返回栈顶的数据项但不移除，栈不被修改
<5>.isEmpty ()：返回栈是否为空栈
<6>.size ()：返回栈中有多少个数据项
2.简单操作样例：
| Stack Operation | Stack Contents | Return Value |
|---|---|---|
| s = Stack() | [] | Stack object |
| s.isEmpty() | [] | True |
| s.push(4) | [4] | |
| s.push('dog') | [4, 'dog'] | |
| s.peek() | [4, 'dog'] | 'dog' |
| s.push(True) | [4, 'dog', True] | |
| s.size() | [4, 'dog', True] | 3 |
| s.isEmpty() | [4, 'dog', True] | False |
| s.push(8.4) | [4, 'dog', True, 8.4] | |
| s.pop() | [4, 'dog', True] | 8.4 |
| s.pop() | [4, 'dog'] | True |
| s.size() | [4, 'dog'] | 2 |
3.操作实例代码实现：
class Stack:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def push(self,item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return self.items[len(self.items) - 1]
def size(self):
return len(self.items)
# 操作样例
s = Stack()
print("s.isEmpty():", s.isEmpty()) # True
s.push(4)
s.push('dog')
print("s.peek():", s.peek()) # 'dog'
s.push(True)
print("s.size():", s.size()) # 3
print("s.isEmpty():", s.isEmpty()) # False
s.push(8.4)
print("s.pop():", s.pop()) # 8.4
print("s.pop():", s.pop()) # True
print("s.size():", s.size()) # 2 三.栈的应用
1.简单括号匹配：
class Stack:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def push(self,item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return self.items[len(self.items) - 1]
def size(self):
return len(self.items)
def parChecker(symbolString):
s = Stack()
balanced = True
index = 0
while index < len(symbolString) and balanced:
symbol = symbolString[index]
if symbol == "(":
s.push(symbol)
else:
if s.isEmpty():
balanced = False
else:
s.pop()
index = index + 1
if balanced and s.isEmpty():
return True
else:
return False
# 测试示例
print(parChecker("((()))")) # True
print(parChecker("(()")) # Error: unmatched left parentheses
print(parChecker("(]")) # Error at position 1: mismatched ']'
print(parChecker("{[()]}")) # True
print(parChecker("{[(])}")) # Error at position 3: mismatched ')'代码分析：
1.提供的代码是一个使用栈（Stack）检查括号平衡性的函数 parChecker。这个函数可以判断一个字符串中的括号是否匹配（即每个左括号 ( 都有对应的右括号 )）。
2.实现过程：
<1>.初始化栈：创建一个空栈 s 用于存储左括号 (。
<2>.遍历字符串：从左到右扫描每个字符：
遇到左括号 ( 时，将其压入栈。
遇到右括号 ) 时：
如果栈为空，说明没有匹配的左括号，返回 False。
如果栈不为空，弹出栈顶元素（即匹配一个左括号）。
<3>.最终判断：遍历结束后，如果栈为空且所有括号都匹配，则返回 True，否则返回 False。
3.复杂度分析：
<1>.时间复杂度：O (n)，其中 n 是字符串长度。
<2>.空间复杂度：O (n)，最坏情况下栈存储所有左括号（如 "((((("）。
2.将十进制数转换成二进制数：
def divideBy2(decnumber):
remstack = Stack()
while decnumber > 0:
rem = decnumber % 2
remstack.push(rem)
decnumber = decnumber // 2
binstring = ""
while not remstack.isEmpty():
binstring = binstring + str(remstack.pop())
return binstring
print(divideBy2(100))
print(divideBy2(200))
print(divideBy2(300))
print(divideBy2(400))
print(divideBy2(500))代码分析：
1.提供的代码是一个使用栈（Stack）将十进制数转换为二进制数的函数 divideBy2。这个函数通过不断除以 2 并记录余数，最后反向拼接余数得到二进制表示。
2.实现过程：
<1>.初始化栈：创建一个空栈 remstack 用于存储每次除法的余数。
<2>.循环取余：当十进制数 decnumber 大于 0 时，不断进行以下操作：
1.计算 decnumber % 2 得到余数（0 或 1）。
2.将余数压入栈 remstack。
3.更新 decnumber 为其整数除法结果（decnumber // 2）。
<3>.拼接二进制字符串：从栈中弹出所有元素并拼接成字符串，得到二进制表示。
3.复杂度分析：
<1>.时间复杂度：O(log n)
每次循环将输入数减半，循环次数为 log₂(n)，每次操作（取余、压栈）时间为 O (1)。
<2>.空间复杂度：O(log n)
栈中存储的余数数量为 log₂(n)，拼接字符串的空间也为 log₂(n)。
优化改进：
将上述代码改进成可以任意进制转换，适配性更强：
class Stack:
def __init__(self):
self.items = []
def isEmpty(self):
return self.items == []
def push(self,item):
self.items.append(item)
def pop(self):
return self.items.pop()
def peek(self):
return self.items[len(self.items) - 1]
def size(self):
return len(self.items)
def baseConverter(decnumber,base):
digits = "0123456789ABCDEF"
remstack = Stack()
while decnumber > 0:
rem = decnumber % base
remstack.push(rem)
decnumber = decnumber // base
newstring = ""
while not remstack.isEmpty():
newstring = newstring + digits[remstack.pop()]
return newstring
print(baseConverter(100,2))
print(baseConverter(100,4))
print(baseConverter(100,6))
print(baseConverter(100,8))
print(baseConverter(100,10))
print(baseConverter(100,16))以上就是一些比较经典的栈的应用。
