将排序数组转为平衡二叉查找树

最新推荐文章于 2024-08-14 21:25:09 发布

wolenski

最新推荐文章于 2024-08-14 21:25:09 发布

阅读量1k

点赞数

分类专栏：数据结构与算法文章标签： tree arrays search each null go

数据结构与算法专栏收录该内容

76 篇文章

订阅专栏

本文介绍如何将一个元素按升序排列的数组转换为平衡二叉搜索树，通过递归方法选择中间元素作为根节点，并对左右子数组进行递归操作，最终实现O(N)时间复杂度的高效转换。

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

Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

If you are having hard time in understanding my previous post: Largest Binary Search Tree (BST) in a binary tree, do not fret as that problem is a comparably trickier tree problem for an interview session. But that should not be an excuse for you to not improve your ability to think recursively (without your brain stack being overflowed of course ).

Recursion is a very powerful problem-solving mechanism, and you would not go very far without it during an interview session. Here might be an easier tree problem for you to start before you hop on those challenging ones.

Hint:
This question is highly recursive in nature. Think of how binary search works.

An example of a height-balanced tree. A height-balanced tree is a tree whose subtrees differ in height by no more than one and the subtrees are height-balanced, too.

Solution:
If you would have to choose an array element to be the root of a balanced BST, which element would you pick? The root of a balanced BST should be the middle element from the sorted array.

You would pick the middle element from the sorted array in each iteration. You then create a node in the tree initialized with this element. After the element is chosen, what is left? Could you identify the sub-problems within the problem?

There are two arrays left — The one on its left and the one on its right. These two arrays are the sub-problems of the original problem, since both of them are sorted. Furthermore, they are subtrees of the current node’s left and right child.

The code below creates a balanced BST from the sorted array in O(N) time (N is the number of elements in the array). Compare how similar the code is to a binary search algorithm. Both are using the divide and conquer methodology.

BinaryTree* sortedArrayToBST(int arr[], int start, int end) {
  if (start > end) return NULL;
  // same as (start+end)/2, avoids overflow.
  int mid = start + (end - start) / 2;
  BinaryTree *node = new BinaryTree(arr[mid]);
  node->left = sortedArrayToBST(arr, start, mid-1);
  node->right = sortedArrayToBST(arr, mid+1, end);
  return node;
}
 
BinaryTree* sortedArrayToBST(int arr[], int n) {
  return sortedArrayToBST(arr, 0, n-1);
}

http://www.leetcode.com/2010/11/convert-sorted-array-into-balanced.html