有序数组转换为平衡二叉树(BST)

最新推荐文章于 2025-07-10 14:57:18 发布
原创 最新推荐文章于 2025-07-10 14:57:18 发布 · 3.1k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种将有序数组转换为平衡二叉搜索树的方法，并提供了详细的C++实现代码。通过递归地选择中间元素作为根节点，确保了树的平衡性。
把有序数组转换为平衡二叉树。
<pre name="code" class="cpp">TreeNode* buildTree(vector<int> &nums,int start,int last)
{
	int mid = (start + last) / 2;
	TreeNode *root = new TreeNode(nums[mid]);
	if(start == last)
	{
		return root;
	}
	if(start <= mid - 1)
	{
		root->left = buildTree(nums,start,mid-1);
	}
	if(mid+1 <=  last)
	{
		root->right = buildTree(nums,mid+1,last);
	}
	return root;
}

TreeNode* sortedArrayToBST(vector<int>& nums) {
	if(nums.empty())
		return NULL;
	return buildTree(nums,0,nums.size()-1);
}




                

        

    

    
  



    



                



	

		

			

				
					
C语言实现有序数组转换为平衡二叉树

				
			

			

				

					TechWhizKid的博客
				

				

					09-06
					
					71
					
				

			

		

		

			
				
函数中，我们首先检查起始索引是否大于结束索引，如果是，则返回空指针，表示当前子数组为空。否则，我们计算中间元素的索引，并创建一个新的节点作为当前子树的根节点。在本文中，我将向您展示如何使用C语言将有序数组转换为平衡二叉树。平衡二叉树是一种特殊的二叉树，它的左子树和右子树的高度差不超过1，这样可以保证树的操作具有较好的性能。，它将有序数组转换为平衡二叉树。该函数将接受一个整数数组和数组的起始索引和结束索引作为参数。接下来，我们将编写一个简单的主函数来测试它。在上面的代码中，我们定义了一个有序数组。

			
		

	



                

            
              



	

		

			

				
					
有序平衡二叉树(AVL树)

				
			

			

				

					07-23
				

			

		

		

			
				
一棵AVL树或者是空树，或者是具有下列性质的二叉搜索树：它的左子树和右子树都是AVL树，且左子树和右子树的高度之差的绝对值不超过1。

			
		

	



              


  
              

                


	

		

			

				
					
有序数组建立平衡二叉树

				
			

			

				

					qq_45419640的博客
				

				

					03-23
					
					503
					
				

			

		

		

			
				
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* sortedArrayToBST(vec.

			
		

	





	

		

			

				
					
根据升序数组创建高度平衡(height-balanced)二叉搜索树

					
最新发布

				
			

			

				

					Rerdual的博客
				

				

					07-10
					
					149
					
				

			

		

		

			
				
根据二叉树的结构特性，用二分法寻找子结点（递归）。递归的条件：给定当前结点n（当前结点总为数组的最中间元素），n的左子结点应当是原数组以n左侧1个的元素为上界的数组的最中间元素，n的右子结点应当是原数组以n右侧1个的元素为下界的数组中的最中间元素。因此，核心在于不断找到左、右两个数组的最中间元素。递归的停止条件是数组为空。给定一个升序数组，例如[-10, 3, 5, 9, 7]，创建一个高度平衡的二叉树。所谓高度平衡的二叉树，即任意一个结点的左右子树的深度(depth)差异<=1。

			
		

	



		

			
		



	

		

			

				
					
LeetCode题解(0108)：将有序数组转换为高度平衡二叉树(Python)

				
			

			

				

					长行
				

				

					06-17
					
					380
					
				

			

		

		

			
				
LeetCode题解：0108（将有序数组转换为二叉搜索树）
题目链接（简单）
高度平衡二叉树是指每个节点左右两个子树的高度差的绝对值不超过1个。




解法
执行用时




Ans 1 (Python)
56ms (>79.75%)


解法一（中序遍历）：
def sortedArrayToBST(self, nums: List[int]) -> TreeNode:
    def helper(left, right):
        if left > right:
   

			
		

	





	

		

			

				
					
将升序数组转化为平衡二叉树

				
			

			

				

					WonSoon的专栏
				

				

					04-29
					
					1801
					
				

			

		

		

			
				
public class Solution {
    TreeNode convert(int num[], int l, int r) {
        if (l >= r) return null;
        int m = (l + r) / 2;
        TreeNode left = convert(num, l, m);
        TreeNode root 

			
		

	





	

		

			

				
					
数组转化为二叉树

				
			

			

				

					star714的博客
				

				

					09-19
					
					3090
					
				

			

		

		

			
				
题目： 数组按照前序遍历方式方式转化为二叉树


思路： 二叉树前序遍历变形


代码：
Node * BinaryInit(int *a, int index, int len)
{
    if (index > len - 1)
        return NULL;
    Node *pNode = (Node *)malloc(sizeof(Node));
 

			
		

	





	

		

			

				
					
【LeetCode】108.将有序数组转换为平衡二叉树（中序遍历三种方法，java实现）

				
			

			

				

					Viper的程序员修炼手册
				

				

					06-25
					
					869
					
				

			

		

		

			
				
题目
链接

解析
遍历树的方法。DFS（先序遍历，中序遍历，后序遍历）；BFS。
遍历树的两种通用策略：


深度优先遍历（DFS）
这种方法以深度 depth 优先为策略，从根节点开始一直遍历到某个叶子节点，然后回到根节点，在遍历另外一个分支。
根据根节点，左孩子节点和右孩子节点的访问顺序又可以将 DFS 细分为先序遍历 preorder，中序遍历 inorder 和后序遍历 postorder。


广度优先遍历（BFS）
按照高度顺序，从上往下逐层遍历节点。
先遍历上层节点再遍历下层节点。


下图

			
		

	





	

		

			

				
					
将有序数组转换为平衡的二叉搜索树

				
			

			

				

					JunsIr的技术栈
				

				

					11-29
					
					1386
					
				

			

		

		

			
				
数据结构-树-将有序数组转换为二叉搜索树
问题描述
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例
给定有序数组: [-10,-3,0,5,9],
一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：
给定有序数组: [-10,-3,0,5,...

			
		

	





	

		

			

				
					
python 将有序数组转换为二叉树的方法

				
			

			

				

					09-19
				

			

		

		

			
				
在Python编程中，有序数组转换为二叉树是一种常见的数据结构操作，特别是在处理二叉排序树（Binary Search Tree，简称BST）的时候。二叉排序树是一种特殊的二叉树，其特性是左子树上的所有节点的值都小于根节点，而...

			
		

	





	

		

			

				
					
将有序数组转化为平衡二叉树（108）

				
			

			

				

					weixin_45631744的博客
				

				

					08-09
					
					1120
					
				

			

		

		

			
				
题目： 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。给定有序数组: [-10，-3，0，5，9]。
概念详解
1.高度平衡二叉搜索树（AVL树）
（1）左子树与右子树的高度之差的绝对值不超过1。
（2）整棵树中的每棵左子树与右子树都是AVL树。
（3）每个节点都有一个平衡因子(balance factor–bf),任一节点的平衡因子是-1/0/1。(每个节点的平衡因子等于右子树的高度减去左子树的高度 )
2.AVL树的效率
一棵AVL树有N个节点，其高度可以保持在log2N，插入/删除/查找

			
		

	





	

		

			

				
					
(将有序数组转成平衡二叉树)LeetCode#108. Convert Sorted Array to Binary Search Tree

				
			

			

				

					小仙女的博客
				

				

					06-06
					
					584
					
				

			

		

		

			
				
将有序数组转成二叉平衡树

			
		

	





	

		

			

				
					
将有序数组转换为二叉搜索树

				
			

			

				

					程序员大航子
				

				

					09-17
					
					663
					
				

			

		

		

			
				
转载本文章请标明作者和出处
本文出自《Darwin的程序空间》


开始行动，你已经成功一半了，献给正在奋斗的我们
题目
将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。
示例：

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
.

			
		

	





	

		

			

				
					
根据数组建立平衡二叉搜索树

				
			

			

				

					少说，多做。
				

				

					11-26
					
					5384
					
				

			

		

		

			
				
它是一 棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉（搜索）树。

 

二分：用有序数组中中间的数生成搜索二叉树的头节点，然后对数组的左右部分分别生成左右子树即可（重复过程）。

生成的二叉树中序遍历一定还是这个序列。

 

非常简单，不过多叙述：


public class SortedArrayToBalancedBST {

	public sta...

			
		

	





	

		

			

				
					
LeetCode 108 Easy 排序数组构造平衡二叉树BST Python

				
			

			

				

					h
				

				

					12-12
					
					720
					
				

			

		

		

			
				
    算法：递归

    思路：

        关键在于如何构造这颗二叉查找树（BST）可以让左右的高度相差不高于1，就是平衡二叉树的概念

        如果每次以数组的中间节点来构造这颗BST，那么其左右数组的元素就是相等或者相差1的，就可以实现

        高度相差1 ！！

            如奇数个元素，1,2,3,4,5，以3为根，左子树[1,2]两个元素，右子树...

			
		

	





	

		

			

				
					
给定数组构建平衡二叉树BST

				
			

			

				

					jh__chen的博客
				

				

					01-25
					
					743
					
				

			

		

		

			
				
给定数组构建平衡二叉树
中序遍历，总是选择中间位置左边的数字作为根节点
选择中间位置左边的数字作为根节点，则根节点的下标为mid=(left+right)/2，此处的除法为整数除法。
官方题解：
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return helper(nums, 0, nums.length - 1);
    }

    public TreeNode helper(int[] n

			
		

	





	

		

			

				
					
leetcode有序数组转换成BST

				
			

			

				

					hancaicai123的博客
				

				

					08-14
					
					639
					
				

			

		

		

			
				
1 .convert-sorted-array-to-binary-search-tree 
题目要求： 
Given an array where elements are sorted in ascending order, convert it to a height balanced BST 
解题思路: 
分冶递归，每次找序列的中间值 
有序数组首先考虑二分法/**
 * Definiti

			
		

	





	

		

			

				
					
有序二叉树，平衡二叉树，二三四树，红黑树

				
			

			

				

					m0_61983575的博客
				

				

					03-31
					
					1012
					
				

			

		

		

			
				
有序二叉树：



平衡二叉树具有以下特点：

1）它是一颗空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两颗子树都是一颗平衡二叉树。

2）平衡因子： 左子树的高度 - 右子树的高度

我们将平衡因子的绝对值小于1的的有序二叉树称为平衡二叉树

旋转：LL,RR

LL



RR



LR



RL



造成不平衡的节点最后插入

红黑树

红黑树：介于有序二叉树和平衡二叉树之间的树，最优二叉树





二三四树



红黑树

红黑树中的节点不是红色就是黑色
	红黑树中根节点一定是黑

			
		

	





	

		

			

				
					
数据结构 算法 时间复杂度 有序二叉树 平衡二叉树

				
			

			

				

					a1463073169的博客
				

				

					03-31
					
					726
					
				

			

		

		

			
				
类和对象（Java中最基本的部分，目前已经学完了） → 练习最基本的数据结构和算法 → Java基础的中阶（封装、继承、多态）→ 高阶（反射代理）

			
		

	





	

		

			

				
					
如何将数组转换为二叉树?

				
			

			

				

					03-18
				

			

		

		

			
				
### 将数组转换为二叉树的算法及实现

将数组转换为二叉树是一种常见的数据结构操作，尤其是在处理平衡二叉搜索树（BST）时更为重要。以下是关于该主题的具体说明：

#### 方法概述
一种常见的方式是通过递归来构建二叉树。对于给定的一个有序数组，可以将其视为中序遍历的结果来构造一棵平衡二叉搜索树[^1]。

#### 单层递归逻辑
在递归过程中，选取数组中间位置的元素作为当前根节点，并分别对其左侧部分和右侧部分再次应用相同的逻辑以生成左子树和右子树。

#### Java 实现示例
下面提供了一个基于上述思路的Java代码片段用于演示如何从一个整型数组创建对应的二叉树:

```java
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {}
    
    TreeNode(int val) { this.val = val; }
}

// 主要方法：将数组转化为二叉树
public TreeNode sortedArrayToBST(int[] nums) {
    if(nums == null || nums.length == 0){
        return null;
    }

    return helper(nums, 0, nums.length - 1);
}

private TreeNode helper(int[] nums, int start, int end){
    if(start > end){
        return null;
    }

    // 总是选择中间位置左边的数字作为根节点
    int mid = (start + end)/2;
    TreeNode root = new TreeNode(nums[mid]);

    // 构建左子树
    root.left = helper(nums, start, mid - 1);

    // 构建右子树
    root.right = helper(nums, mid + 1, end);

    return root;
}
```

此代码定义了一个`TreeNode`类表示二叉树中的每一个结点，并实现了主要的功能函数 `sortedArrayToBST()` 和辅助函数 `helper()` 来完成整个过程。

#### JavaScript 的解决方案
如果考虑JavaScript环境下的情况，则可以通过类似的递归策略来进行转化。需要注意的是，在实际开发环境中可能还需要额外注意边界条件以及异常处理等问题[^3]。

```javascript
function arrayToBst(arr) {
    function buildTree(left, right) {
        if (left > right) return null;

        const mid = Math.floor((left + right) / 2);
        let node = new Node(arr[mid]);
        
        node.left = buildTree(left, mid - 1);
        node.right = buildTree(mid + 1, right);

        return node;
    }

    return buildTree(0, arr.length - 1);
}

class Node {
    constructor(value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}
```

这里展示了另一种语言环境下执行相同任务的例子。

#### 特殊方法讨论
还有一种特别的方法适用于特定场景——即严格按照输入数组顺序建立完全二叉树的情况。这种方法利用了满二叉树性质，其中父节点与其两个孩子之间的关系可通过简单的算术运算得出[^4]。

```java
ThreadNode createTree(int[] data, int index) {
    ThreadNode node = null;
    if(index <= data.length){
        node = new ThreadNode(data[index - 1]);
        node.setLeft(createTree(data, 2*index));
        node.setRight(createTree(data, 2*index+1));
    }
    return node;
}
```
这段代码展示了一种特殊的递归模式用来按层次填充二叉树节点。

### 结论
综上所述，无论是采用标准的分治法还是其他变体形式，都可以有效地解决由数组向二叉树转变的问题。每种技术都有其适用范围和局限性，因此应根据具体需求灵活选用合适的方案。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值