// 中序遍历递归 
void InOrder(pBTNode pRoot)
{
	if (pRoot) {
		InOrder(pRoot->_pLeft);
		printf("%c ", pRoot->_data);
		InOrder(pRoot->_pRight);
	}
}

void InOrder(int r)
{
  if(!r)return;
  push_down(r);
  InOrder(ch[r][0]);
  printf("%d ",key[r]);
  InOrder(ch[r][1]);
}

void InOrder(NodeTree* ApT) {

    if(ApT != NULL) {
        InOrder(ApT->left);
        Visit(ApT->info);
        InOrder(ApT->right);
    }
}

void Node::InOrder(Node *a) {
	if (a != NULL)
	{
		InOrder(a->left);
		std::cout << a->key << " ";
		InOrder(a->right);
	}
};

void InOrder(BinaryTreeNode<T> *t)
{// Inorder traversal of *t.
   if (t) {
      InOrder(t->LeftChild);   // do left subtree
      Visit(t);                // visit tree root
      InOrder(t->RightChild);  // do right subtree
      }
}

void InOrder(Tree Root)		//InOrder Traversal
{
	if (Root !=NULL)
	{
		InOrder(Root->Left);
		printf("%c",Root->data);
		InOrder(Root->Right);
	}
}

void InOrder(BiTree *&T)
{
	if(T!=NULL)
	{
		InOrder(T->lchild );
		printf("%c",T->data );
		InOrder(T->rchild );
	}
}

void  BinaryST<T>::InOrder(BSTNode<T> *ptr)
{
	if (ptr == NULL)
		return;

	InOrder(ptr->lC);
	cout << ptr->data.key << "(" << ptr->data.val << ")" << " ";
	InOrder(ptr->rC);
}

void InOrder(BiTree *bt)
{
	if (bt != NULL)
	{
		InOrder(bt->lchild);
		printf("%c", bt->data);
		InOrder(bt->rchild);
	}
}

void BinarySearchTree<Key, Value>::InOrder (BSTnode* subtree, Visit& visitor)
{
    if (subtree!=NULL)
    {
        InOrder(subtree->m_left, visitor);
        visitor(subtree->m_value);
        InOrder(subtree->m_right, visitor);
    }
}

void  BinaryST<T>::InOrder(BSTNode<T> *ptr)  {
	Item item;
	if(ptr == NULL)
		return;
	InOrder(ptr->lC);
	item = ptr->data;
	cout << item.key << "(" << item.val << ") ";
	InOrder(ptr->rC);
}

void InOrder(BTree *p)	//中序遍历BST
{
	if (p!=NULL) 
	{
		InOrder(p->lchild);					//中序遍历左子树
		printf("  %c(%d)\n",p->ch,p->count);//访问根结点
		InOrder(p->rchild);					//中序遍历右子树
	}
}

//中序遍历
void InOrder(BiTree T)
{
     if(T!=NULL)
     {
        InOrder(T->lchild);
        Visit(T);
        InOrder(T->rchild);
     }
}

void InOrder(Btree *root)
{
	if(root != NULL)
	{
		InOrder(root->left);
		printf("%d\n",root-data);
		InOrder(root->right);
	}
}

//从左子节点开始遍历树
static void InOrder(const Node * root,void (* pfun)(Item item))
{
	if(root != NULL)
	{
		InOrder(root->left,pfun);
		TraverseQueue(root->queue,pfun);
		InOrder(root->right,pfun);
	}
}

static void InOrder(const Node * root,void(* pfun)(Item item))
{
	if(root != NULL)
	{
		(*pfun)(root->item);
		InOrder(root->left,pfun);
		InOrder(root->right,pfun);
	}
}

void InOrder(treeNode* root)    // 중위 순회
{
  if(root!=NULL)
  {
    InOrder(root->left);    // Left Node Move
    printf("%c  ",root->data);  // Data Read
    InOrder(root->right);   // Right Node Move
  }
}

// 中序递归遍历
void RecurseInOrder(TreeNode *root)
{
	if(root)
    {
        InOrder(root->leftchild);
        std::cout << root->data << " ";
        InOrder(root->rightchild);
    }
}

// To get ascending order, do an in-order traversal of the tree
void BST::InOrder(BasePtr Item)
{  if ( !Item ) return;                // I.e., NULL tree

   InOrder(Item->Left);                // Process Left sub-tree
   cout << setw(4) << Item->Data       // Process this node
        << '(' << Item->Height << ')';
   if ( ++Nitems % 10 == 0 )
      cout.put('\n');
   InOrder(Item->Right);               // Process Right sub-tree
}

/**
 * This function is not right
 */
void InOrder(TBSTree tr) {
	if (!tr) 
		return;

	if (tr->leftthread == 0)
		InOrder(tr->left);
	printf("%p\t%d\n", tr, tr->elem);
	if (tr->rightthread == 0)
		InOrder(tr->right);
}