编程之法之字符串
字符串
1.1 字符串的旋转
(leetcode 796) 给定两个字符串, A 和 B。A 的旋转操作就是将 A 最左边的字符移动到最右边。 例如, 若 A = 'abcde'，在移动一次之后结果就是'bcdea' 。如果在若干次旋转操作之后，A 能变成B，那么返回True。
注：主要需要考虑为空的情况，另外就是当num超过字符串长度
class Solution:
def rotateString(self, A: str, B: str) -> bool:
if not A and not B:
return True
if not A or not B:
return False
for i in range(len(A)+1):
if B == self.rotate(A,i):
return True
return False
def rotate(self,A,num):
indx = num%len(A)
return A[indx:] + A[:indx]
1.2 字符串的包含
给定两个分别由字母组成的字符串A和字符串B，字符串B的长度比字符串A短。请问，如何最快地判断字符串B中所有字母是否都在字符串A里？
def StringContain(strA,strB):
strHash = 0
for v in strA:
strHash |= (1<<(ord(v)-ord('A'))
for v in strB:
if (strHash & (1 << (ord(v)-ord('A')))==0):
return False
return True
1.3 字符串的全排列
(leetcode 46) 给定一个没有重复数字的序列，返回其所有可能的全排列。
class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
self.visited = [0] * len(nums)
self.nums = nums
self.result = []
self.dfs([])
return self.result
def dfs(self,path):
if len(path) == len(self.nums):
self.result.append(path)
else:
for i in range(len(self.nums)):
if not self.visited[i]:
self.visited[i] = 1
self.dfs(path+[self.nums[i]])
self.visited[i] = 0
第二种方法比第一种要慢
class Solution:
def permute(self, nums: List[int]) -> List[List[int]]:
self.result = []
self.perm(nums,0,len(nums))
return self.result
def perm(self,nums,fr,to):
if to <= 1:
self.result.append(nums)
return
if fr==to:
tmp = nums[:]
self.result.append(tmp)
else:
for i in range(fr,to):
nums[i],nums[fr] = nums[fr],nums[i]
self.perm(nums,fr+1,to)
nums[i],nums[fr] = nums[fr],nums[i]
1.3.1 字典序排列
(leetcode 31) 下一个排列。
实现获取下一个排列的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。
注：这道题就是典型的字典序排列问题，过程如下：
- 找到排列中最右边的一个升序首位位置i
- 如果i小于0，说明找不到，则直接返回；
- 找到排列中第i个位置右边最后一个比nums[i]大的位置j；
- 交换i和j位置的数；
- 把第i+1到最后的部分翻转；
class Solution:
def nextPermutation(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
# 找到最后一个升序首位
indx = -1
for i in range(len(nums)-2,-1,-1):
if nums[i] < nums[i+1]:
indx = i
break
# 已经找到所有的
if indx<0:
nums.sort()
return
# 找到右边最后一个比nums_i大的位置
k = len(nums)-1
for k in range(len(nums)-1,indx,-1):
if nums[k] > nums[indx]:
break
nums[indx], nums[k] = nums[k], nums[indx]
nums[indx+1:] = nums[indx+1:][::-1]
1.4 回文判断
(leetcode 234) 请判断一个链表是否为回文链表。
这道题比较经典，涉及到如何使用快慢表，如何翻转链表；
class Solution:
def isPalindrome(self, head: ListNode) -> bool:
slow = fast = head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
new_head = None
while slow:
p = slow
slow = slow.next
p.next = new_head
new_head = p
while new_head:
if new_head.val != head.val:
return False
new_head = new_head.next
head = head.next
return True
1.5 最长回文子串
(leetcode 5) 最长回文子串
注：注意对情况的讨论，第一种解法参考编程之法，原文中的代码在while语句中缺少边界判断，会报错。
class Solution:
def longestPalindrome(self, s: str) -> str:
if not s:
return s
s = "#".join(s.strip())
s = "#" + s + "#"
p = [0]*len(s)
mx = 0
for i in range(1,len(s)):
if mx > i:
p[i] = min(p[2*id-i],mx-i)
else:
p[i] = 1
while i+p[i] < len(s) and i-p[i] > 0 and (s[i+p[i]] == s[i-p[i]]):
p[i] += 1
if p[i] + i > mx:
mx = p[i] + i
id = i
l = max(p)-1
indx = p.index(l+1)
maxs = s[indx-l:indx+l+1]
return "".join(maxs.split("#"))
class Solution:
def longestPalindrome(self, s: str) -> str:
n = len(s)
maxl = 0
start = 0
for i in range(n):
if i-maxl >= 1 and s[i-maxl-1:i+1] == s[i-maxl-1:i+1][::-1]:
start = i - maxl - 1
maxl += 2
continue
if i-maxl >= 0 and s[i-maxl:i+1] == s[i-maxl:i+1][::-1]:
start = i - maxl
maxl += 1
return s[start:start+maxl]
