Task5

【二叉树】

实现一个二叉查找树，并且支持插入、删除、查找操作
实现查找二叉查找树中某个节点的后继、前驱节点
实现二叉树前、中、后序以及按层遍历

【堆】

实现一个小顶堆、大顶堆、优先级队列
实现堆排序
利用优先级队列合并 K 个有序数组
求一组动态数据集合的最大 Top K

二叉查找树(内部函数已实现BFS与三种DFS算法)：

class Node(object):     def __init__(self, value):         self.value = value         self.lchild = None         self.rchild = None   class BinarySearchTree(object):     def __init__(self, value):         self.root = Node(value)      def find(self, value, node, parent, nodetype):         if node is None:             return False, node, parent, nodetype         elif node.value == value:             return True, node, parent, nodetype         elif node.value < value:             return self.find(value, node.rchild, node, 'rchild')         else:             return self.find(value, node.lchild, node, 'lchild')      def insert(self, value):         flag, node, parent, nodetype = self.find(value, self.root, self.root, None)         if nodetype == 'lchild':             parent.lchild = Node(value)         else:             parent.rchild = Node(value)      def preorder(self, node):         if node is None:             return         print(node.value)         self.preorder(node.lchild)         self.preorder(node.rchild)      def inorder(self, node):         if node is None:             return         self.inorder(node.lchild)         print(node.value)         self.inorder(node.rchild)      def postorder(self, node):         if node is None:             return         self.postorder(node.lchild)         self.postorder(node.rchild)         print(node.value)      def bfs(self, node):         if node is None:             return         else:             queue = []             queue.append(node)             while queue:                 cur = queue.pop(0)                 print(cur.value)                 if cur.lchild is not None:                     queue.append(cur.lchild)                 if cur.rchild is not None:                     queue.append(cur.rchild)      def findmin(self, node):         if node.lchild == None:             return node         else:             return self.findmin(node.lchild)      def delvalue(self, value):         flag, node, parent, nodetype = self.find(value, self.root, self.root, None)         if not flag:             return         else:             if node.lchild is None and node.rchild is None:                 if nodetype == 'lchild':                     parent.lchild = None                 else:                     parent.rchild = None                 del node             elif node.lchild is not None and node.rchild is not None:                 minnode = self.findmin(node.rchild)                 n = minnode.value                 self.delvalue(n)                 node.value = n             else:                 if nodetype == 'lchild':                     if node.lchild is None:                         parent.lchild = node.rchild                     else:                         parent.lchild = node.lchild                 else:                     if node.lchild is None:                         parent.rchild = node.rchild                     else:                         parent.rchild = node.lchild                 del node   if __name__ == '__main__':     b = BinarySearchTree(10)     b.insert(5)     b.insert(15)     b.insert(3)     b.insert(8)     b.insert(6)     b.insert(9)     b.insert(16)     b.preorder(b.root)     flag, *rest = b.find(6, b.root, b.root, None)     print(flag)     flag, *rest = b.find(11, b.root, b.root, None)     print(flag)     b.delvalue(5)     flag, *rest = b.find(5, b.root, b.root, None)     print(flag)     b.preorder(b.root)

大顶堆堆排序（小顶堆类似，不再赘述）:

from collections import deque   def swap(L, i, j):     L[i], L[j] = L[j], L[i]     return L   def heap_adjust(L, start, end):     temp = L[start]      i = start     j = 2 * i      while j <= end:         if (j < end) and (L[j] < L[j + 1]):             j += 1         if temp < L[j]:             L[i] = L[j]             i = j             j = 2 * i         else:             break     L[i] = temp   def heap_sort(L):     L_length = len(L) - 1      first_sort_count = L_length // 2     for i in range(first_sort_count):         heap_adjust(L, first_sort_count - i, L_length)      for i in range(L_length - 1):         L = swap_param(L, 1, L_length - i)         heap_adjust(L, 1, L_length - i - 1)      return [L[i] for i in range(1, len(L))]   L = deque([50, 16, 30, 10, 60, 90, 2, 80, 70]) L.appendleft(0) print(heap_sort(L))

优先级队列如下：

import heapq   class PriorityQueue:     def __init__(self):         self._queue = []         self._index = 0      def push(self, item, priority):         heapq.heappush(self._queue, (-priority, self._index, item))         self._index += 1      def pop(self):         return heapq.heappop(self._queue)[-1]   class Item:     def __init__(self, name):         self.name = name      def __repr__(self):         return 'Item({!r})'.format(self.name)   if __name__ == "__main__":     q = PriorityQueue()     q.push(Item('python'), 1)     q.push(Item('java'), 5)     q.push(Item('swift'), 4)     q.push(Item('c++'), 1)     for i in range(4):         print(q.pop())