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