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

最新推荐文章于 2022-11-18 17:25:12 发布

蓝凌女巫

最新推荐文章于 2022-11-18 17:25:12 发布

阅读量445

点赞数

分类专栏： Python学习文章标签：二叉树列表算法数据结构 python

本文链接：https://blog.csdn.net/weixin_48264519/article/details/117886352

版权

Python学习专栏收录该内容

21 篇文章 13 订阅

订阅专栏

1. 二叉树复原（10分）

题目内容：
给定一种序列化二叉树的方式：从根节点起始按层次遍历二叉树所有“可能”存在节点的位置：若该位置存在节点，则输出节点值，并在下一层相应增加两个可用位置；否则输出None，且不增加下一层的可用位置。
例如"[5, 4, 7, 3, None, 2, None, -1, None, 9]"是下图所示的二叉树序列化的结果：
在这里插入图片描述
其中红色箭头对所有的None进行了标记。
现给出一个二叉树以这种形式序列化的结果，请复原该二叉树并给出它的中序遍历。

输入格式:
一行合法的Python表达式，可解析为包含整数与None的列表

输出格式：
二叉树中序遍历的整数序列，以空格分隔

输入样例：
[5, 4, 7, 3, None, 2, None, -1, None, 9]

输出样例：
-1 3 4 5 9 2 7

输入样例2：
[5,1,4,None,None,3,6]

输出样例2：
1 5 3 4 6

注：树结构如图（红色箭头对None的对应位置进行了标记）：
在这里插入图片描述

参考代码模板：

def seq2tree(seq):
    # 将列表反序列化为树
    pass

def inorderTree(root):
    # 中序遍历树
    pass

lst = eval(input())
tree = seq2tree(lst)
inorder = inorderTree(tree)
print(inorder) # 请自行确定打印方式

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

# 首先是自己定义的二叉树，注意，此处二叉树的定义直接影响后面的代码
# 将自己定义的二叉树保存后就可以直接import了
# 如果import其他的module里面的二叉树，下面的代码需要根据情况修改
class BinaryTree:
    def __init__(self, rootObj):
        self.key = rootObj
        self.leftChild = None
        self.rightChild = None

    def insertLeft(self, newNode):
        if self.leftChild == None:
            self.leftChild = BinaryTree(newNode)
        else:
            t = BinaryTree(newNode)
            t.leftChild = self.leftChild
            self.leftChild = t

    def insertRight(self, newNode):
        if self.rightChild == None:
            self.rightChild = BinaryTree(newNode)
        else:
            t = BinaryTree(newNode)
            t.rightChild = self.rightChild
            self.rightChild = t

    def getRootVal(self):
        return self.key

    def setRootVal(self,obj):
        self.key = obj
        
    def getLeftChild(self):
        return self.leftChild

    def getRightChild(self):
        return self.rightChild

# 接下来是通过列表将二叉树还原
def seq2tree(seq):
    
    queue = [] # 创建一个列队，存放下层的节点
    tree = BinaryTree(None)
    queue.append(tree)
    currentTree = tree
 
    while seq:
        l = len(queue)  # 查看当前可用节点队列里有多少节点，依次调用它们
        for i in range(l):
            currentTree = queue.pop(0)
            if not seq:
                break
            else:
                data = seq.pop(0)
                currentTree.setRootVal(data)  # 从列表中取出元素，存入当前节点
                if data != None:  # 如果该元素不是None，那么为该节点插入两个子节点，并并将子节点存进可用节点队列
                    currentTree.insertLeft(None)
                    currentTree.insertRight(None)
                    queue.append(currentTree.getLeftChild())
                    queue.append(currentTree.getRightChild())
    return tree
# 接下俩就是正常的中序遍历
def inorderTree(tree):
    if tree.getRootVal() == None:
        return []
    else:
        left = inorderTree(tree.getLeftChild())
        root = tree.getRootVal()
        right = inorderTree(tree.getRightChild())
        return left + [root] + right
    
lst = eval(input())
tree = seq2tree(lst)
inorder = inorderTree(tree)
print(' '.join(str(x) for x in inorder))

2. 翻转二叉树（10分）

题目内容：
给定一个二叉树，请给出它的镜面翻转。
为方便起见，本题只给出完全二叉树的层次遍历，请给出相应的翻转二叉树的中序遍历。

备注:
这个问题来自开源软件开发者Max Howell在Google面试被拒的经历：

谷歌：我们90％的工程师使用您编写的软件(Homebrew)，但是您却无法在面试时在白板上写出翻转二叉树这道题，这太糟糕了

输入格式:
一行空格分隔的整数序列，表示一个完全二叉树的层次遍历

输出格式：
一行空格分隔的整数序列，表示翻转后的二叉树的中序遍历

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

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

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

!!!这题解题思路和上一题一模一样，就是最后中序遍历时把左右子树调换一下，偷懒的直接略过就好了!!!

class BinaryTree:
    def __init__(self, rootObj):
        self.key = rootObj
        self.leftChild = None
        self.rightChild = None

    def insertLeft(self, newNode):
        if self.leftChild == None:
            self.leftChild = BinaryTree(newNode)
        else:
            t = BinaryTree(newNode)
            t.leftChild = self.leftChild
            self.leftChild = t

    def insertRight(self, newNode):
        if self.rightChild == None:
            self.rightChild = BinaryTree(newNode)
        else:
            t = BinaryTree(newNode)
            t.rightChild = self.rightChild
            self.rightChild = t

    def getRootVal(self):
        return self.key

    def setRootVal(self,obj):
        self.key = obj
        
    def getLeftChild(self):
        return self.leftChild

    def getRightChild(self):
        return self.rightChild

# 这个题解题过程和上一个基本一致，就是在最后中序遍历时调换一下左右子树的位置
def seq2tree(seq):
    
    queue = [] # 创建一个列队，存放下层的节点
    tree = BinaryTree(None)
    queue.append(tree)
    currentTree = tree
 
    while seq:
        l = len(queue)  # 查看当前可用节点队列里有多少节点，依次调用它们
        for i in range(l):
            currentTree = queue.pop(0)
            if not seq:
                break
            else:
                currentTree.setRootVal(seq.pop(0))  # 从列表中取出元素，存入当前节点
                currentTree.insertLeft(None)
                currentTree.insertRight(None)
                queue.append(currentTree.getLeftChild())
                queue.append(currentTree.getRightChild())
    return tree
# 接下俩就是正常的中序遍历
def inorderTree(tree):
    if tree.getRootVal() == None:
        return []
    else:
        right = inorderTree(tree.getRightChild())
        root = tree.getRootVal()
        left = inorderTree(tree.getLeftChild())
        return right + [root] + left
    
lst =list(input().split())
tree = seq2tree(lst)
inorder = inorderTree(tree)
print(' '.join(str(x) for x in inorder))

3. 多叉树遍历（10分）

题目内容：
给定以嵌套列表形式给出的多叉树，求它的后序遍历

注：每个代表非空多叉树的列表包含至少一项；列表第一项代表节点值，其后每一项分别为子树；遍历子树时以列表下标从小到大的顺序进行。

输入格式:
一行合法的Python表达式，可解析为嵌套列表形式的多叉树结构

输出格式：
一行整数，以空格分隔

输入样例：
[1,[2,[3,[4],[5]],[6]],[7],[8,[9],[10]]]

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

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

def postorderTree(tree):
    if len(tree) == 1:
        return tree
    else:
        result = []
        for i in range(1, len(tree)):
            result += postorderTree(tree[i])
        result += tree[:1]
        return result


lst = eval(input())
postorder = postorderTree(lst)
print(*postorder)