So drucken Sie einen binären Suchbaum mit meinem eigenen Datentyp und seiner Methode

Question

Ich werde gebeten, eine Anwendung "PrintIt" zu schreiben, um eine Datendatei des Formats "51850 Kianna Squares, Terre Haute | 552.531.3674 | Gislason Kenna "in eine BST und dann durchqueren die BST und drucken Sie die Telefonliste in der Reihenfolge des Namens. Ich erhielt den Code für eine generische BST und erstellte meinen eigenen Record-Datentyp, der die vollständige Zeile in ihrem aktuellen Format speichert. Ich habe eine Methode erstellt, die die Zeile analysiert und nur den Namen aus der Zeile in einer getName() -Methode extrahiert. Ich habe Probleme herauszufinden, wie ich meine BST dazu bringen kann, die Methode getName() zu verwenden, so dass jeder Knoten eingefügt wird, indem die Namen verglichen und in alphabetischer Reihenfolge des Namens ausgedruckt werden.

Ich bin dann aufgefordert, in einer 20-Eintrags-Abfrage-Datei voller 20 verschiedene Namen zu lesen. Ich muss dann jeden Namen aus der Abfragedatei vergleichen und nach einem Record-Objekt mit demselben Namen suchen. Das Aufzeichnungsobjekt enthält die vollständige Zeile im Originalformat von "51850 Kianna Squares, Terre Haute | 552.531.3674 | Gislason Kenna", also weiß ich, dass ich jeden Namen mit der Methode getName() des Datensatzobjekts vergleichen muss, aber wieder habe Ärger. Wie bekomme ich den binären Suchbaum, um die Methode getName() zum Suchen und Sortieren zu implementieren?

My Record-Klasse:

public class NodeInfo implements Comparable<NodeInfo> 
{ 
String line; 
String name; 

public String getName(String lineTwo) 
{ 
    String split = "\\|"; 
    String segments[] = lineTwo.split(split); 
    String name = segments[segments.length -1]; 
    return name; 
} 
public void setName(String name) 
{ 
    this.name = name; 
} 
public NodeInfo(String record) 
{ 
    this.line = record; 
} 
public String getLine() 
{ 
    return line; 
} 
public int compareTo(NodeInfo other) 
{ 
    String x = this.line; 
    String y = other.line; 
    return x.compareTo(y); 
} 
public String toString() 
{ 
    return line; 
} 

} 

Meine binäre Suchbaum Klasse:

public class BinarySearchTree<NodeInfo extends Comparable<? super NodeInfo>> extends BinaryTree<NodeInfo> 
{ 
public void insert (NodeInfo d) 
{ 
    if (root == null) 
     root = new BinaryTreeNode<NodeInfo> (d, null, null); 
    else 
     insert (d, root); 
} 
public void insert (NodeInfo d, BinaryTreeNode<NodeInfo> node) 
{ 
    if (d.compareTo (node.data) <= 0) 
    { 
     if (node.left == null) 
      node.left = new BinaryTreeNode<NodeInfo> (d, null, null); 
     else 
      insert (d, node.left); 
    } 
    else 
    { 
     if (node.right == null) 
      node.right = new BinaryTreeNode<NodeInfo> (d, null, null); 
     else 
      insert (d, node.right); 
    } 
} 

public BinaryTreeNode<NodeInfo> find (NodeInfo d) 
{ 
    if (root == null) 
     return null; 
    else 
     return find (d, root); 
} 
public BinaryTreeNode<NodeInfo> find (NodeInfo d, BinaryTreeNode<NodeInfo> node) 
{ 
    if (d.compareTo (node.data) == 0) 
     return node; 
    else if (d.compareTo (node.data) < 0) 
     return (node.left == null) ? null : find (d, node.left); 
    else 
     return (node.right == null) ? null : find (d, node.right); 
} 

Meine Binärbaum Knotenklasse:

public class BinaryTreeNode<NodeInfo> 
{ 
NodeInfo data; 
BinaryTreeNode<NodeInfo> left; 
BinaryTreeNode<NodeInfo> right; 

public BinaryTreeNode (NodeInfo d, BinaryTreeNode<NodeInfo> l, BinaryTreeNode<NodeInfo> r) 
{ 
    data = d; 
    left = l; 
    right = r; 
} 

BinaryTreeNode<NodeInfo> getLeft() 
{ 
    return left; 
} 
BinaryTreeNode<NodeInfo> getRight() 
{ 
    return right; 
} 
} 

Meine Binärbaum Klasse:

public class BinaryTree<NodeInfo> { 
BinaryTreeNode<NodeInfo> root; 

public BinaryTree() { 
    root = null; 
} 
public void visit(BinaryTreeNode<NodeInfo> node) { 
    System.out.println(node.data); 
} 
public void inOrder() { 
    inOrder(root); 
} 

public void inOrder(BinaryTreeNode<NodeInfo> node) { 
    if (node != null) { 
     inOrder(node.getLeft()); 
     visit(node); 
     inOrder(node.getRight()); 
    } 
} 
} 

und schließlich so weit meine Hauptmethode:

import java.io.File; 
import java.util.ArrayList; 
import java.util.Scanner; 

public class ReadFile { 

public static void main(String[] args) { 

    Scanner scanOne = new Scanner(System.in); 
    ArrayList<NodeInfo> holder = new ArrayList<>(); 

    try { 

     Scanner scan = new Scanner(System.in); 


     File file = new File("testdata"); 

     scan = new Scanner(file); 

     while(scan.hasNextLine()) 
     { 

      String line = scan.nextLine(); 

      NodeInfo info = new NodeInfo(line); 
      holder.add(info); 


     } 
     scan.close(); 

    } 
    catch (Exception ex) 
    { 
     ex.printStackTrace(); 
    } 


    BinarySearchTree<NodeInfo> directory = new BinarySearchTree<>(); 

    for(int i = 0; i < holder.size(); i++) 
    { 
     NodeInfo one = holder.get(i); 
     String line = one.getLine(); 



     directory.insert(one); 

    } 

    directory.inOrder(); 

} 
} 

Answer 1

Ihr BST ist für das Suchen und Sortieren der NodeInfo des compareTo-Methode aufrufen, die wiederum die Leitung Attribut verwendet zwei Einträge zu vergleichen. Machen Sie den Vergleich, um den Attributnamen anstelle der Attributlinie für die Vergleiche zu verwenden. Erstellen Sie einen schnellen Scan. Ich habe den Aufruf von setName der NodeInfo-Instanz nicht gefunden. Sie fügen das entweder dem Scan-Teil hinzu oder verwenden einen Aufruf von getName in der compareTo-Methode, anstatt das Namensattribut zu verwenden.

public class NodeInfo implements Comparable<NodeInfo> 
{ 
... 

public int compareTo(NodeInfo other) 
{ 
    String x = getName(this.line); 
    String y = getName(other.line); 
    return x.compareTo(y); 
} 
... 
}