void Bvh::constructTree(Node* n) { if (n->endPrim < n->startPrim) { std::cout << "ERROR: endPrim is smaller than startPrim in constructTree" << std::endl; return; } // Compute the node's bounding box and assign the start and endPrim to the node std::pair<Vec3f, Vec3f> bb = Bvh::computeBB(n->startPrim, n->endPrim); n->bbMin = bb.first; n->bbMax = bb.second; if (n->endPrim - n->startPrim + 1 > MAX_TRIANGLES_PER_LEAF) { // Decide how to split the primitives and // perform the actual split: shuffle the indices in the global list // so that they're split into two intervals; return the index that // separates the two intervals int splitPrim = Bvh::partitionPrimitives(n->startPrim, n->endPrim); // Create the left child and recursively call this // function with the left triangle interval n->leftChild = new Node(n->startPrim, splitPrim-1); constructTree(n->leftChild); // Create the right child and recursively call this // function with the right triangle interval n->rightChild = new Node(splitPrim, n->endPrim); constructTree(n->rightChild); } }
// A function to input new data void inputNew() { int res=0,i=0; while(i<3) { if(ti==0) { printf("Enter temperature\n"); scanf("%d",&ta); res=constructTree(); } else if(ti==1) { printf("Enter humidity\n"); scanf("%d",&ha); res=constructTree(); } else if(ti==2) { printf("Enter windspeed\n"); scanf("%d",&wa); res=constructTree(); } if(res==1) break; mGini=max(); i++; } }
TreeNode* constructTree(const vector<int> &A, int low, int high) { if(low>high) return NULL; int mid = (low+high)/2; TreeNode* t = new TreeNode(A[mid]); t->left = constructTree(A,low,mid-1); t->right = constructTree(A,mid+1,high); return t; }
TreeNode* constructTree(vector<int>& nums, int left, int right) { if(left >= right) return NULL; int max_idx = left; for(int i = left; i < right; i++) if(nums[i] > nums[max_idx]) max_idx = i; TreeNode* node = new TreeNode(nums[max_idx]); node->left = constructTree(nums, left, max_idx); node->right = constructTree(nums, max_idx+1, right); return node; }
TreeNode *constructTree(int left, int right) { if (left > right) return nullptr; int mid = left + (right - left) / 2; TreeNode *leftNode = constructTree(left, mid-1); TreeNode *node = new TreeNode(ptrNode->val); node->left = leftNode; ptrNode = ptrNode->next; TreeNode *rightNode = constructTree(mid+1, right); node->right = rightNode; return node; }
int main() { vector<string> data = {"1", "2", "3"}; auto root = constructTree(data); cout << Solution().sumNumbers(root); return 1; }
void octreeSolid::init(SurfaceObj* obj, int res) { sufObj = obj; constructTree(sufObj, res); computeBoxAndVolume(m_root); }
void octreeSolid::init(SurfaceObj* obj, float voxelSize) { sufObj = obj; constructTree(sufObj, voxelSize); computeBoxAndVolume(m_root); }
TreeNode *buildTree(vector<int> &inorder, vector<int> &postorder) { if(inorder.size() == 0) return NULL; else{ constructTree(inorder, postorder, 0, inorder.size()-1, postorder.size()-1); } }
void constructTreeTest(int *pre_order, int *in_order, int length) { std::cout << "---The pre order sequence is:---\n"; for(int index = 0; index < length; ++index) std::cout << pre_order[index]; std::cout << std::endl; std::cout << "---The in_order sequence is:---\n"; for(int index = 0; index < length; ++index) std::cout << in_order[index]; std::cout << std::endl; try { BinaryTreeNode *root = constructTree(pre_order, in_order, length); printTree(root); destroyTree(root); } catch(std::exception &exception) { std::cout << "Invalid inout.\n"; } }
TreeNode *constructTree(InputIterator pStart, InputIterator pEnd, InputIterator iStart, InputIterator iEnd) { if (pStart == pEnd) { return nullptr; } if (iStart == iEnd) { return nullptr; } auto root = new TreeNode(*pStart); auto rootIndex = find(iStart, iEnd, *pStart); auto leftLength = distance(iStart, rootIndex); root->left = constructTree(next(pStart), next(pStart, leftLength+1), iStart, next(iStart, leftLength)); root->right = constructTree(next(pStart, leftLength+1), pEnd, next(rootIndex), iEnd); return root; }
/* MAINLINE */ int main(int argc, const char *argv[]){ printf("MakeTreeSpawn - Gareth Bradshaw Feb 2003\n"); /* parse command line */ decodeIntParam(argc, argv, intParams); decodeBoolParam(argc, argv, boolParams); printf("Options : \n"); writeParam(stdout, intParams); writeParam(stdout, boolParams); /* look for filenames and construct trees */ int numFiles = 0; for (int i = 1; i < argc; i++){ if (argv[i] != NULL){ constructTree(argv[i], yaml); numFiles++; } } /* check we had a file name */ if (numFiles == 0) error("no files given :("); waitForKey(); }
Bvh::Bvh(std::vector<RTTriangle>& triangles) : m_triangles(&triangles), m_root(new Node(0, (int)(triangles.size()-1))) { constructTree(m_root); std::cout << "DEBUG: BVH construction complete." << std::endl; std::cout << "Total nodes: " << getNumOfNodes() << std::endl; std::cout << "Leaf nodes: " << getNumOfLeafNodes() << std::endl; std::cout << "Maximum depth: " << getDepth() << std::endl << std::endl; }
int main() { vector<string> data{"1","2","3","#","#","4","5"}; auto root = constructTree(data); Codec cd; auto s = cd.serialize(root); auto proot = cd.deserialize(s); return 1; }
node *constructTree(int *pre, int *post, int start, int end, int *preStart){ if(end-start+1 <1 ) return NULL; node *n = newNode(pre[*preStart]); n->left = NULL; n->right = NULL; ++*preStart; if(end-start+1 >1){ int i = find(post+start, post+end+1, pre[*preStart+1]) - post; if(i <= end){ n->left = constructTree(pre, post, start, i, preStart); n->right = constructTree(pre, post, i+1, end, preStart); } } return n; }
TreeNode* constructTree(vector<int> &preorder, vector<int> &inorder, int start, int end, int start2, map<int,int> &inorderMap) { if (start > end) return NULL; int i; TreeNode* newNode; newNode = new TreeNode(preorder[start]); int rootVal = preorder[start]; //To avoid the loop function, using map instead //for (i = start; i <= end && inorder[i] != rootVal; i++); i = inorderMap[rootVal] - start2 + start; newNode->left = constructTree(preorder, inorder, start+1, i, start2, inorderMap); newNode->right = constructTree(preorder, inorder, i+1, end, inorderMap[rootVal] + 1,inorderMap); return newNode; }
TreeNode* constructTree(vector<int> &nums, size_t begin, size_t end) { if (begin > end) return nullptr; size_t mid = (begin+end+1)/2; //begin + (end - begin + 1) / 2; TreeNode *root = new TreeNode(nums[mid]); if (mid - begin > 0) root->left = constructTree(nums, begin, mid - 1); else root->left = nullptr; if (end - begin > 0) root->right = constructTree(nums, mid + 1, end); else root->right = nullptr; return root; }
TreeNode *constructTree(vector<int> &inorder, vector<int> &postorder, int istart, int iend, int pend) { if(istart>iend) return NULL; else{ int root_val = postorder[pend]; TreeNode *root = new TreeNode(root_val); int mid; for(auto it = inorder.begin() + istart; it <= inorder.begin() + iend; it++) { if(*it == root_val) { mid = it - inorder.begin(); break; } } root->left = constructTree(inorder, postorder, istart, mid-1, pend-1-iend+mid); root->right = constructTree(inorder, postorder, mid+1, iend, pend-1); return root; } }
void octreeSolid::init(char* filePath, int res) { surfaceLoaded = true; sufObj = new SurfaceObj; sufObj->readObjDataSTL(filePath); sufObj->constructAABBTree(); constructTree(sufObj, res); computeBoxAndVolume(m_root); }
TreeNode *constructTree(vector<int>& preorder, int i, int j, vector<int>& inorder, int x, int y){ if(i > j){ return NULL; } TreeNode *root = new TreeNode(preorder[i]); int mid; for(mid = x; mid <= y; mid++){ if(inorder[mid] == preorder[i]){ break; } } int left_tree_size = mid - x; root->left = constructTree(preorder, i + 1, i + left_tree_size, inorder, x, mid - 1); root->right = constructTree(preorder, i + left_tree_size + 1, j, inorder, mid + 1, y); return root; }
TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) { if (preorder.size() == 0) return NULL; map<int,int> inorderMap; for (int i = 0; i < inorder.size(); i++) inorderMap[inorder[i]] = i; return constructTree(preorder, inorder, 0, preorder.size()-1, 0, inorderMap); }
void octreeSolid::initTest() { surfaceLoaded = true; sufObj = new SurfaceObj; sufObj->readObjDataSTL("../Data_File/euroFighter.stl"); sufObj->constructAABBTree(); constructTree(sufObj, 4); computeBoxAndVolume(m_root); }
TreeNode* sortedListToBST(ListNode* head) { ListNode *curNode = head; int num = 0; while (curNode != nullptr) { curNode = curNode->next; num++; } ptrNode = head; return constructTree(0, num-1); }
int main(){ int pre[] = {1, 2, 4, 8, 9, 5, 3, 6, 7}; int post[] = {8, 9, 4, 5, 2, 6, 7, 3, 1}; int size = sizeof( pre ) / sizeof(int); int preStart = 0; struct node *root = constructTree(pre, post, 0, size-1, &preStart); printf("Inorder traversal of the constructed tree: \n"); printInorder(root); return 0; }
struct TreeNode* constructTree(int* nums, int start, int end) { int mid; struct TreeNode *root; if (NULL == nums) return NULL; mid = (start + end) / 2; root = (struct TreeNode *)malloc(sizeof(struct TreeNode)); root->val = nums[mid]; if (mid == end) root->right = NULL; else root->right = constructTree(nums, mid + 1, end); if (mid == start) root->left = NULL; else root->left = constructTree(nums, start, mid - 1); return root; }
int main () { int pre[] = {10, 5, 1, 7, 40, 50}; int size = sizeof( pre ) / sizeof( pre[0] ); struct node *root = constructTree(pre, size); printf(" Inorder traversal of the constructed tree: \n"); printInorder(root); return 0; }
Bvh::Bvh(std::vector<RTTriangle>& triangles) : m_triangles(&triangles), m_root(new Node(0, (int)(triangles.size()-1))) { Timer stopwatch; stopwatch.start(); constructTree(m_root); stopwatch.end(); std::cout << "BVH construction complete:" << std::endl; std::cout << "--------------------------" << std::endl; std::cout << "BVH mode.....: " << (mode ? "SAH" : "Spatial") << std::endl; std::cout << "Build time...: " << stopwatch.getTotal() << " sec" << std::endl; std::cout << "Total nodes..: " << getNumOfNodes() << std::endl; std::cout << "Leaf nodes...: " << getNumOfLeafNodes() << std::endl; std::cout << "Maximum depth: " << getDepth() << std::endl << std::endl; }
/** * Given an array of points the function creates a kd-tree containing the points. * * @param arr - the array of SPPoints * @param size - the size of arr * @param dim - the dimension of the points in arr * @param splitMethod - the method to construct * the tree: 0 - RANDOM, 1 - MAX_SPREAD, 2 - INCREMENTAL * * @assert dim = point->dim for each point in arr; * * @return * NULL if arr == NULL or size < 1 or dim <1 or splitMethod * isn't between 0 and 2. * the new kd-tree otherwise */ KDTreeNode kdTreeInit(SPPoint* arr, int size, int dim, int splitMethod) { KDTreeNode kdt; if (arr == NULL || size < 1 || dim < 1 || splitMethod < 0 || splitMethod > 2) return NULL ; KDArray mat; mat = kdArrayInit(arr, size, dim); kdt = constructTree(mat, size, dim, splitMethod, dim); kdArrayDestroy(mat); return kdt; }
vector<string> findWords(vector<vector<char> > &board, vector<string> &words) { // write your code here vector<string> res; if(board.size() == 0 || board[0].size() == 0 || words.size() == 0) { return res; } TrieNode* root = constructTree(words); int row = board.size(); int col = board[0].size(); for(int i=0; i<row; i++) { for(int j=0; j<col; j++) { wordSearch(board, row, col, i, j, root, res); } } return res; }
int main() { int num,i; char c; char sentence[MAXSIZE]; int top=0,arr[MAXSIZE]; NODE *temp1,*temp2; printf("Enter the sentence to be encoded : "); scanf("%[^\n]",sentence); num = calculateFre(fre,sentence); //calculate the frequency of occurrence displayFre(fre); //displayFre() function present in the header file. for(i=0;i<num;i++) { insert(fre[i].ch,fre[i].prob); //insert every character into linked list } //display(); while(n->link != NULL) { temp1=n; temp2 = n->link; n=n->link->link; constructTree(temp1,temp2); } encode(n->root,arr,top); diplayEncodedString(sentence); //inorder(n->root); }