文章目錄

• • 1.刪除最外層的括號
  • • 信息
    • 要求
    • 答案
  • 2.棒球比賽
  • • 信息
    • 示例
    • 答案
  • 3. 用棧實現隊列
  • • 要求
    • 說明:
    • 答案
  • 4.用隊列模擬棧
  • • 描述
    • 注意
    • 答案
  • 5.下一個更大的元素（未解）
  • • 信息：
    • 示例：
    • 注意:
    • 答案：
  • 6.刪除字符串中的所有相鄰重復項
  • • 信息
    • 示例：
    • 答案：
  • 7. 獲取棧中的最小元素 (時間復雜度較大)
  • • 信息
    • 示例:
    • 答案
  • 8.比較包含退格的兩個字符串(復雜度都比較低)
  • • 信息
    • 示例：
    • 答案
  • 9.判斷是否是有效的括號（很巧妙）
  • • 信息：
    • 示例：
    • 答案：
  • 10.二叉樹的中序遍歷（左跟右）
  • • 信息
    • 答案
  • 11.二叉樹的前序遍歷（根左右）
  • • 信息
    • 答案
  • 12.二叉樹的后序排列（順序是：左右根）
  • • 信息
    • 答案
  • 13.使括號有效的最少添加（巧妙）
  • • 信息
    • 示例
    • 答案
  • 14.二叉搜索樹迭代器
  • • 二叉搜索樹
    • 信息
    • 答案
  • 15.扁平化嵌套列表迭代器
  • • 信息
    • 示例：
    • 答案

1.刪除最外層的括號

信息

有效括號字符串為空 ("")、"(" + A + “)” 或 A + B，其中 A 和 B 都是有效的括號字符串，+ 代表字符串的連接。例如，""，"()"，"(())()" 和 “(()(()))” 都是有效的括號字符串。

如果有效字符串 S 非空，且不存在將其拆分為 S = A+B 的方法，我們稱其為原語（primitive），其中 A 和 B 都是非空有效括號字符串。

給出一個非空有效字符串 S，考慮將其進行原語化分解，使得：S = P_1 + P_2 + … + P_k，其中 P_i 是有效括號字符串原語。

對 S 進行原語化分解，刪除分解中每個原語字符串的最外層括號，返回 S 。

要求

示例 1：

輸入："(()())(())" 輸出："()()()" 解釋： 輸入字符串為 "(()())(())"，原語化分解得到 "(()())" + "(())"， 刪除每個部分中的最外層括號后得到 "()()" + "()" = "()()()"。

示例 2：

輸入："(()())(())(()(()))" 輸出："()()()()(())" 解釋： 輸入字符串為 "(()())(())(()(()))"，原語化分解得到 "(()())" + "(())" + "(()(()))"， 刪除每隔部分中的最外層括號后得到 "()()" + "()" + "()(())" = "()()()()(())"。

示例 3：

輸入："()()" 輸出："" 解釋： 輸入字符串為 "()()"，原語化分解得到 "()" + "()"， 刪除每個部分中的最外層括號后得到 "" + "" = ""。

答案

class Solution(object):def removeOuterParentheses(self, S):""":type S: str:rtype: str"""last, cur_len = 0, 0result = []for i, each in enumerate(S):if each == '(':cur_len += 1if each == ')':cur_len -= 1if cur_len == 0:result.append(S[last + 1:i])last = i + 1return ''.join(result)solution = Solution() print(solution.removeOuterParentheses('()()'))

2.棒球比賽

信息

你現在是棒球比賽記錄員。
給定一個字符串列表，每個字符串可以是以下四種類型之一：
1.整數（一輪的得分）：直接表示您在本輪中獲得的積分數。
2. “+”（一輪的得分）：表示本輪獲得的得分是前兩輪有效 回合得分的總和。
3. “D”（一輪的得分）：表示本輪獲得的得分是前一輪有效 回合得分的兩倍。
4. “C”（一個操作，這不是一個回合的分數）：表示您獲得的最后一個有效 回合的分數是無效的，應該被移除。

每一輪的操作都是永久性的，可能會對前一輪和后一輪產生影響。
你需要返回你在所有回合中得分的總和。

示例

示例 1:

輸入: [“5”,“2”,“C”,“D”,"+"]
輸出: 30
解釋:
第1輪：你可以得到5分。總和是：5。
第2輪：你可以得到2分。總和是：7。
操作1：第2輪的數據無效。總和是：5。
第3輪：你可以得到10分（第2輪的數據已被刪除）。總數是：15。
第4輪：你可以得到5 + 10 = 15分。總數是：30。
示例 2:

輸入: [“5”,"-2",“4”,“C”,“D”,“9”,"+","+"]
輸出: 27
解釋:
第1輪：你可以得到5分。總和是：5。
第2輪：你可以得到-2分。總數是：3。
第3輪：你可以得到4分。總和是：7。
操作1：第3輪的數據無效。總數是：3。
第4輪：你可以得到-4分（第三輪的數據已被刪除）。總和是：-1。
第5輪：你可以得到9分。總數是：8。
第6輪：你可以得到-4 + 9 = 5分。總數是13。
第7輪：你可以得到9 + 5 = 14分。總數是27。
注意：

輸入列表的大小將介于1和1000之間。
列表中的每個整數都將介于-30000和30000之間。

答案

class Solution:def calPoints(self, ops):""":type ops: List[str]:rtype: int"""res = []for i in range(len(ops)):if ops[i] == "C":res.pop()elif ops[i] == "D":res.append(res[-1] * 2)elif ops[i] == '+':res.append(res[-1] + res[-2])else:res.append(int(ops[i]))return sum(res)

3. 用棧實現隊列

要求

使用棧實現隊列的下列操作：

push(x) – 將一個元素放入隊列的尾部。
pop() – 從隊列首部移除元素。
peek() – 返回隊列首部的元素。
empty() – 返回隊列是否為空。
示例:

MyQueue queue = new MyQueue();

queue.push(1);
queue.push(2);
queue.peek(); // 返回 1
queue.pop(); // 返回 1
queue.empty(); // 返回 false

說明:

你只能使用標準的棧操作 – 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
你所使用的語言也許不支持棧。你可以使用 list 或者 deque（雙端隊列）來模擬一個棧，只要是標準的棧操作即可。
假設所有操作都是有效的 （例如，一個空的隊列不會調用 pop 或者 peek 操作）。

答案

from collections import deque class MyQueue:def __init__(self):"""Initialize your data structure here."""self.Myqueue = deque()def push(self, x: int) -> None:"""Push element x to the back of queue."""self.Myqueue.append(x)def pop(self) -> int:"""Removes the element from in front of queue and returns that element."""if len(self.Myqueue) > 0:return self.Myqueue.popleft()else:return Nonedef peek(self) -> int:"""Get the front element."""if len(self.Myqueue) > 0:return self.Myqueue[0]else:return Nonedef empty(self) -> bool:"""Returns whether the queue is empty."""return len(self.Myqueue) == 0

4.用隊列模擬棧

描述

使用隊列實現棧的下列操作：

• push(x) – 元素 x 入棧
• pop() – 移除棧頂元素
• top() – 獲取棧頂元素
• empty() – 返回棧是否為空

注意

你只能使用隊列的基本操作– 也就是 push to back, peek/pop from front, size, 和 is empty 這些操作是合法的。
你所使用的語言也許不支持隊列。 你可以使用 list 或者 deque（雙端隊列）來模擬一個隊列 , 只要是標準的隊列操作即可。
你可以假設所有操作都是有效的（例如, 對一個空的棧不會調用 pop 或者 top 操作）。

答案

class MyStack(object):def __init__(self):"""Initialize your data structure here."""self.stack = []self.length = 0def push(self, x):"""Push element x onto stack.:type x: int:rtype: None"""self.stack.append(x)self.length += 1def pop(self):"""Removes the element on top of the stack and returns that element.:rtype: int"""if self.empty() is False:self.length -= 1return self.stack.pop()def top(self):"""Get the top element.:rtype: int"""if self.empty() is False:return self.stack[self.length - 1]def empty(self):"""Returns whether the stack is empty.:rtype: bool"""if len(self.stack) == 0:return Truereturn False

5.下一個更大的元素（未解）

信息：

給定兩個沒有重復元素的數組 nums1 和 nums2 ，其中nums1 是 nums2 的子集。找到 nums1 中每個元素在 nums2 中的下一個比其大的值。

nums1 中數字 x 的下一個更大元素是指 x 在 nums2 中對應位置的右邊的第一個比 x 大的元素。如果不存在，對應位置輸出-1。

示例：

示例 1:

輸入: nums1 = [4,1,2], nums2 = [1,3,4,2].
輸出: [-1,3,-1]
解釋:
對于num1中的數字4，你無法在第二個數組中找到下一個更大的數字，因此輸出 -1。
對于num1中的數字1，第二個數組中數字1右邊的下一個較大數字是 3。
對于num1中的數字2，第二個數組中沒有下一個更大的數字，因此輸出 -1。
示例 2:

輸入: nums1 = [2,4], nums2 = [1,2,3,4].
輸出: [3,-1]
解釋:
對于num1中的數字2，第二個數組中的下一個較大數字是3。
對于num1中的數字4，第二個數組中沒有下一個更大的數字，因此輸出 -1。

注意:

nums1和nums2中所有元素是唯一的。
nums1和nums2 的數組大小都不超過1000。

答案：

未解

6.刪除字符串中的所有相鄰重復項

信息

給出由小寫字母組成的字符串 S，重復項刪除操作會選擇兩個相鄰且相同的字母，并刪除它們。

在 S 上反復執行重復項刪除操作，直到無法繼續刪除。

在完成所有重復項刪除操作后返回最終的字符串。答案保證唯一。

示例：

輸入：“abbaca”
輸出：“ca”
解釋：
例如，在 “abbaca” 中，我們可以刪除 “bb” 由于兩字母相鄰且相同，這是此時唯一可以執行刪除操作的重復項。之后我們得到字符串 “aaca”，其中又只有 “aa” 可以執行重復項刪除操作，所以最后的字符串為 “ca”。

提示：1 <= S.length <= 20000 S 僅由小寫英文字母組成。

答案：

class Solution:def removeDuplicates(self, S: str) -> str:stack=[] # 定義一個棧for i in S:if not stack: # 如果當前棧為空stack.append(i)elif i == stack[-1]: # 如果當前元素與棧頂元素相等stack.pop()else:stack.append(i)return ''.join(stack)

7. 獲取棧中的最小元素 (時間復雜度較大)

信息

設計一個支持 push，pop，top 操作，并能在常數時間內檢索到最小元素的棧。

push(x) – 將元素 x 推入棧中。
pop() – 刪除棧頂的元素。
top() – 獲取棧頂元素。
getMin() – 檢索棧中的最小元素。

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.

答案

class MinStack:def __init__(self):"""initialize your data structure here."""self.stack = []self.flag=0def push(self, x: int) -> None:self.stack.append(x)def pop(self) -> None:if self.stack:self.stack.pop()def top(self) -> int:if self.stack:return self.stack[-1]def getMin(self) -> int:self.flag = self.stack[0]for i in self.stack:if self.flag > i:self.flag = ireturn self.flag

執行結果：

執行用時 :
2828 ms, 在所有 Python3 提交中擊敗了5.02%的用戶
內存消耗 :
16 MB, 在所有 Python3 提交中擊敗了99.88%的用戶

8.比較包含退格的兩個字符串(復雜度都比較低)

信息

給定 S 和 T 兩個字符串，當它們分別被輸入到空白的文本編輯器后，判斷二者是否相等，并返回結果。 # 代表退格字符。

示例：

示例 1：

輸入：S = “ab#c”, T = “ad#c”
輸出：true
解釋：S 和 T 都會變成 “ac”。
示例 2：

輸入：S = “ab##”, T = “c#d#”
輸出：true
解釋：S 和 T 都會變成 “”。
示例 3：

輸入：S = “a##c”, T = “#a#c”
輸出：true
解釋：S 和 T 都會變成 “c”。
示例 4：

輸入：S = “a#c”, T = “b”
輸出：false
解釋：S 會變成 “c”，但 T 仍然是 “b”。

答案

class Solution:def backspaceCompare(self, S: str, T: str) -> bool:# 新建兩個棧stack_a = []stack_b = [] for i in S:if i != '#':stack_a.append(i)elif i == '#' and stack_a:stack_a.pop()for i in T:if i != '#':stack_b.append(i)elif i == '#' and stack_b:stack_b.pop()return stack_a == stack_b

執行結果：
執行用時 :44 ms, 在所有 Python3 提交中擊敗了96.89%的用戶
內存消耗 :13 MB, 在所有 Python3 提交中擊敗了98.24%的用戶

9.判斷是否是有效的括號（很巧妙）

信息：

給定一個只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判斷字符串是否有效。

有效字符串需滿足：

左括號必須用相同類型的右括號閉合。
左括號必須以正確的順序閉合。
注意空字符串可被認為是有效字符串。

示例：

示例 1:

輸入: “()”
輸出: true
示例 2:

輸入: “()[]{}”
輸出: true
示例 3:

輸入: “(]”
輸出: false
示例 4:

輸入: “([)]”
輸出: false
示例 5:

輸入: “{[]}”
輸出: true

答案：

class Solution:def isValid(self, s: str) -> bool:while '{}' in s or '()' in s or '[]' in s:s = s.replace('{}', '')s = s.replace('[]', '')s = s.replace('()', '')return s == ''

10.二叉樹的中序遍歷（左跟右）

信息

給定一個二叉樹，返回它的中序 遍歷。

示例:

輸入: [1,null,2,3]
1

2
/
3

輸出: [1,3,2]
進階: 遞歸算法很簡單，你可以通過迭代算法完成嗎？

答案

class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = Noneclass Solution:def __init__(self):self.stack = []def inorderTraversal(self, root: TreeNode) -> List[int]:if root is None:return self.stackif root.left:self.inorderTraversal(root.left)self.stack.append(root.val)if root.right:self.inorderTraversal(root.right)return self.stack

11.二叉樹的前序遍歷（根左右）

信息

給定一個二叉樹，返回它的 前序 遍歷。

示例:

輸入: [1,null,2,3]
1

2
/
3

輸出: [1,2,3]
進階: 遞歸算法很簡單，你可以通過迭代算法完成嗎？

答案

class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = Noneclass Solution:def __init__(self):self.stack = []def preorderTraversal(self, root: TreeNode) -> List[int]:if root is None:return self.stackself.stack.append(root.val)if root.left:self.preorderTraversal(root.left)if root.right:self.preorderTraversal(root.right)return self.stack

12.二叉樹的后序排列（順序是：左右根）

信息

給定一個二叉樹，返回它的 后序 遍歷。

示例:

輸入: [1,null,2,3]
1

2
/
3

輸出: [3,2,1]
進階: 遞歸算法很簡單，你可以通過迭代算法完成嗎？

答案

class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = Noneclass Solution:def __init__(self):self.stack = []def postorderTraversal(self, root: TreeNode) -> List[int]:if root is None:return self.stackif root.left:self.postorderTraversal(root.left)if root.right:self.postorderTraversal(root.right)self.stack.append(root.val)return self.stack

13.使括號有效的最少添加（巧妙）

信息

給定一個由 ‘(’ 和 ‘)’ 括號組成的字符串 S，我們需要添加最少的括號（ ‘(’ 或是 ‘)’，可以在任何位置），以使得到的括號字符串有效。

從形式上講，只有滿足下面幾點之一，括號字符串才是有效的：

它是一個空字符串，或者
它可以被寫成 AB （A 與 B 連接）, 其中 A 和 B 都是有效字符串，或者
它可以被寫作 (A)，其中 A 是有效字符串。
給定一個括號字符串，返回為使結果字符串有效而必須添加的最少括號數。

示例

示例 1：

輸入："())"
輸出：1
示例 2：

輸入："((("
輸出：3
示例 3：

輸入："()"
輸出：0
示例 4：

輸入："()))(("
輸出：4

提示：S.length <= 1000 S 只包含 '(' 和 ')' 字符。

答案

class Solution:def minAddToMakeValid(self, S: str) -> int:while '()' in S:S= S.replace('()','')return len(S)

14.二叉搜索樹迭代器

二叉搜索樹

二叉查找樹（Binary Search Tree），（又：二叉搜索樹，二叉排序樹）它或者是一棵空樹，或者是具有下列性質的二叉樹： 若它的左子樹不空，則左子樹上所有結點的值均小于它的根結點的值； 若它的右子樹不空，則右子樹上所有結點的值均大于它的根結點的值； 它的左、右子樹也分別為二叉排序樹。

信息

實現一個二叉搜索樹迭代器。你將使用二叉搜索樹的根節點初始化迭代器。

調用 next() 將返回二叉搜索樹中的下一個最小的數。

示例：
BSTIterator iterator = new BSTIterator(root);
iterator.next(); // 返回 3
iterator.next(); // 返回 7
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 9
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 15
iterator.hasNext(); // 返回 true
iterator.next(); // 返回 20
iterator.hasNext(); // 返回 false

提示：

next() 和 hasNext() 操作的時間復雜度是 O(1)，并使用 O(h) 內存，其中 h 是樹的高度。
你可以假設 next() 調用總是有效的，也就是說，當調用 next() 時，BST 中至少存在一個下一個最小的數。

答案

class TreeNode:def __init__(self, x):self.val = xself.left = Noneself.right = Noneclass BSTIterator:def __init__(self, root: TreeNode):self.stack = []while root:self.stack.append(root)root = root.leftdef next(self) -> int:"""@return the next smallest number"""temp = self.stack.pop()res = temp.valtemp = temp.rightwhile temp:self.stack.append(temp)temp = temp.leftreturn resdef hasNext(self) -> bool:"""@return whether we have a next smallest number"""return self.stack != []

15.扁平化嵌套列表迭代器

信息

給定一個嵌套的整型列表。設計一個迭代器，使其能夠遍歷這個整型列表中的所有整數。

列表中的項或者為一個整數，或者是另一個列表。

示例：

示例 1:

輸入: [[1,1],2,[1,1]]
輸出: [1,1,2,1,1]
解釋: 通過重復調用 next 直到 hasNext 返回false，next 返回的元素的順序應該是: [1,1,2,1,1]。
示例 2:

輸入: [1,[4,[6]]]
輸出: [1,4,6]
解釋: 通過重復調用 next 直到 hasNext 返回false，next 返回的元素的順序應該是: [1,4,6]。

答案

總結

以上是生活随笔為你收集整理的python 栈【测试题】的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。