LeetCode-108. Convert Sorted Array to Binary Search Tree

题目描述

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

解题思路

首先想到的是递归的方式，首先取中间位置的元素构成root节点，然后左段元素中取中间位置的元素作为root节点的左节点，取右段元素中间位置的元素作为root节点的右节点，以此类推。
遍历的方式是看了论坛中的解法，结合自己的方式实现了，总的来说，就是借助队列把递归的方式翻译了一下。

代码

递归的方式

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        if(nums == null || nums.length == 0)
            return null;
        return bstCore(nums,0,nums.length-1);

    }
    private TreeNode bstCore(int[] nums,int start,int end){
        if(start > end)
            return null;
        int middle = start+(end-start)/2;
        TreeNode root = new TreeNode(nums[middle]);
        root.left = bstCore(nums,start,middle-1);
        root.right = bstCore(nums,middle+1,end);
        return root;
    }
}

遍历的方式

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        if(nums == null || nums.length == 0)
            return null;
        //return bstCore(nums,0,nums.length-1);
        Queue<MyNode> queue = new LinkedList<MyNode>();
        int left = 0;
        int right = nums.length-1;
        int index = left+(right-left)/2;
        TreeNode root = new TreeNode(nums[index]);
        queue.add(new MyNode(root,0,right,index));
        while(queue.size() != 0){
            MyNode  cur = queue.poll();

            if(cur.left <= cur.index-1){
                int leftIndex = cur.left+(cur.index-1-cur.left)/2; 
                cur.node.left = new TreeNode(nums[leftIndex]);
                queue.add(new MyNode(cur.node.left,cur.left,cur.index-1,leftIndex));
            }
            if(cur.index+1 <= cur.right){
                int rightIndex = cur.index+1+(cur.right - cur.index-1)/2;
                cur.node.right=new TreeNode(nums[rightIndex]);
                queue.add(new MyNode(cur.node.right,cur.index+1,cur.right,rightIndex));
            }

        }
        return root;

    }
    class MyNode{
        public int right;
        public int left;
        public int index;
        public TreeNode node;
        public MyNode(TreeNode node,int left,int right,int index){
            this.node = node;
            this.left = left;
            this.right = right;
            this.index = index;
        }
    }
}