4. Python 树与二叉树

最新推荐文章于 2024-06-10 22:18:41 发布
最新推荐文章于 2024-06-10 22:18:41 发布
阅读量61 收藏
点赞数
分类专栏： Python算法 文章标签： python 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45276194/article/details/129451786
版权

4.1 树

树的一些性质在其它语言的数据结构中学习过就不多赘述了（因为懒）

树的简单实例：模拟文件系统

# 树的实例
class Node:
    def __init__(self, name, type='dir'):
        self.name = name
        self.type = type
        self.children = []
        self.parent = None  # 找回上一层文件夹
# n = Node('hello')
# n2 = Node('world')
# # n2文件夹在n的文件内
# n.children.append(n2)
# n2.parent = n  # 找父母
    # 打印文件名
    def __repr__(self):
        return self.name

class FileSystemTree:
    def __init__(self):
        self.root = Node('/')  # 表示根目录
        self.now = self.root  # 表示当前节点位置

    #创建一个文件夹
    def mkdir(self, name):
        #  name得以 / 结尾
        if name[-1] != '/':
            name += '/'
        node = Node(name)
        self.now.children.append(node)
        node.parent = self.now

    # 展示当前目录下的所有子目录
    def ls(self):
        return self.now.children

    # 切换目录
    def cd(self, name):
        # 相对路径
        if name[-1] != '/':
            name += '/'
        if name == '../':
            self.now = self.now.parent
            return
        # 如果children里面有要找的目录名字，就返回。
        for child in self.now.children:
            if child.name == name:
                self.now = child  # 如果找到了，就切换称它的孩子
                return
        # 如果一直没有找到，就报错
        raise ValueError('invalid dir')


tree = FileSystemTree()
# 在根目录下创建三个目录
tree.mkdir('var/')
tree.mkdir('bin/')
tree.mkdir('usr/')

tree.cd('bin/')
tree.mkdir('python/')
print(tree.ls())  # 跳转到了python/目录下

4.2 二叉树

二叉树的链式存储：将二叉树的节点定义为一个对象，节点之间通过类似链表的链接方式来链接。

节点定义：

class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None

简单构建一个二叉树

class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None  # 左孩子
        self.rchild = None  # 右孩子


a = BiTreeNode('A')
b = BiTreeNode('B')
c = BiTreeNode('C')
d = BiTreeNode('D')
e = BiTreeNode('E')
f = BiTreeNode('F')
g = BiTreeNode('G')
e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f
root = e
print(root.lchild.rchild.data)

还是上面那个图，二叉树的遍历：

  • 前序遍历：EACBDGF
  • 中序遍历：ABCDEGF
  • 后序遍历：BDCAFGE
  • 层次遍历：EAGCFBD
# 二叉树
from collections import deque
class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None  # 左孩子
        self.rchild = None  # 右孩子


a = BiTreeNode('A')
b = BiTreeNode('B')
c = BiTreeNode('C')
d = BiTreeNode('D')
e = BiTreeNode('E')
f = BiTreeNode('F')
g = BiTreeNode('G')
e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f
root = e
print(root.lchild.rchild.data)


# 前序遍历
def pre_order(root):
    # 如果根节点不为空
    if root:
        # 访问根节点
        print(root.data, end='')
        # 访问左子树
        pre_order(root.lchild)
        # 访问右子树
        pre_order(root.rchild)


# 中序遍历
def in_order(root):
    if root:
        # 先访问左子树
        in_order(root.lchild)
        # 访问根节点
        print(root.data, end='')
        # 再访问右子树
        in_order(root.rchild)


# 后序遍历
def post_order(root):
    if root:
        # 先访问左子树
        post_order(root.lchild)
        # 再访问右子树
        post_order(root.rchild)
        # 最后访问根节点
        print(root.data, end='')


# 层次遍历
def level_order(root):
    queue = deque()
    queue.append(root)
    while len(queue) >0:  # 只要队不空
        node = queue.popleft()
        print(node.data, end='')
        if node.lchild:
            queue.append(node.lchild)
        if node.rchild:
            queue.append(node.rchild)


pre_order(root)
print()
in_order(root)
print()
post_order(root)
print()
level_order(root)

4.3 二叉搜索树

二叉搜索树是一颗二叉树且满足性质：设x是二叉树的一个节点。如果y是x左子树的一个节点，那么y.key ≤ x.key；如果y是x右子树的一个节点，那么y.key ≥ x.key。

二叉搜索树的操作：查询、插入、删除

4.3.1 插入

import random


class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None  # 左孩子
        self.rchild = None  # 右孩子
        self.parent = None

class BST:
    def __init__(self, li=None):
        self.root = None
        if li:
            for val in li:
                self.insert_no_rec(val)

    # 插入（递归版）
    def insert(self, node, val):
        if not node:
            node = BiTreeNode(val)
        # 递归左孩子
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node
        # 递归右孩子
        elif val > node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node
        return node

    # 插入（非递归版）
    def insert_no_rec(self, val):
        p = self.root
        if not p:  # 空树
            self.root = BiTreeNode(val)
            return
        # 不是空树 循环
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:  # 左子树不存在
                    p.lchild = BiTreeNode(val)  # 插入该节点
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:  # 右子树不存在
                    p.rchild = BiTreeNode(val)  # 插入该节点
                    p.rchild.parent = p
                    return
            else:  # 等于什么也不干
                return

4.3.2 删除

1.如果要删除的节点是叶子节点：直接删除。

2.如果要删除的节点只有一个孩子：将此节点的父节点与孩子连接，然后删除该节点。

3.如果删除的节点有两个孩子：将其右子树的最小节点（该节点最多有一个右孩子）删除，并替换当前节点。

     # 递归查找
    def query(self, node, val):
        if not node:
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

        # 非递归查找
    def query_no_rec(self, val):
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                 p = p.lchild
            else:
                  return p
        return None

    # 情况一：node是叶子节点
    def __remove_node_1(self, node):
        # 如果是根节点
        if not node.parent:
            self.root = None
        if node == node.parent.lchild:  # node是它父亲节点的左孩子
            node.parent.lchild = None
        else:  # node是它父亲节点的右孩子
           node.parent.rchild = None

    # 情况2.1：node只有一个左孩子
    def __remove_node_2l(self, node):
        if not node.parent:  # 根节点
            self.root = node.lchild  # 它变成根了
            node.lchild.parent = None
        elif node == node.parent.lchild:  # 该节点是父节点的左孩子
            node.parent.lchild = node.lchild  # 该节点的父节点与该节点的左孩子连接
            node.lchild.parent = node.parent
        else:  # 该节点是父节点的右孩子
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    # 情况2.2：node只有一个右孩子
    def __remove_node_2r(self, node):
        if not node.parent:  # 根节点
            self.root = node.rchild
        elif node == node.parent.lchild: # 该节点是父节点的左孩子
            node.parent.lchild = node.rchild  # 该节点的父节点与该节点的右孩子
            node.rchild.parent = node.parent
        else:  # 该节点是父节点的右孩子
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent

    def delete(self, val):
        if self.root:  # 不是空树才能删
            node = self.query_no_rec(val)
            if not node:  # 如果node不存在
                return False
            if not node.lchild and not node.rchild:  # 情况1：叶子节点
                self.__remove_node_1(node)
            elif not node.rchild:  # 情况2.1：没有右孩子只有左孩子
                self.__remove_node_2l(node)
            elif not node.lchild:
                self.__remove_node_2r(node)  # 情况2.2：没有左孩子只有右孩子
            else:  # 情况3：两个孩子都有
                min_node = node.rchild  # 找右孩子的最小节点
                while min_node.lchild:
                    min_node = min_node.lchild  # 一直找最小的那个节点
                node.data = min_node.data
                # 删除min_node 要判断它是情况1还是情况2
                if min_node.rchild:
                    self.__remove_node_2r(min_node)
                else:
                    self.__remove_node_1(min_node)

插入、查找、删除的完整代码

#
import random


class BiTreeNode:
    def __init__(self, data):
        self.data = data
        self.lchild = None  # 左孩子
        self.rchild = None  # 右孩子
        self.parent = None

class BST:
    def __init__(self, li=None):
        self.root = None
        if li:
            for val in li:
                self.insert_no_rec(val)

    # 插入（递归版）
    def insert(self, node, val):
        if not node:
            node = BiTreeNode(val)
        # 递归左孩子
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node
        # 递归右孩子
        elif val > node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node
        return node

    # 插入（非递归版）
    def insert_no_rec(self, val):
        p = self.root
        if not p:  # 空树
            self.root = BiTreeNode(val)
            return
        # 不是空树 循环
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:  # 左子树不存在
                    p.lchild = BiTreeNode(val)  # 插入该节点
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:  # 右子树不存在
                    p.rchild = BiTreeNode(val)  # 插入该节点
                    p.rchild.parent = p
                    return
            else:  # 等于什么也不干
                return

    # 前序遍历
    def pre_order(self, root):
        # 如果根节点不为空
        if root:
            # 访问根节点
            print(root.data, end=' ')
            # 访问左子树
            self.pre_order(root.lchild)
            # 访问右子树
            self.pre_order(root.rchild)

    # 中序遍历
    def in_order(self, root):
        if root:
            # 先访问左子树
            self.in_order(root.lchild)
            # 访问根节点
            print(root.data, end=' ')
            # 再访问右子树
            self.in_order(root.rchild)

    # 后序遍历
    def post_order(self, root):
        if root:
            # 先访问左子树
            self.post_order(root.lchild)
            # 再访问右子树
            self.post_order(root.rchild)
            # 最后访问根节点
            print(root.data, end=' ')

        # 递归查找
    def query(self, node, val):
        if not node:
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

        # 非递归查找
    def query_no_rec(self, val):
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                 p = p.lchild
            else:
                  return p
        return None

    # 情况一：node是叶子节点
    def __remove_node_1(self, node):
        # 如果是根节点
        if not node.parent:
            self.root = None
        if node == node.parent.lchild:  # node是它父亲节点的左孩子
            node.parent.lchild = None
        else:  # node是它父亲节点的右孩子
           node.parent.rchild = None

    # 情况2.1：node只有一个左孩子
    def __remove_node_2l(self, node):
        if not node.parent:  # 根节点
            self.root = node.lchild  # 它变成根了
            node.lchild.parent = None
        elif node == node.parent.lchild:  # 该节点是父节点的左孩子
            node.parent.lchild = node.lchild  # 该节点的父节点与该节点的左孩子连接
            node.lchild.parent = node.parent
        else:  # 该节点是父节点的右孩子
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    # 情况2.2：node只有一个右孩子
    def __remove_node_2r(self, node):
        if not node.parent:  # 根节点
            self.root = node.rchild
        elif node == node.parent.lchild: # 该节点是父节点的左孩子
            node.parent.lchild = node.rchild  # 该节点的父节点与该节点的右孩子
            node.rchild.parent = node.parent
        else:  # 该节点是父节点的右孩子
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent

    def delete(self, val):
        if self.root:  # 不是空树才能删
            node = self.query_no_rec(val)
            if not node:  # 如果node不存在
                return False
            if not node.lchild and not node.rchild:  # 情况1：叶子节点
                self.__remove_node_1(node)
            elif not node.rchild:  # 情况2.1：没有右孩子只有左孩子
                self.__remove_node_2l(node)
            elif not node.lchild:
                self.__remove_node_2r(node)  # 情况2.2：没有左孩子只有右孩子
            else:  # 情况3：两个孩子都有
                min_node = node.rchild  # 找右孩子的最小节点
                while min_node.lchild:
                    min_node = min_node.lchild  # 一直找最小的那个节点
                node.data = min_node.data
                # 删除min_node 要判断它是情况1还是情况2
                if min_node.rchild:
                    self.__remove_node_2r(min_node)
                else:
                    self.__remove_node_1(min_node)
                    
                    
# li = list(range(15))
# random.shuffle(li)
# tree = BST(li)
# tree.pre_order(tree.root)
# print()
# tree.in_order(tree.root)  # 是排好序的
# print()
# tree.post_order(tree.root)
tree = BST([1, 4, 2, 5, 3, 8, 6, 9, 7])
tree.in_order(tree.root)
print()
tree.delete(4)
tree.in_order(tree.root)

二叉搜索树的效率：平均情况下，二叉搜索树进行搜索的时间复杂度为O(lgn)

最坏情况下，二叉搜索树可能非常偏斜

解决方案：随机化插入、AVL树

4.4 AVL树

AVL树是一棵自平衡的二叉搜索树，也叫平衡二叉树，有以下性质：

  • 根的左右子树的高度之差的绝对值不能超过1；
  • 根的左右子树都是平衡二叉树。

4.4.1 插入

  • 插入一个节点可能会破坏AVL树的平衡，可以通过旋转操作来进行修正；
  • 插入一个节点后，只有从插入节点道根节点的路径上的节点的平衡可能被改变。我们需要找出第一个破坏了平衡条件的节点，称之为K。K的两颗子树的高度差2；

不平衡的出现可能有4种情况

1. 不平衡更是由于对K的右孩子的右子树插入导致的：左旋

2. 不平衡是由于对K的左孩子的左子树插入导致的：右旋

 3. 不平衡是由于对K的右孩子的左子树插入导致的：右旋-左旋

  3. 不平衡是由于对K的左孩子的右子树插入导致的：左旋-右旋

from bst import BiTreeNode, BST


class AVLNode(BiTreeNode):
    def __init__(self, data):
        BiTreeNode.__init__(self, data)
        # 平衡度K
        self.bf = 0  # 左边沉是-1，右边沉是1


class AVLTree(BST):
    def __init__(self, li=None):
        BST.__init__(self, li)

    # 左旋
    def rotate_left(self, p, c):
        s2 = c.lchild
        p.rchild = s2
        if s2:
            s2.parent = p
        c.lchild = p
        p.parent = c
        p.bf = 0
        c.bf = 0
        return c

    # 右旋
    def rotate_right(self, p, c):
        s2 = c.rchild
        p.lchild = s2
        if s2:
            s2.parent = p
        c.rchild = p
        p.parent = c
        p.bf = 0
        c.bf = 0
        return c

    # 右旋-左旋
    def rotate_right_left(self, p, c):
        # 右旋
        g = c.lchild
        s3 = g.rchild
        c.lchild = s3
        if s3:
            s3.paren = c
        g.rchild = c
        c.parent = g
        # 左旋
        s2 = g.lchild
        p.rchild = s2
        if s2:
            s2.parent = p
        g.lchild = p
        p.parent = g
        # 更新bf
        if g.bf > 0:
            # 元素插入到s3上
            p.bf = -1
            c.bf = 0
        elif g.bf < 0:
            # 元素插入到s2上
            p.bf = 0
            c.bf = 1
        else:  # 插入的元如是g
            p.bf = 0
            c.bf = 0
        g.bf = 0
        return g

    # 左旋-右旋
    def rotate_left_right(self, p, c):
        # 左旋
        g = c.rchild
        s2 = g.lchild
        c.rchild = s2
        if s2:
            s2.parent = c
        g.lchild = c
        c.parent = g
        # 右旋
        s3 = g.rchild
        p.lchild = s3
        if s3:
            s3.parent = p
        g.rchild = p
        p.parent = g
        # 更新bf
        if g.bf < 0:  # 元素插入到s2
            p.bf = 1
            c.bf = 0
        elif g.bf > 0:  # 元素插入到s3
            p.bf = 0
            c.bf = -1
        else:  # 插入的元素其实是g
            p.bf = 0
            c.bf = 0
        g.bf = 0
        return g

    def insert_no_rec(self, val):
        # 和BST一样，先插入再判断
        p = self.root
        if not p:  # 空树
            self.root = AVLNode(val)
            return
        # 不是空树 循环
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:  # 左子树不存在
                    p.lchild = AVLNode(val)  # 插入该节点
                    p.lchild.parent = p
                    node = p.lchild  # node存储的就是插入的节点
                    break
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:  # 右子树不存在
                    p.rchild = AVLNode(val)  # 插入该节点
                    p.rchild.parent = p
                    node = p.rchild
                    break
            else:  # val == p.data
                return
        # 更新balance factor(bf)
        while node.parent:  # node.parent不空
            if node.parent.lchild == node:  # 传递是从左子树来的，左子树更沉
                # 更新node.parent的bf -=1
                if node.parent.bf < 0:  # 原来node.parent.bf == -1，更新后变成-2->>>就要进行旋转
                    # 做旋转
                    # 看node哪边沉
                    g = node.parent.parent  # 为了连接旋转之后的子树用
                    x = node.parent  # 记一下旋转之前子树的根
                    if node.bf > 0:  # 右边沉
                        n = self.rotate_left_right(node.parent, node)
                    else:  # 左边沉
                        n = self.rotate_right(node.parent, node)
                    # 记得把n和g连起来
                elif node.parent.bf > 0:  # 原来原来node.parent.bf == 1，更新后变成0
                    node.parent.bf = 0
                    # 不再传递
                    break
                else:  # # 原来原来node.parent.bf == 0，更新后变成-1
                    node.parent.bf = -1
                    node = node.parent
                    # 继续传递
                    continue
            else:  # 传递是从右子树来的，右子树更沉
                # 更新后的node.parent.bf +=1
                if node.parent.bf > 0:  # 原来node.parent.bf == 1，更新后变成2
                    # 左旋转，看node哪边沉
                    g = node.parent.parent  # 为了连接旋转之后的子树用
                    x = node.parent  # 记一下旋转之前子树的根
                    if node.bf < 0:  # node.bf = -1
                        n = self.rotate_right_left(node.parent, node)
                    else:  # node.bf = 1
                        n = self.rotate_left(node.parent, node)
                    # 记得连起来
                elif node.parent.bf < 0:  # 原来node.parent.bf == -1，更新后变成0
                    node.parent.bf = 0
                    break
                else: # 原来node.parent.bf == 0，更新后变成1
                    node.parent.bf = 1
                    node = node.parent
                    # 继续传递
                    continue
            # 连接旋转后的子树->>>就是连接g和n
            n.parent = g
            if g:  # g不空
                if x == g.lchild:  # g原来的左孩子是node.parent
                    g.lchild = n
                else:  # g原来的右孩子是node.parent
                    g.rchild = n
                break
            else:  # g空
                self.root = n
                break


tree = AVLTree([9, 8, 7, 6, 5, 4, 3, 2, 1])
tree.pre_order(tree.root)
print()
tree.in_order(tree.root)

AVL树的扩展：B树，B树是一颗自平衡的多路搜索树。常用于数据库的索引。

秃头少女Emily
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
树和二叉树的转换代码python_Python - 将n-ary树转换为二叉树
weixin_28864485的博客
02-12 873
class Tree:def __init__(self, new_key):self.__key = new_key # Root key valueself.__children = [] # List of childrenself.__num_of_descendants = 0 # Number of Descendants of this node# Prints the...
python数据结构树和二叉树简介
01-20
一、树的定义 树形结构是一类重要的非线性结构。树形结构是结点之间有分支，并具有层次关系的结构。它非常类似于自然界中的树。树的递归定义：树(Tree)是n(n≥0)个结点的有限集T，T为空...特点：（1）二叉树是有序树，
Django让web开发更简单（四）：设计视图
weixin_43431593的博客
10-01 345
Views views，即视图，用于处理业务逻辑，整合前端请求、数据处理和响应。可以先看看我的另一篇文章进行了解：https://blog.csdn.net/weixin_43431593/article/details/107142415
看懂二叉树的三种遍历
Apollo的博客
04-18 3203
转载自 https://blog.csdn.net/soundwave_/article/details/53120766 二叉树有三种遍历方式，前序遍历（preorder traversal ），中序遍历（inorder traversal ），后序遍历（postorder traversal ）。下面给出详细的解释： 1．先（根）序遍历的递归算法定义： 若二叉树非空，则依次执行如下...
Python实现二叉树递归遍历
flyingluohaipeng的博客
03-24 1523
二叉树是一种基础数据结构，二叉树有两种存储方式顺序存储，和链式存储。顺序存储就是用数组来存，链式存储用链表存储，相对于链表二叉树的节点里多了一个指针， 有两个指针，指向左右孩子。
965. 单值二叉树 Python
ChengSlime的博客
07-20 135
单值二叉树 如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。 只有给定的树是单值二叉树时，才返回 true；否则返回 false。 示例 1： 输入：[1,1,1,1,1,null,1] 输出：true 示例 2： 输入：[2,2,2,5,2] 输出：false 提示： 给定树的节点数范围是 [1, 100]。 每个节点的值都是整数，范围为 [0, 99] 。 class Solution: def isUnivalTree(self, root: TreeNode) -> .
12.python实现顺序存储二叉树
woshiwjma956的博客
08-31 1442
顺序存储二叉树是指用一个数组存储的二叉树，一般用于完全二叉树，物理上用数组存储逻辑上是一个树结构。 第n个元素的左节点索引2n+1 第n个元素的右节点索引2n+2 第n个元素的父节点为(n-1)/2 n为元素在数组中的索引 class Node(object): def __init__(self, data): self.data = data class ArrayBinaryTree(object): """ 顺序存储二叉树是指用一个数组存储的二叉树，一
13.python实现线索化二叉树
woshiwjma956的博客
08-31 610
线索二叉树 二叉树的叶子节点会有一些空的指针，如果有n个节点则会有n+1个空指针域，将这些空指针域利用起来存在该二叉树为某一种遍历次序下的前驱节点和后继节点的二叉树成为线索二叉树。根据线索二叉树性质不同分为前序线索二叉树，中序线索二叉树，后续线索二叉树。 一个节点的前一个节点为前驱节点，一个节点的后一个节点为后继节点 核心思想 当线索化二叉树的时候left和right就分为两种情况 left指向左子树或者指向前驱节点 right指向右子树或者后继节点 实现线索化二叉树的需要对之前Node节点实体进行
Python数据结构与算法篇（十二）-- 树和二叉树
CarpeDiem
03-19 1881
终于学到了二叉树，LeetCode里面三分之一都是关于二叉树，俗话说打铁还需自身硬，本节学习树的基本概念，二叉树的实现、遍历、转换二叉树等。
Python 树算法 之 二叉树 详解
Nick.Peng's Blogs
04-08 1018
树与树算法 树的概念: 是一种抽象数据类型(ADT), 或是实作这种抽象数据类型的数据结构，用来模拟具有树状结构性质的数据集合。它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 树的特点: 每个节点有0个或多个子节点 没有父节点的节点叫根节点 每一个非根节点有且只有一个父节点 除了根节点...
【python】二叉树的创建
weixin_44844635的博客
07-11 2590
面试题目：使用 python 定义树节点，并实例化一个二叉树
树和二叉树python实现与讲解.docx
10-30
二叉树
Python3 合并二叉树的实现
09-18
主要介绍了Python3 合并二叉树的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Python实现普通二叉树
12-21
二叉树是每个节点最多有两个子树的树结构，本文使用Python来实现普通的二叉树。 关于二叉树的介绍，可以参考：https://blog.csdn.net/weixin_43790276/article/details/104737870 一、实现节点类 所有树结构都是由一...
Python实现完全二叉树
01-20
物理有序将数据存储在连续的内存空间中，例如存储在一个列表中，这种方式因为有下标，在遍历速度上有一定的优势，但是，对于一棵二叉树来说，将数据存储在一个线性的列表中，不容易体现出树中父节点与子节点之间的...
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏
m0_73367097的博客
06-08 1909
自制植物大战僵尸
删除目录
橙子味冰可乐的博客
06-07 526
shutil.rmtree("C:\\demo\\test") # 删除C:\demo目录下的test子目录及其内容。os.rmdir("C:\\demo\\test\\dir\\mr") # 删除C:\demo\test\dir\mr目录。path = "C:\\demo\\test\\dir\\mr" # 指定要创建的目录。os.rmdir("C:\\demo\\test\\dir\\mr") # 删除目录。
基于JavaScript 如何实现爬山算法以及优化方案
最新发布
乐闻世界
06-10 1205
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
Java——简单图书管理系统
m0_74100417的博客
06-09 1234
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
python树转二叉树
11-24
树和二叉树是两种不同的数据结构，它们之间的转换需要进行一定的处理。下面是将树转换为二叉树的Python代码： ```python class TreeNode: def __init__(self, x): self.val = x self.left = None self.right = None def tree_to_bst(root): if not root: return None new_root = TreeNode(root.val) if len(root.children) > 0: new_root.left = tree_to_bst(root.children[0]) curr = new_root.left for child in root.children[1:]: curr.right = tree_to_bst(child) curr = curr.right return new_root ``` 上述代码中，我们定义了一个TreeNode类，表示二叉树的节点。然后我们定义了一个tree_to_bst函数，用于将树转换为二叉树。该函数的参数是树的根节点，返回值是二叉树的根节点。 在函数内部，我们首先判断根节点是否为空，如果为空则直接返回None。否则，我们创建一个新的二叉树根节点new_root，其值为树的根节点的值。然后，我们判断树的根节点是否有子节点，如果有，则将其第一个子节点转换为二叉树节点，并将其作为new_root的左子节点。接着，我们遍历树的其他子节点，将它们转换为二叉树节点，并将它们依次作为new_root的右子节点。 需要注意的是，上述代码中的TreeNode类只包含了一个值和左右子节点，如果需要在节点中存储更多的信息，可以在TreeNode类中添加相应的属性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

秃头少女Emily

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值