排序数组转变为平衡二叉树

2019独角兽企业重金招聘Python工程师标准>>>

原题

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

题目大意

　　给定一个升序排列的二叉树，将其转换为一棵高度平衡的二叉树。

解题思路

　　采用递归分治法。

代码实现

树结点类

public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

• 1
• 2
• 3
• 4
• 5
• 6

• 1
• 2
• 3
• 4
• 5
• 6

算法实现类

public class Solution {

    public TreeNode sortedArrayToBST(int[] nums) {
        // 参数检验
        if (nums == null || nums.length < 1) {
            return null;
        }

        // 递归分治法求解
        return solve(nums, 0, nums.length - 1);
    }

    /**
     * 递归分治求解方法
     *
     * @param nums  升序排序数组
     * @param start 开始位置
     * @param end   结束位置
     * @return 根结点
     */
    public TreeNode solve(int[] nums, int start, int end) {
        // 还有未处理的数据
        if (start <= end) {
            // 找蹭位置
            int mid = start + ((end - start) >> 1);
            // 构造根结点
            TreeNode root = new TreeNode(nums[mid]);
            // 求左子树
            root.left = solve(nums, start, mid - 1);
            // 求右子树
            root.right = solve(nums, mid + 1, end);
            // 返回结果
            return root;
        }

        return null;
    }
}

 

 

题目

给一个已排序的数组，将其转化为一颗平衡二叉树。

平衡二叉树要求左右子树的高度差不超过1。我们把排序数组的中间节点作为根，可保证左右子树的元素个数差不超过1，则肯定是平衡二叉树。这个很好理解，不多解释了。利用递归可以很容易的解决。使用递归的一个要点是，一定要相信我们的递归函数会返回正确的结果，只要处理好返回条件，代码就很简单了。

例如：

01	Input:  Array {1, 2, 3}

02	Output: A Balanced BST

03

2

04

/  \

05

1    3

06

07	Input: Array {1, 2, 3, 4}

08	Output: A Balanced BST

09

3

10

/  \

11

2    4

12

/

13

1

下面是java的实现：

01	public class SortedArrayToBST {

02

03	public static Tree SortedArrayToBST(int arr[], int s, int e) {

04

//返回条件

05	if (s > e)

06	return null;

07	int mid = (s + e) / 2;

08	//把中间节点作为根

09	Tree root = new Tree(arr[mid]);

10	//分别递归左右子树

11	root.left = SortedArrayToBST(arr, s, mid - 1);

12	root.right = SortedArrayToBST(arr, mid + 1, e);

13	return root;

14

}

15

16

//二叉树类

17	static class Tree {

18	public Tree left, right;

19	public int data;

20

21	public Tree(int d) {

22

data = d;

23

}

24

25

//中序遍历

26	public void inOrder() {

27	if (this.left != null)

28	this.left.inOrder();

29	System.out.print(data + " ");

30	if (this.right != null)

31	this.right.inOrder();

32

}

33

34

//先序遍历

35	public void preOrder() {

36	System.out.print(data + " ");

37	if (this.left != null)

38	this.left.preOrder();

39	if (this.right != null)

40	this.right.preOrder();

41

}

42

}

43

44	public static void main(String[] args) {

45	int arr[] = { 1, 2, 3, 4, 5, 6, 7 };

46	Tree tree = SortedArrayToBST(arr, 0, arr.length - 1);

47	tree.inOrder();

48	System.out.println();

49	tree.preOrder();

50

}

51

}

转载于:https://my.oschina.net/u/2822116/blog/809478