如何在Java中使用迭代器？

Question

我已经实现了优先队列接口来创建堆。你能告诉我如何在其基础上实现一个迭代器吗？请指向一些合适的教程，我是java的新手，而且时间非常紧迫。 实际上，我需要一种方法来根据Object.id从堆中查找并修改对象。我不介意它是O(n)。

public interface PriorityQueue {

    /**
     * The Position interface represents a type that can
     * be used for the decreaseKey operation.
     */
    public interface Position {

        /**
         * Returns the value stored at this position.
         * @return the value stored at this position.
         */
        Comparable getValue();
    }

    Position insert(Comparable x);

    Comparable findMin();

    Comparable deleteMin();

    boolean isEmpty();

    int size();

    void decreaseKey(Position p, Comparable newVal);
}

// 二叉堆类

public class OpenList implements PriorityQueue {

    public OpenList() {
        currentSize = 0;
        array = new Comparable[DEFAULT_CAPACITY + 1];
    }

    public OpenList(int size) {
        currentSize = 0;
        array = new Comparable[DEFAULT_CAPACITY + 1];
        justtocheck = new int[size];
    }

    public OpenList(Comparable[] items) {
        currentSize = items.length;
        array = new Comparable[items.length + 1];

        for (int i = 0; i < items.length; i++) {
            array[i + 1] = items[i];
        }
        buildHeap();
    }

    public int check(Comparable item) {
        for (int i = 0; i < array.length; i++) {
            if (array[1] == item) {
                return 1;
            }
        }
        return array.length;
    }

    public PriorityQueue.Position insert(Comparable x) {
        if (currentSize + 1 == array.length) {
            doubleArray();
        }

        // Percolate up
        int hole = ++currentSize;
        array[ 0] = x;

        for (; x.compareTo(array[hole / 2]) < 0; hole /= 2) {
            array[hole] = array[hole / 2];
        }
        array[hole] = x;

        return null;
    }

    public void decreaseKey(PriorityQueue.Position p, Comparable newVal) {
        throw new UnsupportedOperationException(
            "Cannot use decreaseKey for binary heap");
    }

    public Comparable findMin() {
        if (isEmpty()) {
            throw new UnderflowException("Empty binary heap");
        }
        return array[ 1];
    }

    public Comparable deleteMin() {
        Comparable minItem = findMin();
        array[ 1] = array[currentSize--];
        percolateDown(1);

        return minItem;
    }

    private void buildHeap() {
        for (int i = currentSize / 2; i > 0; i--) {
            percolateDown(i);
        }
    }

    public boolean isEmpty() {
        return currentSize == 0;
    }

    public int size() {
        return currentSize;
    }

    public void makeEmpty() {
        currentSize = 0;
    }
    private static final int DEFAULT_CAPACITY = 100;
    private int currentSize;      // Number of elements in heap
    private Comparable[] array; // The heap array
    public int[] justtocheck;

    private void percolateDown(int hole) {
        int child;
        Comparable tmp = array[hole];

        for (; hole * 2 <= currentSize; hole = child) {
            child = hole * 2;
            if (child != currentSize &&
                array[child + 1].compareTo(array[child]) < 0) {
                child++;
            }
            if (array[child].compareTo(tmp) < 0) {
                array[hole] = array[child];
            } else {
                break;
            }
        }
        array[hole] = tmp;
    }

    private void doubleArray() {
        Comparable[] newArray;

        newArray = new Comparable[array.length * 2];
        for (int i = 0; i < array.length; i++) {
            newArray[i] = array[i];
        }
        array = newArray;

}

- Nitin Garg

Answer 1

你可能会看一下java.util.PriorityQueue。如果你很着急，Arrays.sort()可能就足够了。一旦排序完成，Arrays.binarySearch() 就可以使用了。

- trashgod

---

谢谢...我想那就可以了！！ - Nitin Garg

Answer 2

你的底层数据结构是一个数组，很难编写一个类似Java风格的迭代器。你可以尝试创建一个容器类实现java.util.Iterator，该类持有对Comparable元素及其当前数组索引的引用。当移动容器时，需要手动更新索引。

- Gunslinger47

---

听起来很合理。也许是一个具有基础数组的列表？嗯... http://java.sun.com/javase/6/docs/api/java/util/ArrayList.html - Tyler

谢谢。我认为最简单和最快的方法是根据我的需求重新编写堆类。 - Nitin Garg