Дерево

import java.util.Iterator;
import java.util.List;

public class TreeNodeImpl implements TreeNode{
    private TreeNode parent;
    private List<TreeNode> children;
    private Object data;
 
 
    @Override public TreeNode getParent() {
        return this.parent;
    }
    @Override public void setParent(TreeNode parent) {
        this.parent=parent;
    }
    @Override public Object getData() {
        return this.data;
    }
    @Override public void setData(Object data) {
        this.data=data;
    }
    @Override public TreeNode getRoot() {
        if(parent!=null){
            return parent.getRoot();
        }else return null;
    }
 
    /**
     * Adds the given child to this <code>TreeNode</code> and sets this as the parent to it.
     */
    @Override public void addChild(TreeNode child) {
        this.children.add(child);
        int size = this.children.size();
        this.children.get(size-1).setParent(this);
    }
    /**
     * Returns false if this <code>TreeNode</code> has non-zero number of children.
     * @return true if the node is a leaf (i.e. does not have child nodes)
     */
    @Override public boolean isLeaf() {
        return this.children.isEmpty();
 
    }
    /**
     * Returns the number of children which this <code>TreeNode</code> has.
     */
    @Override public int getChildCount() {
        int myChild=0;
        for(int i=0;i<children.size();i++) {
            myChild += this.children.get(i).getChildCount();
        }
        myChild+=children.size();
        return myChild;
    }
    /**
     * Returns children <code>TreeNode</code>'s as {@link Iterator}.
     */
    @Override public Iterator<TreeNode> getChildrenIterator() {
        final Iterator<TreeNode> iter=new Iterator<TreeNode>() {
           @Override
           public void remove(){
                
           }
            @Override
            public boolean hasNext() {
                if(next()!=null){
                    return true;
                }else return false;
            }
            @Override
            public TreeNode next() {
                return getParent();
            }
        };
        return iter;
    }
 
 
 
    /**
     * Removes the given child from this <code>TreeNode</code> and (if succeeded)
     *  sets null as the parent to it (in order to leave the tree in the consistent state).
     * @return true if succeeded, false if the child was not found
     */
    @Override public boolean removeChild(TreeNode child) {
 
       child.setParent(null);
        return false;
    }
    /**
     * Returns the "expanded" state of this <code>TreeNode</code>.<br/>
     * By default (unless {@link #setExpanded(boolean)} is called)
     *  "expanded" is false (i.e. the node is "collapsed").
     */
    @Override public boolean isExpanded() {
        return false;
    }
    /**
     * Sets the "expanded" state to this <code>TreeNode</code> and to all its children, recursively
     * @param expanded true - to expand this tree branch, false - to collapse this tree branch.
     */
    @Override public void setExpanded(boolean expanded) {
 
    }
 
 
    /**
     * Returns the string representation of the path from root to this <code>TreeNode</code>.<br/>
     * Path elements are separated by "->".<br/>
     * Each path element is either getData().toString() or "empty" if getData()==null.<br/>
     * For example: "root->node1->node13->empty".
     */
    @Override public String getTreePath() {
        return null;
    }
    /**
     * Finds the (first) node with the given data among the parents' sequence of this <code>TreeNode</code>.
     * By convention, the parents' sequence includes this node itself (i.e. the following may be true: obj.findParent(*) == obj).<br/>
     * Data objects should be compared by equals() method (but beware of nulls).
     * @param data the data to find; may be <code>null</code>
     * @return the node found or <code>null</code> if no matching data was found.
     */
    @Override public TreeNode findParent(Object data) {
        return null;
    }
    /**
     * Finds the (first) node with the given data among the children of this <code>TreeNode</code>.<br/>
     * Searches it recursively (if some child doesn't have the given data, the children of this child are searched, and so on).<br/>
     * Data objects should be compared by equals() method (but beware of nulls).
     * @return the node found or <code>null</code> if no matching data was found.
     */
    @Override public TreeNode findChild(Object data) {
        return null;
    }