Leetcode 109. Convert Sorted List to Binary Search Tree

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public void fun(TreeNode s,int[]nums)
    {
		if(nums.length==0)
		{
			//s=null;
		}
		else
		{
            //s=new TreeNode(0);
            int mid=(int)nums.length/2;
			s.val=nums[mid];
			int left=0,right=0;
			right=nums.length-(mid+1);
			left=mid;
			int []lnum=new int[left];
			int []rnum=new int[right];
			if(0<left)
			{
				for(int i=0;i<left;i++)
				{
					lnum[i]=nums[i];
				}
			}
			if((mid+1)<nums.length)
			{
				for(int i=0;i<right;i++)
				{
					rnum[i]=nums[i+mid+1];
				}
			}
            if(left==0)s.left=null;
            if(left>0) 
            {
                s.left=new TreeNode(0);
                fun(s.left,lnum);
            }
            if(right==0) s.right=null;
            if(right>0) 
            {
                s.right=new TreeNode(0);
                fun(s.right,rnum);
            }
			
			
		}
        
    }
    public TreeNode sortedArrayToBST(int[] nums)
    {
    	TreeNode ans=new TreeNode(0);
    	if(nums.length==0)return null;
    	fun(ans,nums);
    	return ans;
    }
    public TreeNode sortedListToBST(ListNode head)
    {
        if(head==null)return null;
        int count=0;
        ListNode s=head;
        while(s!=null)
        {
            s=s.next;
            count++;
        }
        int []nums=new int[count];
        ListNode s1=head;
        for(int i=0;i<count;i++)
        {
            nums[i]=s1.val;
            s1=s1.next;
        }
        return sortedArrayToBST(nums);
        
    }
}

解法：最后总是选中间那个点作为根结点，然后递归左右数组。

109. Convert Sorted List to Binary Search Tree

Description Hints Submissions Discuss Solution

Pick One

---

Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.

For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.

Example:

Given the sorted linked list: [-10,-3,0,5,9],

One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST:

      0
     / \
   -3   9
   /   /
 -10  5