Este artigo descreve os algoritmos de travessia de travessia de profundidade e de largura que implementam a árvore binária em Java. Compartilhe -o para sua referência, como segue:
1. Análise
A prática comum de não-recomendação da primeira travessia de árvores binárias é adotar uma pilha, e a prática comum de não-recomendação de travessia de largura é adotar uma fila.
Travessal de profundidade : cada caminho possível pode ser penetrado até que não possa ser mais profundo, e cada nó só pode ser acessado uma vez. Deve-se notar que a primeira travessia de profundidade da árvore binária é bastante especial e pode ser subdividida em travessia de pré-encomenda, travessia intermediária e travessia subsequente. A descrição específica é a seguinte:
Travessal de primeira ordem : para qualquer subárvore, primeiro acesse a raiz, depois atravesse sua subárvore esquerda e finalmente atravesse sua subárvore direita.
TRAVERSAL DE ORDEM DA MIDIDA : Para qualquer subárvore, primeiro atravessa sua subárvore esquerda, depois acesse a raiz e finalmente atravessa sua subárvore direita.
Travessal de pós-ordem : para qualquer subárvore, primeiro atravessa sua subárvore esquerda, depois atravesse sua subárvore direita e finalmente acesse a raiz.
A primeira travessia da largura : também conhecida como hierarquia, acessando cada camada de cima para baixo por sua vez. Em cada camada, acesse nós da esquerda para a direita (ou da direita para a esquerda). Depois de acessar uma camada, você entrará na próxima camada até que não haja nós que possam ser acessados.
2. Dê exemplos
A árvore de classificação binária mostrada na figura abaixo requer o uso de travessia de pré-encomenda (recursiva, não recursiva), travessia na ordem (recursiva, travessia postome-de-ordem) (recursiva, não recursiva) (recursiva, não-recursiva) e a primeira travessia.
① Código de referência
pacote binaryTreetraverStetest; importar java.util.LinkedList; importar java.util.queue;/** * Travessal de prioridade de profundidade e travessia de prioridade de largura de árvores binárias * @Author Fantasy * @version 1.0 2016/10/05 - 2016/10/07 */Classing Binary */Public ClassTer * @version 1.0/10/05/05/10/07/07 */Class. BinarySorttree <Teger> árvore = new BinarySorttree <Teger> (); Tree.InsertNode (35); Tree.InsertNode (20); árvore.InsertNode (15); Tree.InsertNode (16); Tree.InsertNode (29); Tree.InsertNode (28); árvore.InsertNode (30); árvore.InsertNode (40); Tree.InsertNode (50); Tree.InsertNode (45); Tree.InsertNode (55); System.out.print ("Travessal de pré -encomenda (recursivo):"); Tree.PreorderTraverse (TREE.GETROOT ()); System.out.println (); System.out.print ("Traversal na ordem (recursivo):"); Tree.inOrderTraverse (TREE.GETROOT ()); System.out.println (); System.out.println (); System.out.print ("Traversal de pós-ordem (recursivo):"); TREE.PostOrderTraverse (TREE.GETROOT ()); System.out.println (); System.out.print ("Travessal precursivo (não recorrente):"); Tree.PreorderTraverSenorecursion (Tree.GeGroot ()); System.out.println (); System.out.print ("Traversal na ordem (não recorrente):"); Tree.inOrderTraverSenReCursion (Tree.GeGroot ()); System.out.println (); System.out.println (); System.out.print ("Traversal de pós-ordem (não recorrente):"); Tree.PostOrderTraverSenorCursion (TREE.GETROOT ()); System.out.println (); System.out.print ("Travessal da largura:"); Tree.breadThFirstTraverse (TREE.GETROOT ()); }}/*** nó*/classe nó <e estende comparável <e>> {e value; Nó <E> esquerda; Nó <E> certo; Nó (e valor e) {this.value = value; esquerda = nulo; direita = nulo; }}/** * Use uma sequência precedente para construir uma árvore de classificação binária (também conhecida como uma árvore de pesquisa binária) */classe bináriasorttree <e estende comparável <e>> {nó privado <e> root; BinárioSorttree () {root = null; } public void insertNode (e valor) {if (root == null) {root = novo nó <E> (value); retornar; } Nó <E> currentNode = root; while (true) {if (value.compareto (currentNode.value)> 0) {if (currentNode.right == null) {currentNode.right = new Node <e> (value); quebrar; } currentNode = currentNode.right; } else {if (currentNode.left == null) {currentNode.left = novo nó <E> (valor); quebrar; } currentNode = currentNode.left; }}} public node <e> getRoot () {return root; } / ** * Travessal de pré-encomenda da árvore binária (recursiva) * @param nó * / public void PremeDRaverSverse (nó <E> node) {System.out.print (node.value + ""); if (node.left! = null) pré -encomendTraverSese (node.left); if (node.right! = null) pré -encomendTraverSese (node.right); } / ** * Travessal de encomenda da árvore binária (recursiva) * @param node * / public void inOrderTRaverSe (nó <E> node) {if (node.left! = Null) inOrderTraverse (node.left); System.out.print (node.value + ""); if (node.right! = null) inOrderTraverse (node.right); } / ** * Travessia de pós-ordem da árvore binária (recursiva) * @param node * / public void postOrderTroverSe (nó <e> node) {if (node.left! = Null) postorderTraverSverse (node.left); if (node.right! = NULL) postOrderTraverSe (node.right); System.out.print (node.value + ""); } / ** * Travessal de pré-encomenda da árvore binária (não recorrente) * @param root * / public void Pre-encomendTraverSenorecursion (node <e> root) {linkedList <node <e>> Stack = new LinkedList <node <e>> (); Nó <E> currentNode = null; Stack.push (raiz); while (! Stack.isEmpty ()) {currentNode = Stack.pop (); System.out.print (currentNode.value + ""); if (currentNode.right! = null) pilha.push (currentNode.right); if (currentNode.left! = null) pilha.push (currentnode.left); }} / ** * Travessal de encomenda da árvore binária (não recursiva) * @param root * / public void inOrderTraverSenorecursion (node <e> root) {LinkedList <node <e>> pilha = new LinkedList <nó <e> (); Nó <E> currentNode = root; while (CurrentNode! = NULL ||! Stack.isEmpty ()) {// Faça um loop até o nó da folha mais à esquerda na árvore de classificação binária (CurrentNode é nulo) while (CurrentNode! = NULL) {Stack.push (currentNode); currentNode = currentNode.left; } currentNode = Stack.pop (); System.out.print (currentNode.value + ""); currentNode = currentNode.right; }} / ** * Travessal de pós-encomenda da árvore binária (não recursiva) * @param root * / public void postorderTraverSenorecursion (node <e> root) {LinkedList <node <E >> Nó <E> currentNode = root; Nó <E> RightNode = NULL; while (CurrentNode! = NULL ||! Stack.isEmpty ()) {// Faça um loop até o nó da folha na extremidade mais à esquerda da árvore de classificação binária (CurrentNode é nulo) while (currentNode! = NULL) {Stack.push (currentNode); currentNode = currentNode.left; } currentNode = Stack.pop (); // O nó atual não possui nó direito ou o nó anterior (o nó que foi emitido) é o nó certo do nó atual, então o nó atual é emitido enquanto (currentNode.right == null || RightNode = CurrentNode; if (Stack.isEmpty ()) {return; // Saídas raiz, as extremidades atravessadas} currentNode = Stack.pop (); } Stack.push (CurrentNode); // ainda existe o nó certo que não atravessa currentNode = currentNode.right; }} / *** Breando primeiro travessia de árvore binária, também conhecida como árvore binária hierárquica de travessia* @param nó* / public void larthfirstTraverse (nó <e> root) {fileee <node <e>> Queue = new Linkedlist <node <e>> (); Nó <E> currentNode = null; fila.offer (root); while (! System.out.print (currentNode.value + ""); if (currentNode.left! = null) fila.offer (currentNode.left); if (currentNode.right! = null) fila.offer (currentNode.right); }}}② Resultado da saída
Travessal de pré -encomenda (recursivo): 35 20 15 16 29 28 30 40 50 45 55
Traversal na ordem (Recursão): 15 16 20 28 29 30 35 40 45 50 55
Travessal da Pós -Promoção (Recursão): 16 15 28 30 29 20 45 55 50 40 35
Travessal de pré-encomenda (não recorrente): 35 20 15 16 29 28 30 40 50 45 55
Traversal na ordem (não recorrente): 15 16 20 28 29 30 35 40 45 50 55
Traversal da Orome (não recorrente): 16 15 28 30 29 20 45 55 50 40 35
Arraversal da amplitude da prioridade: 35 20 40 15 29 50 16 28 30 45 55
Para obter mais informações sobre os algoritmos Java, os leitores interessados neste site podem visualizar os tópicos: "Estrutura de dados Java e tutorial de algoritmo", "Resumo das dicas de nó da operação Java Dom", "Resumo de dicas de operação de Java e Operação de Java" e "Resumo de Java cache" Tips "TIPS"
Espero que este artigo seja útil para a programação Java de todos.