本博客來自於對左神初級班的筆記整理，個人將java改爲Python
1、用固定大小的數組實現一個棧
根據棧先進後出的特性，設置一個指針始終指向數組已存入元素的末尾後一個空缺位置。push時先存入元素指針再後移，pop時指針先前移再取出元素，查看當前棧頂的元素就是返回指針-1對應的值。代碼如下：
class ArrayStack:
def __init__(self, N):
self.array = [None]*N
self.n = N # 開闢的固定數組的size
self.size = 0 # 棧中已有數的size
def push(self, value):
if self.size == self.n:
print("The stack is full")
return False
else:
self.array[self.size] = value
self.size += 1
def pop(self):
if self.size == 0:
print("The stack is empty")
return False
else:
value = self.array[self.size-1]
self.array[self.size-1] = None
self.size -= 1
return value
def peak(self): # 返回棧頂元素
if self.size == 0:
print("The stack is empty")
return False
else:
return self.array[self.size-1]
if __name__ == '__main__':
N = int(input())
x = ArrayStack(N)
# 測試
x.push(5)
print(x.peak())
print(x.pop())
2、用固定大小的數組實現一個隊列
根據隊列先進先出的特性，需要設置兩個指針，一個指向出隊列的元素，一個指向進隊列的位置，同時指針到數組尾端時對數組大小求餘，使數組能循環利用。
# 固定大小數組實現隊列
class ArrayQueue:
def __init__(self,N):
self.array = [None]*N
self.n = N
self.size = 0
self.first = 0 # 出隊列
self.last = 0 # 入隊列
def enqueue(self, value):
if self.size == self.n:
print("The queue is full")
return False
else:
self.size += 1
self.array[self.last] = value
self.last = self.last+1 if self.last != self.n - 1 else 0
def dequeue(self):
if self.size == 0:
print("The queue is empty")
return False
else:
self.size -= 1
value = self.array[self.first]
self.first = self.first + 1 if self.first != self.n - 1 else 0
return value
def peak(self):
if self.size == 0:
print("The queue is empty")
return False
else:
return self.array[self.first]
if __name__ == '__main__':
N = int(input())
x = ArrayQueue(N)
# 測試
x.enqueue(5)
print(x.peak())
print(x.dequeue())
x.enqueue(6)
print(x.dequeue())
3、實現一個特殊的棧，在實現棧的基本功能的基礎上，再實現返 回棧中最小元素的操作。
【要求】 1．pop、push、getMin操作的時間複雜度都是O(1)。 2．設計的棧類型可以使用現成的棧結構
思路是開闢兩個棧，第一個棧保持正常操作，第二個棧如果進入的數比棧頂元素小，就入棧，pop時如果原棧和最小棧定元素相同，則同時刪除最小棧中的元素，最後返回最小棧頂元素即爲最小值。原題在leetcode上https://leetcode-cn.com/problems/min-stack/
# 返回棧的最小值，時間複雜度爲O(1)
class MinStack:
def __init__(self):
"""
initialize your data structure here.
"""
self.stackData = []
self.minstack = []
def push(self, x: int) -> None:
self.stackData.append(x)
if len(self.minstack)==0 or x <= self.minstack[-1]:
self.minstack.append(x)
def pop(self) -> None:
if len(self.stackData) == 0:
# print("This stack is empty")
return None
else:
value = self.stackData.pop()
if self.minstack[-1] == value:
self.minstack.pop()
return value
def top(self) -> int:
if len(self.stackData) == 0:
return None
else:
return self.stackData[-1]
def getMin(self) -> int:
if len(self.minstack) == 0:
return None
else:
return self.minstack[-1]
if __name__ == '__main__':
minStack =MinStack()
minStack.push(-2)
minStack.push(0)
minStack.push(-3)
print(minStack.getMin()) # -3
print(minStack.pop()) # -3
print(minStack.top()) # 0
print(minStack.getMin()) # -2
4、如何使用隊列實現棧結構
按道理來講，是需要兩個隊列，每次取棧頂元素的時候，就將一個隊列除了最後一個元素之外所有元素全部進入另一個隊列中，然後將兩隊列作交換。但是python中有一個內置的deque，雙邊隊列，可以類似於作弊的行爲，直接從list左邊取值。此處還是按照兩個隊列來寫。題目地址：https://leetcode-cn.com/problems/implement-stack-using-queues/
from collections import deque
class MyStack:
def __init__(self):
"""
Initialize your data structure here.
"""
self.stack1 = deque([])
self.stack2 = deque([])
def push(self, x: int) -> None:
"""
Push element x onto stack.
"""
self.stack1.append(x)
def pop(self) -> int:
"""
Removes the element on top of the stack and returns that element.
"""
l = len(self.stack1)
print(self.stack1)
for i in range(l-1):
self.stack2.append(self.stack1.popleft())
value = self.stack1.popleft()
tmp = self.stack2
self.stack2 = self.stack1
self.stack1 = tmp
# print(self.stack1)
return value
def top(self) -> int:
"""
Get the top element.
"""
return self.stack1[len(self.stack1)-1]
def empty(self) -> bool:
"""
Returns whether the stack is empty.
"""
if len(self.stack1)==0:
return True
else:
return False
5、用棧實現隊列
同理，用棧實現隊列，還是要用到兩個棧，一個push棧，一個pop棧，主要滿足兩個基本原則：1、如果往pop棧倒入數據，push棧一定要倒空2、pop棧如果有數據，一定不能從push棧往pop棧放數據。（等於pop棧走了一批再從push棧倒入下一批）題目：https://leetcode-cn.com/problems/implement-queue-using-stacks/
class MyQueue:
def __init__(self):
"""
Initialize your data structure here.
"""
self.pushStack = []
self.popStack = []
def push(self, x: int) -> None:
"""
Push element x to the back of queue.
"""
self.pushStack.append(x)
def pop(self) -> int:
"""
Removes the element from in front of queue and returns that element.
"""
l = len(self.pushStack)
if self.popStack == []:
for i in range(l):
self.popStack.append(self.pushStack.pop())
return self.popStack.pop()
def peek(self) -> int:
"""
Get the front element.
"""
l = len(self.pushStack)
if self.popStack == []:
for i in range(l):
self.popStack.append(self.pushStack.pop())
return self.popStack[-1]
def empty(self) -> bool:
"""
Returns whether the queue is empty.
"""
return self.pushStack == [] and self.popStack == []