From 1b7cfc0bcc3c08e8deca79bc82b70c274cc4d42b Mon Sep 17 00:00:00 2001
From: Fabio Scotto di Santolo <fabio.scottodisantolo@gmail.com>
Date: Wed, 14 Mar 2018 21:13:12 +0100
Subject: [PATCH] =?UTF-8?q?aggiunti=20algoritmi=20di=20visitazione=20alber?=
 =?UTF-8?q?o=20in=20ampiezza,=20profondit=C3=A0=20(pre-ordine,=20post-ordi?=
 =?UTF-8?q?ne)=20e=20visita=20albero=20binario=20in=20ordine=20simmetrico?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../adt/tree/AbstractBinaryTree.java          |  31 +++++
 src/it/algoritmi/adt/tree/AbstractTree.java   |  75 +++++++++++
 .../algoritmi/adt/tree/ArrayBinaryTree.java   | 120 ------------------
 .../algoritmi/adt/tree/LinkedBinaryTree.java  |  32 -----
 4 files changed, 106 insertions(+), 152 deletions(-)
 delete mode 100644 src/it/algoritmi/adt/tree/ArrayBinaryTree.java

diff --git a/src/it/algoritmi/adt/tree/AbstractBinaryTree.java b/src/it/algoritmi/adt/tree/AbstractBinaryTree.java
index add0b46..9953790 100644
--- a/src/it/algoritmi/adt/tree/AbstractBinaryTree.java
+++ b/src/it/algoritmi/adt/tree/AbstractBinaryTree.java
@@ -50,4 +50,35 @@ public abstract class AbstractBinaryTree<E> extends AbstractTree<E> implements B
 		return snapshot;
 	}
 	
+	/**
+	 * Aggiunge a snapshot le posizioni del sottoalbero avente radice position.
+	 * @param position
+	 * @param snapshot
+	 */
+	private void inorderSubtree(Position<E> position, List<Position<E>> snapshot) {
+		if(left(position) != null) inorderSubtree(left(position), snapshot);
+		snapshot.add(position);
+		if(right(position) != null) inorderSubtree(right(position), snapshot);
+	}
+	
+	/**
+	 * Restituisce una lista delle posizioni dell'albero, in ordine simmetrico
+	 * @return lista delle posizioni in ordine simmetrico
+	 */
+	protected Iterable<Position<E>> inorder() {
+		List<Position<E>> snapshot = new ArrayList<>();
+		if(!isEmpty()) inorderSubtree(root(), snapshot);
+		return snapshot;
+	}
+	
+	
+	/**
+	 * Restituisce una lista delle posizioni dell'albero
+	 * @return lista delle posizioni.
+	 */
+	@Override
+	public Iterable<Position<E>> positions() {
+		return inorder();
+	}
+
 }
diff --git a/src/it/algoritmi/adt/tree/AbstractTree.java b/src/it/algoritmi/adt/tree/AbstractTree.java
index 0040706..decb0e7 100644
--- a/src/it/algoritmi/adt/tree/AbstractTree.java
+++ b/src/it/algoritmi/adt/tree/AbstractTree.java
@@ -1,7 +1,12 @@
 package it.algoritmi.adt.tree;
 
+import java.util.ArrayList;
+import java.util.List;
+
 import it.algoritmi.adt.Position;
+import it.algoritmi.adt.Queue;
 import it.algoritmi.adt.Tree;
+import it.algoritmi.adt.queue.LinkedQueue;
 
 /** Una classe di base astratta che implementa in parte l'interfaccia Tree. */
 public abstract class AbstractTree<E> implements Tree<E> {
@@ -62,4 +67,74 @@ public abstract class AbstractTree<E> implements Tree<E> {
 		return h;
 	}
 	
+	/**
+	 * Aggiunge a snapshot le posizioni del sottoalbero avente radice position.
+	 * @param position
+	 * @param snapshot
+	 */
+	private void preorderSubtree(Position<E> position, List<Position<E>> snapshot) {
+		snapshot.add(position);	// in pre-ordine, aggiungiamo position prima dei sottoalberi
+		for(Position<E> c : children(position))
+			preorderSubtree(c, snapshot);
+	}
+	
+	/**
+	 * Restituisce una lista delle posizioni dell'albero, in pre-ordine.
+	 * @return lista delle posizioni in pre-ordine
+	 */
+	protected Iterable<Position<E>> preorder() {
+		List<Position<E>> snapshot = new ArrayList<>();
+		if(!isEmpty()) preorderSubtree(root(), snapshot);	// riempe ricorsivamente snapshot
+		return snapshot;
+	}
+
+	/**
+	 * Aggiunge a snapshot le posizioni del sottoalbero avente radice position.
+	 * @param position
+	 * @param snapshot
+	 */
+	private void postorderSubtree(Position<E> position, List<Position<E>> snapshot) {
+		for(Position<E> c : children(position))
+			postorderSubtree(c, snapshot);
+		snapshot.add(position);
+	}
+	
+	/**
+	 * Restituisce una lista delle posizioni dell'albero, in post-ordine
+	 * @return lista delle posizioni in post-ordine
+	 */
+	protected Iterable<Position<E>> postorder() {
+		List<Position<E>> snapshot = new ArrayList<>();
+		if(!isEmpty()) postorderSubtree(root(), snapshot);
+		return snapshot;
+	}
+	
+	/**
+	 * Restituisce una lista delle posizioni dell'albero, attraversato in ampiezza.
+	 * @return lista delle posizioni in ampiezza
+	 */
+	protected Iterable<Position<E>> breadthFirst() {
+		List<Position<E>> snapshot = new ArrayList<>();
+		if(!isEmpty()) {
+			Queue<Position<E>> fringe = new LinkedQueue<>();
+			fringe.enqueue(root());							// inizia con la radice
+			while(!fringe.isEmpty()) {
+				Position<E> position = fringe.dequeue(); 	// estrae dall'inizio della coda
+				snapshot.add(position);						// aggiunge questa posizione
+				for(Position<E> c : children(position))
+					fringe.enqueue(c);						// aggiunge i figli in fondo alla coda
+			}
+		}
+		return snapshot;
+	}
+	
+	/**
+	 * Restituisce una lista delle posizioni dell'albero
+	 * @return lista delle posizioni.
+	 */
+	@Override
+	public Iterable<Position<E>> positions() {
+		return preorder();
+	}
+
 }
diff --git a/src/it/algoritmi/adt/tree/ArrayBinaryTree.java b/src/it/algoritmi/adt/tree/ArrayBinaryTree.java
deleted file mode 100644
index 05f19a6..0000000
--- a/src/it/algoritmi/adt/tree/ArrayBinaryTree.java
+++ /dev/null
@@ -1,120 +0,0 @@
-package it.algoritmi.adt.tree;
-
-import java.util.Iterator;
-
-import it.algoritmi.adt.Position;
-
-public class ArrayBinaryTree<E> extends AbstractBinaryTree<E> {
-	
-	//----------------- classe Node annidata -------------------------
-	protected static class Node<E> implements Position<E> {
-		private E element;
-		private Node<E> parent;
-		private Node<E> left;
-		private Node<E> right;
-		
-		public Node(E element, Node<E> above, Node<E> leftChild, Node<E> rightChild) {
-			this.element = element;
-			this.parent = above;
-			this.left = leftChild;
-			this.right = rightChild;
-		}
-
-		@Override
-		public E getElement() {
-			return element;
-		}
-
-		public void setElement(E element) {
-			this.element = element;
-		}
-
-		public Node<E> getParent() {
-			return parent;
-		}
-
-		public void setParent(Node<E> parent) {
-			this.parent = parent;
-		}
-
-		public Node<E> getLeft() {
-			return left;
-		}
-
-		public void setLeft(Node<E> left) {
-			this.left = left;
-		}
-
-		public Node<E> getRight() {
-			return right;
-		}
-
-		public void setRight(Node<E> right) {
-			this.right = right;
-		}
-	}
-	//----------------- fine della classe Node annidata -------------------
-	
-	public static final int CAPACITY = 16;
-	
-	private Node<E>[] data;
-	private int size;
-	
-	public ArrayBinaryTree() {
-		this(CAPACITY);
-	}
-	
-	@SuppressWarnings("unchecked")
-	public ArrayBinaryTree(int capacity) {
-		data = (Node<E>[]) new Object[capacity];
-		size = 0;
-	}
-	
-	@Override
-	public Position<E> left(Position<E> position) throws IllegalArgumentException {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-	@Override
-	public Position<E> right(Position<E> position) throws IllegalArgumentException {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-	@Override
-	public Position<E> root() {
-		return data[0];
-	}
-
-	@Override
-	public Position<E> parent(Position<E> position) throws IllegalArgumentException {
-		if(isRoot(position)) return null;
-		int index = depth(position);
-		
-		return null;
-	}
-
-	/**
-	 * Restituisce il numero di nodi presenti
-	 * nell'albero.
-	 * @return numero di nodi dell'albero
-	 */
-	@Override
-	public int size() {
-		return size;
-	}
-
-	@Override
-	public Iterable<Position<E>> positions() {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-	@Override
-	public Iterator<E> iterator() {
-		// TODO Auto-generated method stub
-		return null;
-	}
-
-}
diff --git a/src/it/algoritmi/adt/tree/LinkedBinaryTree.java b/src/it/algoritmi/adt/tree/LinkedBinaryTree.java
index d69e441..b91a79d 100644
--- a/src/it/algoritmi/adt/tree/LinkedBinaryTree.java
+++ b/src/it/algoritmi/adt/tree/LinkedBinaryTree.java
@@ -1,8 +1,6 @@
 package it.algoritmi.adt.tree;
 
-import java.util.ArrayList;
 import java.util.Iterator;
-import java.util.List;
 
 import it.algoritmi.adt.Position;
 
@@ -241,36 +239,6 @@ public class LinkedBinaryTree<E> extends AbstractBinaryTree<E> {
 		node.setParent(node);
 		return tmp;
 	}
-	
-	/**
-	 * Aggiunge a snapshot le posizioni del sottoalbero avente radice position.
-	 * @param position
-	 * @param snapshot
-	 */
-	private void preorderSubtree(Position<E> position, List<Position<E>> snapshot) {
-		snapshot.add(position);	// in pre-ordine, aggiungiamo position prima dei sottoalberi
-		for(Position<E> c : children(position))
-			preorderSubtree(c, snapshot);
-	}
-	
-	/**
-	 * Restituisce una lista delle posizioni dell'albero, in pre-ordine.
-	 * @return lista delle posizioni in pre-ordine
-	 */
-	protected Iterable<Position<E>> preorder() {
-		List<Position<E>> snapshot = new ArrayList<>();
-		if(!isEmpty()) preorderSubtree(root(), snapshot);	// riempe ricorsivamente snapshot
-		return snapshot;
-	}
-	
-	/**
-	 * Restituisce una lista delle posizioni dell'albero
-	 * @return lista delle posizioni.
-	 */
-	@Override
-	public Iterable<Position<E>> positions() {
-		return preorder();
-	}
 
 	//------------------ classe ElementIterator annidata ----------
 	/** Adatta l'iterazione prodotta da positions() per restituire elementi. */