Nós será baseado em uma árvore binária na figura abaixo (especificamente, binário árvore de busca) estrutura para alcançar árvore seqüência percurso
para alcançar a árvore binária: Clique aqui
Para realizar a passagem da sequência da árvore, o método mais comum é usar uma fila para alcançar.
Vamos simular o processo de travessia. Suponhamos que temos uma fila fila , o estado da fila da primeira fila não há nada na
fila fila da frente e traseiros ponteiros para o local original (seta azul da FIG frontal e traseira localização comum), como mostrado abaixo:
1. Reunimos 3 nós e colocamos o nó na fila.Neste
momento , a situação na fila é a seguinte (a seta azul na figura indica a posição comum da frente e da parte traseira ):
2. Coloque os nós filhos esquerdo e direito do terceiro nó na fila.Quando cada nó de subárvore entra na fila, o ponteiro traseiro também deve se mover para trás (ou seja, a posição da seta azul) como mostrado abaixo:
3. O ponteiro frontal se move um pouco de volta para vermelho Na seta
4. Precisamos obter os nós esquerdo e direito do nó apontados pela seta vermelha atual (ou seja, nó 1 na figura acima) para ingressar na fila (a subárvore esquerda do nó 1 está vazia, portanto não está na fila e o nó direito da subárvore é 2 Junte-se a ele) e, ao mesmo tempo, mova o ponteiro traseiro para a posição da seta azul na figura abaixo.
Repita o procedimento 3 e 4, até a frente na traseira atrás do ponteiro, representando completa passagem de árvore binária.
Entenda o princípio, a implementação do código acima é outra questão, o principal método de implementação é dividido em recursão e loop.
O que eu dou abaixo é a versão recursiva.
Minha suposição é que a fila mantenha o endereço de cada nó, e cada vez que a fila for inserida não será o valor do conteúdo específico do nó, mas o endereço do espaço de memória em que o nó está localizado.
Se você deseja entender em detalhes, é recomendável seguir a lógica do código passo a passo para simular, você pode entender por que isso é feito ~, esse também é o método mais rápido.
void LevelTravel(Node* queue[] , Node *t , int front , int rear)
{
if (front > rear) return;
queue[front] = t;
printf("%d ", queue[front]->data);
if(t->left)
queue[++rear] = t->left;
if(t->right)
queue[++rear] = t->right;
LevelTravel(queue,queue[front+1], front+1 , rear);
}
A seguir está o código completo:
Existem apenas quatro nós no teste de código a seguir, mas mais testes de nós foram aprovados sem problemas.
#include<stdio.h>
#include<malloc.h>
/**/
typedef struct node
{
int data;
struct node* left, * right;
}Node;
void insert(Node** t, int data)
{
if (*t == NULL)
{
(*t) = (Node*)malloc(sizeof(Node));
(*t)->data = data;
(*t)->left = (*t)->right = NULL;
}
else if (data >= (*t)->data)
{
insert(&((*t)->right), data);
}
else insert(&((*t)->left), data);
}
/**前序遍历 根左右**/
void PreOrderTravel(Node* T)
{
if (T == NULL )
return;
printf("%d ", T->data);
PreOrderTravel(T->left);
PreOrderTravel(T->right);
}
/**中序遍历 左根右**/
void InOrderTravel(Node* T)
{
if (T == NULL)
return;
InOrderTravel(T->left);
printf("%d ", T->data);
InOrderTravel(T->right);
}
/**后序遍历 左右根**/
void TailOrderTravel(Node* T)
{
if (T == NULL)
return;
TailOrderTravel(T->left);
TailOrderTravel(T->right);
printf("%d ", T->data);
}
void LevelTravel(Node* queue[] , Node *t , int front , int rear)
{
if (front > rear) return;
queue[front] = t;
printf("%d ", queue[front]->data);
if(t->left)
queue[++rear] = t->left;
if(t->right)
queue[++rear] = t->right;
LevelTravel(queue,queue[front+1], front+1 , rear);
}
int main()
{
Node* t = NULL;
int i,a[4] = { 3,1,4,2 };
Node* queue[10];
for(i = 0; i < 4; i++)
insert(&t, a[i]);
PreOrderTravel(t); printf("\n");
InOrderTravel(t); printf("\n");
TailOrderTravel(t); printf("\n");
LevelTravel(queue, t, 0, 0);
}
Execute a captura de tela da seguinte maneira:
