41.思路：分别在列表中存放两个单词的索引，再用两次遍历求距离
# 给定一个单词列表和两个单词 word1 和 word2，返回列表中这两个单词之间的最短距离。
# 示例:
# 假设 words = ["practice", "makes", "perfect", "coding", "makes"]
# 输入: word1 = “coding”, word2 = “practice”
# 输出: 3
# 输入: word1 = "makes", word2 = "coding"
# 输出: 1
#me
class Solution0(object):
def shortestDistance(self, words, word1, word2):
result = []
idwords1 = [id_ for id_,word in enumerate(words) if word == word1]
idwords2 = [id_ for id_,word in enumerate(words) if word == word2]
for id1 in idwords1:
for id2 in idwords2:
result.append(abs(id1-id2))
return min(result)
#other 复杂度O(n)
class Solution1(object):
def shortestDistance(self, words, word1, word2):
n = m = min_distance = size = len(words)
for i in range(size):
if words[i] == word1:
n = i
elif words[i] == word2:
m = i
if m != size and m != size:
min_distance = min(min_distance, abs(m - n))
return min_distance
*42.思路：奇数移动到奇数、偶数移动到偶数是无消耗的，意思是算奇数和偶数的个数。
# 数轴上放置了一些筹码，每个筹码的位置存在数组 chips 当中。
# 你可以对 任何筹码 执行下面两种操作之一（不限操作次数，0 次也可以）：
# 将第 i 个筹码向左或者右移动 2 个单位，代价为 0。
# 将第 i 个筹码向左或者右移动 1 个单位，代价为 1。
# 最开始的时候，同一位置上也可能放着两个或者更多的筹码。
# 返回将所有筹码移动到同一位置（任意位置）上所需要的最小代价。
# 示例 1：
# 输入：chips = [1,2,3]
# 输出：1
# 解释：第二个筹码移动到位置三的代价是 1，第一个筹码移动到位置三的代价是 0，总代价为 1。
# 示例 2：
# 输入：chips = [2,2,2,3,3]
# 输出：2
# 解释：第四和第五个筹码移动到位置二的代价都是 1，所以最小总代价为 2。
#me
class Solution(object):
def minCostToMoveChips(self, chips):
jiShuNum = len([i for i in chips if i%2 == 1])
ouShuNum = len([j for j in chips if j%2 == 0])
return min([jiShuNum,ouShuNum])
43.思路：直述题意
# 给定仅有小写字母组成的字符串数组 A，返回列表中的每个字符串中都显示的全部字符（包括重复字符）组成的列表。例如，如果一个字符在每个字符串中出现 3 次，但不是 4 次，则需要在最终答案中包含该字符 3 次。
# 你可以按任意顺序返回答案。
# 示例 1：
# 输入：["bella","label","roller"]
# 输出：["e","l","l"]
# 示例 2：
# 输入：["cool","lock","cook"]
# 输出：["c","o"]
#me
class Solution0(object):
def commonChars(self, A):
allSigWord = []
for word in A:
for sigword in word:
allSigWord.append(str(sigword))
allReWord = [i for i in allSigWord if allSigWord.count(i)>=len(A)]
result = []
for sigReWord in set(allReWord):
allnum = []
for word in A:
allnum.append(word.count(sigReWord))
for i in range(min(allnum)):
result.append(sigReWord)
return(result)
#other
#思路：使用Counter得到每个字符串的字典，字典相交，然后转换为list输出
#counter是 colletions内的一个类,可以理解为一个简单的计数器，可以统计字符出现的个数
from collections import Counter
class Solution1(object):
def commonChars(self, A):
ans = Counter(A[0])
for i in range(1, len(A)):
ans &= Counter(A[i])
return list(ans.elements())
#other
class Solution:
def commonChars(self, A):
return [i for c in set(A[0]) for i in c * min(w.count(c) for w in A)] if A else []
44.思路：直述题意
# 给定一个字符串 S 和一个字符 C。返回一个代表字符串 S 中每个字符到字符串 S 中的字符 C 的最短距离的数组。
# 示例 1:
# 输入: S = "loveleetcode", C = 'e'
# 输出: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0]
#me
class Solution0(object):
def shortestToChar(self, S, C):
C_ids = [Id for Id,s in enumerate(S) if s==C]
result = []
for Id,s in enumerate(S):
mid = []
for C_id in C_ids:
mid.append(abs(Id-C_id))
result.append(min(mid))
return result
#other
class Solution1(object):
def shortestToChar(self, S, C):
return [min([abs(i - j) for j in [k for k, c in enumerate(S) if c == C]]) for i in range(len(S))]
45.思路：1.使用列表存放最后两个数的和，2.递归算法
# 斐波那契数，通常用 F(n) 表示，形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
# F(0) = 0, F(1) = 1
# F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
# 给定 N，计算 F(N)。
# 示例 1：
# 输入：2
# 输出：1
# 解释：F(2) = F(1) + F(0) = 1 + 0 = 1.
# 示例 2：
# 输入：3
# 输出：2
# 解释：F(3) = F(2) + F(1) = 1 + 1 = 2.
# 示例 3：
# 输入：4
# 输出：3
# 解释：F(4) = F(3) + F(2) = 2 + 1 = 3.
#me
class Solution0(object):
def fib(self, N):
resultList = [0,1]
if N == 2:
return 1
else:
while(N):
resultList.append(resultList[-1]+resultList[-2])
N-=1
return resultList[-2]
#other
class Solution1(object):
def fib(N):
if N in [0, 1]:
return N
a, b = 0, 1
while N > 1:
a, b = b, a + b
N -= 1
return b
class Solution2(object):
class Solution():
def Fibnacci(self, n):
if n <= 0:
return 0
if n == 1:
return 1
return self.Fibnacci(n - 1) + self.Fibnacci(n - 2)
46.思路：while循环，直到各个位数相加之和为一位数。
# 给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。
# 示例:
# 输入: 38
# 输出: 2
# 解释: 各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。 由于 2 是一位数，所以返回 2。
#me
class Solution0(object):
def addDigits(self, num):
while(len(str(num))-1):
num = sum([int(i) for i in list(str(num))])
return str(num)[-1]
#other
class Solution1(object):
def addDigits(self, num):
while len(str(num)) > 1:
num = eval("+".join(list(str(num))))
return num
47.思路：1.直述题意，2.模拟法（动态规划）
#给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
#在杨辉三角中，每个数是它左上方和右上方的数的和
#示例:
# 输入: 5
# 输出:
# [
# [1],
# [1,1],
# [1,2,1],
# [1,3,3,1],
# [1,4,6,4,1]
# ]
#me
class Solution0(object):
def generate(self, numRows):
Result = [(i+1)*[1] for i in range(numRows)]
if numRows <=2:
return Result
else:
for i in range(2,numRows):
for j in range(1,len(Result[i])-1):
Result[i][j] = Result[i-1][j-1]+Result[i-1][j]
return Result
#other
# 1.初始化结果数组，numRowsnumRows表示结果数组dpdp的行数，每一行的元素个数等于所处第几行。全部初始化为0
# 2.将边界全部初始化为1
# 3.遍历dpdp，将为00的位置使用动态规划填入，公式：dp[i][j]=dp[i-1][j-1]+dp[i-1][j]dp[i][j]=dp[i−1][j−1]+dp[i−1][j]
class Solution:
def generate(self, numRows):
dp=[[0]*n for n in range(1,numRows+1)]
for i in range(numRows):
dp[i][0]=dp[i][-1]=1
for i in range(0,numRows):
for j in range(i+1):
if(dp[i][j]==0):
dp[i][j]=dp[i-1][j-1]+dp[i-1][j]
return dp
48.思路：直述题意
# 给出一个按 非递减 顺序排列的数组 nums，和一个目标数值 target。假如数组 nums 中绝大多数元素的数值都等于 target，则返回 True，否则请返回 False。
# 所谓占绝大多数，是指在长度为 N 的数组中出现必须 超过 N/2 次。
#me
class Solution(object):
def isMajorityElement(self, nums, target):
return bool(nums.count(target)>len(nums)//2)
49.思路：先处理"C"操作，再进行其他操作
# 你现在是棒球比赛记录员。
# 给定一个字符串列表，每个字符串可以是以下四种类型之一：
# 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。
#me
class Solution0(object):
def calPoints(self, ops):
for ele in ops:
if ele == 'C':
ops = ops[:ops.index(ele) - 1] + ops[ops.index(ele) + 1:]
result = 0
for i in ops:
if i == 'D':
result += int(ops[ops.index(i) - 1]) * 2
ops[ops.index(i)] = int(ops[ops.index(i) - 1]) * 2
elif i == '+':
result += (int(ops[ops.index(i) - 1]) + int(ops[ops.index(i) - 2]))
ops[ops.index(i)] = (int(ops[ops.index(i) - 1]) + int(ops[ops.index(i) - 2]))
else:
result += int(i)
return result
#other
class Solution1(object):
def calPoints(self, ops):
stack = []
for op in ops:
if op == '+':
stack.append(stack[-1] + stack[-2])
elif op == 'C':
stack.pop()
elif op == 'D':
stack.append(2 * stack[-1])
else:
stack.append(int(op))
return sum(stack)
50.思路：转换思想，找出最长的字符串
# 给定两个字符串，你需要从这两个字符串中找出最长的特殊序列。最长特殊序列定义如下：该序列为某字符串独有的最长子序列（即不能是其他字符串的子序列）。
# 子序列可以通过删去字符串中的某些字符实现，但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列，任何字符串为其自身的子序列。
# 输入为两个字符串，输出最长特殊序列的长度。如果不存在，则返回 -1。
# 示例 :
# 输入: "aba", "cdc"
# 输出: 3
# 解析: 最长特殊序列可为 "aba" (或 "cdc")
#me
class Solution0(object):
def findLUSlength(self, a, b):
na = a if len(a)>len(b) else b
nb = b if len(b)<len(a) else a
result = []
for i in range(len(na)-1):
for j in range(1,len(na)+1):
sub = na[i:j]
print(sub)
if sub not in nb:
result.append(len(sub))
if result != []:
return max(result)
else:
return -1
#other
class Solution1(object):
def findLUSlength(self, a, b):
if a == b:
return -1
elif len(a) > len(b):
return len(a)
else:
return len(b)
51.思路：转换思想，求差值
# 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
# 说明：
# 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
# 示例 1:
# 输入: [2,2,1]
# 输出: 1
# 示例 2:
# 输入: [4,1,2,1,2]
# 输出: 4
#other
class Solution1(object):
def singleNumber(self, nums):
return sum(set(nums))*2-sum(nums)
52.思路：用集合来判断糖果的种类个数，因为弟弟和妹妹两个人糖果数一样，所以总个数的一半为界
# 给定一个偶数长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果平均分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。
# 示例 1:
# 输入: candies = [1,1,2,2,3,3]
# 输出: 3
# 解析: 一共有三种种类的糖果，每一种都有两个。
# 最优分配方案：妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。
# 示例 2 :
# 输入: candies = [1,1,2,3]
# 输出: 2
# 解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1]，妹妹有两种不同的糖果，弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。
#me
class Solution(object):
def distributeCandies(self, candies):
return len(set(candies)) if len(set(candies))<=len(candies)//2 else len(candies)//2
*53.思路：通过栈来实现
# 给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
# 在 S 上反复执行重复项删除操作，直到无法继续删除。
# 在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
# 示例：
# 输入："abbaca"
# 输出："ca"
# 解释：
# 例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
#me
#栈的思想
class Solution(object):
def removeDuplicates(self, S):
Stack = []
for s in S:
if Stack == []:
Stack.append(s)
elif s!= Stack[-1]:
Stack.append(s)
else:
Stack.pop()
return ''.join(Stack)
54.思路：直述题意
# 给你两个数组，arr1 和 arr2，
# arr2 中的元素各不相同
# arr2 中的每个元素都出现在 arr1 中
# 对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。
# 示例：
# 输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
# 输出：[2,2,2,1,4,3,3,9,6,7,19]
#me
class Solution(object):
def relativeSortArray(self, arr1, arr2):
orgarr2 = list(arr2)
containList = [i for i in arr1 if i in arr2]
notContainList = sorted([i for i in arr1 if i not in arr2])
for i in containList:
arr2.insert(arr2.index(i),i)
midResult = arr2+notContainList
for i in orgarr2:
midResult.remove(i)
return midResult
#other
class Solution1(object):
def relativeSortArray(self, arr1, arr2):
arr3 = []
set_2 = set(arr2)
for i in arr1[::-1]:
if i not in set_2:
arr1.remove(i)
arr3.append(i)
arr3.sort(reverse = True)
for i in arr2[::-1]:
num = arr1.count(i)
arr3.extend([i for j in range(num)])
return arr3[::-1]
55.思路：直述题意
# 给你一份『词汇表』（字符串数组） words 和一张『字母表』（字符串） chars。
# 假如你可以用 chars 中的『字母』（字符）拼写出 words 中的某个『单词』（字符串），那么我们就认为你掌握了这个单词。
# 注意：每次拼写时，chars 中的每个字母都只能用一次。
# 返回词汇表 words 中你掌握的所有单词的 长度之和。
# 示例 1：
# 输入：words = ["cat","bt","hat","tree"], chars = "atach"
# 输出：6
# 解释：
# 可以形成字符串 "cat" 和 "hat"，所以答案是 3 + 3 = 6。
# 示例 2：
# 输入：words = ["hello","world","leetcode"], chars = "welldonehoneyr"
# 输出：10
# 解释：
# 可以形成字符串 "hello" 和 "world"，所以答案是 5 + 5 = 10。
#me
class Solution(object):
def countCharacters(self, words, chars):
mid = []
for word in words:
flag = True
for sigWord in word:
if word.count(sigWord)>chars.count(sigWord):
flag = False
break
if flag:
mid.append(word)
return len(''.join(mid))
#other
import collections
class Solution1(object):
def countCharacters(self, words, chars):
ans = 0
cnt = collections.Counter(chars)
for w in words:
c = collections.Counter(w)
if all([c[i] <= cnt[i] for i in c]):
ans += len(w)
return ans
56.思路：先排序，再计算相邻两个元素的最小绝对差
# 给你个整数数组 arr，其中每个元素都 不相同。
# 请你找到所有具有最小绝对差的元素对，并且按升序的顺序返回。
# 示例 1：
# 输入：arr = [4,2,1,3]
# 输出：[[1,2],[2,3],[3,4]]
# 示例 2：
# 输入：arr = [1,3,6,10,15]
# 输出：[[1,3]]
# 示例 3：
# 输入：arr = [3,8,-10,23,19,-4,-14,27]
# 输出：[[-14,-10],[19,23],[23,27]]
#me
class Solution(object):
def minimumAbsDifference(self, arr):
abslist = sorted(arr)
midresult = []
lastresult = []
for i in range(1, len(abslist)):
midresult.append(abslist[i]-abslist[i-1])
min_abstract = min(midresult)
for Id, result in enumerate(midresult):
mid = []
if result == min_abstract:
mid.append(abslist[Id])
mid.append(abslist[Id+1])
lastresult.append(mid)
return lastresult
57.思路：直述题意
# 我们要把给定的字符串 S 从左到右写到每一行上，每一行的最大宽度为100个单位，如果我们在写某个字母的时候会使这行超过了100 个单位，那么我们应该把这个字母写到下一行。我们给定了一个数组 widths ，这个数组 widths[0] 代表 'a' 需要的单位， widths[1] 代表 'b' 需要的单位，...， widths[25] 代表 'z' 需要的单位。
# 现在回答两个问题：至少多少行能放下S，以及最后一行使用的宽度是多少个单位？将你的答案作为长度为2的整数列表返回。
# 示例 1:
# 输入:
# widths = [10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
# S = "abcdefghijklmnopqrstuvwxyz"
# 输出: [3, 60]
# 解释:
# 所有的字符拥有相同的占用单位10。所以书写所有的26个字母，
# 我们需要2个整行和占用60个单位的一行。
# 示例 2:
# 输入:
# widths = [4,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10]
# S = "bbbcccdddaaa"
# 输出: [2, 4]
# 解释:
# 除去字母'a'所有的字符都是相同的单位10，并且字符串 "bbbcccdddaa" 将会覆盖 9 * 10 + 2 * 4 = 98 个单位.
# 最后一个字母 'a' 将会被写到第二行，因为第一行只剩下2个单位了。
# 所以，这个答案是2行，第二行有4个单位宽度。
#other
class Solution(object):
def numberOfLines(self, widths, S):
line = 1
result = 0
for i in S:
num = ord(i) - 97
result += widths[num]
if result > 100:
result = 0 + widths[num]
line += 1
if result == 100:
result = 0
line += 1
return [line, result]
58.思路：先变为一维向量，再按照列元素个数取值存放
# 在MATLAB中，有一个非常有用的函数 reshape，它可以将一个矩阵重塑为另一个大小不同的新矩阵，但保留其原始数据。
# 给出一个由二维数组表示的矩阵，以及两个正整数r和c，分别表示想要的重构的矩阵的行数和列数。
# 重构后的矩阵需要将原始矩阵的所有元素以相同的行遍历顺序填充。
# 如果具有给定参数的reshape操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。
# 示例 1:
# 输入:
# nums =
# [[1,2],
# [3,4]]
# r = 1, c = 4
# 输出:
# [[1,2,3,4]]
# 解释:
# 行遍历nums的结果是 [1,2,3,4]。新的矩阵是 1 * 4 矩阵, 用之前的元素值一行一行填充新矩阵。
# 示例 2:
# 输入:
# nums =
# [[1,2],
# [3,4]]
# r = 2, c = 4
# 输出:
# [[1,2],
# [3,4]]
#me
class Solution0(object):
def matrixReshape(self, nums, r, c):
allNum = []
for i in nums:
allNum += i
result = []
if len(allNum)%r==0:
for sub1 in range(r):
j = len(allNum)//r
subNum = allNum[sub1*j:(sub1+1)*j]
result.append(subNum)
return result
else:
return nums
#other
class Solution1(object):
def matrixReshape(self, nums, r, c):
if len(nums) == 0:
return nums
c0 = len(nums[0])
r0 = len(nums)
if r*c != r0*c0:
return nums
result = [[0]*c for _ in range(r)]
for i in range(r):
for j in range(c):
t = i*c+j
result[i][j] = nums[t//c0][t%c0]
return result
59.思路：将当前元素索引以后的元素存放在列表中，然后查找
# 给定两个没有重复元素的数组 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。
#me
class Solution0(object):
def nextGreaterElement(self, nums1, nums2):
result = []
for i in nums1:
sub = []
subList = nums2[nums2.index(i):]
for j in subList:
if j > i:
sub.append(j)
sub1 = [-1] if sub==[] else sub
mid = sub1[0]
result.append(mid)
return result
#other
# 思路
# 遍历nums2，维护一个递减栈
# 当得到一个更大的数的时候，将栈里小于它的数都放到哈希表当中
# 举例来说，如果nums2里是3,2,1,4，那么栈前三位都是3,2,1，当遍历到4的时候，发现4比1大，这时候，哈希表里要添加hashmap[1] = 4,hashmap[2] = 4,hashmap[3] = 4。含义是，对于1这个数字而言，右边第一个比它大的数字是4。后面几个同理。
# 遍历nums1，对每一项查找哈希表，找到第一个比它大的数，并返回一个列表作为答案。如果在哈希表中不存在则返回默认值-1。
class Solution1(object):
def nextGreaterElement(self, nums1, nums2):
stack, hashmap = list(), dict()
for i in nums2:
while len(stack) != 0 and stack[-1] < i:hashmap[stack.pop()] = i
stack.append(i)
return [hashmap.get(i,-1) for i in nums1]
60.思路：用两个栈实现，一个栈负责压入，另一个负责弹出
# 使用栈实现队列的下列操作：
# push(x) -- 将一个元素放入队列的尾部。
# pop() -- 从队列首部移除元素。
# peek() -- 返回队列首部的元素。
# empty() -- 返回队列是否为空。
# 示例:
# MyQuque queue = new MyQueue();
# queue.push(1);
# queue.push(2);
# queue.peek(); // 返回 1
# queue.pop(); // 返回 1
# queue.empty(); // 返回 false
#me
class MyQueue(object):
def __init__(self):
"""
Initialize your data structure here.
"""
self.stack1 = []
self.stack2 = []
def push(self, x):
"""
Push element x to the back of queue.
:type x: int
:rtype: None
"""
self.stack1.append(x)
def pop(self):
"""
Removes the element from in front of queue and returns that element.
:rtype: int
"""
if self.stack2:
return self.stack2.pop()
else:
while self.stack1:
self.stack2.append(self.stack1.pop())
return self.stack2.pop()
def peek(self):
"""
Get the front element.
:rtype: int
"""
if self.stack1:
return self.stack1[0]
else:
return self.stack2[-1]
def empty(self):
"""
Returns whether the queue is empty.
:rtype: bool
"""
if self.stack1 == [] and self.stack2 == []:
return True
else:
return False