LeetCode--Convert Sorted Array to Binary Search Tree（平衡二叉搜索树）

题意：给定一有序数组，生成一颗平衡二叉树。
题解：平衡二叉树任意节点的左右子树深度相差最大为1.
因为二叉搜索树任意节点的左子树节点都比它小，右子树节点都比它大。所以对于一个有序数组我们选取中间的节点作为根，再分别递归地调用生成左右两个子树。

代码如下：

class Solution {
public:
    TreeNode* buildTree(vector<int> &num,int left,int right){
        if(left > right)
            return NULL;
        int mid;
        if((left+right)%2 == 0){
            mid = (left+right)>>1;
        }
        else{
            mid = ((left+right)>>1)+1;
        }
        TreeNode* newNode = new TreeNode(num[mid]);
        newNode->left = buildTree(num,left,mid-1);
        newNode->right = buildTree(num,mid+1,right);
        return newNode;
    }
    TreeNode *sortedArrayToBST(vector<int> &num) {
        if(num.size() == 0)
            return NULL;
        return buildTree(num,0,num.size()-1);
    }
};

由有序链表转化成BST：

class Solution {
public:
    TreeNode* buildTree(ListNode* head,int listLen){
        if(listLen == 0)
            return NULL;
        int mid = listLen>>1;
        int tmpLen = 0;
        ListNode* tmpNode = head;
        while(tmpLen != mid){
            tmpLen++;
            tmpNode = tmpNode->next;
        }
        TreeNode* newNode = new TreeNode(tmpNode->val);
        newNode->left = buildTree(head,mid);
        newNode->right = buildTree(tmpNode->next,listLen-mid-1);
        return newNode;
    }
    TreeNode *sortedListToBST(ListNode *head) {
        int listLen = 0;
        ListNode* tmp = head;
        while(tmp){
            tmp = tmp->next;
            listLen++;
        }
        return buildTree(head,listLen);
    }
};