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);
}
void postOrder(BiTreeNode* tree)
{
if (tree != NULL) {
postOrder(tree->left);
postOrder(tree->right);
printf("%d ", tree->data);
} // end if
} // end poseOrder()
/**
* Processes the TBST in post-order, applying the specified function at
* each Node. Defaults to print(), starting at root.
*
* @param func function to apply to each Node pointer along the path.
* Design this function with only a single Node pointer in mind.
* @param output ostream object to append the output content to
* @param cur pointer to Node at which to process and start recursion on.
*/
void TBST::postOrder(void (*func)(Node*, ostream&), ostream& output, Node* cur) {
if(cur != NULL) {
if(cur->hasLeftChild())
postOrder(func, output, cur->getLeft());
if(cur->hasRightChild())
postOrder(func, output, cur->getRight());
func(cur, output);
}
}
/*** 后序遍历***/
void postOrder(BitTree* T)
{
if(T){
postOrder(T->lchild);
postOrder(T->rchild);
printf("%c ", T->data);
}
}
void postOrder(node *root) {
if (root==NULL)
return;
postOrder(root->left);
postOrder(root->right);
cout << root->data << " ";
}
/* begin postorder traversal of tree */
void postOrder( TreeNodePtr treePtr )
{
/* if tree is not empty then traverse */
if ( treePtr != NULL ) {
postOrder( treePtr->leftPtr );
postOrder( treePtr->rightPtr );
printf( "%3d", treePtr->data );
} /* end if */
} /* end function postOrder */
void postOrder(tree *p)
{
if(*p)
{
postOrder(&(*p)->left);
postOrder(&(*p)->rigth);
show(&(*p)->info);
}
}
void HashTable::postOrder(MovieNode *node) {
if (node-> leftChild != NULL) {
postOrder(node-> leftChild);
}
if (node-> rightChild != NULL) {
postOrder(node-> rightChild);
}
std::cout << "Deleting: " << node-> title << std::endl;
delete node;
}
void
postOrder(TreeNode* root)
{
if (root)
{
postOrder(root->left);
postOrder(root->right);
std::cout<<root->val<<" ";
}
}
void BST::postOrder(BSTNode* root)
{
if (root == NULL){
return;
}
postOrder(root->left);
postOrder(root->right);
cout << root->value << " ";
}
bool BTree<T>::postOrder(void (*visit) (BTreeNode<T>*), BTreeNode<T>* t)
{
if (t)
{
postOrder(visit, t->left);
postOrder(visit, t->right);
visit(t);
}
return true;
}
