【二叉树】
1. 实现一个二叉查找树，并且支持插入、删除、查找操作
class Node:
def __init__(self, data):
self.data = data
self.lchild = None
self.rchild = None
class BST:
def __init__(self, node_list):
self.root = Node(node_list[0])
for data in node_list[1:]:
self.insert(data)
# 查找
def search(self, node, parent, data):
if node is None:
return False, node, parent
if node.data == data:
return True, node, parent
if node.data > data:
return self.search(node.lchild, node, data)
else:
return self.search(node.rchild, node, data)
# 插入
def insert(self, data):
flag, n, p = self.search(self.root, self.root, data)
if not flag:
new_node = Node(data)
if data > p.data:
p.rchild = new_node
else:
p.lchild = new_node
# 删除
def delete(self, root, data):
flag, n, p = self.search(root, root, data)
if flag is False:
print "无该关键字，删除失败"
else:
if n.lchild is None:
if n == p.lchild:
p.lchild = n.rchild
else:
p.rchild = n.rchild
del p
elif n.rchild is None:
if n == p.lchild:
p.lchild = n.lchild
else:
p.rchild = n.lchild
del p
else: # 左右子树均不为空
pre = n.rchild
if pre.lchild is None:
n.data = pre.data
n.rchild = pre.rchild
del pre
else:
next = pre.lchild
while next.lchild is not None:
pre = next
next = next.lchild
n.data = next.data
pre.lchild = next.rchild
del p
2. 实现查找二叉查找树中某个节点的后继、前驱节点
class Solution:
def GetNext(self, pNode):
# write code here
dummy = pNode
#找到根节点
while dummy.next:
dummy = dummy.next
#中序遍历
ls = self.inorderTraversal(dummy)
#找pNode所在索引的下一个
if ls.index(pNode) != (len(ls)-1):
return ls[ls.index(pNode)+1]
else:
return None
def GetBefore(self, pNode):
# write code here
dummy = pNode
#找到根节点
while dummy.next:
dummy = dummy.next
#中序遍历
ls = self.inorderTraversal(dummy)
#找pNode所在索引的下一个
if ls.index(pNode) != 0:
return ls[ls.index(pNode)-1]
else:
return None
def inorderTraversal(self, root):
if root==None:
return []
return self.inorderTraversal(root.left)+[root]+self.inorderTraversal(root.right)
3. 实现二叉树前、中、后序以及按层遍历
class Solution:
def preorderTraversal(self, root: TreeNode) -> List[int]:
if root==None:
return []
return [root.val]+self.preorderTraversal(root.left)+self.preorderTraversal(root.right)
def inorderTraversal(self, root: TreeNode) -> List[int]:
if root==None:
return []
return self.inorderTraversal(root.left)+[root.val]+self.inorderTraversal(root.right)
def postorderTraversal(self, root: TreeNode) -> List[int]:
if root==None:
return []
return self.postorderTraversal(root.left)+self.postorderTraversal(root.right)+[root.val]
def levelOrder(self, root: TreeNode) -> List[List[int]]:
if not root:
return []
result = []
queue = collections.deque()
queue.append(root)
while queue:
level_size = len(queue)
current_level = []
for _ in range(level_size):
node = queue.popleft()
current_level.append(node.val)
if node.left: queue.append(node.left)
if node.right: queue.append(node.right)
result.append(current_level)
return result
练习：
1. 翻转二叉树 https://leetcode-cn.com/problems/invert-binary-tree/
思路：递归
class Solution:
def invertTree(self, root: TreeNode) -> TreeNode:
if root == None:
return None
root.left, root.right = root.right, root.left
self.invertTree(root.left)
self.invertTree(root.right)
return root
2. 二叉树的最大深度 https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/
思路：1. 深度优先搜索 2. 广度优先搜索
class Solution:
def maxDepth(self, root: TreeNode) -> int:
if root is None:
return 0
‘‘‘
#深度优先搜索+分治
return max(self.maxDepth(root.left), self.maxDepth(root.right))+1
‘‘‘
‘‘‘
#深度优先搜索+栈
self.ans = 0
self._dfs(root, 0)
return self.ans
def _dfs(self, node, level):
if not node:
return
if self.ans < level + 1:
self.ans = level + 1
self._dfs(node.left, level + 1)
self._dfs(node.right, level + 1)
‘‘‘
#广度优先搜索+双端队列deque
queue = collections.deque()
queue.append(root)
ans = 0
while queue:
ans += 1
for _ in range(len(queue)):
node = queue.popleft()
if node.left:
queue.append(node.left)
if node.right:
queue.append(node.right)
return ans
3. 验证二叉查找树 [作为可选] https://leetcode-cn.com/problems/validate-binary-search-tree/
思路：递归
class Solution:
def isValidBST(self, root: TreeNode) -> bool:
#max(leftnode)<root
#min(rightnode)>root
return self.valid(root, float(‘-inf‘), float(‘inf‘))
def valid(self, root, min, max):
if not root:
return True
if root.val >= max or root.val <= min:
return False
return self.valid(root.left, min, root.val) and self.valid(root.right, root.val, max)
【堆】
1. 实现一个小顶堆、大顶堆、优先级队列
class ZHeap:
def __init__(self, item=[]):
# 初始化。item为数组
self.items = item
self.heapsize = len(self.items)
def LEFT(self, i):
return 2 * i + 1
def RIGHT(self, i):
return 2 * i + 2
def PARENT(self, i):
return (i - 1) / 2
def MIN_HEAPIFY(self, i):
# 最小堆化：使以i为根的子树成为最小堆
l = self.LEFT(i)
r = self.RIGHT(i)
if l < self.heapsize and self.items[l] < self.items[i]:
smallest = l
else:
smallest = i
if r < self.heapsize and self.items[r] < self.items[smallest]:
smallest = r
if smallest != i:
self.items[i], self.items[smallest] = self.items[smallest], self.items[i]
self.MIN_HEAPIFY(smallest)
def INSERT(self, val):
# 插入一个值val，并且调整使满足堆结构
self.items.append(val)
idx = len(self.items) - 1
parIdx = self.PARENT(idx)
while parIdx >= 0:
if self.items[parIdx] > self.items[idx]:
self.items[parIdx], self.items[idx] = self.items[idx], self.items[parIdx]
idx = parIdx
parIdx = self.PARENT(parIdx)
else:
break
self.heapsize += 1
def DELETE(self):
last = len(self.items) - 1
if last < 0:
# 堆为空
return None
# else:
self.items[0], self.items[last] = self.items[last], self.items[0]
val = self.items.pop()
self.heapsize -= 1
self.MIN_HEAPIFY(0)
return val
def BUILD_MIN_HEAP(self):
# 建立最小堆, O(nlog(n))
i = self.PARENT(len(self.items) - 1)
while i >= 0:
self.MIN_HEAPIFY(i)
i -= 1
def SHOW(self):
print self.items
class ZPriorityQ(ZHeap):
def __init__(self, item=[]):
ZHeap.__init__(self, item)
def enQ(self, val):
ZHeap.INSERT(self, val)
def deQ(self):
val = ZHeap.DELETE(self)
return val
class MaxHeap:
def __init__(self, data):
data.insert(0, None)
self.heap = data
self.heapSize = 0
for i in range(1,len(self.heap)):
self.heapSize += 1
self.__bubble(i)
def __sink(self, pos):
left, right = 2*pos, 2*pos+1
next = pos
if left <= self.heapSize and self.compare(self.heap[left], self.heap[next]) > 0:
next = left
if right <= self.heapSize and self.compare(self.heap[right], self.heap[next]) > 0:
next = right
if next == pos:
return
self.__exchange(pos, next)
return self.__sink(next)
def __bubble(self, pos): # build
if pos <= 1:
return
ppos = pos/2
if self.compare(self.heap[pos], self.heap[ppos]) > 0:
self.__exchange(pos, ppos)
return self.__bubble(ppos)
def compare(self, a, b):
return a - b
def __exchange(self, i, j):
temp = self.heap[i]
self.heap[i] = self.heap[j]
self.heap[j] = temp
def sort(self):
while self.heapSize > 1:
self.__exchange(1, self.heapSize)
self.heapSize -= 1
self.__sink(1)
self.heap.remove(None)
return self.heap
2. 实现堆排序
def sift_down(arr, start, end):
root = start
while True:
# 从root开始对最大堆调整
child = 2 * root + 1
if child > end:
break
# 找出两个child中交大的一个
if child + 1 <= end and arr[child] < arr[child + 1]:
child += 1
if arr[root] < arr[child]:
# 最大堆小于较大的child, 交换顺序
arr[root], arr[child] = arr[child], arr[root]
# 正在调整的节点设置为root
root = child
else:
# 无需调整的时候, 退出
break
def heap_sort(arr):
# 从最后一个有子节点的孩子还是调整最大堆
first = len(arr) // 2 - 1
for start in range(first, -1, -1):
sift_down(arr, start, len(arr) - 1)
# 将最大的放到堆的最后一个, 堆-1, 继续调整排序
for end in range(len(arr) -1, 0, -1):
arr[0], arr[end] = arr[end], arr[0]
sift_down(arr, 0, end - 1)
3. 利用优先级队列合并 K 个有序数组
class Solution:
def mergeKLists(self, lists):
"""
:type lists: List[ListNode]
:rtype: ListNode
"""
heap = []
for ln in lists:
if ln:
heap.append((ln.val, ln))
dummy = ListNode(0)
cur = dummy
heapq.heapify(heap)
while heap:
valu, ln_index = heapq.heappop(heap)
cur.next = ln_index
cur = cur.next
if ln_index.next:
heapq.heappush(heap, (ln_index.next.val, ln_index.next))
return dummy.next
4. 求一组动态数据集合的最大 Top K
def findKthLargest(self, nums, k):
import heapq
return heapq.nlargest(k, nums)[-1]
练习：
路径总和 https://leetcode-cn.com/problems/path-sum/
思路：递归
class Solution:
def hasPathSum(self, root: TreeNode, sum: int) -> bool:
if root is None:
return False
if root.val == sum and root.left is None and root.right is None:
return True
else:
return self.hasPathSum(root.right, sum-root.val) or self.hasPathSum(root.left, sum-root.val)
原文地址：https://www.cnblogs.com/deeplearning-man/p/10884763.html
时间： 2024-08-28 17:45:19