void inorderTraversal(struct node *root)
{ if(root->left != NULL)
inorderTraversal(root->left);
printf("%d ", root->a);
if(root->right != NULL)
inorderTraversal(root->right);
}
void inorderTraversal(TreeNode *node, vector<TreeNode *> &list, vector<int> &numbers){
if(node == NULL) return;
inorderTraversal(node->left, list, numbers);
list.push_back(node);
numbers.push_back(node->val);
inorderTraversal(node->right, list, numbers);
}
void inorderTraversal(TreeNode* root, vector<int> &v) {
if(root==NULL)
return;
inorderTraversal(root->left, v);
v.push_back(root->val);
inorderTraversal(root->right, v);
}
void inorderTraversal(TreeNode *node, vector<int> &res) {
if (node->left != NULL)
inorderTraversal(node->left, res);
res.push_back(node->val);
if (node->right != NULL)
inorderTraversal(node->right, res);
}
void inorderTraversal(struct node *tree){
if(tree!=NULL){
inorderTraversal(tree->left);
printf("%d\t",tree->data);
inorderTraversal(tree->right);
}
}
vector<int> inorderTraversal(TreeNode* root) {
if(!root) return v;
inorderTraversal(root->left);
v.push_back(root->val);
inorderTraversal(root->right);
return v;
}
void inorderTraversal(struct BSTNode*root)
{
if(root==NULL)
return;
inorderTraversal(root->left);
printf("%d ",root->key);
inorderTraversal(root->right);
}
void inorderTraversal(struct node *root) {
if(root == NULL) {
return;
}
inorderTraversal(root->l_child);
printf("%d ", root->value);
inorderTraversal(root->r_child);
}
void inorderTraversal(NODE * root){
if (root == NULL)
return;
inorderTraversal(root->left);
printf("%d ", root->val);
inorderTraversal(root->right);
}
/*
Function to display all the nodes in the min heap by doing a inorder traversal
*/
void inorderTraversal(minHeap *hp, int i) {
if(LCHILD(i) < hp->size) {
inorderTraversal(hp, LCHILD(i)) ;
}
printf("%d ", hp->elem[i].data) ;
if(RCHILD(i) < hp->size) {
inorderTraversal(hp, RCHILD(i)) ;
}
}
void inorderTraversal(struct NODE *s){
if(s == NULL)
return;
inorderTraversal(s->l);
printf("%c\t",s->data);
inorderTraversal(s->r);
}
// 0ms 12.54%
// Recursive
vector<int> inorderTraversal(TreeNode* root) {
vector<int> tmp, ret;
if(!root) return ret;
tmp = inorderTraversal(root->left);
ret.insert(ret.end(), tmp.begin(), tmp.end());
ret.push_back(root->val);
tmp = inorderTraversal(root->right);
ret.insert(ret.end(), tmp.begin(), tmp.end());
return ret;
}
void inorderTraversal(TreeNode* root, vector<int> &a, int k)
{
// Stop the traversal when we reach the kth element
if(!root || a.size() == k)
return;
inorderTraversal(root->left, a, k);
a.push_back(root->val);
inorderTraversal(root->right,a, k);
return;
}
void inorderTraversal (TTN_p_t root) {
if (root == NULL)
return;
inorderTraversal(root->left);
if (root->k1 != LESS)
printf(" %d", root->k1);
inorderTraversal(root->mid);
if (root->k2 != LESS)
printf(" %d", root->k2);
inorderTraversal(root->right);
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int>result;
if(!root) return result;
vector<int>temp1 = inorderTraversal(root->left);
result.insert(result.end(),temp1.begin(),temp1.end());
result.push_back(root->val);
vector<int>temp2 = inorderTraversal(root->right);
result.insert(result.end(),temp2.begin(),temp2.end());
return result;
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> vi;
if(root==nullptr)
return vi;
vi = inorderTraversal(root->left);
vi.push_back(root->val);
vector<int> tmp;
tmp = inorderTraversal(root->right);
vi.insert(vi.end(), tmp.begin(), tmp.end());
return vi;
}
vector<int> inorderTraversal(TreeNode *root) {
vector<int> r;
if(!root) return r;
vector<int> leftr = inorderTraversal(root->left);
r.insert(r.end(), leftr.begin(), leftr.end());
r.push_back(root->val);
vector<int> rightr = inorderTraversal(root->right);
r.insert(r.end(), rightr.begin(), rightr.end());
return r;
}
void inorderTraversal(TreeNode * pstRoot, vector<int> & vecResult)
{
if (pstRoot == NULL)
{
return;
}
inorderTraversal(pstRoot -> left, vecResult);
vecResult.push_back(pstRoot -> val);
inorderTraversal(pstRoot -> right, vecResult);
}
vector<int> inorderTraversal(TreeNode *root) {
vector<int> result;
if (NULL == root)
return result;
vector<int> leftResult = inorderTraversal(root->left);
vector<int> rightResult = inorderTraversal(root->right);
for( int i = 0 ; i < leftResult.size(); ++i)
result.push_back(leftResult[i]);
result.push_back(root->val);
for( int i = 0 ; i < rightResult.size(); ++i)
result.push_back(rightResult[i]);
return result;
}
vector<int> inorderTraversal(TreeNode *root) {
// write your code here
std::vector<int> v1;
if (root==nullptr) return rt_invt;
if (root->left) v1=inorderTraversal(root->left);
rt_invt.push_back(root->val);
if (root->right) v1=inorderTraversal(root->right);
return rt_invt;
}
vector<int> inorderTraversal(TreeNode* root) {
if(root==nullptr) return vector<int>();
vector<int> result;
if(root->left) {
for(auto e: inorderTraversal(root->left))
result.push_back(e);
}
result.push_back(root->val);
if(root->right) {
for(auto e: inorderTraversal(root->right))
result.push_back(e);
}
return result;
}
vector<int> inorderTraversal(TreeNode* root)
{
vector<int> res;
if(root)
{
vector<int> lefttmp = inorderTraversal(root->left);
res.insert(res.end(),lefttmp.begin(),lefttmp.end());
res.push_back(root->val);
vector<int> righttmp = inorderTraversal(root->right);
res.insert(res.end(),righttmp.begin(),righttmp.end());
}
return res;
}
int main()
{
struct BST*T;
T=(struct BST*)malloc(sizeof(struct BST*));
T->root=NULL;
struct BSTNode **nodeArray;
nodeArray=(struct BSTNode**)malloc(sizeof(struct BstNode*)*10);
nodeArray[0]=makeNode(500);
nodeArray[1]=makeNode(200);
nodeArray[2]=makeNode(700);
nodeArray[3]=makeNode(100);
nodeArray[4]=makeNode(300);
nodeArray[5]=makeNode(400);
nodeArray[6]=makeNode(600);
nodeArray[7]=makeNode(0);
nodeArray[8]=makeNode(900);
nodeArray[9]=makeNode(800);
BSTInsert(T,nodeArray[0]);
BSTInsert(T,nodeArray[1]);
BSTInsert(T,nodeArray[2]);
BSTInsert(T,nodeArray[3]);
BSTInsert(T,nodeArray[4]);
BSTInsert(T,nodeArray[5]);
BSTInsert(T,nodeArray[6]);
BSTInsert(T,nodeArray[7]);
BSTInsert(T,nodeArray[8]);
BSTInsert(T,nodeArray[9]);
inorderTraversal(T->root);
return 0;
}
int main (int argc, char const * argv []) {
int x;
printf("Enter elements one by one, -1 to break: ");
TTN_p_t tree = NULL;
do {
scanf(" %d", &x);
if (x >= 0)
tree = insertItem(tree, x);
} while (x >= 0);
// TTN_p_t tree = insertItem(NULL, 4);
// tree = insertItem(tree, 3);
// tree = insertItem(tree, 2);
// tree = insertItem(tree, 5);
// tree = insertItem(tree, 6);
// tree = insertItem(tree, 1);
// tree = insertItem(tree, 8);
// tree = insertItem(tree, 7);
printf("Inorder: \n");
inorderTraversal(tree);
printf("\n\n");
return 0;
}
int main()
{
int returnSize = 0;
/* struct TreeNode *left = malloc(sizeof(struct TreeNode));
left->left = NULL;
left->right = NULL;
left->val = 2;
struct TreeNode *right = malloc(sizeof(struct TreeNode));
right->left = NULL;
right->right = NULL;
right->val = 2;
struct TreeNode *root = malloc(sizeof(struct TreeNode));
root->left = left;
root->right = right;
root->val = 1;
*/
struct TreeNode *root = malloc(sizeof(struct TreeNode));
root->left = NULL;
root->right = NULL;
root->val = 1;
int *result = inorderTraversal(root, &returnSize);
for (int i = 0; i < returnSize; i++)
{
printf("%d ", result[i]);
}
putchar('\n');
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
if( root == NULL)
return result;
inorderTraversal(root, result);
return result;
}
vector<int> inorderTraversal(TreeNode *root) {
vector<int> left,right,ans;ans.clear();
if (root==NULL) return ans;
if (root->left!=NULL)
{
left=inorderTraversal(root->left);
for (int i=0;i<left.size();i++) ans.push_back(left[i]);
}
ans.push_back(root->val);
if (root->right!=NULL)
{
right=inorderTraversal(root->right);
for (int i=0;i<right.size();i++) ans.push_back(right[i]);
}
return ans;
}
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;
}
/* 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> inorderTraversal(TreeNode *root) {
vector<int> r;
if(root==NULL){
return r;
}
vector<int> l = inorderTraversal(root->left);
for(int i=0; i<l.size(); i++){
r.push_back(l[i]);
}
r.push_back(root->val);
l = inorderTraversal(root->right);
for(int i=0; i<l.size(); i++){
r.push_back(l[i]);
}
return r;
}
