p43 将有序数组转化为二分搜索树 (leetcode 108)

class Solution 
{
public:
    TreeNode* sortedArrayToBST(vector<int>& nums,int start,int end)
    {
        if (start > end) return NULL;
        int mid = start + (end-start)/2;

        TreeNode* root = new TreeNode(nums[mid]);
        root->left = sortedArrayToBST(nums,start,mid-1);
        root->right = sortedArrayToBST(nums,mid+1,end);

        return root;
    }

    TreeNode* sortedArrayToBST(vector<int>& nums) 
    {
        if (nums.size() == 0) return NULL;

        return sortedArrayToBST(nums,0,nums.size()-1);
    }
};

class Solution {
    private TreeNode sortedArrayToBST(int[] nums,int start,int end)
    {
        if(start>end) return null;
        int mid=start+(end-start)/2;

        TreeNode root=new TreeNode(nums[mid]);
        root.left=sortedArrayToBST(nums,start,mid-1);
        root.right=sortedArrayToBST(nums,mid+1,end);

        return root;
    }

    public TreeNode sortedArrayToBST(int[] nums)
    {
           if(nums==null||nums.length==0) return null;
           
           return sortedArrayToBST(nums,0,nums.length-1);
    }
}

class Solution 
{
public:
    struct Item
    {
    public:
        TreeNode* parent;
        int start;
        int end;
        bool isLeft;

        Item(TreeNode* parent, int start, int end, bool isLeft)
        {
            this->parent = parent;
            this->start = start;
            this->end = end;
            this->isLeft=isLeft;
        }
    };

    TreeNode* sortedArrayToBST(vector<int>& nums) 
    {
        if (nums.size() == 0) return NULL;
        stack<Item*> stack;
        TreeNode* dummy = new TreeNode(0);
        stack.push(new Item(dummy,0,nums.size()-1,true));

        while (!stack.empty())
        {
            Item* item = stack.top();
            stack.pop();

            if (item->start <= item->end)
            {
                int mid = item->start + (item->end-item->start) / 2;
                TreeNode* child = new TreeNode(nums[mid]);

                if (item->isLeft) item->parent->left = child;
                else item->parent->right = child;

                stack.push(new Item(child,item->start,mid-1,true));
                stack.push(new Item(child,mid+1,item->end,false));
            }
        }

        return  dummy->left;
    }
};

class Solution {
    private class Item
    {
        TreeNode parent;
        int start;
        int end;
        boolean isLeft;
        
        Item(TreeNode parent,int start,int end,boolean isLeft)
        {
            this.parent=parent;
            this.start=start;
            this.end=end;
            this.isLeft=isLeft;
        }
    }

    public TreeNode sortedArrayToBST(int[] nums)
    {
           if(nums==null||nums.length==0) return null;
           TreeNode dummy=new TreeNode(0);
           Stack<Item> stack=new Stack<>();
           stack.push(new Item(dummy,0,nums.length-1,true));
           
           while(!stack.empty())
           {
               Item item=stack.pop();
               
               if(item.start<=item.end)
               {
                   int mid=item.start+(item.end-item.start)/2;
                   TreeNode child=new TreeNode(nums[mid]);
                   
                   if(item.isLeft) item.parent.left=child;
                   else item.parent.right=child;
                   
                   stack.push(new Item(child,item.start,mid-1,true));
                   stack.push(new Item(child,mid+1,item.end,false));
               }
           }
           
           return dummy.left;
    }

}