树面试题总结

最新推荐文章于 2021-04-23 23:21:15 发布

liuwangleoooO

最新推荐文章于 2021-04-23 23:21:15 发布

阅读量401

点赞数

分类专栏： # 树文章标签：二叉树数据结构

本文链接：https://blog.csdn.net/qq_36581961/article/details/114572349

版权

树专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文章目录

树的几个概念
二叉树
平衡二叉树(AVL)
红黑树
B树
B+树
常见面试题

树的几个概念

由一个或一个以上的节点组成，存在一个特殊的节点，成为树根。其中的每一个子集合本身也是一种树形结构，即此根节点的子树。

几个关于树的专有名词

度数：每个节点所有子树的个数
层数：树的层数
高度：树的最大层数
树叶或终端节点：度数为零的节点就是树叶。
父节点：每一个节点都有连接的上一层节点。
子节点：每一个节点都有连接的下一层节点。
兄弟节点：有共同父节点的节点。
非终端节点：树叶以内的节点。
同代：在同一棵具有相同层数的节点。

二叉树

概念

由有限节点所组成的集合，此结合可以为空集合，或由一个树根及其左右两个子树组成。
特点

可以是空集合但若不是空集合则节点上一定要有一个键值
每一个树根的值需大于左子树的值
每一个树根的值需小于右子树的值
左右子树也是二叉查找树
树的每一个节点的值都不相同

二叉树与树的区别

树不可以为空集合二叉树可以
树的度数为d>=0 但二叉树的节点度数为0<=0<=2
树的子树没有次序关系二叉树则有

高度为k的二叉树的总结点数为 2k-1
在二叉树中，层数为i的节点数最多为 2(i-1)

存储方式

# 数组的方式存储
def treeCreateByArray(btree, data, length):
    for i in range(1, length):
        level = 1
        while btree[level] != 0:
            if data[i] > btree[level]:  # 如果数组内的值大于树根 就往右子树比较
                level = level * 2 + 1
            else:
                level = level * 2
        btree[level] = data[i]
    return btree


# 链表的存储方式
class tree():
    def __init__(self):
        self.data = 0
        self.left = None
        self.right = None


def treeCreateByLinkList(root, val):
    newnode = tree()
    newnode.data = val
    newnode.left = None
    newnode.right = None
    if root == None:
        root = newnode
        return root
    else:
        current = root
        while current != None:
            backup = current
            if current.data > val:
                current = current.left
            else:
                current = current.right
        if backup.data > val:
            backup.left = newnode
        else:
            backup.right = newnode
    return root

操作


# 插入
"""
二叉树查找：
def search(ptr,val):
    while True:
        if ptr is None:
            return None
        if ptr.data == val:
            return ptr
        elif ptr.data >val:
            ptr = ptr.left
        else:
            ptr = ptr.right
"""


class Tree:
    def __init__(self):
        self.data = 0
        self.left = None
        self.right = None


def createTree(root, val):
    """
    创建一个二叉树
    :param root:
    :param val:
    :return:
    """
    newnode = Tree()
    newnode.data = val
    newnode.left = None
    newnode.right = None
    if root is None:
        root = newnode
        return root
    else:
        current = root
        while current is not None:
            backup = current
            if current.data > val:
                current = current.left
            else:
                current = current.right
        if backup.data > val:
            backup.left = newnode
        else:
            backup.right = newnode
        return root


def search(root, val):
    i = 1
    while True:
        if root is None:
            return None
        if root.data == val:
            print("查找了{0}次".format(i))
            return root
        elif root.data > val:
            root = root.left
        else:
            root = root.right
        i += 1


def inorder(root):
    if root is not None:
        inorder(root.left)
        print("[%2d]" % root.data, end=" ")
        inorder(root.right)


if __name__ == '__main__':
    data = [7, 1, 4, 2, 8, 13, 12, 11, 15, 9, 5]
    root = None
    for i in range(11):
        root = createTree(root, data[i])
    target = int(input("请输入查找的数值"))
    if search(root, target) is not None:
        print("找到了")
    else:
        print("NO NO ...没找到")
        print("准备插入")
        root = createTree(root, target)
        inorder(root)

# 删除
"""
存在三种情况：
1.删除的节点为树叶，只要将其相连的父节点指向None
2.删除的节点只有一棵子树，
3.删除的节点有两棵子树
    找出中序立即先行者 即将欲删除节点的左子树中最大者往上提 该节点的左子树往右找 直到右指针指向None
    找出中序立即后继者 即将欲删除节点的右子树中最小者往上提 该节点的右子树往左找 直到左指针指向None
"""

平衡二叉树(AVL)

红黑树

B树

B+树

常见面试题

二叉树的三种遍历方式

# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
 
#
#
# @param root TreeNode类 the root of binary tree
# @return int整型二维数组
#
class Solution:
    def threeOrders(self , root ):
        # write code here
        self.res = [[], [], []]
        self.dfs(root)
        return self.res
    def dfs(self , root ):
        if root is None:
            return False
        self.res[0].append(root.val)
        self.dfs(root.left)
        self.res[1].append(root.val)
        self.dfs(root.right)
        self.res[2].append(root.val)
        return True

二叉树的最大深度

题目
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7

class TreeNode():
    def __init__(self):
        self.right = None
        self.left = None
        self.val = None
# 方法一 递归
def maxDepth(root):
    '''
    使用递归的方式
    :param root:
    :return:
    '''
    if root is None:
        return 0
    return max(maxDepth(root.left), maxDepth(root.right)) + 1
# 方法二 广度优先搜索
'''
这里，我们需要添加一个辅助队列。我们将当前层的所有节点都存入这个辅助队列中。
在这里需要注意一点，当我们准备搜索下一层时，这里需要将队列中当前层的所有节点都进行出队，然后让这些节点往下层搜索。
那么，如果当前层的所有节点都出列，队列还非空，那么说明下一层还有节点。循环直至队列为空，
定义变量 depth，每层搜索的时候维护更新该值，那么最终，depth 就是我们要求的二叉树最大深度。
'''
def maxDepth2(root):
    if not root:
        return 0
    from collections import deque
    queue = deque()
    depth = 0
    queue.append(root)
    while queue:
        size = len(queue)
        for i in range(size):
            node = queue.popleft()
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        depth += 1
    return depth

maxDepth2([3, 9, 20, '', '', 15, 7])

二叉树的层次遍历

"""
给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。
"""

def levelOrder(root):
    if root is None:
        return []
    levels = []
    from collections import deque
    # 定义队列
    queue = deque()
    # 最终的返回结果
    result = []
    # 先将根节点入队
    queue.append(root)
    while queue:
        # 记录当前队列的长度
        size = len(queue)
        # 临时列表存储每一层的节点
        cur_level = []
        for _ in range(size):
            # 出队
            node = queue.popleft()
            # 将当前值存储
            cur_level.append(node.val)
            # 当前值的左右节点非空时 入队
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)

        result.append(cur_level)
    return result

有序数组转化为二叉树


"""
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
  一.若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  二.若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  三.它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树
"""
def sortedArrayToBST(nums):
    """
    :type nums: List[int]
    :rtype: TreeNode
    """
    if not nums:
        return None
    length = len(nums)
    mid = length // 2
    root = TreeNode(nums[mid])
    root.left = sortedArrayToBST(nums[:mid])
    root.right = sortedArrayToBST(nums[mid + 1:])
    return root

print(sortedArrayToBST([-10, -3, 0, 5, 9]))

判断是否为对称二叉树

"""
给定一个二叉树，检查它是否是镜像对称的。
# 递归大法
"""


def isSymmetric(root):
    if not root:
        return None
    return auxiliary(root.left, root.right)


def auxiliary(leftNode, rightNode):
    if not leftNode and not rightNode:
        return True
    if not leftNode and rightNode:
        return False
    if leftNode and not rightNode:
        return False
    if leftNode.val != rightNode.val:
        return False
    else:
        return auxiliary(leftNode.left, rightNode.right) and auxiliary(leftNode.right, rightNode.left)

liuwangleoooO

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
树面试题总结

文章目录树的几个概念二叉树概念存储方式操作平衡二叉树(AVL)红黑树B树B+树常见面试题二叉树的三种遍历方式二叉树的最大深度二叉树的层次遍历有序数组转化为二叉树判断是否为对称二叉树树的几个概念由一个或一个以上的节点组成，存在一个特殊的节点，成为树根。其中的每一个子集合本身也是一种树形结构，即此根节点的子树。几个关于树的专有名词度数：每个节点所有子树的个数层数：树的层数高度：树的最大层数树叶或终端节点：度数为零的节点就是树叶。父节点：每一个节点都有连接的上一层节点。子节点：每一个节点都有连
复制链接

扫一扫