void postorder_traversal(struct node* node){
if(node!=NULL){
postorder_traversal(node->left);
postorder_traversal(node->right);
printf("%d ",node->data);
}
}
void postorder_traversal(treenode *T){
if(T==NULL)
return;
postorder_traversal(T->lc);
postorder_traversal(T->rc);
printf("%d ", T->id);
}
// Function for postorder traversal of Binary Tree
void postorder_traversal(struct node* tree)
{
if(tree == NULL)
return;
postorder_traversal(tree->left);
postorder_traversal(tree->right);
printf("\t%d", tree->data);
}
void postorder_traversal(minHeap *hp, int i) {
printf("%d ", hp->elem[i].data) ;
if((2i) < hp->size) {
postorder_traversal(hp, (2i)) ;
}
if((2i+1) < hp->size) {
postorder_traversal(hp, (2i+1)) ;
}
}
void postorder_traversal(struct node *root, int *arr, int* i3){
if (root != NULL && arr != NULL)
{
postorder_traversal(root->left, arr, i3);
postorder_traversal(root->right, arr, i3);
arr[*i3] = root->data;
(*i3)++;
}
}
void postorder_traversal( tree *T )
{
if(T!=NULL)
{
postorder_traversal( T->left );
postorder_traversal( T->right );
printf("%d ",T->item);
}
}
void postorder_traversal(struct node *root, int *arr, int *index){
if (root == NULL)
return;
postorder_traversal(root->left, arr, index);
postorder_traversal(root->right, arr, index);
arr[*index] = root->data;
*index = *index + 1;
}
string CBinarySearchDictionary::postorder_traversal(Node *pNode)
{
string strValue = "";
string strLeft = "";
string strRight = "";
if (pNode != NULL)
{
strLeft = postorder_traversal(pNode->pLeft);
strRight = postorder_traversal(pNode->pRight);
strValue = strLeft + "\t" + strRight + "\t" + pNode->strNameValue;
}
return strValue;
}
main()
{
tree *t;
t=NULL;
int i,q,w,flag;
char c,d;
while(1)
{
scanf("%d",&q);
c=getchar();
// insert(q,&t1);
if(c=='\n')
break;
}
while(1)
{
scanf("%d",&w);
d=getchar();
insert(w,&t);
if(d=='\n')
break;
}
inorder_traversal(t);
printf("\n");
preorder_traversal(t);
printf("\n");
postorder_traversal(t);
printf("\n");
levelprint(t);
printf("\n");
}
void postorder(struct node *root, int *arr){
if (arr == NULL)
return;
int i = 0;
postorder_traversal(root, arr, &i);
}
void KTREE::postorder_traversal(TNode* node)
{
int f=0;
for (int i=0;i<MAX;i++)
if (node->getChild(i)!=0)
{
postorder_traversal(node->getChild(i));
}
cout <<" "<<node->getElement();
}
int main()
{
char msg[] = " deadbeef";
binary_tree_t t = create_tree(msg, 8);
printf("%d", tree_height(t));
sep;
preorder_traversal(t, print_node);
sep;
postorder_traversal(t, print_node);
sep;
inorder_traversal(t, print_node);
return 0;
}
void KTREE::postorder_traversal()
{ //postorder
TNode *tmp;
tmp=top;
int i;
if (top==0)
cout <<"empty tree !!!"<<endl;
else
{
for (i=0;i<MAX;i++)
{
if (top->getChild(i)!=0)
postorder_traversal(top->getChild(i));
}
cout <<" "<<top->getElement();
}
cout<<endl;
}
void test_tree() {
vector<char> output;
Node<char> *tree = populate_test_tree();
// level-order
output.clear();
levelorder_traversal(tree, output);
assert(output == expected_output_levelorder);
// pre-order
output.clear();
preorder_traversal(tree, output);
assert(output == expected_output_preorder);
// in-order
output.clear();
inorder_traversal(tree, output);
assert(output == expected_output_inorder);
// post-order
output.clear();
postorder_traversal(tree, output);
assert(output == expected_output_postorder);
// pre-order (non-recursive)
output.clear();
preorder_traversal_nonrecursive(tree, output);
assert(output == expected_output_preorder);
// in-order (non-recursive)
output.clear();
inorder_traversal_nonrecursive(tree, output);
assert(output == expected_output_inorder);
// post-order (non-recursive)
output.clear();
postorder_traversal_nonrecursive(tree, output);
assert(output == expected_output_postorder);
}
static int traverse_dump(struct bitree *tree, TRAVE_DIRECTION dir)
{
int cnt = -1, depth;
const char *str = NULL;
if (!tree)
goto exit;
if (dir >= TRAVE_PREORDER && dir < TRAVE_MAX)
str = TRAVERSE_STRINGS[dir];
switch (dir) {
case TRAVE_PREORDER:
cnt = preorder_traversal(tree->root, visit);
break;
case TRAVE_INORDER:
cnt = inorder_traversal(tree->root, visit);
break;
case TRAVE_POSTORDER:
cnt = postorder_traversal(tree->root, visit);
break;
case TRAVE_LEVELORDER:
cnt = levelorder_traversal(tree->root, visit, &depth);
fprintf(stdout, "%s: depth:%d\n", str, depth);
break;
default:
break;
}
fprintf(stdout, "%s: total %d nodes traversed\n",
(str == NULL) ? "N/A" : str , cnt);
dump_visit_list(TRUE);
exit:
return cnt;
}
int main()
{
char choice[100];
char choice2[100];
int element;
struct node * root = NULL;
do {
scanf("%s", choice);
if (!strcmp(choice, "preorder\0")) {
preorder_traversal(root);
printf("\n");
} else if (!strcmp(choice, "postorder\0")) {
postorder_traversal(root);
printf("\n");
} else if (!strcmp(choice, "inorder\0")) {
inorder_traversal(root);
printf("\n");
} else if (!strcmp(choice, "insert\0")) {
scanf(" %d", &element);
tree_insert(&root, element);
} else if (!strcmp(choice, "successor\0")) {
scanf(" %d", &element);
tree_insert(&root, element);
} else if (!strcmp(choice, "insert\0")) {
scanf(" %d", &element);
tree_insert(&root, element);
} else if (!strcmp(choice, "delete\0")) {
scanf(" %d", &element);
tree_delete(&root, element);
}
} while (strcmp(choice, "exit\0"));
return 0;
}
int main()
{
int choice, counter, flag, num;
char temp[LIMIT];
struct node *root = NULL;
system("clear");
//root->left = create_leaf_node(2);
//root->right = create_leaf_node(31);
//root->left->left = create_leaf_node(14);
//root->left->right = create_leaf_node(5);
//root->right->left = create_leaf_node(44);
//root->right->right = create_leaf_node(15);
do
{
// Display Menu for Operation on Binary Tree
printf("\n This program implements a AVL Tree \n");
printf("\n 1. Insert an element");
printf("\n 2. Delete an element");
printf("\n 3. Search an element");
printf("\n 4. Perform Inorder Traversal");
printf("\n 5. Perform Preorder Traversal");
printf("\n 6. Perform Postorder Traversal");
printf("\n 7. Display AVL Tree (Level Order)");
printf("\n 8. Exit");
printf("\n Enter your choice(1-8) : ");
scanf("%s", temp);
if (strlen(temp) > 1 || atoi(temp) < 1 || atoi(temp) > 8)
{
choice = 0;
}
else
choice = atoi(temp);
memset(temp, 0 , LIMIT);
switch(choice)
{
case 1:
do
{
flag = 0;
printf("\n Enter the integer element to be inserted : ");
scanf("%s", temp);
for(counter = 0; counter < strlen(temp); counter++)
{
if (temp[counter] < 48 || temp[counter] > 57)
{
printf("\n Invalid Data Type Entered .. Please input valid data type ... ");
flag = 1;
break;
}
}
num = atoi(temp);
}while(flag == 1);
root = insert_node(root, num);
printf("\n Element Inserted");
break;
case 2:
do
{
flag = 0;
printf("\n Enter the element to be deleted : ");
scanf("%s", temp);
for(counter = 0; counter < strlen(temp); counter++)
{
if (temp[counter] < 48 || temp[counter] > 57)
{
printf("\n Invalid Data Type Entered .. Please input valid data type ... ");
flag = 1;
break;
}
}
num = atoi(temp);
}while(flag == 1);
flag = binary_search(root, num);
if (flag == 1)
{
root = delete_node(root, num);
printf("\n Element Deleted");
}
else
printf("\n Deletion Element not found");
break;
case 3:
do
{
flag = 0;
printf("\n Enter the element to be searched : ");
scanf("%s", temp);
for(counter = 0; counter < strlen(temp); counter++)
{
if (temp[counter] < 48 || temp[counter] > 57)
{
printf("\n Invalid Data Type Entered .. Please input valid data type ... ");
flag = 1;
break;
}
}
num = atoi(temp);
}while(flag == 1);
flag = binary_search(root, num);
if (flag == 1)
printf("\n Element Found");
else
printf("\n Element not found");
break;
case 4:
printf("\n The Inorder Traversal of Entered Binary Tree is : \n");
inorder_traversal(root);
break;
case 5:
printf("\n The Preorder Traversal of Entered Binary Tree is : \n");
preorder_traversal(root);
break;
case 6:
printf("\n The Postorder Traversal of Entered Binary Tree is : \n");
postorder_traversal(root);
break;
case 7:
level_order_traversal(root);
break;
case 8:
break;
default:
printf("\nInvalid Choice\n");
}
}while(choice != 8);
return 0;
}
void postorder(struct node* root, int *arr)
{
int i2 = 0;
postorder_traversal(root, arr, &i2);
}
void post_visit(treenode *T){
printf("result by using postorder traversal: ");
postorder_traversal(T);
printf("\n");
}
string CBinarySearchDictionary::postorder()
{
return postorder_traversal(root);
}
void postorder_traversal(const Basic &b, Visitor &v)
{
for (const auto &p: b.get_args()) postorder_traversal(*p, v);
b.accept(v);
}
