【LeetCode】Convert Sorted Array to Binary Search Tree && Convert Sorted List to Binary Search Tree

1、Convert Sorted Array to Binary Search Tree 
Total Accepted: 8749 Total Submissions: 27493 My Submissions
Given an array where elements are sorted in ascending order, convert it to a height balanced BST.
2、Convert Sorted List to Binary Search Tree  
Total Accepted: 7649 Total Submissions: 28780 My Submissions
Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.
升序数组转为二叉搜索树。
其实2本质上是1的变形，尽管2是链表，但是可以转成数组，扫描一遍链表即可完成。
针对1来说，每次搜索，需要搜索中间那个数字，作为root节点。int mid = (low + high) >> 1。递归深入，即可求得结果。
针对2来说，有两种办法。1)是扫描一遍，将链表转为数字，然后调用1的方法即可解决。2)扫描链表，每次用快慢指针来找到中间节点。这个要比方法1快30ms左右。

1、Java AC

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

	private TreeNode createBSTree(int[] num, int low, int high) {
		if (low > high) {
			return null;
		}
		if (low == high) {
			return new TreeNode(num[low]);
		}
		int mid = (low + high) >> 1;
		TreeNode root = new TreeNode(num[mid]);
		root.left = createBSTree(num, low, mid - 1);
		root.right = createBSTree(num, mid + 1, high);
		return root;
	}
}

2、1)Java AC

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; next = null; }
 * }
 */
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        if(head == null){
            return null;
        }
        int len = 0;
        List<Integer> list = new ArrayList<Integer>();
        while(head != null){
            list.add(head.val);
            head = head.next;
            len++;
        }
        return createBSTree(list, 0, len - 1);
    }
	private TreeNode createBSTree(List<Integer> list, int low, int high) {
		if (low > high) {
			return null;
		}
		if (low == high) {
			return new TreeNode(list.get(low));
		}
		int mid = (low + high) >> 1;
		TreeNode root = new TreeNode(list.get(mid));
		root.left = createBSTree(list, low, mid - 1);
		root.right = createBSTree(list, mid + 1, high);
		return root;
	}
}

2、2)Java AC

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; next = null; }
 * }
 */
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        if(head == null){
            return null;
        }
        return createBSTree(head, null);
    }
	private TreeNode createBSTree(ListNode start, ListNode end) {
		if(start == end){
		    return null;
		}
		ListNode fastNode = start;
		ListNode slowNode = start;
		while(fastNode != end && fastNode.next != end){
		    slowNode = slowNode.next;
		    fastNode = fastNode.next.next;
		}
		TreeNode root = new TreeNode(slowNode.val);
		root.left = createBSTree(start, slowNode);
		root.right = createBSTree(slowNode.next, end);
		return root;
	}
}