思路:python代码直接利用list的insert特性
class FrontMiddleBackQueue:
def __init__(self):
self.queque = []
def pushFront(self, val: int) -> None:
self.queque.insert(0, val)
def pushMiddle(self, val: int) -> None:
self.queque.insert(len(self.queque)//2, val)
def pushBack(self, val: int) -> None:
self.queque.append(val)
def popFront(self) -> int:
if self.queque: return self.queque.pop(0)
return -1
def popMiddle(self) -> int:
if self.queque: return self.queque.pop((len(self.queque)-1)//2)
return -1
def popBack(self) -> int:
if self.queque: return self.queque.pop(-1)
return -1
# Your FrontMiddleBackQueue object will be instantiated and called as such:
# obj = FrontMiddleBackQueue()
# obj.pushFront(val)
# obj.pushMiddle(val)
# obj.pushBack(val)
# param_4 = obj.popFront()
# param_5 = obj.popMiddle()
# param_6 = obj.popBack()
c++实现:利用vector特性
class FrontMiddleBackQueue {
public:
vector<int> queue;
FrontMiddleBackQueue() {
}
void pushFront(int val) {
queue.insert(queue.begin(), val);
}
void pushMiddle(int val) {
int pos = queue.size() / 2;
queue.insert(queue.begin() + pos, val);
}
void pushBack(int val) {
queue.push_back(val);
}
int popFront() {
if(queue.empty()){
return -1;
}
int value = queue[0];
queue.erase(queue.begin());
return value;
}
int popMiddle() {
if(queue.empty()){
return -1;
}
int pos = (queue.size()-1)/2;
int value = queue[pos];
queue.erase(queue.begin() + pos);
return value;
}
int popBack() {
if(queue.empty()){
return -1;
}
int value = queue[queue.size()-1];
// queue.erase(queue.end()-1);
queue.pop_back();
return value;
}
};
/**
* Your FrontMiddleBackQueue object will be instantiated and called as such:
* FrontMiddleBackQueue* obj = new FrontMiddleBackQueue();
* obj->pushFront(val);
* obj->pushMiddle(val);
* obj->pushBack(val);
* int param_4 = obj->popFront();
* int param_5 = obj->popMiddle();
* int param_6 = obj->popBack();
*/
思路:
python代码:
class Solution:
def getNode(self, n, first, second):
nums = 0
while first <= n:
nums += min(n+1, second) - first
first *= 10
second *= 10
return nums
def findKthNumber(self, n: int, k: int) -> int:
cur = 1
k -= 1
while k > 0:
nums = self.getNode(n, cur, cur+1)
if nums <= k: #第k个数不在以cur为根节点的树上
cur += 1 #cur在字典序数组中从左往右移动
k -= nums
else:#在子树中
cur *= 10 #cur在字典序数组中从上往下移动
k -= 1 #刨除根节点
return cur
c++实现:
class Solution {
public:
int getNode(long n, long first, long second){
int nums = 0;
while(first <= n){
nums += min(n+1, second) - first;
first *= 10;
second *= 10;
}
return nums;
}
int findKthNumber(int n, int k) {
long cur = 1;
k -= 1;
while(k > 0){
int nums = getNode(n, cur, cur + 1);
if(nums <= k){
cur += 1;
k -= nums;
}
else{
cur *= 10;
k -= 1;
}
}
return cur;
}
};
3.复原 IP 地址
思路:递归+回溯
分两种情况:如果开头是0 需要单独拿出来, 不是的话 在分 1位, 2位, 3位的 只是需要注意,两位 三位需要有数字范围限定
class Solution:
def backtrace(self, s, track, count):
if len(track) == 4 and count == self.length:
self.res.append('.'.join(track))
return
if len(track) == 4 and count != self.length:
return
if count == self.length:
return
n = len(s)
for i in range(n):
if s[i] == '0': #0要单独拿出来
self.backtrace(s[i+1:], track + ['0'], count + 1)
else:
self.backtrace(s[i+1:], track + [s[i]], count + 1)#一位数的
if i < n-1 and 10 <= int(s[i:i+2])<=99:
self.backtrace(s[i+2:], track + [s[i:i+2]], count + 2)#两位数的
if i < n-2 and 100 <= int(s[i:i+3])<=255:
self.backtrace(s[i+3:], track + [s[i:i+3]], count + 3)#三位数的
def restoreIpAddresses(self, s: str) -> List[str]:
self.res = []
self.length = len(s)
if self.length > 12:
return []
self.backtrace(s, [], 0)
return self.res
c++实现:
class Solution {
public:
vector<string> res;
void backtrace(string s, vector<string>& track, int count, int length){
if(track.size() == 4 && count == length){
string temp = "";
for(int i = 0; i < 4; i++){
temp += track[i];
if(i != 3){
temp += ".";
}
}
res.push_back(temp);
return;
}
if(track.size() == 4 && count != length){
return;
}
if(count == length){
return;
}
int n = s.size();
for(int i = 0; i < n; i++){
if(s[i] == '0'){
track.push_back("0");
backtrace(s.substr(i + 1, n - 1), track, count + 1, length);
track.pop_back();
}
else{
string temp_;
temp_ = s[i];
track.push_back(temp_);
backtrace(s.substr(i + 1, n - 1), track, count + 1, length);
track.pop_back();
if(i < n-1 && 10 <= atoi(s.substr(i, 2).c_str()) && atoi(s.substr(i, 2).c_str()) <= 99){
track.push_back(s.substr(i, 2));
backtrace(s.substr(i + 2, n - 2), track, count + 2, length);
track.pop_back();
}
if(i < n-2 && 100 <= atoi(s.substr(i, 3).c_str()) && atoi(s.substr(i, 3).c_str()) <= 255){
track.push_back(s.substr(i, 3));
backtrace(s.substr(i + 3, n - 3), track, count + 3, length);
track.pop_back();
}
}
}
}
vector<string> restoreIpAddresses(string s) {
int length = s.size();
if(length > 12){
return {};
}
vector<string> track;
backtrace(s, track, 0, length);
return res;
}
};
思路1.暴力破解
"""
给一个字符串,找出最长的没有重复字符的子字符串,并返回该字符串的长度
"""
# class solution:
def lengthOfLongestSubstring(s):
max_len=0
if(len(s)==1 or len(s)==0):
max_len=len(s)
#第一层循环从最左侧到右侧第二个,第二层循环从第一层紧跟的一个到最后一个,找出所有不重复的子字符串,比较长度得出最长。
for i in range(0,len(s)-1):
for j in range(i+1,len(s)):
if s[j] in s[i:j]:
if j-i>max_len:
right=j
left=i
max_len=right-left
array=s[i:j]
break
elif j==len(s)-1:
if max_len<j-i+1:
max_len=j-i+1
array = s[:(j+1)]
return max_len,array
# # sol=solution()
result,array=lengthOfLongestSubstring('abcabcbbb')
print(result,array)
思路2.滑动窗口
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
dict_={}
res = 0
left,right=0,0
while right<len(s):
dict_[s[right]]=dict_.get(s[right],0)+1
while dict_[s[right]]>1:
dict_[s[left]]-=1
left+=1
res = max(res, right-left+1)
right+=1
return res
思路3.利用字典,用key存储字符 value存储其相应的index
#hash 用key存储字符 value存储其相应的index
class Solution:
def lengthOfLongestSubstring(self, s):
dict_={}
max_length = 0
start = 0
for index,char in enumerate(s):
if char in dict_ and start<=dict_[char]:
start = dict_[char]+1
else:
max_length = max(max_length, index - start +1)
dict_[char] = index
print('==dict_:',dict_)
return max_length
s = 'abcdafg'
sol = Solution()
res = sol.lengthOfLongestSubstring(s)
print('res:', res)
5,给出两个有序的数字列表,长度分别为m,n。找到这两个列表中的中间值。
"""
给出两个有序的数字列表,长度分别为m,n。找到这两个列表中的中间值。
"""
class solution:
def findMedianSortedArrays(self,nums1,nums2):
nums3=[0]*(len(nums1)+len(nums2))
l_i,r_i,i=0,0,0
#两个列表进行比较,将较小值放入新的列表
while(l_i<len(nums1)) and (r_i<len(nums2)):
if nums1[l_i]<nums2[r_i]:
nums3[i]=nums1[l_i]
l_i+=1
else:
nums3[i]=nums2[r_i]
r_i+=1
i+=1
#将未遍历完的列表加入新的列表
if l_i!=len(nums1):
nums3[i:]=nums1[l_i:]
else:
nums3[i:]=nums2[r_i:]
len_3=len(nums3)
if len_3%2!=0:
return float(nums3[(len_3-1)//2])
return (nums3[len_3//2-1]+nums3[len_3//2])/2
sol=solution()
num1=[1,3,5]
num2=[2,4]
result=sol.findMedianSortedArrays(num1,num2)
print(result)
6.将字符串 "PAYPALISHIRING"
以Z字形排列成给定的行数:
P A H N
A P L S I I G
Y I R
之后从左往右,逐行读取字符:"PAHNAPLSIIGYIR"
暴力解法:
class Solution:
def convert(self,s,numRows):
n=numRows
res_list=[]
l=len(s)
if n==1:
return s
for i in range(n):
for j in range(l):
if j%(2*n-2)==i or j%(2*n-2)==2*n-2-i:
res_list.append(s[j])
res=''.join(res_list)
return res
sol=Solution()
res=sol.convert('abcdefg',3)
print(res)
更好的解法,不需要遍历整个字符串长度
class Solution:
def convert(self, s, numRows):
str_length=len(s)
node_length=2*numRows-2
result=''
if str_length==0 or numRows==0 or numRows==1:
return s
#从第一行遍历到最后一行
for i in range(numRows):
#大的改进
for j in range(i,str_length,node_length):
#第一行和最后一行和普通行的整列数据
result+=s[j]
#得到斜着部分 j-2*i+node_length
if i!=0 and i!=numRows-1 and j-2*i+node_length<str_length:
result+=s[j-2*i+node_length]
return result
sol=Solution()
res=sol.convert('abcdefg',3)
print(res)
思路:和减去nums中的数,就是缺失的啦
class Solution:
def missingNumber(self, nums: List[int]) -> int:
n = len(nums)
sum_ = n*(n+1)//2
for num in nums:
sum_ -= num
return sum_
c++实现:
class Solution {
public:
int missingNumber(vector<int>& nums) {
int n = nums.size();
int sum_ = n*(n+1)/2;
for(auto num: nums){
sum_ -= num;
}
return sum_;
}
};
8.整数反转
class Solution:
def reverse(self, x):
"""
:type x: int
:rtype: int
"""
sign = [-1, 1][x > 0]
res=sign*int(str(abs(x))[::-1])
return res if -(2**31)<=res<=2**31-1 else 0
sol=Solution()
res=sol.reverse(-123)
print(res)
c++实现:
class Solution {
public:
int reverse(int x) {
//栈
int res = 0;
while(x != 0){
int temp = x % 10;
x /=10;
if(res > INT_MAX/10 || (res == INT_MAX/10 && temp > 7)) return 0;
if(res < INT_MIN/10 || (res == INT_MIN/10 && temp < -8)) return 0;
res = res * 10 + temp;
}
return res;
}
};
'
思路:删除首尾空格
判断删除空格后的第一个字符是否是+或者-
如果是+或者- 下一个字符必须是数字 否则返回0,是的话就一直合并到字母
如果是数字就一直合并到出现字母停止
# 删除首尾空格
# 判断删除空格后的第一个字符是否是+或者-
# 如果是+或者- 下一个字符必须是数字 否则返回0,是的话就一直合并到字母
# 如果是数字就一直合并到出现字母停止
class Solution:
def strToInt(self, str):
new_str = str.strip()
if len(new_str) == 0:
return 0
sign, start = 1, 0
if new_str[0] == "-":
sign = -1
start = 1
if new_str[0] == "+":
sign = 1
start = 1
res = 0
for c in new_str[start:]:
if "0" <= c <= "9":
res = 10 * res + int(c)
else:
break
res = sign * res
if res > 2 ** 31 - 1:
return 2 ** 31 - 1
elif res < -2 ** 31:
return -2 ** 31
else:
return res
str = "4193 with words"
sol = Solution()
res = sol.strToInt(str)
print(res)
10.外观数列
思路:核心是双指针做聚类,只不过需要聚类的字符串需要更新,外面需要套一个for循环
python代码:
class Solution:
def countAndSay(self, n: int) -> str:
#双指针外面 套一个循环n就行
pre = ""
res = "1"
for k in range(1, n):
pre = res
res = ""
left, right = 0, 0
while right < len(pre):
while right < len(pre) and pre[left] == pre[right]:
right += 1
res += str(right - left) + pre[left]
left = right
return res
c++代码:
class Solution {
public:
string countAndSay(int n) {
string res = "1";
string s = "";
for(int k = 1; k < n; k++){
s = res;
res = "";
int left = 0, right = 0;
while(right < s.size()){
while(right < s.size() && s[left] == s[right]){
right++;
}
res += to_string(right - left) + s[left];
left = right;
}
}
return res;
}
};
11.只出现一次的数字 III
思路1:hash
class Solution:
def singleNumber(self, nums: List[int]) -> List[int]:
dict_ = {}
for num in nums:
if num not in dict_:
dict_[num] = 1
else:
dict_[num] -= 1
res = []
for key in dict_:
if dict_[key] != 0:
res.append(key)
return res
c++:
class Solution {
public:
vector<int> singleNumber(vector<int>& nums) {
map<int, int> dict_;
for(auto num: nums){
if(dict_.count(num) == 0){
dict_[num] += 1;
}
else{
dict_[num] -= 1;
}
}
vector<int> res;
map<int, int> ::iterator it;
for(it = dict_.begin(); it != dict_.end(); it++){
if(it->second != 0){
res.push_back(it->first);
}
}
return res;
}
};
思路2:因为有两个不同的数,如果能将两个不同的数分组开,那么异或一下自然就出来了。
class Solution {
public:
vector<int> singleNumber(vector<int>& nums) {
//div保持的是两位要找的数的异或 ^
long div = 0;
int a = 0, b = 0;
for(int num : nums)
div ^= num;
//取最低位的1,这个1表示的是在这个bit,a与b一个为0一个为1
div &= -div;
for(int num : nums)
{
if(div & num)
a ^= num;
else{
b ^= num;
}
}
return {a,b};
}
};
思路:贪心算法
class Solution:
def intToRoman(self, num: int) -> str:
# 使用哈希表,按照从大到小顺序排列
dict_ = {1000:'M', 900:'CM', 500:'D', 400:'CD', 100:'C', 90:'XC', 50:'L', 40:'XL', 10:'X', 9:'IX', 5:'V', 4:'IV', 1:'I'}
res = ""
for key in dict_:
count = num // key
if count != 0:
res += count*dict_[key]
num %= key
return res;
c++实现:
class Solution {
public:
string intToRoman(int num) {
int value[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
string str_[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
string res;
for(int i = 0; i < 13; i++){
while(num >= value[i]){
num -= value[i];
res += str_[i];
}
}
return res;
}
};
13.罗马数字转整数
思路:贪心算法
class Solution:
def romanToInt(self, s: str) -> int:
dict_ = {'M':1000,"CM":900,'D':500, "CD":400, 'C':100, "XC":90, 'L':50,
"XL":40, 'X':10, "IX":9, 'V':5, "IV":4,'I':1}
n = len(s)
res = 0
i= 0
while i < n:
if i < n-1 and s[i:i+2] in dict_:
res += dict_[s[i:i+2]]
i += 2
else:
res += dict_[s[i]]
i += 1
return res
c++实现:
class Solution {
public:
int romanToInt(string s) {
int value[] = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
string str_[] = {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
map<string, int> dict_;
int length = sizeof(value)/sizeof(value[0]);
for(int i = 0; i < length; i++){
dict_[str_[i]] = value[i];
}
int res = 0;
int i = 0;
int n = s.size();
while(i < n){
if (i < n-1 && dict_.count(s.substr(i, 2))){
res += dict_[s.substr(i, 2)];
i += 2;
}
else{
res += dict_[s.substr(i, 1)];
i++;
}
}
return res;
}
};
找最短字符串即可
class Solution:
def longestCommonPrefix(self, strs: List[str]) -> str:
min_length = min([len(str_) for str_ in strs]) #最短字符串
for i in range(min_length):
for j in range(1, len(strs)):
if strs[0][i] != strs[j][i]:
return strs[0][:i]
return strs[0][:min_length]
c++实现:
class Solution {
public:
string longestCommonPrefix(vector<string>& strs) {
int min_lenth = INT_MAX;
int n = strs.size();
for(int i = 0; i < n; i++){
int temp_ = strs[i].size();
if(temp_ < min_lenth){
min_lenth = temp_;
}
}
for(int i = 0; i < min_lenth; i++){
for (int j = 1; j < n; j++){
if(strs[0][i] != strs[j][i]){
return strs[0].substr(0, i);
}
}
}
return strs[0].substr(0, min_lenth);
}
};
14.三数之和
思路1: 固定两数,寻找第三个数,两层循环,最复杂解法,列表比较大时,时间会很长
class Solution:
def threeSum(self, nums):
"""
:type nums: List[int]
:rtype: List[List[int]]
"""
result=[]
nums.sort()
length=len(nums)
for i in range(length-1):
for j in range(i+1,length):
if -(nums[i]+nums[j]) in nums[j+1:]:
tmp=[nums[i],nums[j],-(nums[i]+nums[j])]
if tmp not in result:
result.append(tmp)
return result
思路2: 双指针,固定一个数,让其余两个数从第一个数+1和尾 向中间靠近,只需要循环一遍
# 双指针:排好序以后,双指针去寻找两数之和等于第一个
class Solution:
def threeSum(self, nums):
nums = sorted(nums)
res = []
n = len(nums)
print('==nums:', nums)
for i in range(n):
if i>0 and nums[i]==nums[i-1]:#去除相同的第一个数[-1, 0, 1, 2, -1, -4]
continue
start = i + 1
end = n - 1
# print('==start:', start)
# print('==end:', end)
while start < end:
if nums[i] + nums[start] + nums[end] == 0:
res.append([nums[i], nums[start], nums[end]])
start += 1
end -= 1
while start<end and nums[start]==nums[start-1]:# 首部出现连续两个数[-2, 0, 0, 2, 2]
start+=1
while start<end and nums[end]==nums[end+1]:# 尾部出现连续两个数[-2, 0, 0, 2, 2]
end-=1
elif (nums[i] + nums[start] + nums[end]) > 0:
end -= 1
else:
start += 1
print('==res:', res)
return res
# nums = [-1, 0, 1, 2, -1, -4]
nums = [-2, 0, 0, 2, 2]
sol = Solution()
sol.threeSum(nums)
十五:最接近的三数之和
固定一个数,让其余两个数从首,尾 向中间靠近,只需要循环一遍
class Solution:
def threeSumClosest(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: int
"""
nums.sort()
length=len(nums)
res=[]
for i,num in enumerate(nums[0:-2]):
l,r=i+1,length-1
if num+nums[r]+nums[r-1]<target:#从右边遍历
res.append(num+nums[r]+nums[r-1])
elif num+nums[l]+nums[l+1]>target:#从左边遍历
res.append(num + nums[l] + nums[l+1])
else:
while l<r:#左边索引小于右边时,遍历
res.append(num + nums[l] + nums[r])
if num+nums[l]+nums[r]<target:
l+=1
elif num+nums[l]+nums[r]>target:
r-=1
else:
return target
res.sort(key=lambda x:abs(x-target))
return res[0]
nums = [-1,2,1,-4]
target = 1.
sol=Solution()
result=sol.threeSumClosest(nums,target)
print(result)
16.给定一个仅包含数字 2-9
的字符串,返回所有它能表示的字母组合。
给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。
力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台
输入:"23"
输出:["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
class Solution:
def letterCombinations(self, digits):
"""
:type digits: str
:rtype: List[str]
"""
if not digits: return []
#建立字典
table={'2':['a','b','c'],
'3':['d','e','f'],
'4':['g','h','i'],
'5':['j','k','l'],
'6':['m','n','o'],
'7':['p','q','r','s'],
'8':['t','u','v'],
'9':['w','x','y','z']}
result=['']
for digit in digits:
str_list=[]
for char_single in table[digit]:
str_list+=[x+char_single for x in result]
print(str_list)
#result存储前一个数对应的字母
result=str_list
return result
17.Pow(x, n)
思路:一层一层递归 超时
class Solution:
def myPow(self, x: float, n: int) -> float:
if n == 0:
return 1
if n == 1:
return x
if n > 0:
return x*self.myPow(x, n-1)
else:
return 1/(x*self.myPow(x, abs(n)-1))
思路:快速幂
class Solution:
def help(self, x, n):
if n == 0:
return 1
temp = self.myPow(x, n//2)
if n % 2 == 0:
return temp*temp
else:
return x*(temp*temp)
def myPow(self, x: float, n: int) -> float:
if n > 0:
return self.help(x, n)
else:
return 1 / self.help(x, -n)
c++实现:
class Solution {
public:
double help(double x, long long n){
if(n == 0){
return 1.;
}
double temp = help(x, n / 2);
if (n % 2){
return x*(temp*temp);
}
else{
return temp*temp;
}
}
double myPow(double x, int n) {
long long N = n;
if(n > 0){
return help(x, N);
}
else{
return 1. / help(x, -N);
}
}
};
18:螺旋矩阵
思路:循环打印
class Solution:
def help(self, x1, x2, y1, y2, matrix):
for i in range(x1, x2 + 1):
self.res.append(matrix[y1][i]) #1, 2, 3
for i in range(y1 + 1, y2 + 1):
self.res.append(matrix[i][x2]) #6, 9
if x1 < x2 and y1 < y2:
for i in range(x2 - 1, x1, -1):
self.res.append(matrix[y2][i]) #8
for i in range(y2, y1, -1):
self.res.append(matrix[i][x1]) #7, 4
def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
self.res = []
x1, y1, x2, y2 = 0, 0, len(matrix[0]) - 1, len(matrix) - 1
while(x1 <= x2 and y1 <= y2):
self.help(x1, x2, y1, y2, matrix)
x1 += 1
y1 += 1
x2 -= 1
y2 -= 1
return self.res
c++实现:
class Solution {
public:
vector<int> res;
void help(int x1, int y1, int x2, int y2, vector<vector<int>>& matrix){
for(int i = x1; i < x2 + 1; i++){
res.push_back(matrix[y1][i]); //1, 2, 3
}
for(int i = y1 + 1; i < y2 + 1; i++){
res.push_back(matrix[i][x2]); //6, 9
}
if(x2 > x1 && y2 > y1){
for(int i = x2 - 1; i > x1 ; i--){
res.push_back(matrix[y2][i]); //8
}
for(int i = y2; i > y1 ; i--){
res.push_back(matrix[i][x1]); //7,4
}
}
}
vector<int> spiralOrder(vector<vector<int>>& matrix) {
int x1 = 0, y1 = 0, x2 = matrix[0].size() - 1, y2 = matrix.size() - 1;
while(x1 <= x2 && y1 <= y2){
help(x1, y1, x2, y2, matrix);
x1++;
y1++;
x2--;
y2--;
}
return res;
}
};
20-1.用栈实现队列
思路:就是将先进后出换成先进先出,这样的话在出队列的时候,需要将栈A除去栈底的元素给栈B,在弹出A中元素,在把栈B给A,一直循环保持栈A只有一个元素
python代码:
class MyQueue:
def __init__(self):
"""
Initialize your data structure here.
"""
self.stack_A = []
self.stack_B = []
def push(self, x: int) -> None:
"""
Push element x to the back of queue.
"""
self.stack_A.append(x)
def pop(self) -> int:
"""
Removes the element from in front of queue and returns that element.
"""
while len(self.stack_A)>1:
self.stack_B.append(self.stack_A.pop())
value = self.stack_A.pop()
while len(self.stack_B):
self.stack_A.append(self.stack_B.pop())
return value
def peek(self) -> int:
"""
Get the front element.
"""
if len(self.stack_A):
return self.stack_A[0]
else:
return None
def empty(self) -> bool:
"""
Returns whether the queue is empty.
"""
if len(self.stack_A):
return False
else:
return True
# Your MyQueue object will be instantiated and called as such:
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()
c++:
#include <map>
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>
#include <limits.h>
#include <math.h>
#include <stack>
class MyQueue {
public:
stack<int> stack_A;
stack<int> stack_B;
/** Initialize your data structure here. */
MyQueue() {
}
/** Push element x to the back of queue. */
void push(int x) {
stack_A.push(x);
}
/** Removes the element from in front of queue and returns that element. */
int pop() {
if(stack_B.empty()){
while (!stack_A.empty()){
stack_B.push(stack_A.top());
stack_A.pop();
}
}
int value = stack_B.top();
stack_B.pop();
return value;
}
/** Get the front element. */
int peek() {
int res = pop();
stack_B.push(res);
return res;
}
/** Returns whether the queue is empty. */
bool empty() {
return stack_A.empty() && stack_B.empty();
}
};
int main()
{
MyQueue* obj = new MyQueue();
int x=1;
obj->push(x);
x=2;
obj->push(x);
x=3;
obj->push(x);
int param_2 = obj->pop();
cout<<"param_2:"<<param_2<<endl;
int param_3 = obj->peek();
cout<<param_3<<endl;
bool param_4 = obj->empty();
cout<<param_4<<endl;
delete obj;
obj=NULL;
return 0;
}
20-2.用队列实现栈
思路:就是将先进先出换成先进后出,这样的话在出栈的时候,需要将队列A除去队尾的元素给队列B,在弹出A中元素,在把队列B给A,一直循环保持队列A只有一个元素
python代码:
class MyStack:
def __init__(self):
"""
Initialize your data structure here.
"""
self.quene_A = []
self.quene_B = []
def push(self, x):
"""
Push element x onto stack.
"""
self.quene_A.append(x)
def pop(self):
"""
Removes the element on top of the stack and returns that element.
"""
if len(self.quene_A)==0:
return None
while len(self.quene_A)>1:
self.quene_B.append(self.quene_A.pop(0))
value = self.quene_A.pop()
self.quene_A=self.quene_B
self.quene_B =[]
return value
def top(self):
"""
Get the top element.
"""
if len(self.quene_A) == 0:
return None
return self.quene_A[-1]
def empty(self):
"""
Returns whether the stack is empty.
"""
if len(self.quene_A):
return True
else:
return False
# Your MyStack object will be instantiated and called as such:
obj = MyStack()
obj.push(1)
obj.push(2)
obj.push(3)
param_2 = obj.pop()
print('==param_2:', param_2)
param_3 = obj.top()
print('==param_3:', param_3)
param_4 = obj.empty()
print('=param_4:', param_4)
c++:
#include <map>
#include <vector>
#include <iostream>
#include <string>
#include <algorithm>
#include <limits.h>
#include <math.h>
class MyStack {
public:
queue<int> queue_A;
queue<int> queue_B;
/** Initialize your data structure here. */
MyStack() {
}
/** Push element x onto stack. */
void push(int x) {
queue_A.push(x);
}
/** Removes the element on top of the stack and returns that element. */
int pop() {
int length = queue_A.size();
cout<<length<<endl;
while (length>1)//让A中只有一个元素
{
length--;
queue_B.push(queue_A.front());
queue_A.pop();
}
int res = queue_A.front();//弹出的A就是栈顶元素
queue_A.pop();
queue_A = queue_B;
while (!queue_B.empty())
{
queue_B.pop();
}
return res;
}
/** Get the top element. */
int top() {
return queue_A.back();
}
/** Returns whether the stack is empty. */
bool empty() {
return queue_A.empty();
}
};
int main()
{
MyStack* obj = new MyStack();
int x=1;
obj->push(x);
x=2;
obj->push(x);
x=3;
obj->push(x);
int param_2 = obj->pop();
cout<<"param_2:"<<param_2<<endl;
int param_3 = obj->top();
cout<<param_3<<endl;
bool param_4 = obj->empty();
cout<<param_4<<endl;
delete obj;
obj=NULL;
return 0;
}
时间复杂度O(N)
class Solution:
def maxSubArray(self, nums):
for i in range(1,len(nums)):
nums[i]+=max(nums[i-1],0)
print('==nums:', nums)
return max(nums)
sol =Solution()
# nums =[-1]
nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
res = sol.maxSubArray(nums)
print('res:',res)
二十二,利用链表实现多项式加法
解题思路
存储方式可以采用链表存储和数组存储,为了熟悉链式操作,所以采用链表存储。其中指针定义的格式如下所示
class Node:
def __init__(self, coef, exp):
self.coef = coef
self.exp = exp
self.next = None
def get_data(self):
return [self.coef, self.exp]
class List:
def __init__(self, head):
self.head = head
# 添加节点
def addNode(self, node):
temp = self.head
while temp.next is not None:
temp = temp.next
temp.next = node
# 打印
def printLink(self, head):
res = []
while head is not None:
res.append(head.get_data())
head = head.next
return res
def adds(l1, l2): # l1,l2为链表,且不为空
p1 = l1.head
p2 = l2.head
addRes = []
while (p1 is not None) and (p2 is not None):
tmp1_exp = p1.get_data()[1]
tmp2_exp = p2.get_data()[1]
# 当指数相同时,系数相加
if tmp1_exp == tmp2_exp:
addRes.append([p1.get_data()[0] + p2.get_data()[0], p1.get_data()[1]])
p1 = p1.next
p2 = p2.next
if tmp1_exp > tmp2_exp:
addRes.append([p1.get_data()[0], p1.get_data()[1]])
p1 = p1.next
if tmp1_exp < tmp2_exp:
addRes.append([p2.get_data()[0], p2.get_data()[1]])
p2 = p2.next
while p1 is not None:
addRes.append([p1.get_data()[0], p1.get_data()[1]])
p1 = p1.next
while p2 is not None:
addRes.append([p2.get_data()[0], p2.get_data()[1]])
p2 = p2.next
res1 = []
for item in addRes:
if item[0] != 0:
res1.append(item[0])
res1.append(item[1])
if len(res1) == 0:
return [0, 0]
return res1
def muls(l1, l2):
p1 = l1.head
p2 = l2.head
mulRes = []
while p1 is not None:
tmp1 = p1.get_data()
while p2 is not None:
tmp2 = p2.get_data()
mulRes.append([tmp1[0] * tmp2[0], tmp1[1] + tmp2[1]])
p2 = p2.next
p2 = l2.head
p1 = p1.next
exps = []
for item in mulRes:
if item[1] not in exps:
exps.append(item[1])
d = {}
for item in mulRes:
if item[1] not in d.keys():
d[item[1]] = 0
d[item[1]] += item[0]
d = sorted(d.items(), key=lambda x: x[0], reverse=True)
res2 = []
for item in d:
# 如果多项式中出现抵消,即系数为0需要删除
if item[1] != 0:
res2.append(item[1])
res2.append(item[0])
# 如果最后出现空数组需要输出0 0
if len(res2) == 0:
return [0, 0]
return res2
def print_list(x):
for i in x[:-1]:
print(i, end=' ')
print(x[-1], end='')
# 输入
# a1 = list(map(int, input().split()))
# a2 = list(map(int, input().split()))
a1=[4,3,4,-5,2,6,1,-2,0]
a2=[3,5,20,-7,4,3,1]
# 变为链表
if a1[0] != 0:
head1 = Node(a1[1], a1[2])
l1 = List(head1)
if a1[0] > 1:
for i in range(a1[0] - 1):
node = Node(a1[i * 2 + 3], a1[i * 2 + 4])
l1.addNode(node)
if a2[0] != 0:
head2 = Node(a2[1], a2[2])
l2 = List(head2)
if a2[0] > 1:
for i in range(a2[0] - 1):
node = Node(a2[i * 2 + 3], a2[i * 2 + 4])
l2.addNode(node)
# 考虑链表长度进行运算
if len(a1) == 1 and len(a2) == 1: # 都为0,则输出都为0
print_list([0, 0])
print()
print_list([0, 0])
elif len(a1) == 1 and len(a2) > 1: # 一个为0,另一个为多项式
print_list([0, 0])
print()
print_list(a2[1:])
elif len(a2) == 1 and len(a1) > 1:
print_list([0, 0])
print()
print_list(a1[1:])
else: # 都为多项式
# print_list(muls(l1, l2))
# print()
print_list(adds(l1, l2))
23-1.滑动窗口中位数
#滑动窗口 双指针
class Solution:
def medianSlidingWindow(self, nums, k):
left, right = 0, 0
length = len(nums)
res = []
while right + k <= length:
part_num = sorted(nums[left:right + k])
print('==part_num:', part_num)
if k % 2 == 1: # 奇数
res.append(part_num[k // 2])
else:
res.append((part_num[k // 2] + part_num[k // 2 - 1]) / 2)
left += 1
right += 1
print(res)
return res
nums = [1, 3, -1, -3, 5, 3, 6, 7]
k = 3
sol = Solution()
sol.medianSlidingWindow(nums, k)
24:一只青蛙一次可以跳上1级台阶,也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。
答案需要取模 1e9+7(1000000007),如计算初始结果为:1000000008,请返回 1。
1.
class Solution(object):
def numWays(self, n):
"""
:type n: int
:rtype: int
"""
if n==0:
return 1
if 1<=n<3:
return n
dp = [0]*(n+1)
dp[1],dp[2] = 1,2
for i in range(3, n+1):
dp[i] = dp[i-1]+dp[i-2]
return dp[-1]%(1000000007)
2.
class Solution(object):
def climbStairs(self, n):
"""
:type n: int
:rtype: int
"""
i=1
j=2
for _ in range(3,n):
i,j=j,i+j
return i+j if n>2 else n
class Solution:
def minCostClimbingStairs(self, cost):
dp = [0]*len(cost)
dp[0],dp[1] =cost[0],cost[1]
for i in range(2,len(cost)):
dp[i] = min(dp[i-1],dp[i-2])+cost[i]
print(dp)
return min(dp[-1],dp[-2])
sol =Solution()
cost = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1]
sol.minCostClimbingStairs(cost)
c++:
class Solution {
public:
int minCostClimbingStairs(vector<int>& cost) {
int n = cost.size();
vector<int> dp(n, 0);
dp[0] = cost[0];
dp[1] = cost[1];
for(int i=2; i<n; i++){
dp[i] = min(dp[i-1], dp[i-2]) + cost[i];
}
return min(dp[n-1], dp[n-2]);
}
};
二十五:#一个四位数,如1024,1004,打印出他们的中文形式,如果一千零二十四,一千零四
a=9002
number_key={'0':'零','1':'一','2':'二','3':'三','4':'四',
'5':'五','6':'六','7':'七','8':'八','9':'九'}
c=''
if a%1000:
for i,_ in enumerate(str(a)):
while(i==0):
c+=number_key[str(a)[i]]+'千'
break
while(i==1):
if str(a)[i]=='0' and str(a)[i]==str(a)[i+1]:
c+=number_key[str(a)[i]]
break
if str(a)[i]=='0' and str(a)[i]!=str(a)[i+1]:
c+=number_key[str(a)[i]]+number_key[str(a)[i+1]]+'十'
break
if str(a)[i] !='0' and str(a)[i+1]=='0':
c+=number_key[str(a)[i]]+'百'
break
else:
c+=number_key[str(a)[i]]+'百'+number_key[str(a)[i+1]]+'十'
break
while(i==3):
if str(a)[i]=='0':
break
else:
c += number_key[str(a)[i]]
break
else:
c+=number_key[str(a)[0]]+'千'
print(c)
二十六:#找一串最长字符串 不含数字
#找一串最长字符串 不含数字
str1 = "abc123abcd234abcdefgha324adsdawqdasdaseqqwe345abchded"
#第一种解法
#空间换时间做法 O(n)
all_count=[]
count=''
flag=0
for i in str1:
if i.isdigit():
flag=1
if len(count):
all_count.append(count)
count=''
else:
flag=0
count+=i
print(all_count)
num=[len(i) for i in all_count]
print(all_count[num.index(max(num))])
二十七:# 给定一行字符串,求出这行字符串中出现频率最高的字符,字符串中含有标点符号, # 字符不区分大小写。如果出现频率相同时,输出先出现在字符串中的字符。
s='AbAdefg ahigkl Mnopq rstu o v wBBBBBB!'
a={s[0]:1}
for i in s[1:]:
if i !=' ':
if i in a:
a[i]+=1
else:
a[i]=1
print(a)
print(a.items())
#a.items() 将dict变成list
b=sorted(a.items(),key=lambda x:x[1])
print(b)
print(b[-1][0])
print(b[-1][1])
二十八:#给出一个字符串,然后计算字符串中数字的和,
s=input()
# s='ssddd-12jijij-12hi-12'
a=''
for i in s:
if i.isdigit() or i=='-':
a+=i
else:
a+='+'
print(a)
if '-' in a:
print(eval(a))
else:
print(int(a))
eval知识补充:
x = 7
print(eval( '3 * x' ))
print(eval('2 +++- 2'))
二十九:#有一对奶牛,从出生后的第四年开始生小牛,每次生一对小牛, # 问现在有m对小牛,在第n年后有多少奶牛?
def cal(n):
if n==None:
return None
if n<=3:
return 1
else:
return cal(n-3)+cal(n-1) #上一年的牛 + 今年出生的牛
n=4
m=2
print(cal(n))
三十:渔夫捕鱼
# A、B、C、D、E五人在某天夜里合伙捕鱼 最后疲惫不堪各自睡觉
# 第二天A第一个醒来 他将鱼分为5份 扔掉多余的1条 拿走自己的一份
# B第二个醒来 也将鱼分为5份 扔掉多余的1条 拿走自己的一份
# 然后C、D、E依次醒来也按同样的方式分鱼 问他们至少捕了多少条鱼
total=6
while True:
enough=True
single_fish=total
for person in range(5):
if (single_fish -1) % 5==0:
print('before single_fish=', single_fish)
single_fish=(single_fish-1)//5*4
print('after single_fish=', single_fish)
else:
enough=False
break
if enough:
print('total=', total)
break
total+=5
class Solution:
def removeDuplicates(self, nums):
# temp=0
# n = len(nums)
# for i in range(1,n):
# if nums[i]==nums[i-1]:
# temp+=1
# return n-temp
j = 0
for i in range(1, len(nums)):
if nums[i] != nums[j]:
j += 1
nums[j] = nums[i]
print(nums)
return j + 1
nums = [1, 1, 2]
sol = Solution()
res = sol.removeDuplicates(nums)
print('==res:', res)
三十三.给定一个排序数组,你需要在原地删除重复出现的元素,使得每个元素最多出现两次,返回移除后数组的新长度。给定 nums = [1,1,1,2,2,3],函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2,3 。
nums = [1,1,1,2,2,3,3,3,4]
class Solution(object):
def removeDuplicates(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
if len(nums)<=2:
return len(nums)
k=2
for i in range(k,len(nums)):
if nums[i]!=nums[k-1] or nums[i]!=nums[k-2]:
nums[k]=nums[i]
k+=1
return k
sol=Solution()
k=sol.removeDuplicates(nums)
print(k)
print(nums[:k])
三十四:给定一个按照升序排列的整数数组 nums
,和一个目标值 target
。找出给定目标值在数组中的开始位置和结束位置。
nums = [5,7,7,8,8,10]
target = 8
def solution(nums,target):
a=[]
#O(N)时间复杂度
for i in range(len(nums)):
if target==nums[i]:
a.append(i)
if len(a)==0:
a=[-1,-1]
return a
res=solution(nums,target)
print('res=',res)
#O(log(N))时间复杂度 双指针查找
def solution(nums,target):
low=0
high=len(nums)-1
while(low<=high):
if target==nums[low] and target==nums[high]:
return [low,high]
elif target!=nums[low]:
low+=1
elif target!=nums[high]:
high-=1
return [-1,-1]
res=solution(nums,target)
print('res=',res)
三十五:给定一个排序数组和一个目标值,在数组中找到目标值,并返回其索引。如果目标值不存在于数组中,返回它将会被按顺序插入的位置。你可以假设数组中无重复元素。
示例 1:
输入: [1,3,5,6], 5
输出: 2
#时间复杂度O(log(N))
nums=[3,4,5,6,7]
target=9
def searchInsert(nums, target):
low=0
high=len(nums)
while(low<high):
mid = low + (high - low) // 2
# print('mid:',mid)
if nums[mid]>target or nums[mid]==target:
high=mid
else:
low=mid+1
return low
res=searchInsert(nums,target)
print('res:',res)
#O(N)时间复杂度
nums=[3,4,5,6,7]
target=1
def searchInsert(nums, target):
for i in range(len(nums)):
if nums[i]>target:
return i
if nums[i]==target:
return i
return len(nums)
res=searchInsert(nums,target)
print('res:',res)
三十六.给定一个无重复元素的数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字
candidates = [2,3,6,7]
target = 7
所求解集为:
[
[7],
[2,2,3]
]
# #给定一个无重复元素的数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合
candidates = [2,4,6]
target = 7
def combinationSum(candidates, target):
results=[]
for i,num in enumerate(candidates):
if target==num:
results.append([num])
elif num<target:
print('num:',num)
result_son=combinationSum(candidates[i:],target-num)
print('result_son:',result_son)
for result in result_son:
result.append(num)
results.append(result)
return results
res=combinationSum(candidates,target)
print('res:',res)
三十七.给定一个数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。candidates 中的每个数字在每个组合中只能使用一次。
candidates = [8,10]
target = 8
class Solution:
def combinationSum2(self, candidates, target):
candidates.sort()
print('candidates:',candidates)
res=[]
self.addsort(candidates,target,res,[])
return res
def addsort(self,candidates,target,res,cur):
for i in range(len(candidates)):
if target==candidates[i]:
if cur+[candidates[i]] not in res:
res.append(cur+[candidates[i]])
print('res:',res)
elif candidates[i]>target:
return
else:
self.addsort(candidates[i+1:],target-candidates[i],res,cur+[candidates[i]])
solv=Solution()
res=solv.combinationSum2(candidates,target)
print('res:',res)
三十八.合并矩形框算法
class Solution:
def merge(self, intervals,threshold):
# intervals.sort(key=lambda x: x[0])
# print(intervals)
merged = []
for interval in intervals:
# print('interval:',interval)
#x2减去下一个框的x1
if not merged or abs(merged[-1][2]-interval[0]) <threshold :
if len(merged):
merged[-1][-2:] = interval[-2:]
else:
merged.append(interval)
else:
merged.append(interval)
print('merged:',merged)
return merged
# a=[[1,3],[2,6],[12,10],[15,18]]
import numpy as np
import cv2
points=np.array([[0,0,20,20],
[30,0,20,50],
[90,0,70,20],
[220,0,200,200],
[240,0,220,200],
[250,230,260,280]])
img=np.zeros((500,500))
#before merge
for point in points:
x1,y1,x2,y2=point
cv2.rectangle(img,(x1,y1),(x2,y2),color=(255,255,255),thickness=1)
cv2.imwrite('img_before.jpg',img)
#after merge
sol=Solution()
res=sol.merge(points,threshold=100)
print(res)
#before merge
# for point in res:
# x1,y1,x2,y2=point
# cv2.rectangle(img,(x1,y1),(x2,y2),color=(255,255,255),thickness=1)
# cv2.imwrite('img_after.jpg',img)
三十九.求众数
class Solution(object):
def majorityElement(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
res={}
for num in nums:
if num not in res:
res[num]=1
else:
res[num]+=1
index=sorted(res,key=lambda i:res[i])
return index[-1]
a=[1,1,1,2,2,3,3,3,3,3]
sol=Solution()
res=sol.majorityElement(a)
print('res:',res)
四十.缺失的第一个正数
class Solution(object):
def firstMissingPositive(self, nums):
"""
:type nums: List[int]
:rtype: int
"""
num=1
for i in range(len(nums)):
if num in nums:
num+=1
return num
a=[1,2,3,-1]
sol=Solution()
res=sol.firstMissingPositive(a)
print('res:',res)
四十二.牛顿法开跟号
class Solution(object):
def mySqrt(self, a):
"""
:type x: int
:rtype: int
"""
x0=a
while x0*x0>a:
x0=(x0*x0+a)/(2*x0)
return int(x0)
sol=Solution()
x=5
res=sol.mySqrt(x)
print('res:',res)
四十三.堆栈实现加减乘除(逆波兰表达式求值)
class Solution(object):
def evalRPN(self, tokens):
"""
:type tokens: List[str]
:rtype: int
"""
stack = []
cal = {"+" : lambda x,y :x+y, "-" : lambda x,y : x-y, "*" : lambda x,y : x*y, "/" : lambda x,y : int(x/y)}
for i in tokens:
print('stack:',stack)
if i not in ["+","-","*","/"]:
stack.append(int(i))
else:
b = stack.pop()
a = stack.pop()
stack.append(cal[i](a,b))
return stack[0]
a=["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
sol=Solution()
res=sol.evalRPN(a)
print('res:',res)
四十五.给定一个字符串,逐个翻转字符串中的每个单词。
输入: " hello world! "
输出: "world! hello"
class Solution(object):
def reverseWords(self, s):
"""
:type s: str
:rtype: str
"""
return " ".join(s.split()[::-1])
class Solution(object):
def intersection(self, nums1, nums2):
"""
:type nums1: List[int]
:type nums2: List[int]
:rtype: List[int]
"""
inter = set(nums1) & set(nums2)
res = []
for i in inter:
res += [i] * min(nums1.count(i), nums2.count(i))
return res
nums1 = [1,2,3,2,1]
nums2 = [2,3,2]
sol=Solution()
res=sol.intersection(nums1,nums2)
print('res:', res)
五十.给定一个包含红色、白色和蓝色,一共 n 个元素的数组,原地对它们进行排序,使得相同颜色的元素相邻,并按照红色、白色、蓝色顺序排列。此题中,我们使用整数 0、 1 和 2 分别表示红色、白色和蓝色
力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台
利用三指针,(p0, p2 和curr)来分别追踪0的最右边界,2的最左边界和当前考虑的元素。
class Solution(object):
def sortColors(self, nums):
"""
:type nums: List[int]
:rtype: None Do not return anything, modify nums in-place instead.
"""
p0=0
curr=0
p2=len(nums)-1
while curr<=p2:
if nums[curr]==0:
nums[p0],nums[curr]=nums[curr],nums[p0]
p0+=1
curr+=1
elif nums[curr]==1:
curr += 1
else:#nums[curr]==2
nums[p2],nums[curr] = nums[curr],nums[p2]
p2 -= 1
print(nums)
return nums
nums=[2,0,2,1,1,0]
sol=Solution()
sol.sortColors(nums)
解法1:双指针
class Solution(object):
def isPalindrome(self, s):
"""
:type s: str
:rtype: bool
"""
i = 0
j = len(s)-1
while i<j:
while i < len(s) and not s[i].isalnum():
i += 1
while j>=0 and not s[j].isalnum():
j-=1
#多个符号时 i跳得太多
if i>j:
return True
if s[i].upper()!=s[j].upper():
return False
else:
i+=1
j-=1
#while外面自然是i>=j
return True
s= ""
sol = Solution()
res = sol.isPalindrome(s)
print('res:',res)
解法2:
class Solution(object):
def isPalindrome(self, s):
"""
:type s: str
:rtype: bool
"""
s = ''.join(list(filter(str.isalnum,s))).lower()
print('s:',s)
return s==s[::-1]
五十二,验证回文串2,字符串只包含从 a-z 的小写字母。字符串的最大长度是50000。
https://leetcode-cn.com/problems/valid-palindrome-ii/
class Solution(object):
def validPalindrome(self, s):
"""
:type s: str
:rtype: bool
"""
if s==s[::-1]:
return True
l=0
r=len(s)-1
while l<r:
if s[l]==s[r]:
l+=1
r-=1
else:
part1=s[l+1:r+1]
part2=s[l:r]
# print('part1',part1)
# print('part2',part2)
return part1 == part1[::-1] or part2 == part2[::-1]
s= "abca"
sol = Solution()
res = sol.validPalindrome(s)
print('res:',res)
五十三.汉诺他问题
如果只有一个A直接给C,当大与1个时,将n-1暂时给B,剩下的最大的给C,然后再将n-1给C.
def hannota(n,A,B,C):
if n==1:
print(A+'->'+C)
else:
hannota(n - 1,A,C,B)
print(A + '->' + C)
hannota(n - 1, B, A, C)
if __name__ == '__main__':
n=2
A='A'
B='B'
C='C'
hannota(n,A,B,C)
五十四.有效的数独 要求:行 ,列和3x3只能出现一个数字一次
https://leetcode-cn.com/problems/valid-sudoku/
class Solution(object):
def isValidSudoku(self, board):
"""
:type board: List[List[str]]
:rtype: bool
"""
# init data
rows = [{} for i in range(9)]
columns = [{} for i in range(9)]
boxes = [{} for i in range(9)]
# print(rows)
# print(rows[2].get(3, 0))
rows[2][3]=rows[2].get(3, 0)
# print(rows)
for i in range(9):
for j in range(9):
num = board[i][j]
if num != '.':
num = int(num)
box_index = (i // 3) * 3 + j // 3
# keep the current cell value
rows[i][num] = rows[i].get(num,0) + 1
columns[j][num] = columns[j].get(num,0)+1
boxes[box_index][num]=boxes[box_index].get(num,0)+1
if rows[i][num]>1 or columns[j][num]>1 or boxes[box_index][num]>1:
return False
return True
board=[
["5","3",".",".","7",".",".",".","."],
["6",".",".","1","9","5",".",".","."],
[".","9","8",".",".",".",".","6","."],
["8",".",".",".","6",".",".",".","3"],
["4",".",".","8",".","3",".",".","1"],
["7",".",".",".","2",".",".",".","6"],
[".","6",".",".",".",".","2","8","."],
[".",".",".","4","1","9",".",".","5"],
[".",".",".",".","8",".",".","7","9"]
]
sol = Solution()
res = sol.isValidSudoku(board)
print('res:')
print(res)
五十五.给定一个整数数组和一个整数 k,判断数组中是否存在两个不同的索引 i 和 j,使得 nums [i] = nums [j],并且 i 和 j 的差的绝对值最大为 k。
力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台
class Solution:
def containsNearbyDuplicate(self, nums, k):
"""
:type nums: List[int]
:type k: int
:rtype: bool
"""
nums_len = len(nums)
if nums_len <= 1:
return False
#key存放列表值,value存放位置索引
nums_dict = {}
for i in range(nums_len):
print(nums_dict)
if nums[i] in nums_dict:
if i-nums_dict[nums[i]] <= k:
return True
nums_dict[nums[i]] = i
return False
nums = [1,2,3,1]
k = 3
sol = Solution()
res = sol.containsNearbyDuplicate(nums,k)
print('res:')
print(res)
思路:双指针 滑动窗口
class Solution:
def minSubArrayLen(self, s, nums):
i = 0
j = 0
ans = float('inf')
while j < len(nums):
# 向右滑动 直到大于s
if sum(nums[i:j + 1]) < s:
# Sum=sum(nums[begin:right])
j += 1
# 找到滑窗之和大于s的地方
else:
# 当前长度若是小于之前的 则更新
if j - i < ans:
ans = j - i + 1
i += 1
return 0 if ans == float('inf') else ans
s = 7
nums = [2,3,1,2,4,3]
sol = Solution()
res = sol.minSubArrayLen(s, nums)
print('==res:', res)
class Solution {
public:
int minSubArrayLen(int target, vector<int>& nums) {
int left=0, right = 0;
int min_len = INT_MAX;
while(right < nums.size()){
target -= nums[right];
right += 1;
while(target <= 0){
min_len = min(min_len, right - left);
target += nums[left];
left +=1;
}
}
// if(min_len == INT_MAX){
// return 0;
// }
// else{
// return min_len;
// }
return min_len == INT_MAX? 0 : min_len;
}
};
五十七.滑动窗口找到长度最长的子数组 <=4 [3,1,2,1] 最长为[1,2,1]
class Solution(object):
def minSubArrayLen(self, s, nums):
"""
:type s: int
:type nums: List[int]
:rtype: int
"""
final_begin=0
final_end=0
begin=0
right=0
ans=0#float('inf')
while right<len(nums):
# print('begin:', begin)
# print('right:', right)
# print(nums[begin:right+1])
#向右滑动 直到大于s
if sum(nums[begin:right+1]) <= s:
# Sum=sum(nums[begin:right])
right+=1
# 当前长度若是大于之前的 则更新
if right-begin>ans:
ans = right-begin +1
final_begin=begin
final_end=right
#找到滑窗之和大于s的地方
else:
begin+=1
print('final_begin:',final_begin)
print('final_end:',final_end)
print(nums[final_begin:final_end+1])
return 0 if ans==float('inf') else ans
s = 4
nums = [3,1,2,1]
# s = 3
# nums = [1,1]
sol=Solution()
res=sol.minSubArrayLen(s,nums)
print('res:',res)
五十九.将矩阵存在0的行列都置零
https://leetcode-cn.com/problems/set-matrix-zeroes
import numpy as np
class Solution(object):
def setZeroes(self, matrix):
"""
:type matrix: List[List[int]]
:rtype: None Do not return anything, modify matrix in-place instead.
"""
print(np.array(matrix))
# matrix=np.array(matrix)
is_col=False
#记录为0的索引,并此处的行头和猎头置为零
for i in range(len(matrix)):
if matrix[i][0]==0:
is_col=True
for j in range(1,len(matrix[0])):
# print(matrix[i][j])
if matrix[i][j]==0:
matrix[0][j] = 0
matrix[i][0] = 0
# break
print(np.array(matrix))
for i in range(1,len(matrix)):
for j in range(1,len(matrix[0])):
if not matrix[i][0] or not matrix[0][j]:
matrix[i][j]=0
print(np.array(matrix))
# 对第一个数存在0将这一列置为0
print(np.array(matrix))
if matrix[0][0] == 0:
for j in range(len(matrix[0])):
matrix[0][j] = 0
#对第一列存在0将整列置零
if is_col:
for i in range(len(matrix)):
matrix[i][0]=0
print(np.array(matrix))
return matrix
# matrix = [[1,1,1],
# [1,0,1],
# [1,1,1]]
# matrix=[[0,1,2,0],
# [3,4,5,2],
# [1,3,1,5]]
matrix=[[1,1,1],
[0,1,2]]
sol=Solution()
res=sol.setZeroes(matrix)
print('res:',res)
六十.给定一个包含 n 个整数的数组 nums 和一个目标值 target,判断 nums 中是否存在四个元素 a,b,c 和 d ,使得 a + b + c + d 的值与 target 相等?找出所有满足条件且不重复的四元组。
力扣(LeetCode)官网 - 全球极客挚爱的技术成长平台
class Solution(object):
def fourSum(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[List[int]]
"""
nums.sort()
# print('nums:',nums)
ans = set()
for i in range(len(nums)-3):#第一层循环到达三个数之前
for j in range(i+1,len(nums)-2):#最后两个数需要固定
left=j+1 #左指针
right=len(nums)-1 #右指针
while(right>left):
temp=nums[i]+nums[j]+nums[left]+nums[right]
if temp==target:
ans.add((nums[i],nums[j],nums[left],nums[right]))
left+=1
right-=1
elif temp>target:
right-=1
else:
left+=1
# print('ans:',ans)
ans = sorted(ans)
res=[]
for i in ans:
res.append(i)
# print('res:',res)
return res
nums = [-3,-2,-1,0,0,1,2,3]
target = 0
sol=Solution()
res=sol.fourSum(nums, target)
print('res:',res)
思路1滑动窗口:
class Solution:
def lengthOfLongestSubstring(self, s):
left, right = 0, 0
dict_ = {}
res = 0
while right < len(s):
dict_[s[right]] = dict_.get(s[right], 0) + 1
while dict_[s[right]] > 1:
dict_[s[left]] -= 1
left += 1
right += 1
res = max(right - left, res)
print('==res:', res)
return res
s = "abcabcbb"
sol = Solution()
sol.lengthOfLongestSubstring(s)
思路2.hash
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
occ = set()
n = len(s)
# 右指针,初始值为 -1,相当于我们在字符串的左边界的左侧,还没有开始移动
start, ans = -1, 0
for i in range(n):
# print('===occ:', occ)
if i != 0:
# 左指针向右移动一格,移除一个字符
occ.remove(s[i - 1])
while start + 1 < n and s[start + 1] not in occ:
# 不断地移动右指针
occ.add(s[start + 1])
start += 1
# 第 i 到 rk 个字符是一个极长的无重复字符子串
ans = max(ans, start - i + 1)
return ans
六十二.串联所有单词的子串
给定一个字符串s和一些长度相同的单词 words。找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。
注意子串要与 words 中的单词完全匹配,中间不能有其他字符,但不需要考虑 words 中单词串联的顺序。
#通过滑动去裁剪主串得到子串,然后子串与需要匹配的字符串数组去统计出现的个数,个数相等即找到
class Solution:
def findSubstring(self, s, words):
from collections import Counter
if not s or not words:
return []
all_len = len(''.join(words))
print('==all_len:', all_len)
n = len(s)
words = Counter(words)
print('==words', words)
res = []
for i in range(0, n-all_len+1):
temp = s[i:i+all_len]
# print(temp)
c_temp=[]
for j in range(0, all_len,all_len//len(words)):
c_temp.append(temp[j:j+all_len//len(words)])
# print(c_temp)
if Counter(c_temp)==words:
res.append(i)
# print('res:', res)
return res
if __name__ == '__main__':
solution = Solution()
# s = "abc"
# words = ["a"]
s = "barfoothefoobarman"
words = ["foo", "bar"]
res = solution.findSubstring(s, words)
print('res:', res)
六十三.给你一个字符串 S、一个字符串 T,请在字符串 S 里面找出:包含 T 所有字母的最小子串。
输入: S = "ADOBECODEBANC", T = "ABC"
输出: "BANC"
双指针法:
from collections import Counter
def minWindow(s, t):
"""
:type s: str
:type t: str
:rtype: str
"""
if not t or not s:
return ""
dict_t = Counter(t)
print('==dict_t:', dict_t)
required = len(dict_t)
l, r = 0, 0
formed = 0
window_counts = {}
# ans tuple of the form (window length, left, right)
ans = float("inf"), None, None
while r < len(s):
character = s[r]
window_counts[character] = window_counts.get(character, 0) + 1
print('==window_counts:', window_counts)
#s = "ABAACBAB"
#t = "ABC"
#相等的话就加1
if character in dict_t and window_counts[character] == dict_t[character]:
formed += 1
#找到满足要求的 进行存储
while l <= r and formed == required:
character = s[l]
print('==character:', character)
# Save the smallest window until now.
if r - l + 1 < ans[0]:
ans = (r - l + 1, l, r)
#
window_counts[character] -= 1
#左指针向右移动 出现不符合的就减一
if character in dict_t and window_counts[character] < dict_t[character]:
formed -= 1
#移动左指针
l += 1
#右指针移动
r += 1
return "" if ans[0] == float("inf") else s[ans[1]:ans[2] + 1]
S = "ABAACBAB"
T = "ABC"
res = minWindow(S, T)
print('res:', res)
六十四.替换子串得到平衡字符串
有一个只含有'Q'
, 'W'
, 'E'
,'R'
四种字符,且长度为 n
的字符串。假如在该字符串中,这四个字符都恰好出现n/4
次,那么它就是一个「平衡字符串」。
输入:s = "QQWE"
输出:1
解释:我们需要把一个 'Q' 替换成 'R',这样得到的 "RQWE" (或 "QRWE") 是平衡的。
import collections
class Solution(object):
def balancedString(self, s):
"""
python版本
:type s: str
:rtype: int
"""
cnt = collections.Counter(s)
res = n = len(s)
left, avg = 0, n//4
for right, c in enumerate(s):
# print('c:', c)
#一直进行字符减操作
cnt[c] -= 1
print('cnt:', cnt)
#直到n//4大于单个字符的个数 说明右边界找到 在对左边界进行右移 找最小的长度
while left < n and all(avg >= cnt[x] for x in 'QWER'):
res = min(res, right - left + 1)
print('res:', res)
cnt[s[left]] += 1
print('==cnt:', cnt)
left += 1
print('res:', res)
return res
sol = Solution()
s = 'WQWRQQQW'
sol.balancedString(s)
# 1、构建邻接矩阵;
# 2、将1的颜色置为1,从2开始遍历邻接矩阵;
# 3、每一次遍历,新建一个颜色集合([1,2,3,4]),取出key对应的花园代号,遍历代号。
# 如果该代号花园已经有颜色了,取出其颜色,从颜色集合中去掉;如果该花园没有颜色,跳过;
# 全部代号遍历结束后,取颜色集合第一个颜色作为当前key 的颜色,存入结果中;
# 4、反复计算更新结果,最后输出结果;
class Solution(object):
def gardenNoAdj(self, N, paths):
"""
:type N: int
:type paths: List[List[int]]
:rtype: List[int]
"""
recorder = {}
for i in range(1, N+1, 1):
recorder[str(i)] = []
for path in paths:
recorder[str(path[0])].append(path[1])
recorder[str(path[1])].append(path[0])
print('===recorder:', recorder)
#将1的颜色置为1,从2开始遍历
result = [1]
for i in range(2, N+1, 1):
colors = [1, 2, 3, 4]
sub_nodes = recorder[str(i)]
print('==sub_nodes:', sub_nodes)
for sub_node in sub_nodes:
if sub_node > len(result):#没有颜色,跳过
continue
else:
if result[sub_node-1] in colors:#有颜色进行移除
colors.remove(result[sub_node-1])
result.append(colors[0])
print('==result:', result)
return result
# N = 3
# paths = [[1, 2],
# [2, 3],
# [3, 1]]
N = 4
paths = [[1, 2],
[3, 4]]
sol = Solution()
sol.gardenNoAdj(N, paths)
思路:统计所有人的入度和出度信息,将满足出度为0,入度为 N - 1的节点输出。
#维护两个列表一个用于记录入度,一个用于记录出度,满足入度为N-1, 出度为0的就是法官
class Solution:
def findJudge(self, N, trust):
input_degree = [0]*N
ouput_degree = [0]*N
for trust_ in trust:
input_degree[trust_[0] - 1] += 0
input_degree[trust_[1] - 1] += 1
ouput_degree[trust_[0] - 1] += 1
ouput_degree[trust_[1] - 1] += 0
print('==input_degree:', input_degree)
print('==ouput_degree:', ouput_degree)
for i in range(len(input_degree)):
if input_degree[i] == N-1 and ouput_degree[i] == 0:
return i+1
return -1
# N = 2
# trust = [[1, 2]]
# N = 3
# trust = [[1, 3],
# [2, 3]]
# N = 3
# trust = [[1,3],
# [2,3],
# [3,1]]
N = 4
trust = [[1,3],
[1,4],
[2,3],
[2,4],
[4,3]]
sol = Solution()
res = sol.findJudge(N, trust)
print(res)
#维护一个列表用于记录入度与出度的差值,差值为N-1, 就是法官
class Solution:
def findJudge(self, N, trust):
count = [0]*N
for trust_ in trust:
count[trust_[0] - 1] -= 1
count[trust_[1] - 1] += 1
print('==count:', count)
for i in range(len(count)):
if count[i] == N-1:
return i+1
return -1
# N = 2
# trust = [[1, 2]]
# N = 3
# trust = [[1, 3],
# [2, 3]]
# N = 3
# trust = [[1, 3],
# [2, 3],
# [3, 1]]
N = 4
trust = [[1,3],
[1,4],
[2,3],
[2,4],
[4,3]]
sol = Solution()
res = sol.findJudge(N, trust)
print(res)
利用弗洛伊德算法找出节点与节点之间的路径,计算出邻接矩阵。
#佛罗伊德算法:dp矩阵先进行初始化,用两个节点是否经过中间节点,来更新中间节点的dp矩阵
class Solution:
def checkIfPrerequisite(self, n, prerequisites, queries):
dp = [[0 for i in range(n)] for j in range(n)]
print(dp)
for prerequisite in prerequisites:
dp[prerequisite[0]][prerequisite[1]] = 1
print(dp)
for k in range(n):#k代表中间节点
for i in range(n):#i开始节点
for j in range(n):#j终止节点
if dp[i][k] ==1 and dp[k][j]==1:
dp[i][j] = 1
print(dp)
res = []
for querie in queries:
# print(dp[querie[0]][querie[-1]])
res.append(dp[querie[0]][querie[-1]])
return res
n = 5
prerequisites = [[0, 1],
[1, 2],
[2, 3],
[3, 4]]
queries = [[0, 4],
[4, 0],
[1, 3],
[3, 0]]
sol = Solution()
res = sol.checkIfPrerequisite(n, prerequisites, queries)
print('res:', res)
# 1、先求出数组的平均数 avg,如果平均数 avg 不为整数,也就是说数组的数字总和不能平均的分为 k 份,那么直接返回 false;
#
# 2、创建一个布尔数组 flag,用来记录 nums 数组中数字的状态(已用还是未用)。 temp 的作用是记录当前子集的数字总和,temp 初始为 avg ,当 temp 等于 0 时,当前这个子集也就可以确定了。index 是用来记录遍历数组时从哪个位置开始遍历,以防将前面的数字重新计算。
#
# 3、当 temp = 0 的时候,也就是新一个子集求解完,那么继续求解下一个子集,k - 1,temp 重新置为 avg;当 temp != 0 时,就是子集还未求解完,那么继续求解子集,继续从数组中取数字,递归求解。
#
# 4、当 k 个子集全部求解完,返回 true,如果一直求解不出,则返回 false。
class Solution:
def canPartitionKSubsets(self, nums, k):
if sum(nums) % k != 0:#先判断能不能分成k组
return False
avg = sum(nums)/k
flag = [0]*len(nums)
print('==flag:', flag)
return self.helper(nums, flag, avg, k, avg, 0)
def helper(self, nums, flag, avg, k, temp, index):
if k == 0:#k为0说明划分好了k个子集
return True
if temp == 0:#平均数减去子集的剩下数字.如果为0继续求解下一个子集,k-1,temp重置为avg,下标index也重置为0
return self.helper(nums, flag, avg, k - 1, avg, 0)
#划分当前子集
for i in range(index, len(nums)):
if flag[i]:#已经使用过
continue
flag[i] =1 #标记使用
print('==flag:', flag)
# 递归调用子过程,父过程是否为true,取决于子过程的结果
if (temp - nums[i]) >= 0 and self.helper(nums, flag, avg, k, temp - nums[i], index + 1):
return True
#往下执行 说明没有使用 重置为0
flag[i] = 0
return False
nums = [4, 3, 2, 3, 5, 2, 1]
k = 4
target, rem = divmod(sum(nums), k)
print('==target:', target)
print('==rem:', rem)
# nums = [129, 17, 74, 57, 1421, 99, 92, 285, 1276, 218, 1588, 215, 369, 117, 153, 22]
# k = 3
sol = Solution()
res = sol.canPartitionKSubsets(nums, k)
print('=res:', res)