Question

我试图在AVL树上实现迭代器，我坚持这个特定的功能：

// Typical use of a nonstatic member class
public class MySet<E> extends AbstractSet<E> {
    ... // Bulk of the class omitted

    public Iterator<E> iterator() {
        return new MyIterator();
    }

    private class MyIterator implements Iterator<E> {
        ...
    }
}

我添加了两个类：

完整代码，Node类：

 /**
     * @return an iterator  for the Avl Tree. The returned  iterator  iterates  over the tree nodes.
     * in an ascending order, and does NOT implement the remove() method.
     */
    public Iterator<Integer> iterator(){
        List myList=new ArrayList<>();
        Node counter=root;
        Node counter1=root.getChildernLeft();
        if(counter1==null){
            myList.add(counter1);
        }

        Node counter1=root.getChildernLeft();
    }

AvlTree的完整代码：`

public class Node {

private Node parent;
private Node childernRight;
private Node childernLeft;
private int data;
private int height;


/**
 * constractor
 */
public Node(int data, Node childernLeft, Node childernRight) {
    this.data = data;
    this.childernLeft = childernLeft;
    this.childernRight = childernRight;
    this.childernRight.setParent(this);
    this.childernLeft.setParent(this);
}

public Node(int data) {
    this.data = data;
}

public Node getParent() {
    return parent;
}

public Node getChildernRight() {
    return childernRight;
}

public Node getChildernLeft() {
    return childernLeft;
}

public void setParent(Node parent) {
    this.parent = parent;
}

public void setChildernRight(Node childernRight) {
    this.childernRight = childernRight;
    this.childernRight.setParent(this);
}

public void setChildernLeft(Node childernLeft) {
    this.childernLeft = childernLeft;
    this.childernLeft.setParent(this);
}

public int getData() {
    return data;
}

public String toString() {
    if (this.childernLeft != null && this.getChildernRight() != null) {
        return childernLeft.toString() + "," + this.data + "," + childernRight.toString();
    } else if (this.childernLeft != null && this.getChildernRight() == null) {
        return childernLeft.toString() + "," + this.data;
    } else if (this.childernLeft == null && this.getChildernRight() != null) {
        return this.data + "," + childernRight.toString();
    } else {
        return this.data + "";
    }
}

public int balanceFactor() {
    int balanceFactor = childernRight.height - childernLeft.height;
    return balanceFactor;
}

public boolean hasChildrenRight() {

    if (this.childernRight != null) {
        return true;
    }
    else{
        return false;
    }
}

public boolean hasChildrenLeft() {

    if (this.childernLeft != null) {
        return true;
    }
    else{
        return false;
    }
}


/**
 * if we have many children in the tree
 */
public void addNode(Node val){
    if(hasChildrenRight()&&this.data>val.data){
        this.setChildernRight(val);
    }
    if(!hasChildrenLeft()&&this.data<val.data){
        this.setChildernLeft(val);
    }
    if(!hasChildrenLeft()&&!hasChildrenRight()){
        if(this.data>val.data){
        setChildernLeft(val);
        }
        else{
            setChildernRight(val);
        }
    }

    if(val.data>this.data){
        childernRight.addNode(val);
    }
    else{
        childernLeft.addNode(val);
    }

}
}

`

Answer 1

您可以使用堆栈

实现迭代器

public Iterator<V> iterator() {
        return new Itr();
    }

    private class Itr<V> implements Iterator<V> {
        TreeNode<V> localNode = (TreeNode<V>) root;
        Stack<TreeNode<V>> stack;

        public Itr() {
            stack = new ArrayStack<TreeNode<V>>();

            while (localNode != null) {
                stack.push(localNode);
                localNode = localNode.getLeftChield();
            }
        }

        public boolean hasNext() {
            return !stack.empty();
        }

        public V next() {
            TreeNode<V> node = stack.pop();
            V v = node.getValue();
            if (node.getRightChield() != null) {
                node = node.getRightChield();
                while (node != null) {
                    stack.push(node);
                    node = node.getLeftChield();
                }
            }
            return v;
        }

        public void remove() {
            throw new UnsupportedOperationException();

        }

    }

AVL树java上的迭代器实现

我添加了两个类：

1 个答案: