TreeNode *sortedArrayToBST(vector<int> &num) {
if (num.size() == 0)
return NULL;
if (num.size()==1)
return new TreeNode(num[0]);
int mid = num.size()/2;
TreeNode *node = new TreeNode(num[mid]);
vector<int>::const_iterator first;
vector<int>::const_iterator last;
first = num.begin();
last = num.begin() + mid;
vector<int> v(first, last);
node->left = sortedArrayToBST(v);
if (mid == num.size()-1) {
node->right = NULL;
} else {
first = num.begin()+mid+1;
last = num.end();
vector<int> v(first, last);
node->right = sortedArrayToBST(v);
}
return node;
}
TreeNode* sortedArrayToBST(randomAccessIterator first, randomAccessIterator last){
if (first >= last) return nullptr;
auto mid = first + distance(first, last) / 2;
TreeNode *root = new TreeNode(*mid);
root -> left = sortedArrayToBST(first, mid);
root -> right = sortedArrayToBST(next(mid), last);
return root;
}
TreeNode* sortedArrayToBST(vector<int>& nums, int first, int last){
if(first > last) return NULL;
int mid = (first + last) >> 1;
TreeNode *root = new TreeNode(nums[mid]);
root->left = sortedArrayToBST(nums, first, mid-1);
root->right = sortedArrayToBST(nums, mid + 1, last);
return root;
}
TreeNode* sortedArrayToBST (RandomAccessIterator first, RandomAccessIterator last) {
const auto length = distance(first, last);
if (length <= 0)
return nullptr;
auto mid = first + length / 2;
TreeNode* root = new TreeNode (*mid); // set mid as root of the whole tree
root->left = sortedArrayToBST(first, mid); // set mid of first part of array as root of left subtree
root->right = sortedArrayToBST(mid + 1, last); // mid of second part ... right subtree
return root;
}
TreeNode *sortedArrayToBST(vector<int> &num, int start, int end) {
if (start > end) { return NULL; }
else if (start == end) { return new TreeNode(num[start]); }
int mid = (start + end) / 2;
TreeNode* root = new TreeNode(num[mid]);
root->left = sortedArrayToBST(num, start, mid-1);
root->right = sortedArrayToBST(num, mid+1, end);
return root;
}
TreeNode* sortedArrayToBST(vector<int> &nums, int l, int r)
{
if(l == r)
return NULL;
int m = l + (r - l) / 2;
TreeNode* root = new TreeNode(nums[m]);
root->left = sortedArrayToBST(nums, l, m);
root->right = sortedArrayToBST(nums, m + 1, r);
return root;
}
TreeNode *sortedArrayToBST(vector<int>::iterator begin, vector<int>::iterator end) {
int n = end-begin;
if (n <= 0)
return NULL;
int m = n/2;
TreeNode *ret = new TreeNode(*(begin+m));
ret->left = sortedArrayToBST(begin, begin+m);
ret->right = sortedArrayToBST(begin+m+1, end);
return ret;
}
/**
* simple recursive
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
if(numsSize == 0) return NULL;
int i = (numsSize % 2) ? (numsSize / 2) : (numsSize / 2 - 1);
int rootval = nums[i];
struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
root->val = rootval;
root->left = sortedArrayToBST(nums, i);
root->right = sortedArrayToBST(nums+i+1, numsSize-i-1);
return root;
}
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
if (numsSize < 1) return NULL;
int mp = numsSize / 2;
struct TreeNode* root = (struct TreeNode*)calloc(1, sizeof(struct TreeNode));
if (!root) return NULL;
root->val = nums[mp];
root->right = sortedArrayToBST(&nums[mp + 1], numsSize - mp - 1);
root->left = sortedArrayToBST(nums, mp);
return root;
}
TreeNode* sortedArrayToBST(int left, int right, vector<int>& nums){
if(left >= right)
return NULL;
int mid = left + (right - left) / 2;
TreeNode* root = new TreeNode(nums[mid]);
root->left = sortedArrayToBST(left, mid, nums);
root->right = sortedArrayToBST(mid + 1, right, nums);
return root;
}
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
struct TreeNode* sortedArrayToBST(int* nums, int numsSize)
{
if (numsSize == 0)
return NULL;
struct TreeNode* t = malloc(sizeof(struct TreeNode*));
int len = numsSize / 2;
t->val = nums[len];
t->left = sortedArrayToBST(nums, len);
t->right = sortedArrayToBST(nums + len + 1, numsSize - 1 - len);
return t;
}
TreeNode *sortedArrayToBST(const vector<int> &num, int left, int right) {
if (right < left)
return NULL;
int mid = left + (right - left) / 2;
TreeNode *root = new TreeNode(num[mid]);
root->left = sortedArrayToBST(num, left, mid-1);
root->right = sortedArrayToBST(num, mid+1, right);
return root;
}
TreeNode *sortedArrayToBST(vector<int> &num, int low, int high) {
if (low >= high) return NULL;
int mid = (low + high) / 2;
TreeNode *node = new TreeNode(num[mid]);
node->left = sortedArrayToBST(num, low, mid);
node->right = sortedArrayToBST(num, mid+1, high);
return node;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
size_t size = nums.size();
if (size == 0) return NULL;
if (size == 1) return new TreeNode(nums[0]);
size_t middle = size / 2;
TreeNode *tree = new TreeNode(nums[middle]);
vector<int> leftNums(nums.begin(), nums.begin() + middle);
vector<int> rightNums(nums.begin() + middle + 1, nums.end());
tree->left = sortedArrayToBST(leftNums);
tree->right = sortedArrayToBST(rightNums);
return tree;
}
struct node* sortedArrayToBST(int *arr, int first, int last)
{
if (first > last)
return NULL;
int mid = (first + last) / 2;
struct node* root = NULL;
root = add_node(root, arr[mid]);
root->left = sortedArrayToBST(arr, first, mid - 1);
root->right = sortedArrayToBST(arr, mid + 1, last);
return root;
}
template<typename RandomAccessIterator> TreeNode* sortedArrayToBST(RandomAccessIterator first,RandomAccessIterator last)
{
const auto len = distance(first,last);
if(len <= 0)
return nullptr;
auto mid = first + len/2;
TreeNode* root = new TreeNode(*mid);
root->left = sortedArrayToBST(first,mid);
root->right = sortedArrayToBST(mid+1,last);
return root;
}
TreeNode *sortedArrayToBST(RandomAccessIterator begin, RandomAccessIterator end) {
const auto length = distance(begin, end);
if (length <= 0) return nullptr;
auto mid = begin + length / 2;
TreeNode *root = new TreeNode(*mid);
root->left = sortedArrayToBST(begin, mid);
root->right = sortedArrayToBST(mid+1, end);
return root;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
int n = nums.size();
if (n == 0) return NULL;
if (n == 1) return new TreeNode(nums[0]);
int mid = n/2;
TreeNode * root = new TreeNode(nums[mid]);
std::vector<int> LeftNodes(nums.begin(), nums.begin() + mid);
std::vector<int> RightNodes(nums.begin() + mid + 1, nums.end());
root->left = sortedArrayToBST(LeftNodes);
root->right = sortedArrayToBST(RightNodes);
return root;
}
TreeNode* sortedArrayToBST(vector<int>& nums) {
if(nums.size() == 0) return NULL;
if(nums.size() == 1) return new TreeNode(nums[0]);
int mid_point = nums.size()/2;
std::vector<int> left_num(nums.begin(), nums.begin()+mid_point);
std::vector<int> right_num(nums.begin()+mid_point+1, nums.end());
int mid_point_val = *(nums.begin()+mid_point);
TreeNode* root = new TreeNode(mid_point_val);
root->left = sortedArrayToBST(left_num);
root->right = sortedArrayToBST(right_num);
return root;
}
TreeNode *sortedArrayToBST(vector<int> &num) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if(num.size() == 0)
return 0;
int mid = (num.size() - 1)/2;
TreeNode* root = new TreeNode(num[mid]);
if(mid > 0)
sortedArrayToBST(num, 0, mid, root, true);
if(num.size() - mid - 1 > 0)
sortedArrayToBST(num, mid+1, num.size()-mid-1, root, false);
return root;
}
TreeNode *sortedArrayToBST(vector<int> &num) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if (num.size() <= 0) return NULL;
if (num.size() == 1) return new TreeNode(num[0]);
vector<int> leftTree(num.begin(), num.begin() + num.size() / 2);
vector<int> rightTree(num.begin() + num.size() / 2 + 1, num.end());
TreeNode *ret = new TreeNode(num[num.size() / 2]);
ret->left = sortedArrayToBST(leftTree);
ret->right = sortedArrayToBST(rightTree);
return ret;
}
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
struct TreeNode *root;
if(numsSize==0){
return NULL;
}
root=(struct TreeNode*)malloc(sizeof(struct TreeNode));
root->val=nums[numsSize/2];
root->left=sortedArrayToBST(nums,numsSize/2);
root->right=sortedArrayToBST(nums+numsSize/2+1,numsSize-numsSize/2-1);
return root;
}
struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
if (nums == NULL || numsSize == 0)
return NULL;
int Mid;
Tree Root;
Mid = numsSize / 2;
Root = NewNode(nums[Mid]);
Root -> left = sortedArrayToBST(nums, Mid);
Root -> right = sortedArrayToBST(nums + Mid + 1, numsSize - Mid - 1);
return Root;
}
TreeNode* sortedArrayToBST(
const vector<int> &nums,
int begin,
int end) {
if (begin == end) {
return nullptr;
}
int mid = (begin + end) / 2;
auto node = new TreeNode(nums[mid]);
node->left = sortedArrayToBST(nums, begin, mid);
node->right = sortedArrayToBST(nums, mid+1, end);
return node;
}
void main()
{
int test[3] = {1,2,3};
struct TreeNode* root = sortedArrayToBST(test, 3);
printf("%d,%d,%d\n", root->val, root->left->val, root->right->val);
}
struct TreeNode* sortedArrayToBST(int* nums, int numsSize)
{
if(!nums || numsSize == 0)
return NULL;
int mid = numsSize/2;
struct TreeNode *root = (struct TreeNode *)malloc(sizeof(struct TreeNode));
struct TreeNode *left = sortedArrayToBST(nums, mid);
struct TreeNode *right = sortedArrayToBST(nums+mid+1, numsSize-mid-1);
root->val = nums[mid];
root->left = left;
root->right = right;
return root;
}
int main(int argc, char const *argv[])
{
int i, Len;
int* Array;
Tree T;
Len = 16;
Array = malloc(sizeof(int) * Len);
for (i = 0; i < Len; ++i)
Array[i] = i;
T = sortedArrayToBST(Array, Len);
PreOrderTraverse(T);
printf("\n");
InOrderTraverse(T);
printf("\n");
PostOrderTraverse(T);
printf("\n");
return 0;
}
int main(){
int array[] = {2,3,4,6,7,9,13,15,17,18,20} ;
struct TreeNode* root = sortedArrayToBST(array,11) ;
printT(root) ;
printf("\n") ;
return 0 ;
}
/**
* This function merges two balanced BSTs with roots as root1 and root2.
* m and n are the sizes of the trees respectively
*/
struct node* mergeTrees(struct node *root1, struct node *root2, int m, int n)
{
/**
* Store inorder traversal of first tree in an array arr1[]
*/
int *arr1 = new int[m];
int i = 0;
storeInorder(root1, arr1, &i);
/**
* Store inorder traversal of second tree in another array arr2[]
*/
int *arr2 = new int[n];
int j = 0;
storeInorder(root2, arr2, &j);
/**
* Merge the two sorted array into one
*/
int *mergedArr = merge(arr1, arr2, m, n);
/**
* Construct a tree from the merged array and return root of the tree
*/
return sortedArrayToBST(mergedArr, 0, m+n-1);
}
struct node * convert_array_to_bst(int *arr, int len){
if (arr == NULL || len <= 0)
return NULL;
struct node *root = NULL;
root = sortedArrayToBST(arr, 0, len);
return root;
}
