数据结构与算法--字符串

字符串

字符串是由若干字符组成的有限序列,即一个字符数组

反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1：
输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]
示例 2：
输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

def solution(strs):
	left = 0
	right = len(strs) - 1
	while left < right:
		strs[left], strs[right] = strs[right], strs[left]
		left += 1
		right -= 1

反转字符串II

给定一个字符串 s 和一个整数 k，你需要对从字符串开头算起的每隔 2k 个字符的前 k 个字符进行反转。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例:
输入: s = “abcdefg”, k = 2
输出: “bacdfeg”

def solution(strs, k):
	def reverse_str(s):
		left = 0
		right = len(s) - 1
		while left < right:
			text[left], text[right] = text[right], text[left]
			left += 1
			right -= 1
	res = list(strs)
	for i in range(0, len(res), k):
		res[i:i+k] = reverse_str(res[i:i+k])
	return "".join(res)

替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。
示例 1： 输入：s = “We are happy.”
输出：“We%20are%20happy.”

def solution(s):
	counter = s.count(" ")
	res = list(s)

	res.extand([" "] * (counter * 2))
	left, right = len(s)-1, len(res)-1
	while left >= 0:
		if res[left] != " ":
			res[right] = res[left]
			right -= 1
		else:
			res[right-2: right+1] = '%20'
			right -= 3
		left -= 1
	return "".join(res)

翻转字符串里的单词

给定一个字符串，逐个翻转字符串中的每个单词。
示例 1：
输入: “the sky is blue”
输出: “blue is sky the”
示例 2：
输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：
输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

def solution(strs):
	def trim_space(s):
		n = len(s)
		left = 0
		right = n - 1
		while left <= right and s[left] == " ":
			left += 1
		while left <= right and s[right] == " ":
			right -= 1
		tmp = []
		while left <= right:
			if s[left] != " ":
				tmp.append(s[left])
			elif tmp[-1] != " ":
				tmp.append(s[left])
			left += 1
		return tmp
	
	def reverse_str(strs, left, right):
		while left < right:
			strs[left], strs[right] = strs[right], strs[left]
			left += 1
			right -= 1

	def reverse_word(strs):
		start = 0
		end = 0
		n = len(strs)
		while start < n:
			while end < n and strs[end] != " ":
				end += 1
			reverse_str(strs, start, end)
			start = end + 1
			end += 1 
	tmps = trim_space(strs)
	reverse_str(tmps, 0, len(tmps)-1)
	reverse_word(tmps)
	return "".join(tmps)	

左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。
示例 1：
输入: s = “abcdefg”, k = 2
输出: “cdefgab”
示例 2：
输入: s = “lrloseumgh”, k = 6
输出: “umghlrlose”
限制：
1 <= k < s.length <= 10000

def reverseLeftWords(s, n):
        def reverse_str(s, start, end):
            while start < end:
                s[start], s[end] = s[end], s[start]
                start += 1
                end -= 1
            return None
        tmp = list(s)
        end = len(tmp) - 1
        reverse_str(tmp, 0, n-1)
        reverse_str(tmp, n, end)
        reverse_str(tmp, 0, end)
        return "".join(tmp)

实现 strStr()

实现 strStr() 函数。
给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
示例 1: 输入: haystack = “hello”, needle = “ll” 输出: 2
示例 2: 输入: haystack = “aaaaa”, needle = “bba” 输出: -1
说明: 当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。 对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符

KMP算法:当出现字符串不匹配时，可以记录一部分之前已经匹配的文本内容，利用这些信息避免从头再去做匹配。

def solution(s, p):
	a = len(s)
	b = len(p)
	if b == 0:
		return 0
	cur = get_next(b, p)
	j = -1
	for i in range(a):
		while j >= 0 and p[j+1] != s[i]:
			j = cur[j]
		if p[j+1] == s[i]:
			j += 1
		if j == (b-1):
			return j-b+1
	return -1
	def get_next(b, p):
		cur = ["" for i in range(b)]
		j, k = 0, -1
		cur[0] = k
		for i in range(1, len(p)):
			while (k > -1 and  p[k+1] != p[i]):
				k = cur[k]
			if p[k+1] == p[i]:
				k += 1
			cur[i] = k
		return cur

重复的子字符串

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
示例 1:
输入: “abab”
输出: True
解释: 可由子字符串 “ab” 重复两次构成。
示例 2:
输入: “aba”
输出: False
示例 3:
输入: “abcabcabcabc”
输出: True
解释: 可由子字符串 “abc” 重复四次构成。 (或者子字符串 “abcabc” 重复两次构成。)

def getnext(cur, s):
	cur = [0] * len(s)
	cur[0] = -1
	j = -1
	for i in range(1, len(s)):
		while j >= 0 and s[i] != s[j+1]:
			j = cur[j]
		if s[j+1] == s[i]:
			j += 1
		cur[i] = j
	return cur

def solution(s):
	if len(s) == 0:
		return False
	 cur = getnext(cur, s)
	 if cur[-1] != -1 and len(s) % (len(s) - (cur[-1]+1)) == 0:
	 	return True
	 return False