vector<int> preorderTraversal(TreeNode* root){ //Recursive solution vector<int> empty; if (root == NULL) return empty; vector<int> output; output.push_back(root->val); output = preorderTraversal(root->left); output = preorderTraversal(root->right); return output; //Iterative solution /*stack<TreeNode*> myStack; vector<int> output; if(root == NULL) return output; while (myStack.size() > 0 || root != NULL){ if (root != NULL){ output.push_back(root->val); if (root->right != NULL) myStack.push(root->right); root = root->left; } else{ root = myStack.top(); myStack.pop(); } }*/ }
/** * Return an array of size *returnSize. * Note: The returned array must be malloced, assume caller calls free(). */ int* preorderTraversal(struct TreeNode* root, int* returnSize) { int* leftReturnSize = (int *)malloc(sizeof(int)); int* rightReturnSize = (int *)malloc(sizeof(int)); int* leftReturnArray; int* rightReturnArray; int* returnArray; int i,j; if (root == NULL) { *returnSize = 0; return NULL; } else { leftReturnArray = preorderTraversal(root->left, leftReturnSize); rightReturnArray = preorderTraversal(root->right, rightReturnSize); returnArray = (int *)malloc( (1 + *leftReturnSize + *rightReturnSize) * sizeof(int)); returnArray[0] = root->val; for (i = 0 , j = 1; i < *leftReturnSize; i++, j++) { returnArray[j] = leftReturnArray[i]; } free(leftReturnSize); if (leftReturnArray != NULL) { free(leftReturnArray); } for (i = 0; i < *rightReturnSize; i++, j++) { returnArray[j] = rightReturnArray[i]; } if (rightReturnArray != NULL) { free(rightReturnArray); } free(rightReturnSize); *returnSize = j; return returnArray; } }
/** * @param root: The root of binary tree. * @return: Preorder in vector which contains node values. */ vector<int> preorderTraversal(TreeNode *root) { // write your code here vector<int> nums; if (root == NULL)return nums; vector<int> leftNums; vector<int> rightNums; nums.push_back(root->val); if (root->left != NULL) { leftNums = preorderTraversal(root->left); for (auto &item: leftNums) { //遍历容器中的各个成员! nums.push_back(item); } } if (root->right != NULL) { rightNums = preorderTraversal(root->right); for (auto &item: rightNums) { //遍历容器中的各个成员! nums.push_back(item); } } return nums; }
void preorderTraversal(TreeNode* root ,vector<int> & path){ if( root == NULL) return ; path.push_back(root->val); preorderTraversal(root->left, path); preorderTraversal(root->right, path); }
void preorderTraversal (NODE_p_t root) { if (root != NULL) { printf(" %d", root->data); preorderTraversal(root->left); preorderTraversal(root->right); } }
void preorderTraversal(struct node *tree){ if(tree!=NULL){ printf("%d\t",tree->data); preorderTraversal(tree->left); preorderTraversal(tree->right); } }
void preorderTraversal(struct node *root) { printf("%d ", root->a); if(root->left != NULL) preorderTraversal(root->left); if(root->right != NULL) preorderTraversal(root->right); }
vector<int> preorderTraversal(TreeNode* root) { if (root != NULL) { res.push_back(root->val); preorderTraversal(root->left); preorderTraversal(root->right); } return res; }
vector<int> preorderTraversal(TreeNode *root) { if(root == NULL) return outcome; outcome.push_back(root->val); preorderTraversal(root->left); // 前序遍历左子树 preorderTraversal(root->right); // 前序遍历右子树 return outcome; }
void preorderTraversal(NODE * root){ if (root == NULL) return; printf("%d ", root->val); preorderTraversal(root->left); preorderTraversal(root->right); }
vector<int> preorderTraversal1(TreeNode *root) { if(root){ v.push_back(root->val); preorderTraversal(root->left); preorderTraversal(root->right); } return v; }
void preorderTraversal(TreeNode *root,vector<int> &vector){ if (root == NULL) { return; } vector.push_back(root->val); preorderTraversal(root->left, vector); preorderTraversal(root->right, vector); }
int preorderTraversal(TreeNode* node, int sum) { if (node == nullptr) { return 0; } int cnt = calculateSum(node, sum, 0); cnt += preorderTraversal(node->left, sum); cnt += preorderTraversal(node->right, sum); return cnt; }
/* Function to display all the nodes in the min heap by doing a preorder traversal */ void preorderTraversal(minHeap *hp, int i) { if(LCHILD(i) < hp->size) { preorderTraversal(hp, LCHILD(i)) ; } if(RCHILD(i) < hp->size) { preorderTraversal(hp, RCHILD(i)) ; } printf("%d ", hp->elem[i].data) ; }
void preorderTraversal(struct NODE *s){ if(s == NULL) return; printf("%c\t",s->data); preorderTraversal(s->l); preorderTraversal(s->r); }
vector<int> preorderTraversal(TreeNode* root) { vector<int> retval; if (root == NULL) return retval; retval.push_back(root->val); vector<int> lhs = preorderTraversal(root->left); vector<int> rhs = preorderTraversal(root->right); if (lhs.size() > 0) retval.insert(retval.end(), lhs.begin(), lhs.end()); if (rhs.size() > 0) retval.insert(retval.end(), rhs.begin(), rhs.end()); return retval; }
/** * @param root: The root of binary tree. * @return: Preorder in vector which contains node values. */ vector<int> preorderTraversal(TreeNode *root) { static vector<int> result; if (root == NULL) return result; result.push_back(root->val); preorderTraversal(root->left); preorderTraversal(root->right); return result; }
/* * Affichage préfixés */ void preorderTraversal(BinaryTree *tree) { printf("%d ", tree->value); if(isEmpty(leftChild(tree)) == FALSE) preorderTraversal(leftChild(tree)); if(isEmpty(rightChild(tree)) == FALSE) preorderTraversal(rightChild(tree)); }
vector<int> preorderTraversal(TreeNode* root) { if(!root)return result; if(root) result.push_back(root->val); if(root->left) result=preorderTraversal(root->left); if(root->right) result=preorderTraversal(root->right); return result; }
void preorderTraversal(TreeNode* node, vector<int>& v) { if (node == nullptr) { return; } v.push_back(node->val); preorderTraversal(node->left, v); preorderTraversal(node->right, v); }
/** * @param root: The root of binary tree. * @return: Preorder in vector which contains node values. */ vector<int> preorderTraversal(TreeNode *root) { // write your code here vector<int> result; if (root != NULL) { vector<int> left = preorderTraversal(root->left); vector<int> right = preorderTraversal(root->right); result.push_back(root->val); result.insert(result.end(), left.begin(),left.end()); result.insert(result.end(), right.begin(),right.end()); } return result; }
vector<int> preorderTraversal(TreeNode* root) { // Version 1: recursive if(root != NULL) { node.push_back(root->val); preorderTraversal(root->left); preorderTraversal(root->right); } return node; // Version 2: dfs }
vector<int> preorderTraversal(TreeNode* root) { vector<int> result; if (root == nullptr) return result; // Add root result.push_back(root->val); // Append left tree vector<int> resLeft = preorderTraversal(root->left); result.insert(result.end(), resLeft.begin(), resLeft.end()); // Append right tree vector<int> resRight = preorderTraversal(root->right); result.insert(result.end(), resRight.begin(), resRight.end()); // return result; }
vector<int> preorderTraversal(TreeNode *root) { vector<int> result; if(root == NULL) return result; result.push_back(root->val); if (root -> left != NULL) { vector<int> result_left = preorderTraversal(root -> left); result.insert(result.end(), result_left.begin(), result_left.end()); } if (root -> right != NULL) { vector<int> result_right = preorderTraversal(root -> right); result.insert(result.end(), result_right.begin(), result_right.end()); } return result; }
vector<int> preorderTraversal(TreeNode *root) { vector<int> ans; if (root){ ans.push_back(root->val); vector<int> left = preorderTraversal(root->left); int ll = left.size(); for (int i = 0; i < ll; i++) ans.push_back(left[i]); vector<int> right = preorderTraversal(root->right); int lr = right.size(); for (int i = 0; i < lr; i++) ans.push_back(right[i]); } return ans; }
/* Main function for testing different functions of the assignment */ int main() { printf("%u\n",compareValues(2.0,2.0)); struct BSTree *tree = newBSTree(); testAddNode(tree); testContainsBSTree(tree); printf("printing in-order traversal \n"); inorderTraversal(tree->root); printf("printing pre-order traversal \n"); preorderTraversal(tree->root); printf("printing post-order traversal \n"); postorderTraversal(tree->root); testLeftMost(tree); testRemoveNode(tree); freeBSTree(tree); return 0; }
vector<int> preorderTraversal(TreeNode* root) { vector<int> result; if( root == NULL) return result; preorderTraversal(root, result); return result; }
int main() { srand(time(NULL)); struct node *tree; int used[N] = {0}; int i = N - M; int path[M], max_path[M], side_path[M], max, j, c, cm; tree = createTree(M, used, &i); inorderTraversal(tree); printf("\n\n"); preorderTraversal(tree); printf("\n\n"); postorderTraversal(tree); printf("\n\n"); max = maxRootSumPath(tree, path, &c); for (j = c; j >= 1; --j) { printf("%d ", path[j]); } printf("\n\n"); int m = INT_MIN; max = maxSumPath(tree, max_path, side_path, &c, &m, &cm); for (j = 1; j <= cm ; ++j) { printf("%d ", max_path[j]); } printf("\n\n"); return 0; }
int main(int argc, char const *argv[]) { RBTree* tree = RBCreate(); while(true){ int num = 0; printf("please enter num: \n"); scanf("%d", &num); if(num == 0){ break; } int i=0; RBInsert(tree, num, num); int size = 0; char** preorder = preorderTraversal(tree, &size); for(i=0;i<size;i++){ printf("%s\n", preorder[i]); } free(preorder); } RBDestroy(tree); return 0; }
vector<int> preorderTraversal(TreeNode* root) { //binary tree; divide and conquer //TC:O(n); SC:O(logn) if (!root){ return {}; } vector<int> res; //divide vector<int> left = preorderTraversal(root->left); vector<int> right = preorderTraversal(root->right); //conquer res.push_back(root->val); res.insert(res.end(), left.begin(), left.end()); res.insert(res.end(), right.begin(), right.end()); return res; }