Leetcode 109 Convert Sorted List to Binary Search Tree 将一个list转换为平衡二叉树

如果做了108题，反而第一反应想把它zhu转换为arr，但其实这是不好的。

题目如下：

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1。

示例:

给定的有序链表： [-10, -3, 0, 5, 9],

一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

转换为数组的而解决办法：

package test;

import java.util.ArrayList;
import java.util.List;

  class ListNode {
      int val;
      ListNode next;
      ListNode(int x) { val = x; }
  }
 


 
public class LC109Try1
{
    public TreeNode sortedListToBST(ListNode head) {
    	if(head==null){
    		return null;
    	}
    	List<Integer> list= new ArrayList<Integer>();
    	ListNode start=head;
        while(start.next!=null){
        	list.add(start.val);
        	start=start.next;
        }
        list.add(start.val);
        Object[] arr=list.toArray();
        int len = arr.length;		
		TreeNode node = pass(arr,0,len-1);
		
		return node;
        
    }
    public TreeNode pass(Object[] nums,int start,int end){
		if(start==end){
			TreeNode node= new TreeNode((Integer)nums[start]);
			return node;
		}
		int mid=(start+end+1)/2;
		TreeNode nodemid =new TreeNode((Integer)nums[mid]);
		if(start<=mid-1){
			nodemid.left=pass(nums,start,mid-1);
		}
		
		if(mid+1<=end){
			nodemid.right=pass(nums,mid+1,end);
		}
		
		return nodemid;
		
	}
    public void dp1(TreeNode node){
    	if(node !=null){
    		System.out.print(node.val+",");
    		dp1(node.left);
        	dp1(node.right);
    	}
    	
    }
    public void dp2(TreeNode node){
    	if(node !=null){
    		dp2(node.left);
    		System.out.print(node.val+",");    		
        	dp2(node.right);
    	}
    	
    }
    public static void main(String[] args)
	{
    	LC109Try1 t = new LC109Try1();
    	ListNode head=new ListNode(-10);
    	ListNode l1=new ListNode(-3);
    	head.next=l1;    	
    	ListNode l2=new ListNode(0);
    	l1.next=l2;
    	ListNode l3=new ListNode(5);
    	l2.next=l3;
    	ListNode l4=new ListNode(9);
    	l3.next=l4;
    	TreeNode node=t.sortedListToBST(head);
    	t.dp1(node);
    	System.out.println();
    	t.dp2(node);
	}

}

好的解决办法：

package test;

public class LC109Try2
{
	ListNode h;//全局变量
	   public int countNodes (ListNode head) {
	       ListNode first = head;
	       int count = 0;
	       while (first != null) {
	           count++;
	           first = first.next;
	       }
	       return count;
	   }
	   public TreeNode sortedListToBST(int start, int end) {
	       if (start > end) {
	           return null;
	       }
	       int mid = (start + end) / 2;
	       TreeNode left = sortedListToBST (start, mid -1);
	       TreeNode root = new TreeNode(h.val);
	       h = h.next;//人家赶着这么做的关键，不就是h在一个一个往后移动吗？自己真的是想多了，无论怎样还是从头开始的
	       TreeNode right = sortedListToBST (mid+1, end);
	       root.left = left;
	       root.right = right;
	       return root;
	   }
	   
	   public TreeNode sortedListToBST(ListNode head) {
	       if (head == null) {
	         return null;
	       }
	       h = head;
	       return sortedListToBST(0, countNodes(head) - 1);
	   }

}

下面是108的解决办法：

package test;



public class LC108Try1
{
	public TreeNode sortedArrayToBST(int[] nums)
	{
		int len = nums.length;
		if (len == 0)
		{
			return null;
		}
		TreeNode node = pass(nums,0,len-1);
		
		return node;

	}
	
	public TreeNode pass(int[] nums,int start,int end){
		if(start==end){
			TreeNode node= new TreeNode(nums[start]);
			return node;
		}
		int mid=(start+end+1)/2;
		TreeNode nodemid =new TreeNode(nums[mid]);
		if(start<=mid-1){
			nodemid.left=pass(nums,start,mid-1);
		}
		
		if(mid+1<=end){
			nodemid.right=pass(nums,mid+1,end);
		}
		
		return nodemid;
		
	}

}

哈哈