// Build segment tree. SegmentTreeNode *buildHelper(const vector<vector<int>>& matrix, const pair<int, int>& start, const pair<int, int>& end) { if (start.first > end.first || start.second > end.second) { return nullptr; } // The root's start and end is given by build method. SegmentTreeNode *root = new SegmentTreeNode(start, end, 0); // If start equals to end, there will be no children for this node. if (start == end) { root->sum = matrix[start.first][start.second]; return root; } int mid_x = (start.first + end.first) / 2; int mid_y = (start.second + end.second) / 2; root->neighbor.emplace_back(buildHelper(matrix, start, make_pair(mid_x, mid_y))); root->neighbor.emplace_back(buildHelper(matrix, make_pair(start.first, mid_y + 1), make_pair(mid_x, end.second))); root->neighbor.emplace_back(buildHelper(matrix, make_pair(mid_x + 1, start.second), make_pair(end.first, mid_y))); root->neighbor.emplace_back(buildHelper(matrix, make_pair(mid_x + 1, mid_y + 1), end)); for (auto& node : root->neighbor) { if (node) { root->sum += node->sum; } } return root; }
// Build segment tree. SegmentTreeNode *buildHelper(const vector<int>& nums, int start, int end) { if (start > end) { return nullptr; } // The root's start and end is given by build method. SegmentTreeNode *root = new SegmentTreeNode(start, end, 0); // If start equals to end, there will be no children for this node. if (start == end) { root->sum = nums[start]; return root; } // Left child: start=numsleft, end=(numsleft + numsright) / 2. root->left = buildHelper(nums, start, (start + end) / 2); // Right child: start=(numsleft + numsright) / 2 + 1, end=numsright. root->right = buildHelper(nums, (start + end) / 2 + 1, end); // Update sum. root->sum = (root->left != nullptr ? root->left->sum : 0) + (root->right != nullptr ? root->right->sum : 0); return root; }
//inserts root and the children of the root void BST::buildHelper(TreeItemType a[],int i,int start,int end,TreeNode* t) { int x; double y; TreeNode* tmp = new TreeNode; tmp->leftChildPtr = NULL; tmp->rightChildPtr= NULL; tmp->item = a[i]; t = tmp; int startL, startR; int endL, endR; startL = start; endL = i - 1; startR = i + 1; endR = end; if(startR != endR) { y = 1; for(x = startR; x < endR;x++) {y++;} y = ceil(y/2) + startR - 1; buildHelper(a,y,startR,endR,t->rightChildPtr); } if(startL != endL) { y = 1; for(x = startL; x < endL;x++) {y++;} y = ceil(y/2) + startL - 1; buildHelper(a,y,startL,endL,t->leftChildPtr); } }
TreeNode *buildHelper(vector<int> &inorder,vector<int> &postorder,int &index,int begin, int end) { if(begin>end) { return NULL; } for(int i=begin;i<=end;i++) { if(inorder[i]==postorder[index]) { TreeNode *root=new TreeNode(postorder[index]); index--; root->right=buildHelper(inorder,postorder,index,i+1,end); root->left=buildHelper(inorder,postorder,index,begin,i-1); return root; } } }
TreeNode* buildHelper(vector<int>& preorder,int preStart,int preEnd, vector<int>& inorder,int inStart,int inEnd) { if (preStart > preEnd || inStart > inEnd) return NULL; int k = inStart; for (; k <= inEnd;k++) { if (inorder[k]==preorder[preStart]) break; } TreeNode* res = new TreeNode(preorder[preStart]); res->left = buildHelper(preorder, preStart + 1, preStart + k - inStart,inorder,inStart,k-1 ); res->right = buildHelper(preorder, preStart + k - inStart + 1, preEnd, inorder, k + 1, inEnd); return res; }
TreeNode* buildHelper(vector<int>& preorder, vector<int>& inorder, int p, int q, int m) { TreeNode *root = NULL; if (q <= p) return root; int val = preorder[m]; root = new TreeNode(val); for (int i = p; i < q; ++i) { if (inorder[i] == val) { root->left = buildHelper(preorder, inorder, p, i, m + 1); root->right = buildHelper(preorder, inorder, i + 1, q, i - p + m + 1); break; } } return root; }
bool QmlObserverTool::build(BuildHelperArguments arguments, QString *log, QString *errorMessage) { arguments.helperName = QCoreApplication::translate("Qt4ProjectManager::QmlObserverTool", "QMLObserver"); arguments.proFilename = QLatin1String("qmlobserver.pro"); return buildHelper(arguments, log, errorMessage); }
//traverse list inorder and add elements to the array int BST::sortHelper(TreeItemType a[], int i, TreeNode* t) { TreeNode* curr = t; TreeItemType x; if(t->leftChildPtr != NULL) { curr = curr->leftChildPtr; sortHelper(a,i,curr); } x = curr->item; a[i] = x; i++; if(t->rightChildPtr != NULL) { curr = curr->rightChildPtr; sortHelper(a,i,curr); } if(i == (size() - 1)) { int j,k; deleteTree(root); j = sizeof(a); k = ceil(j/2); buildHelper(a,k,0,j-1,root); } }
//inserts root and the children of the root void BST::buildHelper(TreeItemType a[],int first, int last) { //TODO: if(first==last){ insertItem(root,a[first]); } else{ int mid = (first+last)/2; insertItem(root, a[mid]); if(mid!=first){ buildHelper(a, first, mid-1); } if(mid!=last){ buildHelper(a, mid+1, last); } } }
TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) { if(inorder.empty()||postorder.empty()) { return NULL; } int index=postorder.size()-1; int begin=0; int end = inorder.size()-1; return buildHelper(inorder,postorder,index,begin,end); }
NumMatrix(vector<vector<int>> &matrix) : matrix_(matrix) { if (!matrix.empty() && !matrix[0].empty()) { const int m = matrix.size(); const int n = matrix[0].size(); root_ = buildHelper(matrix, make_pair(0, 0), make_pair(m - 1, n - 1)); } }
//calls buildHelper, minimizes the height of the BST void BST::minimizeHeight() { //TODO: Must Implement int s = size(); TreeItemType a[s]; sort(a); destroyTree(root); buildHelper(a , 0, s - 1); }
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) { return buildHelper(preorder, 0, preorder.size() - 1, inorder, 0, inorder.size() - 1); }
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) { int size = inorder.size(); return buildHelper(preorder, inorder, 0, size, 0); }
NumArray(vector<int> &nums) : nums_(nums) { root_ = buildHelper(nums, 0, nums.size() - 1); }