算法篇：树之转换为二叉搜索树

1.对有序数组或者有序链表来说，把中间节点当作根节点
2. 左边数组的值都小于根节点，作为左子树；
 右边数组的值都大于根节点，作为右子树。
3. 递归处理左子树和右子树，一直到只剩下一个节点。

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func sortedArrayToBST(nums []int) *TreeNode {
    if len(nums) == 0 {
        return nil
    }
    mid := len(nums)/2
    root := new(TreeNode)
    root.Val = nums[mid]
    root.Left = sortedArrayToBST(nums[:mid])
    root.Right = sortedArrayToBST(nums[mid+1:])
    return root
}
// 算法：核心思想是利用二分法，对有序数组来说，把中间节点当作根节点，
// 左边数组的值都小于根节点，作为左子树；
// 右边数组的值都大于根节点，作为右子树。
// 递归处理左子树和右子树，一直到只剩下一个节点。

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func sortedListToBST(head *ListNode) *TreeNode {
    if head == nil {
        return nil
    }
    if head.Next == nil {
        return &TreeNode{Val:head.Val}
        
    }
    // 小技巧：方便一次循环找到中间节点的前序节点，哨兵
    s := new(ListNode) 
    s.Next = head
    f := head
    for f != nil && f.Next != nil { 
        // 精髓：快慢指针，1步，2步正好是二等分，可以延伸出三等份，n等分
        s = s.Next
        f = f.Next.Next
    }
    
    res := new(TreeNode)
    res.Val = s.Next.Val
    r := s.Next.Next
    s.Next = nil // 左半部分单独成一个链表
    res.Left = sortedListToBST(head)
    res.Right = sortedListToBST(r)
    return res
}
// 算法：利用二分法，这里是采用了链表二分法的常规做法，
// 找到中间节点之后，将链表一分为二，左边的继续构造左子树，右边的为右子树
// 递归处理，直到所有节点都处理完。