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; }