[LeetCode]108. Convert Sorted Array to Binary Search Tree(升序数组转化为平衡二叉树)

108. Convert Sorted Array to Binary Search Tree

原题链接
Given an array where elements are sorted in ascending order, convert it to a height balanced BST.

题目大意：
给定一个升序数组，转化为一个平衡二叉树

思路：

首先要了解二叉排序树BST的定义。给定一个很详细的介绍
其次要明白什么是平衡二叉树
平衡二叉树：在BST的基础上，它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树
二叉排序树和平衡二叉树区分，链接1，链接2
接下来考虑算法，很简单，就是先找到中间元素，创建根节点，左右子树分别用中间元素左边（即小于中间节点的元素）和中间元素右边（即大于中间节点的元素）递归创建。这样，节点的左子树永远比节点小，右子树永远比节点大，且由于平均递归创建每一层的子树，所以两个子树的高度差不会超过1。

代码如下：

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

// Definition for a binary tree node.
  struct TreeNode {
      int val;
      TreeNode *left;
      TreeNode *right;
      TreeNode(int x) : val(x), left(NULL), right(NULL) {}
  };

class Solution {
public:
    TreeNode *sortedArrayToBST(vector<int>& nums) {
        return BuildTree(nums, 0, nums.size()-1);
    }
    TreeNode *BuildTree(vector<int> &nums, int Start, int End){
        if(Start > End) return nullptr;
        if(Start == End) return new TreeNode(nums[Start]);
        int Min = (Start+End)/2;
        TreeNode *node = new TreeNode(nums[Min]);// 根节点
        node->left = BuildTree(nums, Start, Min-1);// 左子树
        node->right = BuildTree(nums, Min+1, End);// 右子树
        return node;
    }
    // 层次遍历
    vector<vector<int> > LevelOrder(TreeNode *root) {
        vector<int> level;
        vector<vector<int> > levels;
        if(root == NULL){
            return levels;
        }
        queue<TreeNode*> cur,next;
        //入队列
        cur.push(root);//入队 将root元素接到队列的末端；
        // 层次遍历
        while(!cur.empty()){
            //当前层遍历
            while(!cur.empty()){
                TreeNode *p = cur.front();//cur.front() 访问队首元素
                cur.pop();//出队 弹出队列的第一个元素，并不会返回元素的值；
                level.push_back(p->val);
                // next保存下一层节点
                //左子树
                if(p->left){
                    next.push(p->left);
                }
                //右子树
                if(p->right){
                    next.push(p->right);
                }
            }//end while
            levels.push_back(level);
            level.clear();
            swap(next,cur);
        }//end while
        return levels;
    }
};
int main()
{
    Solution S;
    vector<int> num = {0,1,2,3,4,5,6,7,8,9};
    TreeNode* root = S.sortedArrayToBST(num);
    vector<vector<int> > levels = S.LevelOrder(root);
    for(int i = 0;i < levels.size();i++){
        for(int j = 0;j < levels[i].size();j++){
            cout<<levels[i][j]<<" ";
        }
        cout<<endl;
    }
    return 0;
}