剑指offer32-I
题目描述:
从上到下打印出二叉树的每个节点,同一层的节点按照从左到右的顺序打印。
示例:
解答:
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, x):
# self.val = x
# self.left = None
# self.right = None
class Solution:
def levelOrder(self, root: TreeNode) -> List[int]:
temp=[root]
ans=[]
while len(temp)>0:
if temp[0] is not None:
ans.append(temp[0].val)
temp.append(temp[0].left)
temp.append(temp[0].right)
temp.pop(0)
return ans
剑指offer33
题目描述:
输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true,否则返回 false。假设输入的数组的任意两个数字都互不相同。
示例:
解答:
class Solution:
def verifyPostorder(self, postorder: List[int]) -> bool:
if len(postorder)<=1:
return True
rootNum=postorder[-1]
for idx in range(len(postorder)):
if postorder[idx]>=rootNum:
break
left=postorder[:idx]
right=postorder[idx:len(postorder)-1]
for i in right:
if i<rootNum:
return False
leftSign=self.verifyPostorder(left)
rightSign=self.verifyPostorder(right)
if leftSign and rightSign:
return True
return False
剑指offer35
题目描述:
请实现 copyRandomList 函数,复制一个复杂链表。在复杂链表中,每个节点除了有一个 next 指针指向下一个节点,还有一个 random 指针指向链表中的任意节点或者 null。
示例:
解答:
"""
# Definition for a Node.
class Node:
def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
self.val = int(x)
self.next = next
self.random = random
"""
class Solution:
def copyRandomList(self, head: 'Node') -> 'Node':
if not head:
return
cur=head
# 1. 复制各节点,并构建拼接链表
while cur:
tmp = Node(cur.val)
tmp.next = cur.next
cur.next = tmp
cur = tmp.next
# 2. 构建各新节点的 random 指向
cur = head
while cur:
if cur.random:
cur.next.random = cur.random.next
cur = cur.next.next
# 3. 拆分两链表
cur = res = head.next
pre = head
while cur.next:
pre.next = pre.next.next
cur.next = cur.next.next
pre = pre.next
cur = cur.next
pre.next = None # 单独处理原链表尾节点
return res # 返回新链表头节点
剑指offer36
题目描述:
输入一棵二叉搜索树,将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点,只能调整树中节点指针的指向。
示例:
解答:
"""
# Definition for a Node.
class Node:
def __init__(self, val, left=None, right=None):
self.val = val
self.left = left
self.right = right
"""
class Solution:
def treeToDoublyList(self, root: 'Node') -> 'Node':
def dfs(cur):
if not cur:
return
dfs(cur.left) # 递归左子树
if self.pre: # 修改节点引用
self.pre.right, cur.left = cur, self.pre
else: # 记录头节点
self.head = cur
self.pre = cur # 保存 cur
dfs(cur.right) # 递归右子树
if not root:
return
self.pre = None
dfs(root)
self.head.left, self.pre.right = self.pre, self.head
return self.head
剑指offer38
题目描述:
输入一个字符串,打印出该字符串中字符的所有排列。
你可以以任意顺序返回这个字符串数组,但里面不能有重复元素。
示例:
解答:
class Solution:
def permutation(self, s: str) -> List[str]:
res = []
t = []
def dfs(subs):
l = len(subs)
if l == 1:
t.append(subs)
res.append(''.join(t))
t.pop()
return
for i in range(l):
if subs[i] in subs[:i]:
continue
t.append(subs[i])
dfs(subs[:i]+subs[i+1:])
t.pop()
dfs(s)
return res