Python|每日一练|排序|递归|链表|字符串|数组|动态规划|哈希表|单选记录：K 个一组翻转链表|括号生成|无重复字符的最长子串

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 += 1

2、括号生成（字符串，动态规划）

数字 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'))