数据结构与算法Python版-第十周作业

1. 二叉查找树填空（10分）

题目内容：
给定一个二叉树结构，与一个整数列表，请将整数填充至二叉树对应节点内，使其成为一个二叉查找树；请输出该二叉查找树的层次遍历。下图展示了给定样例对应的二叉树结构：

输入格式:
每个测试样例第一行包含一个整数，为二叉树的节点总数N。随后N行分别给定了编号由0至(N-1)的节点的左右子树编号，以空格分隔；若编号-1则代表对应子树为空。最后一行给出了以空格分隔的N个整数

输出格式：
对填空后的二叉查找树进行层次遍历，按顺序输出整数序列，即从第1层根结点开始，逐层向下，同一层从左到右，以空格分隔，行尾无多余空格

输入样例：
9
1 6
2 3
-1 -1
-1 4
5 -1
-1 -1
7 -1
-1 8
-1 -1
73 45 11 58 82 25 67 38 42

输出样例：
58 25 82 11 38 67 45 73 42

时间限制：500ms内存限制：32000kb

(学到树和图这里就感觉很吃力了，救救傻孩子吧真的不想努力了( T o T ) ！自己想出的办法又臭又长，然后看到博主@Divine0的解法，非常容易理解也很简洁，贴一贴，原博点这里。)

class TreeNode:
    def __init__(self, key, left=None, right=None):
        self.key = key
        self.val = None
        self.leftChild = left
        self.rightChild = right

def buildTree(N):
    node_list = [TreeNode(i) for i in range(N)]
    for currentNode in node_list:
        seq = [int(j) for j in input().split()]
        if seq[0] != -1:
            currentNode.leftChild = node_list[seq[0]]
        if seq[1] != -1:
            currentNode.rightChild = node_list[seq[1]]
    return node_list[0]

def fillTree(tree):
    if tree:
        fillTree(tree.leftChild)
        tree.val = lst.pop(0)
        fillTree(tree.rightChild)

def printTree(N):
    queue = [tree]
    result = []
    for i in range(N):
        currentNode = queue.pop(0)
        result.append(currentNode.val)
        if currentNode.leftChild:
            queue.append(currentNode.leftChild)
        if currentNode.rightChild:
            queue.append(currentNode.rightChild)
    print(*result)
    
N = int(input())
tree = buildTree(N)
lst = [int(i) for i in input().split()]
lst.sort()
fillTree(tree)
printTree(N)

2. 完全二叉查找树（10分）

题目内容：
给定一系列整数，请构造相应的二叉树，使其既是二叉查找树又是完全二叉树；请输出满足条件的二叉树的层次遍历。

输入格式:
一个整数序列，以空格分隔

输出格式：
对应完全二叉查找树的层次遍历序列，即从第1层根结点开始，逐层向下，同一层从左到右，以空格分隔，行末无多余空格

输入样例：
1 2 3 4 5 6 7 8 9 0

输出样例：
6 3 8 1 5 7 9 0 2 4

时间限制：500ms内存限制：32000kb

这个题填充树和打印树的方法和之前一样，只需要设计生成一个完全二叉树即可。

class TreeNode:
    def __init__(self, key, left=None, right=None):
        self.key = key
        self.val = None
        self.leftChild = left
        self.rightChild = right

# 这里构造一个节点数为N的完全二叉树
def buildTree(N):
    
    tree = TreeNode(0)
    queue = [tree]
    
    while N > 1:
        l = len(queue)
        for i in range(l):
            currentNode = queue.pop(0)
            if N > 1:
                currentNode.leftChild = TreeNode(0)
                queue.append(currentNode.leftChild)
                N -= 1
            else:
                break
            if N > 1:
                currentNode.rightChild = TreeNode(0)
                queue.append(currentNode.rightChild)
                N -= 1
            else:
                break       
    return tree          

def fillTree(tree):
    if tree:
        fillTree(tree.leftChild)
        tree.val = lst.pop(0)
        fillTree(tree.rightChild)

def printTree(N):
    queue = [tree]
    result = []
    for i in range(N):
        currentNode = queue.pop(0)
        result.append(currentNode.val)
        if currentNode.leftChild:
            queue.append(currentNode.leftChild)
        if currentNode.rightChild:
            queue.append(currentNode.rightChild)
    print(*result)
    
lst = list(map(int, input().split()))
lst.sort()
N = len(lst)
tree = buildTree(N)
fillTree(tree)
printTree(N)

3. 从二叉搜索树到更大和树（10分）

题目内容：
给定一个二叉搜索树，请修改树节点，使新树中每个节点的值等于原树中大于等于该节点的值之和；请输出修改后的树的层次遍历序列。

输入格式:
一个不重复的整数序列，以空格分隔，为构造原二叉查找树的节点插入顺序

注：题目保证输入序列无重复

输出格式：
修改后的树的层次遍历序列，即从第1层根结点开始，逐层向下，同一层从左到右，以空格分隔，行尾无多余空格

输入样例：
6 1 8 3 4 9 2 7 5 0

输出样例：
30 45 17 45 42 24 9 44 39 35

时间限制：500ms内存限制：32000kb

这个题比之前都容易一些，因为可以使用pythonds模块里面的BinarySearchTree。
列表中的数字作为key，大于等于键值的数之和作为val，用put()方式生成SBT就可以了。这里因为不能import就把SBT里的部分代码复制过来了。printTree()方法还是和之前一样，唯一有变化的就是generateTree()，但是非常简单。

class BinarySearchTree:
    def __init__(self):
        self.root = None
        self.size = 0
    
    def put(self,key,val):
        if self.root:
            self._put(key,val,self.root)
        else:
            self.root = TreeNode(key,val)
        self.size = self.size + 1
    
    def _put(self,key,val,currentNode):
        if key < currentNode.key:
            if currentNode.leftChild:
                self._put(key,val,currentNode.leftChild)
            else:
                currentNode.leftChild = TreeNode(key,val,parent=currentNode)
        else:
            if currentNode.rightChild:
                self._put(key,val,currentNode.rightChild)
            else:
                currentNode.rightChild = TreeNode(key,val,parent=currentNode)

class TreeNode:
    def __init__(self,key,val,left=None,right=None,parent=None):
        self.key = key
        self.payload = val
        self.leftChild = left
        self.rightChild = right
        self.parent = parent

def generateTree(lst):
    tree = BinarySearchTree() 
    for i in lst:
        s = 0
        for j in lst:
            if j >= i:
                s +=j
        tree.put(i, s)
    return tree

def printTree(N):
    queue = [tree.root]
    result = []
    for i in range(N):
        currentNode = queue.pop(0)
        result.append(currentNode.payload)
        if currentNode.leftChild:
            queue.append(currentNode.leftChild)
        if currentNode.rightChild:
            queue.append(currentNode.rightChild)
    print(*result)
                   
lst = list(map(int,input().split()))
tree = generateTree(lst)
printTree(len(lst))