《数据结构与算法分析python版》第十周编程作业

《数据结构与算法分析python版》第十周编程作业

1、二叉查找树填空

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

输入格式:
每个测试样例第一行包含一个整数，为二叉树的节点总数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

这一部分的内容我觉得这位大佬写的很不错，大家也可以看看源代码出处附上。可能是因为之前对二叉树的遍历听课的时候没认真，所以处理起来就有点吃力，后来看了一些别人的突然有了思路。也整理了一下关于二叉树遍历的内容和各种遍历方法的应用场景。这是地址，希望对大家有所帮助。也欢迎小伙伴互相关注，互相促进。

脚本

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


def buildTree(total):
    node_list = [TreeNode(i) for i in range(total)]
    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(root):
    if root:
        fillTree(root.leftChild)
        root.val = lst.pop(0)
        fillTree(root.rightChild)


def printTree(total):
    queue = [root]
    result = []
    for i in range(total):
        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())
root = buildTree(N)
lst = [int(i) for i in input().split()]
lst.sort()
fillTree(root)
printTree(N)

2、完全二叉查找树

题目内容：
给定一系列整数，请构造相应的二叉树，使其既是二叉查找树又是完全二叉树；请输出满足条件的二叉树的层次遍历。
输入格式:
一个整数序列，以空格分隔
输出格式：
对应完全二叉查找树的层次遍历序列，即从第1层根结点开始，逐层向下，同一层从左到右，以空格分隔，行末无多余空格
输入样例
1 2 3 4 5 6 7 8 9 0
输出样例：
6 3 8 1 5 7 9 0 2 4
脚本

class BinaryTree():
    def __init__(self,key,left = None, right = None):
        
        self.key = key
        self.val = None
        self.left = left
        self.right = right

def buildtree(lst):
    nodelst = [BinaryTree(i) for i in range(1,len(lst)+1)]
    i = 0
    for node in nodelst:
        if node.key ==1:
            pass
        elif node.key %2 == 0:
            nodelst[i].left = node
        elif node.key %2 == 1:
            nodelst[i].right = node
            i = i +1
    return nodelst[0]

def inorderinsert(tree):      
    if tree != None:       
        inorderinsert(tree.left)
        tree.val = lst.pop(0)
        inorderinsert(tree.right)
    return tree


def levelorder(Tree):
    result =[]
    queue = []
    queue.append(Tree)
    for node in queue:
        result.append(node.val)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    return result



lst = input().split()
lst = [int(i) for i in lst]
lst.sort()
tree = buildtree(lst)
ftree = inorderinsert(tree)
print(*levelorder(ftree))

3、从二叉搜索树到更大和树

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

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

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

输出格式：
修改后的树的层次遍历序列，即从第1层根结点开始，逐层向下，同一层从左到右，以空格分隔，行尾无多余空格
输入样例
6 1 8 3 4 9 2 7 5 0
输出样例：
30 45 17 45 42 24 9 44 39 35
脚本

# 这道题还是值得常常看看的。
# 递归栈帧的理解：这里currentTree同时作为外部变量，又在递归函数中作为参数传递。
# 个人理解是它的回溯机制，最终会由下至上将递归对变量的改变回溯给最开始传入的外部变量，也就是currentTree
# currentTree是对实例化的二叉树的一个指向，修改的二叉树对象

class BinaryTree():
    def __init__(self,key,val = None, left = None,right = None):
        self.key = key
        self.val = val
        self.left = left
        self.right = right
    
def buildSumlst(lst):
    newlst = []
    for item in lst:
        newlst.append(sum([i for i in lst if i>= item]))
    nodelst = [BinaryTree(lst[i],val=newlst[i]) for i in range(len(lst))]

    return nodelst
        
def buildTree(lst):
    eTree = nodelst[0]
    currentTree = eTree 
    
    def _Tree(currentTree,i):

        if lst[i] < currentTree.key:
            if currentTree.left:
                currentTree = currentTree.left
                _Tree(currentTree,i)

            else:
                currentTree.left = nodelst[i]
                
        else:
            if currentTree.right:
                currentTree = currentTree.right
                _Tree(currentTree,i)
            else:
                currentTree.right = nodelst[i]
         
        return currentTree
     
    for i in range(1,len(lst)):
        _Tree(currentTree,i)

    return eTree
    # return currentTree

def levelorder(Tree):
    result =[]
    queue = []
    queue.append(Tree)
    for node in queue:
        result.append(node.val)
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)
    return result


lst = input().split(" ")
lst = [int(i) for i in lst ]
nodelst = buildSumlst(lst)
Tree = buildTree(lst)
print(levelorder(Tree))