leetCode:Convert Sorted Array to Binary Search Tree

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

#include<iostream>
#include<vector>
#include<malloc.h>
using namespace std;


struct BSTNode{
    int val;
    BSTNode *left,*right;
//    BSTNode(int x):val(x),left(NULL),right(NULL){};
};

class Solution{
public:
    BSTNode * sortedArrayToBST(vector<int> num){
        int length=num.size();
        BSTNode * root=(BSTNode*)malloc(sizeof(BSTNode));

        if(length==1){
        	root->val=num[0];root->left=NULL;root->right=NULL;
        }
        else if(length==2){
        	vector<int> temp2(1);
        	temp2[0]=num[1];
        	root->val=num[0];root->left=NULL;
            root->right=sortedArrayToBST(temp2);
        }
        else{
            int middle=(length-1)/2;
            root->val=num[middle];
            vector<int> temp1(middle);
            vector<int> temp2(length-middle-1);
            for(int i=0;i<middle;i++)
                temp1[i]=num[i];
            for(int i=0;i<(length-middle-1);i++)
                temp2[i]=num[i+middle+1];

            root->left=sortedArrayToBST(temp1);
            root->right=sortedArrayToBST(temp2);
        }
        return root;
    }

    int InOderTraverse(BSTNode *T){
        if(T!=NULL){
            InOderTraverse(T->left);
            cout<<T->val<<endl;
            InOderTraverse(T->right);
            return 1;
        }return 0;
    }
    
};



int main(){
    vector<int> vec(10);
    for(int i=0;i<10;i++)
    	 vec[i]=i;
    Solution sol;
    BSTNode * T=sol.sortedArrayToBST(vec);
    sol.InOderTraverse(T);

    return 1;
}