LinkedBinaryTree의 toString() 메서드 <E> 클래스

Question

이 클래스의 toString() 메서드를 만드는 방법을 알아 내실 수 있습니까? Node 클래스를 포함하는 LinkedBinaryTree 클래스입니다. 이 클래스가 필요로하는 수퍼 클래스와 인터페이스를 제공하는 것이 toString 메서드를 만드는 데 도움이 될 것이라고 생각하지 않지만 내가 틀렸다면 수정 해줄 것이라고 생각합니다. 여기에 수업이 있습니다 :

public class LinkedBinaryTree<E> extends AbstractBinaryTree<E>{ 
protected static class Node<E> implements Position<E> { 
    private E element; // an element stored at this node 
    private Node<E> parent; // a reference to the parent node (if any) 
    private Node<E> left; // a reference to the left child (if any) 
    private Node<E> right; // a reference to the right child (if any) 

    public Node(E e, Node<E> above, Node<E> leftChild, Node<E> rightChild) { 
     element = e; 
     parent = above; 
     left = leftChild; 
     right = rightChild; 
    } 
    // accessor methods 
    public E getElement() { return element; } 
    public Node<E> getParent() { return parent; } 
    public Node<E> getLeft() { return left; } 
    public Node<E> getRight() { return right; } 
    // update methods 
    public void setElement(E e) { element = e; } 
    public void setParent(Node<E> parentNode) { parent = parentNode; } 
    public void setLeft(Node<E> leftChild) { left = leftChild; } 
    public void setRight(Node<E> rightChild) { right = rightChild; } 
} //----------- end of nested Node class ----------- 


protected Node<E> createNode(E e, Node<E> parent, 
     Node<E> left, Node<E> right) { 
    return new Node<E>(e, parent, left, right); 
} 

// LinkedBinaryTree instance variables 
protected Node<E> root = null; // root of the tree 
private int size = 0; // number of nodes in the tree 

// constructor 
public LinkedBinaryTree() { } // constructs an empty binary tree 

// nonpublic utility 

protected Node<E> validate(Position<E> p) throws IllegalArgumentException { 
    if (!(p instanceof Node)) 
     throw new IllegalArgumentException("Not valid position type"); 
    Node<E> node = (Node<E>) p; // safe cast 
    if (node.getParent() == node) // our convention for defunct node 
     throw new IllegalArgumentException("p is no longer in the tree"); 
    return node; 
} 

// accessor methods (not already implemented in AbstractBinaryTree) 

public int size() { 
    return size; 
} 


public Position<E> root() { 
    return root; 
} 


public Position<E> parent(Position<E> p) throws IllegalArgumentException { 
    Node<E> node = validate(p); 
    return node.getParent(); 
} 


public Position<E> left(Position<E> p) throws IllegalArgumentException { 
    Node<E> node = validate(p); 
    return node.getLeft(); 
} 


public Position<E> right(Position<E> p) throws IllegalArgumentException { 
    Node<E> node = validate(p); 
    return node.getRight(); 
} 

public Position<E> addRoot(E e) throws IllegalStateException { 
    if (!isEmpty()) throw new IllegalStateException("Tree is not empty"); 
    root = createNode(e, null, null, null); 
    size = 1; 
    return root; 
} 


public Position<E> addLeft(Position<E> p, E e) 
     throws IllegalArgumentException { 
    Node<E> parent = validate(p); 
    if (parent.getLeft() != null) 
     throw new IllegalArgumentException("p already has a left child"); 
    Node<E> child = createNode(e, parent, null, null); 
    parent.setLeft(child); 
    size++; 
    return child; 
} 

public Position<E> addRight(Position<E> p, E e) 
     throws IllegalArgumentException { 
    Node<E> parent = validate(p); 
    if (parent.getRight() != null) 
     throw new IllegalArgumentException("p already has a right child"); 
    Node<E> child = createNode(e, parent, null, null); 
    parent.setRight(child); 
    size++; 
    return child; 
} 


public E set(Position<E> p, E e) throws IllegalArgumentException { 
    Node<E> node = validate(p); 
    E temp = node.getElement(); 
    node.setElement(e); 
    return temp; 
} 

public void attach(Position<E> p, LinkedBinaryTree<E> t1, 
     LinkedBinaryTree<E> t2) throws IllegalArgumentException { 
    Node<E> node = validate(p); 
    if (isInternal(p)) throw new IllegalArgumentException("p must be a leaf"); 
    size += t1.size() + t2.size(); 
    if (!t1.isEmpty()) { // attach t1 as left subtree of node 
     t1.root.setParent(node); 
     node.setLeft(t1.root); 
     t1.root = null; 
     t1.size = 0; 
    } 
    if (!t2.isEmpty()) { // attach t2 as right subtree of node 
     t2.root.setParent(node); 
     node.setRight(t2.root); 
     t2.root = null; 
     t2.size = 0; 
    } 
} 

public E remove(Position<E> p) throws IllegalArgumentException { 
    Node<E> node = validate(p); 
    if (numChildren(p) == 2) 
     throw new IllegalArgumentException("p has two children"); 
    Node<E> child = (node.getLeft() != null ? node.getLeft() : node.getRight()); 
    if (child != null) 
     child.setParent(node.getParent()); // child’s grandparent becomes its parent 
    if (node == root) 
     root = child; // child becomes root 
    else { 
     Node<E> parent = node.getParent(); 
     if (node == parent.getLeft()) 
      parent.setLeft(child); 
     else 
      parent.setRight(child); 
    } 
    size--; 
    E temp = node.getElement(); 
    node.setElement(null); // help garbage collection 
    node.setLeft(null); 
    node.setRight(null); 
    node.setParent(node); // our convention for defunct node 
    return temp; 
} 
} 

이 모든 도움을 주시면 감사하겠습니다.

Answer 1

간단한 재귀를 사용하여 수행 할 수 있습니다.

public String toString(){ 
    String stringVal = "["; 
    if(root != null){ 
     stringVal+=getChildNoteString(root); 
    } 

    return stringVal+"]"; 
} 

private String getChildNodeString(Node n){ 
    String nodeStringVal = n+","; 
    if(n.getLeft()!=null){ 
     nodeStringVal += ","+ getChildNodeString(n.getLeft()); 
    } 

    if(n.getRight()!=null){ 
     nodeStringVal += ","+ getChildNodeString(n.getRight()); 
    } 
} 

Answer 2

가 어딘가에 LinkedBinaryTree<E>.class에서 당신이 toString()를 오버라이드 (override) 할 필요가 이것의 예는 다음과 같습니다

@Override // Not strictly necessary but good practice. 
public String toString() { 
    return "Hello World!"; // Replace this with what you want to be returned. 
} 

당신이 방법은 사용자의 요구에 맞게 반환을 정의해야합니다.