平衡二叉树-PHP

最新推荐文章于 2021-08-04 15:07:11 发布
最新推荐文章于 2021-08-04 15:07:11 发布
阅读量205 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： PHP 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/luolaifa000/article/details/84770154
本文详细介绍了平衡二叉树的概念，特点及其实现方法。包括插入、删除操作中如何通过旋转保持树的平衡，提供了PHP代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.平衡树是基于搜索树之上的，主要的特点就是左右子树高度之差不能大于1，即就是平衡因子

2.插入和删除的过程中，要维持各个节点树高度，和维护树平衡

3.维持树平衡，有四种情况，左旋，右旋，先左旋在右旋，先右旋在左旋

github地址 ： https://github.com/luolaifa000/phpStudyCode/blob/master/BlanceTree.php

<?php
function pre($arr)
{
    $data = func_get_args();
    foreach($data as $key=>$val)
    {
        echo '<pre>';
        print_r($val);
        echo '</pre>';
    }
}

function prend()
{
    $data = func_get_args();
    foreach($data as $key=>$val)
    {
        echo '<pre>';
        print_r($val);
        echo '</pre>';
    }
    exit();
}
/**
 * 树节点
 * 
 * @author yumancang
 *
 */
class TreeNode 
{
    /**
     * 左节点
     * @var unknown
     */
    public $lNode;
    
    /**
     * 右节点
     * @var unknown
     */
    public $rNode;
    
    /**
     * 父节点
     * @var unknown
     */
    public $pNode;
    /**
     * 值
     * @var unknown
     */
    public $val;
    
    public $data;
    
    /**
     * 树高度
     * @var unknown
     */
    public $height;
    
    /**
     * 构造
     * 
     * @param int $val
     * @param TreeNode $lNode
     * @param TreeNode $rNode
     */
    public function __construct(int $val = null ,TreeNode $lNode = null ,TreeNode $rNode = null, 
        TreeNode $pNode = null, int $height = 1)
    {
        $this->val = $val;
        $this->lNode = $lNode;
        $this->rNode = $rNode;
        $this->pNode = $pNode;
        $this->height = 1;
    }
}
/**
 * 平衡二叉树
 * 两边子树之前高度差不能大于1，否则需要旋转来达到树平衡
 * @author yumancang
 *
 */
class BlanceTree
{
    public $treeRootNode;
    
    public function __construct()
    {
        $this->treeRootNode = null;
    }

    /**
     * 前序输出树 5 2 1 3 9 8 10
     * 根左右
     * 
     * @param TreeNode $rootNode
     */
    public function prePrintTree(TreeNode $rootNode = null)
    {
        pre($rootNode->val);
        if ($rootNode->lNode) {
            $this->prePrintTree($rootNode->lNode);
        }
        if ($rootNode->rNode) {
            $this->prePrintTree($rootNode->rNode);
        }
        //pre($rootNode);
    }
    /**
     * 中序输出   1 2 3 5 8 9 10
     * 左根右
     * 
     * @param TreeNode $rootNode
     */
    public function middlePrintTree(TreeNode $rootNode = null)
    {
        
        if ($rootNode->lNode) {
            $this->middlePrintTree($rootNode->lNode);
        }
        pre($rootNode->val);
        if ($rootNode->rNode) {
            $this->middlePrintTree($rootNode->rNode);
        }
    }
    
    /**
     * 后序输出  1 3 2 8 10 9 5
     * 左右根
     * 
     * @param TreeNode $rootNode
     */
    public function afterPrintTree(TreeNode $rootNode = null) 
    {
        if ($rootNode->lNode) {
            $this->afterPrintTree($rootNode->lNode);
        }
        if ($rootNode->rNode) {
            $this->afterPrintTree($rootNode->rNode);
        }
        pre($rootNode->val);
    }
    
    /**
     * 
     * 平衡二叉树插入数据
     * 
     */
    public function insertTree($val, &$rootNode, $parentNode = null)
    {
        if ($this->treeRootNode == null) {
            $rootNode = new TreeNode();
            $rootNode->val = $val;
            $rootNode->lNode = null;
            $rootNode->rNode = null;
            $rootNode->pNode = null;
            $rootNode->height = 1;
            return true;
        } else {
            if ($rootNode == null) {
                $rootNode = new TreeNode();
                $rootNode->val = $val;
                $rootNode->lNode = null;
                $rootNode->rNode = null;
                $rootNode->pNode = $parentNode;
                $rootNode->height = 1;
                return true;
            }
        }
        //插入过程已存在就返回不处理
        if ($val == $rootNode->val) {
            return false;
        }
        if ($val < $rootNode->val) {
            $this->insertTree($val, $rootNode->lNode, $rootNode);
        }
        if ($val > $rootNode->val) {
            $this->insertTree($val, $rootNode->rNode, $rootNode);
        }
        $lNodeHeight = $rootNode->lNode ? $rootNode->lNode->height : 1;
        $rNodeHeight = $rootNode->rNode ? $rootNode->rNode->height : 1;
        //求节点的高度
        $rootNode->height = max($lNodeHeight,$rNodeHeight) + 1;
        //节点的平衡因子是否大于1
        #左左情况，右旋
        if (($lNodeHeight - $rNodeHeight) > 1) {
            if ($rootNode->lNode->lNode->height > $rootNode->lNode->rNode->height) {
                $this->rightRotate($rootNode->lNode, $rootNode);
            } else {
                
                $this->leftAndRightRotate($rootNode);
            }
            
        }
        
        #右右情况，左旋
        if (($lNodeHeight - $rNodeHeight) < -1) {
            
            if ($rootNode->rNode->lNode->height > $rootNode->rNode->rNode->height) {
                
                $this->rightAndLeftRotate($rootNode);
            } else {
                $this->leftRotate($rootNode->rNode, $rootNode);
            }
            
        }
        
    }
    
    /**
     * 右左情况，右旋在左旋
     * @param TreeNode $newNode
     * @param TreeNode $oldNode
     */
    public function rightAndLeftRotate(TreeNode $rootNode = null)
    {
        
        //先右旋
        $newNode = $rootNode->rNode->lNode;
        $oldNode = $rootNode->rNode;
        
        $oldNode->lNode = $newNode->rNode;
        $newNode->rNode->pNode = $oldNode;
        
        $newNode->pNode = $oldNode->pNode;
        $oldNode->pNode->rNode = $newNode;
        
        $newNode->rNode = $oldNode;
        $oldNode->pNode = $newNode;

        $newNode->height++;
        $oldNode->height--;
        //在左旋
        $this->leftRotate($rootNode->rNode,$rootNode);
        $this->treeRootNode->pNode = null;
        //prend($this->treeRootNode);
    }
    
    /**
     * 左右情况，左旋在右旋
     * @param TreeNode $newNode
     * @param TreeNode $oldNode
     */
    public function leftAndRightRotate(TreeNode $rootNode = null)
    {
        //先左旋
        $newNode = $rootNode->lNode->rNode;
        $oldNode = $rootNode->lNode;
        
        $oldNode->rNode = $newNode->lNode;
        $newNode->lNode->pNode = $oldNode;
        
        $newNode->pNode = $oldNode->pNode;
        $oldNode->pNode->lNode = $newNode;
        
        $newNode->lNode = $oldNode;
        $oldNode->pNode = $newNode;
        
        $newNode->height++;
        $oldNode->height--;
        
        //在右旋
        $this->rightRotate($rootNode->lNode,$rootNode);
        $this->treeRootNode->pNode = null;
    }
    
    /**
     * 右右情况，左旋
     * @param TreeNode $newNode
     * @param TreeNode $oldNode
     */
    public function leftRotate(TreeNode $newNode = null, TreeNode $oldNode = null)
    {
        $oldNode->rNode = $newNode->lNode;
        if ($newNode->lNode) {
            $newNode->lNode->pNode = $oldNode;
        }
        $newNode->lNode = $oldNode;
        $oldNode->pNode = $newNode;
        
        
        if ($oldNode == $this->treeRootNode)
            $this->treeRootNode = $newNode;
        
        $this->treeRootNode->pNode = null;
            
        $oldNode->height--;
        $oldNode->height--;
        
        //prend($this->treeRootNode);
    }
    
    /**
     * 左左情况，右旋
     * @param TreeNode $newNode
     * @param TreeNode $oldNode
     */
    public function rightRotate(TreeNode $newNode = null, TreeNode $oldNode = null)
    {
        
        $oldNode->lNode = $newNode->rNode;
        if ($newNode->rNode) {
            $newNode->rNode->pNode = $oldNode;
        }
        $newNode->rNode = $oldNode;
        $oldNode->pNode = $newNode;
        
        if ($oldNode == $this->treeRootNode)
            $this->treeRootNode = $newNode;
        $this->treeRootNode->pNode = null;
        $oldNode->height--;
        $oldNode->height--;

        //prend($this->treeRootNode);
    }
    
    /**
     * 查询二叉树
     * 
     * @param int $val
     * @param TreeNode $rootNode
     */
    public function serarchTree(int $val, TreeNode &$rootNode = null)
    {
        if ($rootNode == null) {
            return false;
        }
        if ($val == $rootNode->val) {
            return $rootNode;
        }
        if ($val < $rootNode->val) {
            return $this->serarchTree($val, $rootNode->lNode);
        }
        if ($val > $rootNode->val) {
            return $this->serarchTree($val, $rootNode->rNode);
        }
    }
    
    /**
     * 平衡二叉树中删除节点
     * 跟搜索二叉树删除节点还是不一样的
     * 平衡二叉树原本就维持左右子树高度差不大于1，所有删除过程中
     * 不会出现后继节点出现在子树的子树下面
     * 
     * @param int $val
     * @param TreeNode $rootNode
     */
    public function deleteTree(int $val, TreeNode &$rootNode = null)
    {
        $node = $this->serarchTree($val,$rootNode);
        if (!$node) {
            return false;
        }
        //没有右子树
        if ($node->rNode == null) {
            $this->transplantNode($node,$node->lNode);
        }
        //有右子树
        if ($node->rNode) {
            //右子节点下面没有左节点的话
            if ($node->rNode->lNode == null) {
                $this->transplantNode($node,$node->rNode);
            }
            //右子节点下面有左节点的话
            if ($node->rNode->lNode) {
                //找出下面最小的那个节点，就递归左边
                $minNode = $this->findNodeBelowMin($node->rNode->lNode);
                //移动节点
                $this->transplantNode($minNode,$minNode->rNode);
                $this->transplantSingleNode($node,$minNode);
            }
        }
        
        $lNodeHeight = $node->pNode->lNode ? $rootNode->pNode->lNode->height : 1;
        $rNodeHeight = $rootNode->pNode->rNode ? $rootNode->pNode->rNode->height : 1;
        //求节点的高度
        $node->pNode->height = max($lNodeHeight,$rNodeHeight) + 1;
        //节点的平衡因子是否大于1
        #左左情况，右旋
        if (($lNodeHeight - $rNodeHeight) > 1) {
            if ($node->pNode->lNode->lNode->height > $node->pNode->lNode->rNode->height) {
                $this->rightRotate($node->pNode->lNode, $node->pNode);
            } else {
                
                $this->leftAndRightRotate($node->pNode);
            }
            
        }
        
        #右右情况，左旋
        if (($lNodeHeight - $rNodeHeight) < -1) {
            
            if ($node->pNode->rNode->lNode->height > $node->pNode->rNode->rNode->height) {
                
                $this->rightAndLeftRotate($node->pNode);
            } else {
                $this->leftRotate($node->pNode->rNode, $node->pNode);
            }
            
        }
    }
    /**
     * 移动节点不需要附带自己的左右
     * 
     * 
     * @param TreeNode $source
     * @param TreeNode $des
     * @return boolean
     */
    public function transplantSingleNode(TreeNode $source = null, TreeNode $des = null)
    {
        if ($source == null) {
            return false;
        }
        if ($source->pNode == null) {
            $this->treeRootNode = $des;
            return true;
        }
        //原节点是其父节点的左子树
        if ($source === $source->pNode->lNode) {
            $source->pNode->lNode = $des;
        }
        //原节点是其父节点的右子树
        if ($source === $source->pNode->rNode) {
            $source->pNode->rNode = $des;
        }
        if ($des != null) {
            $des->pNode = $source->pNode;
            $des->rNode = $source->rNode;
            $des->lNode = $source->lNode;
        }
        $des->height = $source->height;
        return true;
    }
    
    /**
     * 找出当前节点和它子树下面最小的节点
     * 
     * @param TreeNode $node
     * @return NULL|TreeNode
     */
    public function findNodeBelowMin(TreeNode $node = null)
    {
        if ($node == null) {
            return null;
        }
        while ($node->lNode != null) {
            $node = $node->lNode;
        }
        return $node;
    }
    
    /**
     * 找出当前节点和它子树下面最大的节点
     * 
     * @param TreeNode $node
     * @return NULL|TreeNode|unknown
     */
    public function findNodeBelowMax(TreeNode $node)
    {
        if ($node == null) {
            return null;
        }
        while ($node->rNode != null) {
            $node = $node->rNode;
        }
        return $node;
    }
    
    /**
     * 移动节点 需要附带自己的左右
     * 
     * @param TreeNode $source
     * @param TreeNode $des
     * @return boolean
     */
    public function transplantNode(TreeNode $source = null, TreeNode $des = null)
    {
        if ($source == null) {
            return false;
        }

        //原节点是其父节点的左子树
        if ($source === $source->pNode->lNode) {
            $source->pNode->lNode = $des;
            
        }
        //原节点是其父节点的右子树
        if ($source === $source->pNode->rNode) {
            $source->pNode->rNode = $des;
        }
        $des != null && $des->pNode = $source->pNode;
        
        while ($source->pNode) {
            $source->pNode->height--;
            $source->pNode = $source->pNode->pNode;
        }

        return true;
    }
    
    public function getNodeBlanceNum(TreeNode $node)
    {
        $lNodeHeight = $node->lNode ? $node->lNode->height : 0;
        $rNodeHeight = $node->rNode ? $node->rNode->height : 0;
        return max($lNodeHeight,$rNodeHeight) + 1;
    }
    
    /**
     * 查找一个节点前继节点
     * 
     * @param int $val
     * @param TreeNode $rootNode
     */
    public function findPreNodeTree(int $val,TreeNode $rootNode = null)
    {

    }
    
    /**
     * 
     * 查找一个节点后继节点
     *
     * @param int $val
     * @param TreeNode $rootNode
     */
    public function findAfterNodeTree(int $val,TreeNode $rootNode = null)
    {

    }
}

$start = memory_get_usage();
$binTree = new BlanceTree();
#插入树
//插入7，左左情况，右旋
/* $binTree->insertTree(10,$binTree->treeRootNode);
$binTree->insertTree(9,$binTree->treeRootNode);
$binTree->insertTree(11,$binTree->treeRootNode);
$binTree->insertTree(8,$binTree->treeRootNode);
$binTree->insertTree(9.1,$binTree->treeRootNode);
$binTree->insertTree(7,$binTree->treeRootNode); */
//插入13，右右情况，左旋
/* $binTree->insertTree(10,$binTree->treeRootNode);
$binTree->insertTree(9,$binTree->treeRootNode);
$binTree->insertTree(11,$binTree->treeRootNode);
$binTree->insertTree(10.1,$binTree->treeRootNode);
$binTree->insertTree(12,$binTree->treeRootNode);
$binTree->insertTree(13,$binTree->treeRootNode); */

//插入9.1，左右情况，先按9左旋，再按9.2右旋
/* $binTree->insertTree(10,$binTree->treeRootNode);
$binTree->insertTree(9,$binTree->treeRootNode);
$binTree->insertTree(11,$binTree->treeRootNode);
$binTree->insertTree(8,$binTree->treeRootNode);
$binTree->insertTree(9.2,$binTree->treeRootNode);
$binTree->insertTree(9.1,$binTree->treeRootNode); */

//插入10.2，右左情况，先按11右旋，再按10.1左旋
/* $binTree->insertTree(10,$binTree->treeRootNode);
$binTree->insertTree(9,$binTree->treeRootNode);
$binTree->insertTree(11,$binTree->treeRootNode);
$binTree->insertTree(10.1,$binTree->treeRootNode);
$binTree->insertTree(12,$binTree->treeRootNode);
$binTree->insertTree(10.2,$binTree->treeRootNode); */

#删除树
//删除根节点，左子树高度大于右边
/* $binTree->insertTree(10,$binTree->treeRootNode);
$binTree->insertTree(9,$binTree->treeRootNode);
$binTree->insertTree(11,$binTree->treeRootNode);
$binTree->insertTree(8,$binTree->treeRootNode);
$binTree->deleteTree(10,$binTree->treeRootNode); */
//删除根节点，左子树高度小于右边
/* $binTree->insertTree(10,$binTree->treeRootNode);
$binTree->insertTree(9,$binTree->treeRootNode);
$binTree->insertTree(11,$binTree->treeRootNode);
$binTree->insertTree(12,$binTree->treeRootNode);
$binTree->deleteTree(10,$binTree->treeRootNode); */
//删除根节点，左子树高度等于右边
/* $binTree->insertTree(10,$binTree->treeRootNode);
$binTree->insertTree(9,$binTree->treeRootNode);
$binTree->insertTree(8,$binTree->treeRootNode);
$binTree->insertTree(11,$binTree->treeRootNode);
$binTree->insertTree(12,$binTree->treeRootNode);
$binTree->deleteTree(10,$binTree->treeRootNode); */
//删除非根节点，左子树高度大于右边
$binTree->insertTree(10,$binTree->treeRootNode);
$binTree->insertTree(9,$binTree->treeRootNode);
$binTree->insertTree(11,$binTree->treeRootNode);
$binTree->insertTree(8,$binTree->treeRootNode);
$binTree->deleteTree(9,$binTree->treeRootNode);
prend($binTree->treeRootNode);
#打印树
pre("中序");
$binTree->middlePrintTree($binTree->treeRootNode);
pre($binTree->treeRootNode);
$end = memory_get_usage();
prend("占用内存:",($end-$start)/1024/1024);

?>

 

 

数据结构-PHP 平衡二叉树(AVL)
qq_38937634的博客
12-11 964
数据结构-PHP 平衡二叉树(AVL) 这篇文章主要介绍一下 平衡二叉树(AVL)，对于 二分搜索树 来说，如果树上的 元素 是顺序 添加的，会导致数据退化成一个 链表，这样就会造成很严重的性能问题，此时就需要在 二分搜索树 的基础上，保证元素插入时平衡，在了解 AVL 之前，需要您对 二分搜索树 有一定的了解，可以参考之前的文章。 1.二分搜索树的问题 如下图所示，若向二分搜索树中添加的元素是按照 顺序 从小到大依次插入的，这样会导致最后节点退化成链表: Tips：反过来依次从大到插入元素也会出现退化
平衡二叉树的平衡实现--插入、删除
Allen_Walker_QAQ的博客
06-13 2500
插入    若向平衡二叉树中插入一个新结点后破坏了平衡二叉树的平衡性。首先要找出插入新结点后失去平衡的根结点的指针最小子树。然后再调整这个子树中有关结点之间的链接关系，使之成为新的平衡子树。当失去平衡的最小子树被调整为平衡子树后，原有其他所有不平衡子树无需调整，整个二叉排序树就又成为一棵平衡二叉树。失去平衡的最小子树是指以离插入结点最近，且平衡因子绝对值大于 1 的结点作为根的子树。假设用 A 表...
PHP二叉树（二）：平衡二叉树（AVL）
LSGOZJ的博客
10-26 2158
关于平衡二叉树的原理网上的资源就挺多的，而且情况有点小复杂，所以在这里我就不再陈述了，直接上代码吧：<?php /** * author:zhongjin * time:2016/10/20 11:53 * description: 平衡二叉树 */ //结点 class Node { public $key; public $parent; public $left
PHP实现平衡二叉树(AVL树)
11-20 145
<?php require 'bstOrder.php'; $test = range(1, 10); //$test = array(3,9,1,4,8,5,7,6,2,10); $tree = new Bst($test, true); //$tree->deleteNode('30');(非平衡树可删除,平衡树的没写删...
平衡二叉树
周翔的专栏
05-24 1122
二叉树的查找，插入和删除操作的时间与树的高度有关，如果树尽量的矮胖，那么时间就短，那就要是满二叉树，或者说满N叉树，对于一颗M个节点的满N叉树时间复杂度为，但是维护满叉树，难度是很大的。所以AVL树(平衡树)放宽了条件，允许左右子树的高度差在一定的范围之内，avl树平衡条件是左右子树高度相差不能为2，而不是满叉树左右子树高度相同。AVL是以提出它的两位苏联数学家的名字头字母命名的。一棵N个节点的A
平衡二叉树及PHP实现~
patriot_28的博客
08-04 328
性质 平衡二叉树（Balanced Binary Tree）又被称为AVL树（有别于AVL算法），除了具有二叉查找树的性质，还具有以下性质： 它是一棵空树或它的左右两个子树的高度差的绝对值不超过1， 并且左右两个子树也是平衡二叉树。 这个方案很好的解决了二叉查找树退化成链表的问题，把插入，查找，删除的时间复杂度最好情况和最坏情况都维持在O(logN)。但是频繁旋转会使插入和删除牺牲掉O(logN)左右的时间，不过相对二叉查找树来说，时间上稳定了很多。 平衡因子 一个节点的平衡因子就是该节点左子树的高度减
PHP实现绘制二叉树图形显示功能详解【包括二叉搜索树、平衡树及红黑树】
10-19
二叉树的种类繁多，包括二叉搜索树（BST）、平衡二叉树（AVL树）、红黑树等，每种树都有其特定的用途和特性。 接下来，我们以PHP语言为例，探讨如何利用PHP实现二叉树的图形显示功能。这部分主要包括以下几个核心...
PHP实现二叉树图
08-25
为了更高效地处理大数据，还可以考虑使用平衡二叉树，如AVL树或红黑树。 在PHP中实现二叉树，还需要考虑错误处理、内存管理以及如何将二叉树序列化和反序列化，以便在持久存储中保存和恢复。此外，还可以扩展这个...
PHP Class&Object -- PHP 自排序二叉树的深入解析
10-27
为了避免这种情况，可以使用自平衡二叉树，如AVL树或红黑树，它们在每次插入或删除后都能自动调整以保持平衡。 总的来说，自排序二叉树在PHP中是一种强大且高效的工具，适用于需要动态维护有序集合的场景，例如...
python 平衡二叉树实现代码示例
09-20
主要介绍了python 平衡二叉树实现代码示例，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
php 平衡二叉树,PHP代码实现平衡二叉树详解
weixin_35767338的博客
03-17 181
一、什么是平衡二叉树平衡二叉树(Self-Balancing Binary Search Tree 或者 Height-Balancing Binary Search Tree)译为 自平衡的二叉查找树或者高度平衡的二叉查找树，简称平衡二叉树，也叫 AVL 树，是一种二叉排序树。每个节点的左子树和右子树的高度差至多等于 1，我们将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子 BF(Ba...
利用PHP实现二叉树的图形显示
LSGOZJ的博客
10-21 6176
前言：最近老师布置了一个作业：理解并实现平衡二叉树和红黑树，本来老师是说用C#写的，但是我学的C#基本都还给老师了，怎么办？那就用现在最熟悉的语言PHP来写吧！有一个问题来了，书上在讲解树的时候基本上会给出形象的树形图。但是当我们自己试着实现某种树，在调试、输出的时候确只能以字符的形式顺序地输出。这给调试等方面带来了很大的不便。然后在各种百度之后，我发现利用PHP实现二叉树的图形显示的资源几乎是零！
Leetcode110. 平衡二叉树 （python3）
weixin_43199534的博客
03-04 391
Leetcode110. 平衡二叉树 题目描述： 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 解法1： class Solution: def isBalanced(self, root): &quot;&quot;&quot; :type root: TreeNode ...
leetcode 110. 平衡二叉树(python3)
算法探索之路
03-13 225
110. 平衡二叉树 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # ...
LeetCode 110 平衡二叉树 Python3
mxxxkuku的博客
03-17 142
1、深度搜索，自顶向下 遍历节点时都判断是否满足平衡的条件 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: def isBalan
leetcode110.平衡二叉树(python3实现)
qq_28805597的博客
11-05 336
问题描述 链接：leetcode110 我的解法 # Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: #取当前结点的高度。叶子节点为0，父
LeetCode110-平衡二叉树-Python3
王俊的博客
02-07 372
题目 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 返回 true 。示例 2: 给定二叉树 [1,2,2,3,3,null,...
平衡二叉树-python
baisong6412的博客
08-10 135
思路：平衡二叉树的左右子树的深度相差不能超过1， 因此可以利用上一题求二叉树的深度的函数，对左右子树求最大深度，如果深度小于1，那么就是平衡二叉树了 # -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None ...
python 平衡二叉树
WYXHAHAHA123的博客
05-06 368
''' 题目描述 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 ''' # -*- coding:utf-8 -*- # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Soluti...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值