Gebäude, Allgemeine Bäume in java (mit Rekursion)
Habe ich fest auf ein problem für ganz wenige Tage. Mein end-Ziel ist die Durchführung preorder, inorder und postorder traversalen auf einem Allgemeinen Baum. Das problem, das ich habe ist nur zum Auffüllen der Struktur. Ich bin nur in der Lage, zum hinzufügen von Knoten zu der Wurzel und dem Stamm der Kinder. Ich bin nicht in der Lage, sich zu bewegen "down" die Vergangenheit, die Wurzeln der Kinder. Ich wachte eines morgens mit der Idee des Aufbaus der Baum rekursiv von einem bottom-up-Ansatz. Ich habe noch nie verwendet die Rekursion also zu aller erst, ist das möglich? Ich würde grundsätzlich bauen die Struktur durch das anlegen der Knoten am Ende des Baums und arbeiten Sie dann mein Weg?
Hier ist mein Knoten-Klasse:
//Represents node of the Tree<T> class
public class Node<T>
{
public T data;
public List<Node<T>> children;
//Default constructor
public Node()
{
super();
children = new ArrayList<Node<T>>();
}
public Node(T data)
{
this();
setData(data);
}
//Return the children of Node<T>
public List<Node<T>> getChildren()
{
if(this.children == null)
{
return new ArrayList<Node<T>>();
}
return this.children;
}
//Sets the children of a Node<T> object
public void setChildren(List<Node<T>> children)
{
this.children = children;
}
//Returns the number of immediate children of this Node<T>
public int getNumberOfChildren()
{
if(children == null)
{
return 0;
}
return children.size();
}
//Adds a child to the list of children for this Node<T>
public void addChild(Node<T> child)
{
if(children == null)
{
children = new ArrayList<Node<T>>();
}
children.add(child);
}
public void addChildAt(int index, Node<T> child) throws IndexOutOfBoundsException
{
if(index == getNumberOfChildren())
{
addChild(child);
return;
}
else
{
children.get(index);
children.add(index, child);
}
}
public boolean isLeaf()
{
if(getNumberOfChildren() == 0)
return true;
return false;
}
public T getData()
{
return this.data;
}
public void setData(T data)
{
this.data = data;
}
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("{").append(getData().toString()).append(",[");
int i = 0;
for(Node<T> e : getChildren())
{
if(i > 0)
{
sb.append(",");
}
sb.append(e.getData().toString());
i++;
}
sb.append("]").append("}");
return sb.toString();
}
}
Hier mein tree-Klasse:
//Tree class
public class Tree<T>
{
private Node<T> root;
//Default constructor
public Tree()
{
super();
}
//Returns the root
public Node<T> getRoot()
{
return this.root;
}
//Set the root of the tree
public void setRoot(Node<T> root)
{
this.root = root;
}
//Returns the Tree<T> as a List of Node<T> objects
public List<Node<T>> toList()
{
List<Node<T>> list = new ArrayList<Node<T>>();
walk(root, list);
return list;
}
//String representation of ttree
public String toString()
{
return toList().toString();
}
//Preorder traversal
private void walk(Node<T> element, List<Node<T>> list)
{
list.add(element);
for(Node<T> data : element.getChildren())
{
walk(data, list);
}
}
}
Dies ist mein Haupt-Treiber-Programm:
//Importing packages
import java.util.Scanner;
import java.util.StringTokenizer;
import java.io.*;
import java.io.BufferedReader;
import java.util.List;
import java.util.ArrayList;
//Class header
public class treeTraversals
{
//Main method
public static void main (String[] args) throws IOException
{
//Defining variables
String file;
int size = 0;
int id = 1;
int counter = 1;
Scanner keyboard = new Scanner(System.in);
//Request file
System.out.print("Enter the filename: ");
file = keyboard.nextLine();
//Read file
File treeFile = new File(file);
Scanner inputFile = new Scanner(treeFile);
BufferedReader reader = new BufferedReader(new FileReader(file));
//Find size of input file
while(reader.readLine() != null)
{
size++;
}
reader.close();
String[] parent = new String[size+1];
String[] child = new String[size+1];
//Add file vaules to arrays
while(inputFile.hasNext())
{
String line = inputFile.nextLine();
StringTokenizer st = new StringTokenizer(line);
while(st.hasMoreTokens())
{
String previousValue = st.nextToken();
String nextValue = st.nextToken();
parent[counter] = previousValue;
child[counter] = nextValue;
counter++;
}
}
System.out.println();
//Output to the screen
System.out.println("The Tree");
System.out.println();
for(int l = 1; l <= size; l++)
{
System.out.print(parent[l] + " ");
System.out.println(child[l]);
}
//Create the root of the tree
Tree tree = new Tree();
Node root = new Node(parent[id]);
tree.setRoot(root);
Node active = new Node();
//Fill tree with nodes
for(id = 1; id <= size; id++)
{
Node parentNode = new Node(parent[id]);
Node childNode = new Node(child[id]);
active = root;
int passage = 0;
//Adds children to the root node
if(parentNode.getData().equals(active.getData()))
{
active.addChild(childNode);
System.out.println(tree.toList());
}
//Adds children to the root's children
else if(!parentNode.getData().equals(active.getData()))
{
boolean marked = false;
int i = -1;
int n = 0;
while(i != active.getNumberOfChildren() && marked == false && n <= 2)
{
active = root;
active = (Node)active.getChildren().get(n);
if(active.getData().equals(parentNode.getData()))
{
active.addChild(childNode);
marked = true;
}
i++;
n++;
}
active = root;
if(n >= 3 && marked == false)
{
for(int p=0; p < active.getNumberOfChildren(); p++)
{
active = (Node)active.getChildren().get(p);
if(active.getData().equals(parentNode.getData()))
{
active.addChild(childNode);
//p++;
marked = true;
}
else
{
active = root;
active = (Node)active.getChildren().get(p);
active = (Node)active.getChildren().get(p);
if(active.getData().equals(parentNode))
{
active.addChild(childNode);
System.out.println("No");
p = 0;
}
}
}
}
}
//See the nodes in the tree
System.out.println(tree.toList());
}
}
}
Schließlich, hier ist die text Datei, die bereitgestellt wird:
a b
a c
a d
b e
b f
d g
d h
d i
e j
e k
g l
g m
k n
k o
k p
Bitte, jede Hilfe würde geschätzt werden, bin ich fest auf meinem eigenen Ansatz, so Frage ich: wie würde ich selbst starten, wenn ich werde mit einem rekursiven Ansatz?
- Es gibt keine inorder traversal für einen Allgemeinen Baum.
- du meinst nicht implementiert in standard-java vielleicht, aber es sind definitiv Bibliotheken.
Du musst angemeldet sein, um einen Kommentar abzugeben.
Habe ich vernachlässigt, um für jetzt und gerade angesichts einer
Tree.insert(parentData, data)
.Mit der Hoffnung, dass dieses hilft Sie begann.
Wie man sieht, mit einem
find(data)
- Methode zum abrufen der (übergeordneten) Knoten hilft.Die search-Methode
find
hier ignoriert alle Sortieren der Werte, und nicht ein preorder-Suche.Soweit Ordnung betrifft, in der Regel auf Knoten hat die form:
Mit einer Sortierreihenfolge:
Könnte man behalten Sie die Werte im gesamten Baum in dieser Reihenfolge.
Sortier-und preorder/postorder Spaziergänge und Brot fírst/Tiefe ersten Spaziergänge sind unterschiedliche Begriffe.