vector<int> postorderTraversal(TreeNode* root) {
vector<int> ret;
if(root == NULL){
return ret;
}
if((root->left == NULL) && (root->right == NULL)){
ret.push_back(root->val);
return ret;
}
vector<int> left;
vector<int> right;
if(root->left){
left = postorderTraversal(root->left);
for(int i=0; i<left.size(); i++){
ret.push_back(left[i]);
}
}
if(root->right){
right = postorderTraversal(root->right);
for(int i=0; i<right.size(); i++){
ret.push_back(right[i]);
}
}
ret.push_back(root->val);
return ret;
}
void postorderTraversal(struct node *tree){
if(tree!=NULL){
postorderTraversal(tree->left);
postorderTraversal(tree->right);
printf("%d\t",tree->data);
}
}
void postorderTraversal(NODE_p_t root) {
if (root != NULL) {
postorderTraversal(root->left);
postorderTraversal(root->right);
printf(" %d", root->data);
}
}
void postorderTraversal(TreeNode* root ,vector<int> & path){
if( root == NULL)
return ;
postorderTraversal(root->left, path);
postorderTraversal(root->right, path);
path.push_back(root->val);
}
void postorderTraversal(TreeNode* root, vector<int>& result) {
if (root != nullptr) {
result.push_back(root->val);
postorderTraversal(root->right, result);
postorderTraversal(root->left, result);
}
}
void postorderTraversal(struct node *root)
{ if(root->left != NULL)
postorderTraversal(root->left);
if(root->right != NULL)
postorderTraversal(root->right);
printf("%d ", root->a);
}
void postorderTraversal(TreeNode *root, std::vector<int> &vals)
{
if(root == NULL)
return;
postorderTraversal(root->left, vals);
postorderTraversal(root->right, vals);
vals.push_back(root->val);
}
void postorderTraversal(NODE * root){
if (root == NULL)
return;
postorderTraversal(root->left);
postorderTraversal(root->right);
printf("%d ", root->val);
}
/*
Function to display all the nodes in the min heap by doing a post order traversal
*/
void postorderTraversal(minHeap *hp, int i) {
printf("%d ", hp->elem[i].data) ;
if(LCHILD(i) < hp->size) {
postorderTraversal(hp, LCHILD(i)) ;
}
if(RCHILD(i) < hp->size) {
postorderTraversal(hp, RCHILD(i)) ;
}
}
void postorderTraversal(struct NODE *s){
if(s == NULL)
return;
postorderTraversal(s->l);
postorderTraversal(s->r);
printf("%c\t",s->data);
}
void postorderTraversal(TreeNode *root, vector<int>& v)
{
if (root == NULL){
return;
}
postorderTraversal(root->left,v);
postorderTraversal(root->right,v);
v.push_back(root->val);
}
vector<int> postorderTraversal(TreeNode *root) {
vector<int> result;
if (root == NULL)
return result;
vector<int> left_vector = postorderTraversal(root->left);
vector<int> right_vector = postorderTraversal(root->right);
result.reserve(left_vector.size() + right_vector.size() + 1);
result.insert(result.end(), left_vector.begin(), left_vector.end());
result.insert(result.end(), right_vector.begin(), right_vector.end());
result.push_back(root->val);
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> ans;
if (!root){
return ans;
}
auto left = postorderTraversal(root->left);
ans.insert(ans.end(), left.begin(), left.end());
auto right = postorderTraversal(root->right);
ans.insert(ans.end(), right.begin(), right.end());
ans.push_back(root->val);
return ans;
}
vector<int> postorderTraversal(TreeNode *root) {
vector<int> ans;
if (root){
vector<int> left = postorderTraversal(root->left);
int ll = left.size();
for (int i = 0; i < ll; i++)
ans.push_back(left[i]);
vector<int> right = postorderTraversal(root->right);
int lr = right.size();
for (int i = 0; i < lr; i++)
ans.push_back(right[i]);
ans.push_back(root->val);
}
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;
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> result;
if( root == NULL)
return result;
postorderTraversal(root, result);
return result;
}
/* 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;
}
int main(){
string trees[] = {"3","9","20","#","#","15","7"};
TreeNode * root = init_complete_binary_tree_from_nodes(trees,0, sizeof(trees)/ sizeof(string));
pre_order_travel(root);
cout<<endl;
print_vector(postorderTraversal(root));
return 0;
}
vector<int> postorderTraversal(TreeNode* root) {
if(root!=NULL) {
if(flag==0) {
flag=1;
postorderTraversal(root->left);
postorderTraversal(root->right);
trav.push_back(root->val);
flag=0;
return trav;
}
postorderTraversal(root->left);
postorderTraversal(root->right);
trav.push_back(root->val);
return trav;
}
return trav;
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> v;
if(root == NULL) return v;
if(root->left != NULL) {
vector<int> temp;
temp = postorderTraversal(root->left);
for(int i = 0; i < temp.size(); i++) {
v.push_back(temp[i]);
}
}
if(root->right != NULL) {
vector<int> temp;
temp = postorderTraversal(root->right);
for(int i = 0; i < temp.size(); i++) {
v.push_back(temp[i]);
}
}
v.push_back(root->val);
return v;
}
//Driver function
int main(void){
struct NODE *root;
root = buildtree(0);
printf("\nTree built\n\nInorder traversal: ");
inorderTraversal(root);
printf("\n\nPre Order traversal: ");
preorderTraversal(root);
printf("\n\nPost Order traversal: ");
postorderTraversal(root);
printf("\n");
return 0;
}
vector<int> postorderTraversal(TreeNode* root) {
if(root != NULL){
if(root -> left == NULL && root -> right == NULL){
return vector<int>(1, root -> val);
}
else {
vector<int> v;
if(root -> left != NULL) {
vector<int> leftv = postorderTraversal(root -> left);
v.insert(v.end(),leftv.begin(),leftv.end());
}
if(root -> right != NULL) {
vector<int> rightv = postorderTraversal(root -> right);
v.insert(v.end(),rightv.begin(),rightv.end());
}
v.push_back(root -> val);
return v;
}
}
else {
return vector<int>(0);
}
}
int main (int argc, const char * argv []) {
printf("\n-------------------------BINARY SEARCH TREE-------------------------\n\n");
NODE_p_t tree = buildTree();
int choice;
do {
printf("\n\n\t1. Rebuild tree.\n");
printf("\t2. Search for an item.\n");
printf("\t3. Search for an item (insert if not found).\n");
printf("\t4. Preorder traversal.\n");
printf("\t5. Inorder traversal.\n");
printf("\t6. Postorder traversal.\n");
printf("\tChoice: ");
scanf(" %d", &choice);
if (choice == 1) {
tree = buildTree();
} else if (choice == 2 || choice == 3) {
int item;
printf("\n\tEnter item to be searched: ");
scanf(" %d", &item);
NODE_p_t element = searchTree(tree, item);
if (element != NULL)
printf("\n\t%d is present in the tree. (%p)", item, element);
else {
if (choice == 2)
printf("\n\t%d is not present in the tree.", item);
else {
insertNode(tree, item);
printf("\n\t%d was not present in the tree. Now it is.", item);
}
}
} else if (choice == 4) {
printf("\n\t Preorder: ");
preorderTraversal(tree);
} else if (choice == 5) {
printf("\n\t Inorder: ");
inorderTraversal(tree);
} else if (choice == 6) {
printf("\n\t Postorder: ");
postorderTraversal(tree);
}
} while (choice >= 1 && choice <= 6);
return 0;
}
int main(int argc, const char * argv[]) {
NODE * root = createNode(5);
root = addToTree(root, 3);
root = addToTree(root, 6);
root = addToTree(root, 1);
root = addToTree(root, 8);
root = addToTree(root, 2);
root = addToTree(root, 7);
root = addToTree(root, 4);
inorderTraversal(root);
printf("\n");
preorderTraversal(root);
printf("\n");
postorderTraversal(root);
return 0;
}
int main(){
char t[]="{1,2,3,#,4,5,#,6,7,#,8}";
struct TreeNode *r = make_tree(t);
int n;
int *res =postorderTraversal(r,&n);
int i=0;
while(i<n){
printf("%d,",res[i]);
++i;
}
puts("show over");
simple_inorder(r);
puts("end of inorder");
simple_preorder(r);
puts("end of preorder");
simple_suforder(r);
puts("end of suforder");
}
vector<int> postorderTraversal(TreeNode *root)
{
vector<int> ret;
postorderTraversal(root,ret);
return ret;
}
void postorderTraversal(TreeNode* root,vector<int>& container){
if(!root)return;
postorderTraversal(root->left,container);
postorderTraversal(root->right,container);
container.push_back(root->val);
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> result;
postorderTraversal(root, result);
reverse(result.begin(), result.end());
return result;
}
int main(){
int option,val;
struct node *ptr;
create_tree(tree);
//clrscr();
do{
printf("\n***************MAIN MENU**********************");
printf("\n 1.Insert Element");
printf("\n 2.Pre-order Traversal");
printf("\n 3.In-order Traversal");
printf("\n 4.Post-order Traversal");
printf("\n 5.Find the smallest element");
printf("\n 6.Find the largest element");
printf("\n 7.Delete an element");
printf("\n 8.Count the total number of nodes");
printf("\n 9.Count the total number of External nodes");
printf("\n 10.Count the total number of Internal nodes");
printf("\n 11.Determine the height of the tree");
printf("\n 12.Find the mirror image of the tree");
printf("\n 13.Delete the tree");
printf("\n 14.Exit");
printf("\n*************************************************");
printf("\n\n");
printf("Enter your option : ");
scanf("%d",&option);
switch(option)
{
case 1: printf("\n Enter the value of the nuw node : ");
scanf("%d",&val);
tree=insertElement(tree,val);
break;
case 2: printf("\n The Elements of the tree are : \n");
preorderTraversal(tree);
break;
case 3: printf("\n The Elements of the tree are : \n");
inorderTraversal(tree);
break;
case 4: printf("\n The Elements of the tree are : \n");
postorderTraversal(tree);
break;
case 5: ptr=findSmallestElement(tree);
printf("\n The smallest Element of the tree is : %d",ptr->data);
break;
case 6: ptr=findLargestElement(tree);
printf("\n The largest Element of the tree is : %d",ptr->data);
break;
case 7: printf("\n Enter the Element to be deleted : ");
scanf("%d",&val);
tree=deleteElement(tree,val);
break;
case 8: printf("\n Total Number of Nodes in the tree is = %d",totalNodes(tree));
break;
case 9: printf("\n Total Number of External Nodes = %d",totalExternalNodes(tree));
break;
case 10: printf("\n Total Number of Internal Nodes = %d",totalInternalNodes(tree));
break;
case 11: printf("\n The Height of Binary Tree is = %d",Height(tree));
break;
case 12: tree=mirrorImage(tree);
break;
case 13: tree=deleteTree(tree);
break;
case 14: printf("Exit\n");
break;
default:
system("cls");
printf("Invalid Option\n");
printf("Re-enter your Option\n\n");
}
}while(option!=14);
getch();
return 0;
}
/// 递归实现
std::vector<int> postorderTraversal(TreeNode* root)
{
std::vector<int> vals;
postorderTraversal(root, vals);
return vals;
}
