algorithme d'apprentissage: avant et après l'arbre binaire dans l'ordre traversal (récursif et non récursif)

1, la traversée de l'arbre binaire

arbre binaire traversal généralement pré-commande, pré-commande, postorder et niveau traversal.

1.1 pré-commande

pré-commande de manière récursive

void pre_traverse(Node *root)
{
	if(NULL == root)
		return; //到达空树，递归的边界
	//访问根节点root
	printf("%d \n", root->data);
	//访问左子树
	pre_traverse(root->lChild);
	//访问右子树
	pre_traverse(root->rChild);
}

de manière non récursive pré-commande

void pre_traverse(Tree *tree, Stack *s)
{
	if(NULL == tree || NULL == s)
		return;
	Node *root = tree->root;

	while(1)
	{
		if(NULL == root)
			break;
		//将根上的数据打印出来
		printf("%d ", root->data);
		
		if(is_empty(s) && NULL == root->lChild && NULL == root->rChild)
		break;
		//将根的右子树入栈
		if(NULL != root->rChild)
			push(s, root->rChild);
		//将根的左子树入栈
		if(NULL != root->lChild)
			push(s, root->lChild);
		//从栈上出栈一个元素
		root = pop(s);
	}
}

1.2 pré-commande

pré-commande de manière récursive

void inorder_traverse(Node *root)
{
	if(NULL == root)
		return; //到达空树
	//访问左子树
	inorder_traverse(root->lChild);
	//访问根节点
	printf("%d ", root->data);
	//访问右子树
	inorder_traverse(root->rChild);
}

de manière non récurrente pré - commande
idée: dans l' ordre: gauche et à droite en utilisant la mise en œuvre pile racine pré - commande

void inorder_traverse(Tree *tree, Stack *s)
{
	if(NULL == tree || NULL == s)
		return ;
	//使用中序遍历二叉树
	Node *root = tree->root;
	
	while(1)
	{
		if(NULL != root)
		{
			//进栈
			push(s, root);
			root = root->lChild;
		}
		else
		{
			//出栈
			root = pop(s);
			printf("%d ", root->data);
			root = root->rChild;
		}
		if(is_empty(s) && NULL == root)
			break;
	}
}

Après la traversée de 1,3 pour

Après une façon récursive pour atteindre l'ordre traversal

void post_traverse(Node *root)
{
	if(NULL == root)
		return;	//到达空树
	//访问左子树
	post_traverse(root->lChild);
	//访问右子树
	post_traverse(root->rChild);
	//访问根节点
	printf("%d ", root->data);
}

séquence arbre traversal binaire non récurrent après
réflexion: C'est une façon très intelligente, le premier ordre est de racines, est la bonne façon d'empiler la racine gauche,
puis la séquence racine est sur le point , donc la façon dont la pile est sur les racines, puis dans l' ordre inverse exportation

void post_traverse(Tree *tree, Stack *s)
{
	if(NULL == tree || NULL == s)
		return ;
	Stack *tmp = init_stack();
	//使用后序遍历二叉树
	Node *root = tree->root;
	if(NULL == root)
		return;

	while(1)
	{
		//入栈
		push(tmp, root);
		if(is_empty(s) && NULL == root->lChild && NULL == root->rChild)
		break;
		//将根的左子树
		if(NULL != root->lChild)
			push(s, root->lChild);
		//将根的右子树入栈
		if(NULL != root->rChild)
			push(s, root->rChild);
		//从栈上一个元素
		root = pop(s);
	}
	Node *p;
	while(! is_empty(tmp))
	{
		p = pop(tmp);
		printf("%d ", p->data);
	}
	printf("\n");
}