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