void postOrder(TreeNodePtr treePtr) {
    if (treePtr != NULL) {
        postOrder(treePtr->leftPtr);
        postOrder(treePtr->rightPtr);
        printf("%3d", treePtr->data);
    }
}

void postOrder(node* ptr){
    if(ptr!=NULL){
        postOrder(ptr->left);
        postOrder(ptr->right);
        printf("%d ",ptr->data);
    }
}

void BST<ItemType>::postOrder(TreeNode<ItemType> *t, ofstream &file)
{
    if(t == NULL) return;
    postOrder(t->right, file);
    postOrder(t->left, file);
    file << t->element << " ";
}

void BinaryTree<T>::postOrder(BinaryTree<T>* pNode) {
    if (pNode == 0)
        return;
    postOrder(pNode->left);
    postOrder(pNode->right);
    cout << pNode->data << endl;
}

void postOrder(node *root) {
    if (root) {
        postOrder(root->left);
        postOrder(root->right);
        cout << root->data << " ";
    }
}

void Solution508::postOrder(TreeNode *root, unordered_map<int, int> &counter, int &maxCount)
{
    if (root == nullptr)
        return;

    if (root->left)
    {
        postOrder(root->left, counter, maxCount);
        root->val += root->left->val;
    }
    if (root->right)
    {
        postOrder(root->right, counter, maxCount);
        root->val += root->right->val;
    }

    int count = counter.count(root->val);
    if (count == 0)
    {
        counter.insert({root->val, 1});
        count = 1;
    } else
        count = ++ counter[root->val];
    maxCount = std::max(maxCount, count);
}

 void postOrder(TreeNode *root, vector<int>& ret) {
 	if(!root)
 		return ;
 	postOrder(root->left, ret);
 	postOrder(root->right, ret);
 	ret.push_back(root->val);
 }

void postOrder(BSTree *myTree) {
  if (myTree) {
    postOrder(myTree -> leftChild);
    postOrder(myTree -> rightChild);
    printf(" %d", myTree -> value);
  }
}

void postOrder(node *root) {
  if(root != NULL){
    postOrder(root->left);
    postOrder(root->right);
    cout << root->data << ' ';
  }
}

void postOrder(struct node *root){
    if (root) {
        postOrder(root->left);
        postOrder(root->right);
        printf("%d ", root->key);
    }
}

void postOrder(TreeNode *root,DISPLAY display){
    if(root != NULL){
        postOrder(root->left, display);
        postOrder(root->right, display);
        display(root->data);
    }
}

/**
 * print the tree with postorder method
 * @param t
 */
void postOrder(tree t) {
    if (t) {
        postOrder(t->left);
        postOrder(t->right);
        printf("%d\n", t->elem);
    }
}

void postOrder(Node * T)
{
	if (T->lchild!=NULL)
		postOrder(T->lchild);
	if (T->rchild!=NULL)
		postOrder(T->rchild);
	str[(*size)++]=T->c+'0';
}

void	BinaryTree::postOrder(treeNode *root)
{
	if(root->leftChild)
		postOrder(root->leftChild);
	if(root->rightChild)
		postOrder(root->rightChild);
	std::cout<<root->data<<" ";
}

void postOrder(struct node *n) {
  if (n == NULL)
    return;

  postOrder(n->left);
  postOrder(n->right);
  printf("%d ", n->key);
}

void BinarySearchTree<T>::postOrder(Node<T> *rootTree) const
{
    if (rootTree != nullptr) {
        postOrder(rootTree->leftChild);
        postOrder(rootTree->rightChild);
        std::cout << rootTree->data << " ";
    }
}

void postOrder(PTreeNode pNode)
{
    if (pNode != NULL) {
        postOrder(pNode->left);
        postOrder(pNode->right);
        visit(pNode);
    }
}

static void postOrder(RBTree rootNode) {
    if(rootNode)
    {
        postOrder(rootNode->lchild);
        postOrder(rootNode->rchild);
        printf("%d(%s) ",rootNode->key,(rootNode->color == RED?"红":"黑"));
    }
}

void postOrder(char t[][MAX_WORD_SIZE + 1], int root, int n)
{
    if (root <= n && strcmp(t[root], "*") != 0) {
        postOrder(t, root * 2, n);
        postOrder(t, root * 2 + 1, n);
        visit(t, root);
    }
}

void postOrder(TNODE *node) {
	if (node == NULL) {
		return;
	}
	postOrder(node->leftChild);
	postOrder(node->rightChild);
	printf("%d ", node->value);
}