109 Title: Ordered list convert binary search tree

One. Problem Description

Given a singly-linked list, wherein the elements sorted in ascending order, to convert it to a well-balanced binary search tree.

In this problem, a highly balanced binary tree is a binary tree refers to the left and right sub-tree of each node is the height difference between the absolute value of not more than 1.

Example:

Given ordered list: [-10, -3, 0, 5, 9],

One possible answer is: [0, -3, 9, -10, null, 5], it can be expressed below this height balanced binary search tree:

      0

      / \

   -3   9

   /    /

-10   5

two. Problem-solving ideas

Thinking this problem: The problem with the idea of ​​the same title 108, but in the beginning to convert into a list List, and then calculated using the same procedure, with particular reference to 108 questions.

three. Results of the

When execution: 10 ms, beat the 7.12% of all users in java submission

Memory consumption: 39.5 MB, defeated 95.51% of all users in java submission

four. Java code

class Solution {
    public TreeNode sortedListToBST(ListNode head) {
         if(head==null) {
                 TreeNode root=null ;
                 return root;
             }else {
                 
                 List<Integer> list=new ArrayList<Integer>();
                 
                 while(head!=null) {
                     list.add(head.val);
                     head=head.next;
                 }
                 int num=list.size()/2;
                 List<Integer> leftlist=new ArrayList<Integer>(list.subList(0, num));
                 List<Integer> rightlist=new ArrayList<Integer>(list.subList(num+1,list.size()));
                TreeNode root=new TreeNode(list.get(num));
                getTree(leftlist,rightlist,root);
                return root;
             }   
    }
    
     public void getTree(List<Integer> leftlist,List<Integer> rightlist,TreeNode root) {
         if(leftlist.size()==0&&rightlist.size()==0) {
             return;
         }
         
         if(leftlist.size()>0) {
         int leftnum=leftlist.size()/2;
         List<Integer> newleftlist=new ArrayList<Integer>(leftlist.subList(0, leftnum));
         List<Integer> newleftlistright=new ArrayList<Integer>(leftlist.subList(leftnum+1, leftlist.size())); 
         root.left=new TreeNode(leftlist.get(leftnum));
         getTree(newleftlist,newleftlistright,root.left);
         }
         
         if(rightlist.size()>0) {
         int rightnum=rightlist.size()/2;
         List<Integer> newrightlistleft=new ArrayList<Integer>(rightlist.subList(0, rightnum));
         List<Integer> newrightlistright=new ArrayList<Integer>(rightlist.subList(rightnum+1, rightlist.size()));
         root.right=new TreeNode(rightlist.get(rightnum));
         getTree(newrightlistleft,newrightlistright,root.right);
         }
     }
    
}