1、K 个一组翻转链表（递归，链表）
给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。
k 是一个正整数，它的值小于或等于链表的长度。
如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。
进阶：
- 你可以设计一个只使用常数额外空间的算法来解决此问题吗？
- 你不能只是单纯的改变节点内部的值，而是需要实际进行节点交换。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[2,1,4,3,5]
示例 2：
输入：head = [1,2,3,4,5], k = 3
输出：[3,2,1,4,5]
示例 3：
输入：head = [1,2,3,4,5], k = 1
输出：[1,2,3,4,5]
示例 4：
输入：head = [1], k = 1
输出：[1]
提示：
- 列表中节点的数量在范围 sz 内
- 1 <= sz <= 5000
- 0 <= Node.val <= 1000
- 1 <= k <= sz
以下程序实现了这一功能，请你填补空白处内容：
class ListNode(object):
def __init__(self, x):
self.val = x
self.next = None
class LinkList:
def __init__(self):
self.head=None
def initList(self, data):
self.head = ListNode(data[0])
r=self.head
p = self.head
for i in data[1:]:
node = ListNode(i)
p.next = node
p = p.next
return r
def convert_list(self,head):
ret = []
if head == None:
return
node = head
while node != None:
ret.append(node.val)
node = node.next
return ret
class Solution(object):
def reverseKGroup(self, head, k):
if head is None:
return None
index = 0
lead, last = 0, 0
pos = head
temp = ListNode(-1)
temp.next = head
head = temp
start = head
_________________;
return head.next
def reverseList(self, head, end):
pos = head.next
last = end
next_start = pos
while pos != end:
head.next = pos
last_pos = pos
pos = pos.next
last_pos.next = last
last = last_pos
return next_start
# %%
l = LinkList()
head = [1,2,3,4, 5]
l1 = l.initList(head)
s = Solution()
print(l.convert_list(s.reverseKGroup(l1, k = 2)))
选项代码：
while pos is not None:
if index % k == k - 1:
last = pos.next
start = self.reverseList(start, last)
pos = start
pos = pos.next
index += 12、括号生成（字符串，动态规划）
数字 n 代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且 有效的 括号组合。
示例 1：
输入：n = 3
输出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：
输入：n = 1
输出：["()"]
提示：
- 1 <= n <= 8
选项代码：
from typing import List
class Solution:
def generateParenthesis(self, n: int) -> List[str]:
def gen(p, lc, rc, r, n):
if lc > n:
return
if lc == n and rc == n:
r.append(''.join(p))
p.append('(')
lc += 1
gen(p, lc, rc, r, n)
p.pop()
lc -= 1
if lc > rc:
p.append(')')
rc += 1
gen(p, lc, rc, r, n)
p.pop()
rc -= 1
results = []
gen([], 0, 0, results, n)
return results
# %%
s = Solution()
print(s.generateParenthesis(n = 3))3、无重复字符的最长子串（哈希表，字符串）
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例 1:
输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:
输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:
输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
示例 4:
输入: s = ""
输出: 0
提示：
- 0 <= s.length <= 5 * 104
- s 由英文字母、数字、符号和空格组成
选项代码：
class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
i = 0
j = 0
m = 0
hset = {}
while j < len(s):
char = s[j]
index = hset.get(char)
if index is not None and index > i:
i = index
m = m if m > j - i + 1 else j - i + 1
hset[char] = j + 1
j += 1
return m
# %%
s = Solution()
print(s.lengthOfLongestSubstring('abcabcbb'))
