void Tree::preOrder(Node *node) {
    if (node) {
        preOrder(node->left());
        this->visit(node);
        preOrder(node->right());
    }
}

void preOrder(node *root) {
	if(root == NULL) return;

	printf("%d\t", root->key);
	preOrder(root->left);
	preOrder(root->right);
}

void BTree::preOrder(tree *temp){
	if(temp!=NULL){
		cout<<temp->data<<" ";
		preOrder(temp->left);
		preOrder(temp->right);
	}
}

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

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

void preOrder(node* root)
{
	if(root == NULL)
		return ;
	printf("%s %d %d\n" , root->key , root->ht , getBalance(root)) ;
	preOrder(root->lc) ;
	preOrder(root->rc) ;
}

void preOrder(struct TNode* root)
{
    if (root == NULL)
        return ;
    printf("%d ", root->data);
    preOrder(root->left);
    preOrder(root->right);
}

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

void preOrder(BINTREENODE *root)
{
	if (root != NULL) {
		printf("%c ", root->data);
		preOrder(root->left);
		preOrder(root->right);
	}
}

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

void preOrder(struct node *root){
	if(root == NULL)
		return;
		
	printf("%d ", root->data);
	preOrder(root->lptr);
	preOrder(root->rptr);
}

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

void TwoThreeTree::preOrder(TNode *r) {
    if (r == NULL) return;

    r->print();
    preOrder(r->left);
    preOrder(r->middle);
    preOrder(r->right);
}

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

/* A utility function to print preorder traversal of BST */
void preOrder(struct Node* node)
{
    if (node == NULL)
        return;
    printf("%d ", node->data);
    preOrder(node->prev);
    preOrder(node->next);
}

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

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

//先序递归遍历二叉树
void preOrder(BiTree root)
{   
    if(root){
        printf("%c ",root->data);
        preOrder(root->lchild);
        preOrder(root->rchild);
    }
}

/*** 前序遍历***/ 
void preOrder(BitTree* T)
{
	if(T){				//不要忘记判断 T 
		printf("%c ", T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

/*Bianry Search Tree 前序遍历递归实现*/
void preOrder(BinaryTree btree, Status(*visit)(BinaryTree)) {
	if (btree != NULL)
	{
		visit(btree);
		preOrder(btree->lchild, visit);
		preOrder(btree->rchild, visit);
	}

}

/**
 * Processes the TBST in pre-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
 *              traversal path.
 * @param output    ostream object to append the output content to
 *              Design this function with only a single Node pointer in mind.
 * @param cur   pointer to Node at which to process and start recursion on.
 */
void TBST::preOrder(void (*func)(Node*, ostream&), ostream& output, Node* cur) {
    if(cur != NULL) {
        func(cur, output);
        if(cur->hasLeftChild())
            preOrder(func, output, cur->getLeft());
        if(cur->hasRightChild())
            preOrder(func, output, cur->getRight());
    }
}