树和堆（Python）

目录

树

利用字典实现

完全实现

插入删除和查询

前、中、后遍历和层序遍历

测试

堆

自带实现

---

树

利用字典实现

import json
from collections import defaultdict

def tree():
    return defaultdict(tree)

完全实现

#二叉树
#二叉查找树：插入、删除、查找
class Node:
    def __init__(self,data):
        self.data = data
        self.lchild = None
        self.rchild = None
    
class BST:
    def __init__(self,datalist):
        if len(datalist)>0:
            self.root = Node(datalist[0])
            for data in datalist[1:]:
                self.insert(data)
        else:
            self.root = None

插入删除和查询

    def search(self,node,parent,data):
        if node==None:
            return False,node,parent
        if node.data == data:
            return True,node,parent
        if node.data<data:
            return self.search(node.rchild,node,data)
        else:
            return self.search(node.lchild,node,data)
            
    def insert(self,data):
        flag,node,parent = self.search(self.root,self.root,data)
        if flag:
            print 'yiyou'
        else:
            new_node = Node(data)
            if data>parent.data:
                parent.rchild = new_node
            else:
                parent.lchild = new_node
    
    def delete(self,data):
        flag,node,parent = self.search(self.root,self.root,data)
        if not flag:
            print 'no one'
        else:
            if node.lchild == None:
                if node == parent.lchild:
                    parent.lchild = node.right
                else:
                    parent.rchild = node.right
            elif node.rchild == None:
                if node == parent.lchild:
                    parent.lchild = node.light
                else:
                    parent.rchild = node.light
            else: #左右子树都不为空
                pre = node.lchild
                if pre.rchild == None:
                    node.data = pre.data
                    node.lchild = pre.lchild
                else:
                    next_node = pre.rchild
                    while not next_node.rchild:
                        pre = next_node
                        next_node = next_node.rchild
                    node.data = next_node.data
                    pre.rchild = next_node.lchild

前、中、后遍历和层序遍历

    def preOrderTraverse(self,node): #前序遍历
        if node:
            print node.data,'  ',
            self.preOrderTraverse(node.lchild)
            self.preOrderTraverse(node.rchild)
            
    def inOrderTraverse(self,node):#中序遍历
        if node:
            self.inOrderTraverse(node.lchild)
            print node.data,'  ',
            self.inOrderTraverse(node.rchild)
    
    def postOrderTraverse(self,node):#后序遍历
        if node:
            self.postOrderTraverse(node.lchild)
            self.postOrderTraverse(node.rchild)
            print node.data,'  ',

    def printFromTopToBottom(self,node):#层序遍历
        if not node:
            print '[]'
            return
        current = [node]
        outlist = []
        while current:
            nextStack = []
            for n in current:
                if n.lchild:
                    nextStack.append(n.lchild)
                if n.rchild:
                    nextStack.append(n.rchild)
                outlist.append(n.data)
            current = nextStack
        print outlist
        return

测试

if __name__=="__main__":
    # 不需要创建节点
    user=tree()
    user['codingpy']['username']='earlgrey'
    user['python']['username']='Guido van Rossum'
    print(json.dumps(user))
    print("*******************************************************")
    a = [49, 38, 65, 97, 60, 76, 13, 27, 5, 1]
    t = BST(a)  # 创建二叉查找树

    # t.width_circle()
    print("\n前序遍历")
    t.preOrderTraverse(t.root)
    print("\n中序遍历")
    t.inOrderTraverse(t.root)

    t.delete(49)
    print("\n后序遍历：")
    t.postOrderTraverse(t.root)
    print("\n层序遍历：")
    t.printFromTopToBottom(t.root)

堆

自带实现

from heapq import *
class Heap_Pri_Queue(object):
    def __init__(self, heap=[]):
        self.heap = heap
        heapify(self.heap)

    def enqueue(self, val):
        heappush(self.heap, val)

    def dequeue(self):
        return heappop(self.heap)

参考：https://github.com/xwj0813/DataStruct/blob/master/%E7%AC%AC5%E5%A4%A9%EF%BC%9A%E4%BA%8C%E5%8F%89%E6%A0%91%EF%BC%8C%E4%BC%98%E5%85%88%E9%98%9F%E5%88%97