Comment mettre en œuvre une première traversée étendue?
Voilà ce que j'ai. Je pensais que la précommande était la même et je l'ai d'abord mélangée avec de la profondeur!
import Java.util.LinkedList;
import Java.util.Queue;
public class Exercise25_1 {
public static void main(String[] args) {
BinaryTree tree = new BinaryTree(new Integer[] {10, 5, 15, 12, 4, 8 });
System.out.print("\nInorder: ");
tree.inorder();
System.out.print("\nPreorder: ");
tree.preorder();
System.out.print("\nPostorder: ");
tree.postorder();
//call the breadth method to test it
System.out.print("\nBreadthFirst:");
tree.breadth();
}
}
class BinaryTree {
private TreeNode root;
/** Create a default binary tree */
public BinaryTree() {
}
/** Create a binary tree from an array of objects */
public BinaryTree(Object[] objects) {
for (int i = 0; i < objects.length; i++) {
insert(objects[i]);
}
}
/** Search element o in this binary tree */
public boolean search(Object o) {
return search(o, root);
}
public boolean search(Object o, TreeNode root) {
if (root == null) {
return false;
}
if (root.element.equals(o)) {
return true;
}
else {
return search(o, root.left) || search(o, root.right);
}
}
/** Return the number of nodes in this binary tree */
public int size() {
return size(root);
}
public int size(TreeNode root) {
if (root == null) {
return 0;
}
else {
return 1 + size(root.left) + size(root.right);
}
}
/** Return the depth of this binary tree. Depth is the
* number of the nodes in the longest path of the tree */
public int depth() {
return depth(root);
}
public int depth(TreeNode root) {
if (root == null) {
return 0;
}
else {
return 1 + Math.max(depth(root.left), depth(root.right));
}
}
/** Insert element o into the binary tree
* Return true if the element is inserted successfully */
public boolean insert(Object o) {
if (root == null) {
root = new TreeNode(o); // Create a new root
}
else {
// Locate the parent node
TreeNode parent = null;
TreeNode current = root;
while (current != null) {
if (((Comparable)o).compareTo(current.element) < 0) {
parent = current;
current = current.left;
}
else if (((Comparable)o).compareTo(current.element) > 0) {
parent = current;
current = current.right;
}
else {
return false; // Duplicate node not inserted
}
}
// Create the new node and attach it to the parent node
if (((Comparable)o).compareTo(parent.element) < 0) {
parent.left = new TreeNode(o);
}
else {
parent.right = new TreeNode(o);
}
}
return true; // Element inserted
}
public void breadth() {
breadth(root);
}
// Implement this method to produce a breadth first
// search traversal
public void breadth(TreeNode root){
if (root == null)
return;
System.out.print(root.element + " ");
breadth(root.left);
breadth(root.right);
}
/** Inorder traversal */
public void inorder() {
inorder(root);
}
/** Inorder traversal from a subtree */
private void inorder(TreeNode root) {
if (root == null) {
return;
}
inorder(root.left);
System.out.print(root.element + " ");
inorder(root.right);
}
/** Postorder traversal */
public void postorder() {
postorder(root);
}
/** Postorder traversal from a subtree */
private void postorder(TreeNode root) {
if (root == null) {
return;
}
postorder(root.left);
postorder(root.right);
System.out.print(root.element + " ");
}
/** Preorder traversal */
public void preorder() {
preorder(root);
}
/** Preorder traversal from a subtree */
private void preorder(TreeNode root) {
if (root == null) {
return;
}
System.out.print(root.element + " ");
preorder(root.left);
preorder(root.right);
}
/** Inner class tree node */
private class TreeNode {
Object element;
TreeNode left;
TreeNode right;
public TreeNode(Object o) {
element = o;
}
}
}
Étendue première recherche
Queue<TreeNode> queue = new LinkedList<BinaryTree.TreeNode>() ;
public void breadth(TreeNode root) {
if (root == null)
return;
queue.clear();
queue.add(root);
while(!queue.isEmpty()){
TreeNode node = queue.remove();
System.out.print(node.element + " ");
if(node.left != null) queue.add(node.left);
if(node.right != null) queue.add(node.right);
}
}
La largeur en premier est une file d'attente, la profondeur en premier est une pile.
Pour élargir d'abord, ajoutez tous les enfants à la file d'attente, puis tirez sur la tête et effectuez d'abord une recherche étendue sur celle-ci, en utilisant la même file d'attente.
Pour la profondeur en premier, ajoutez tous les enfants à la pile, puis faites apparaître et effectuez d'abord une profondeur sur ce nœud, en utilisant la même pile.
Il ne semble pas que vous demandiez une implémentation, je vais donc essayer d'expliquer le processus.
Utilisez une file d'attente. Ajoutez le nœud racine à la file d'attente. Faites exécuter une boucle jusqu'à ce que la file d'attente soit vide. À l'intérieur de la boucle, retirez le premier élément et imprimez-le. Ajoutez ensuite tous ses enfants à l'arrière de la file d'attente (généralement de gauche à droite).
Lorsque la file d'attente est vide, chaque élément doit avoir été imprimé.
En outre, il existe une bonne explication de l'étendue de la première recherche sur wikipedia: http://en.wikipedia.org/wiki/Breadth-first_search
public void breadthFirstSearch(Node root, Consumer<String> c) {
List<Node> queue = new LinkedList<>();
queue.add(root);
while (!queue.isEmpty()) {
Node n = queue.remove(0);
c.accept(n.value);
if (n.left != null)
queue.add(n.left);
if (n.right != null)
queue.add(n.right);
}
}
Et le nœud:
public static class Node {
String value;
Node left;
Node right;
public Node(final String value, final Node left, final Node right) {
this.value = value;
this.left = left;
this.right = right;
}
}
//traverse
public void traverse()
{
if(node == null)
System.out.println("Empty tree");
else
{
Queue<Node> q= new LinkedList<Node>();
q.add(node);
while(q.peek() != null)
{
Node temp = q.remove();
System.out.println(temp.getData());
if(temp.left != null)
q.add(temp.left);
if(temp.right != null)
q.add(temp.right);
}
}
}
}
Ce code que vous avez écrit ne produit pas une traversée BFS correcte: (c'est le code que vous avez déclaré être BFS, mais en fait c'est DFS!)
// search traversal
public void breadth(TreeNode root){
if (root == null)
return;
System.out.print(root.element + " ");
breadth(root.left);
breadth(root.right);
}
Pour implémenter la première recherche étendue, vous devez utiliser une file d'attente. Vous devez pousser les enfants d'un nœud dans la file d'attente (gauche puis droite), puis visiter le nœud (imprimer les données). Ensuite, vous devez supprimer le nœud de la file d'attente. Vous devez continuer ce processus jusqu'à ce que la file d'attente soit vide. Vous pouvez voir ma mise en œuvre du BFS ici: https://github.com/m-vahidalizadeh/foundations/blob/master/src/algorithms/TreeTraverse.Java
Utilisez l'algorithme suivant pour parcourir en profondeur la première recherche-
- Ajoutez d'abord le nœud racine dans la file d'attente avec la méthode put.
- Itérer alors que la file d'attente n'est pas vide.
- Obtenez le premier nœud de la file d'attente, puis imprimez sa valeur.
- Ajoutez les enfants gauche et droit dans la file d'attente (si le nœud actuel a des enfants).
- Terminé. Nous afficherons la valeur de chaque nœud, niveau par niveau, en faisant apparaître/supprimer l'élément
Le code est écrit ci-dessous-
Queue<TreeNode> queue= new LinkedList<>();
private void breadthWiseTraversal(TreeNode root) {
if(root==null){
return;
}
TreeNode temp = root;
queue.clear();
((LinkedList<TreeNode>) queue).add(temp);
while(!queue.isEmpty()){
TreeNode ref= queue.remove();
System.out.print(ref.data+" ");
if(ref.left!=null) {
((LinkedList<TreeNode>) queue).add(ref.left);
}
if(ref.right!=null) {
((LinkedList<TreeNode>) queue).add(ref.right);
}
}
}