int main()
{
BSTree T;
int k;
BSTree result;
printf("建立二叉排序树，请输入序列, 以-1结束:\n");
CreateBST(&T);
printf("先序遍历输出序列为:");
PreOrder(T);
/*
printf("\n请输入要查找的元素:");
fflush(stdin);
scanf("%d",&k);
result = SearchBST(T,k);
if (result != NULL)
printf("要查找的元素为%d\n",result->key);
else
printf("未找到!\n");
result = DelBST(T,k);
printf("删除元素%d后的排序树先序遍历为\n",k);
*/
PreOrder(T);
MakeDot(T);
return 0;
}
/* 先序遍历二叉链表 */
void PreOrder(BiTree T)
{
if(NULL == T) return;
printf("%c ", T->data);
PreOrder(T->lchild);
PreOrder(T->rchild);
}
void PostOrder(TreeNode *T) {
if (T != NULL) {
PreOrder(T->left);
PreOrder(T->right);
printf("%d", T->data);
}
}
//前序遍历二叉树
PreOrder(BiTree T,int level){
if(T){
visit(T->data,level);
PreOrder(T->lchild,level+1);
PreOrder(T->rchild,level+1);
}
}
void testProblems() {
BinTree r, s;
freopen("input/BinTree1.txt", "r", stdin);
r = Create_BinTree();
s = Create_BinTree();
printf("%d\n", IsSubTree(r, s));
freopen("input/BinTree2.txt", "r", stdin);
int res = 0;
r = Create_BinTree();
MaxPathSum(r, res);
printf("%d\n", res);
printf("%d\n", MinDepth(r));
printf("%d\n", MaxDepth(r));
printf("%d\n", IsAvlTree(r));
printf("%d\n", IsSymmetricTree(r));
freopen("input/BinTree4.txt", "r", stdin);
r = Create_BinTree();
PreOrder(r);
printf("\n");
MirrorTree(r);
PreOrder(r);
printf("\n");
freopen("input/BinTree3.txt", "r", stdin);
r = Create_BinTree();
BinNode *p = LastCommonParent(r, 10, 13);
if (p) {
printf("%d\n", ToInt(p));
}
int node = findSucc(r,6);
printf("%d\n", node);
}
void PreOrder(BinTree tree){
if (tree==NULL)
return;
printf("%d ",tree->m_value);
PreOrder(tree->pLeft);
PreOrder(tree->pRight);
}
// 前序遍历递归
void PreOrder(pBTNode pRoot)
{
if (pRoot) {
printf("%c ", pRoot->_data);
PreOrder(pRoot->_pLeft);
PreOrder(pRoot->_pRight);
}
}
void PreOrder(NodeTree* ApT) {
if(ApT != NULL) {
Visit(ApT->info);
PreOrder(ApT->left);
PreOrder(ApT->right);
}
}
void PreOrder(BinaryTreeNode<T> *t)
{// Preorder traversal of *t.
if (t) {
Visit(t); // visit tree root
PreOrder(t->LeftChild); // do left subtree
PreOrder(t->RightChild); // do right subtree
}
}
void Node::PreOrder(Node *a) {
if (a != NULL)
{
std::cout << a->key << " ";
PreOrder(a->left);
PreOrder(a->right);
}
};
/*
*后序
* */
void PostOrder(BiTree t)
{
if(t!=NULL){
PreOrder((BiTree)t->lchild);
PreOrder((BiTree)t->rchild);
visit(t);
}
}
void PreOrder(treeNode* root) // 전위 순회
{
if(root!=NULL) {
printf("%c ",root->data); // Data Read
PreOrder(root->left); // Left Node Move
PreOrder(root->right); // Right Node Move
}
}
void BinarySearchTree<Key, Value>::PreOrder (BSTnode* subtree, Visit& visitor)
{
if (subtree!=NULL)
{
visitor(subtree->m_value);
PreOrder(subtree->m_left, visitor);
PreOrder(subtree->m_right, visitor);
}
}
void PreOrder(BitTree root) /*先序遍历二叉树, root为指向二叉树(或某一子树)根结点的指针*/
{
if (root!=NULL)
{
Visit(root ->data); /*访问根结点*/
PreOrder(root ->LChild); /*先序遍历左子树*/
PreOrder(root ->RChild); /*先序遍历右子树*/
}
}
void PreOrder(BiTree *bt)
{
if (bt != NULL)
{
printf("%c", bt->data);
PreOrder(bt->lchild);
PreOrder(bt->rchild);
}
}
void PreOrder(Tree Root) //PreOrder Traversal
{
if (Root !=NULL)
{
printf("%c",Root->data);
PreOrder(Root->Left);
PreOrder(Root->Right);
}
}
void CTree::PreOrder(CTreeNode *lpRoot)
{
if (lpRoot != NULL)
{
cout << lpRoot->m_data << " ";
PreOrder(lpRoot->m_lpLeft);
PreOrder(lpRoot->m_lpRight);
}
}
//先序遍历二叉树
void PreOrder(BinaryTree *B)
{
if(B)
{
printf("%c\t",B->data);
PreOrder(B->LChild);
PreOrder(B->RChild);
}
}
void BinaryST<T>::PreOrder(BSTNode<T> *ptr)
{
if (ptr == NULL)
return;
cout << ptr->data.key << "(" << ptr->data.val << ")" << " ";
PreOrder(ptr->lC);
PreOrder(ptr->rC);
}
void PreOrder (BiTree * root)
{
if (root != NULL)
{
printf("%c \n", root->data);
PreOrder(root->Lchild);
PreOrder(root->Rchild);
}
}
/**
* Preorder Traversal of a bt
* and Inorder / Postorder Traversal / levelorder
*
* @param bt pointer of bt root
*/
void PreOrder(BTreeNode *bt){
if (bt != NULL) {
printf("%c", bt->data);
PreOrder(bt->lchild);
PreOrder(bt->rchild);
}
return;
}
//先序遍历
void PreOrder(BiTree T)
{
if(T!=NULL)
{
Visit(T);
PreOrder(T->lchild);
PreOrder(T->rchild);
}
}
void PreOrder(Node *node, void (*visit)(Node *node))
{
if (node)
{
// printf("Now: %d\n", node);
visit(node);
PreOrder(node->left, visit);
PreOrder(node->right, visit);
}
}
TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
if(root==NULL||p==NULL||q==NULL)
return NULL;
TreeNode* pNode = root;
int plen = 0, qlen = 0;
PreOrder(pNode, p, stap, &plen);
pNode = root;
PreOrder(pNode, q, staq, &qlen);
return CommonNode(stap, staq, plen, qlen);
}
void PreOrder(BSTree root)
/*先序遍历二叉树, root为指向二叉树根结点的指针*/
{
if (root!=NULL)
{
printf("%d ",root->key); /*输出结点*/
PreOrder(root->lchild); /*先序遍历左子树*/
PreOrder(root->rchild); /*先序遍历右子树*/
}
}
void PreOrder(TreeNode* tree,
QueType& preQue)
// Post: preQue contains the tree items in preorder.
{
if (tree != NULL)
{
preQue.Enqueue(tree->info);
PreOrder(tree->left, preQue);
PreOrder(tree->right, preQue);
}
}
void PreOrder(struct node *head)
{
struct node *pr;
pr=head;
if (head!=NULL)
{
printf("%c",pr->data);
PreOrder(pr->lchild);
PreOrder(pr->rchild);
}
}
void BinaryST<T>::PreOrder(BSTNode<T> *ptr) {
Item item;
if(ptr == NULL)
return;
else{
item = ptr->data;
cout << item.key << "(" << item.val << ") ";
}
PreOrder(ptr->lC);
PreOrder(ptr->rC);
}
void PreOrder(bitree_t *root)
{
if (NULL == root) return;
printf("%c ", root->data);
PreOrder(root->lchild);
PreOrder(root->rchild);
return;
}
void AVLTree::PostOrder(TreeNode *node, QAnimationGroup *group)
{
if (node == NULL) return;
group->addAnimation(node->getTurnRedAnim());
TreePath *path = new TreePath(node, node->Lson, view);
group->addAnimation(path->getToSonAnim());
PreOrder(node->Lson, group);
group->addAnimation(path->getToParentAnim());
path = new TreePath(node, node->Rson, view);
group->addAnimation(path->getToSonAnim());
PreOrder(node->Rson, group);
group->addAnimation(path->getToParentAnim());
group->addAnimation(node->getPopAnim());
group->addAnimation(node->getTurnBlackAnim());
}
