如何在Java中將唯一ID，ID組合映射到清晰的編號行

Question

我想創建一種非遞歸的方式來創建類似於

1
1.1
1.2
1.2.1
1.3
2
2.1  etc etc (these items can be infinitely deep)

我唯一的識別信息是兩個數字的ID。 第一個ID是標識該項目的ID，第二個ID標識其所屬的項目，零始終是文檔根目錄。

例如：

123,0
456,123
789,123
777, 789
999, 123
888,0
444,888

將被翻譯成-

1
1.1
1.2
1.2.1
1.3
2
2.1

數據是內聯讀取的。 我不知道緊隨其后的是什么。 我認為這應該很簡單，但是由於某些原因，我很難找到一個有效的解決方案。 注意：項目將始終按順序排列。 例如，我永遠不會在獲得項目1.1之前獲得項目1.2，依此類推。

Answer 1

我的算法是：

• 讀取每對(x, y) ，將x作為y的子代插入樹中
• 要進行打印，請在樹上運行深度優先的遞歸。 如果要執行此操作而無需遞歸，則可以改用堆棧實現。

當然，這是一個非常籠統的草圖-就具體實現而言，有很多選擇！

Answer 2

如果物品以正確的順序排列，則可以疊放：

public class Item {
    private int id;
    private int parentId;

    public Item(int id, int parentId) {
        this.id = id;
        this.parentId = parentId;
    }

    public int getId() { return id; }
    public int getParentId() { return parentId; }
}

public class NumberedItem {
    private Item item;
    private int childCount;
    private String number;

    public NumberedItem(Item item, String number) {
        this.item = item;
        this.childCount = 0;
        this.number = number;
    }

    public Item getItem() { return item; }
    public String getNumber() { return number; }

    /* package */ int incrementChildCount() {
        return ++childCount;
    }
}

public NumberedItemIterator implements Iterable<NumberedItem> {
    private Iterator<Item> items;
    private Stack<NumberedItem> numberStack;

    public NumberedItemIterator(Iterable<Item> itemsIterable) {
        items = itemsIterable.iterator();
        numberStack = new Stack<NumberedItem>();
        numberStack.push(new NumberedItem(null, null));
    }

    public boolean hasNext() {
        return items.hasNext();
    }

    public NumberedItem next() {
        Item current = items.next();
        int parentId = current.getParentId();

        NumberedItem parent = null;
        while (!numberStack.empty()) {
            NumberedItem candidate = numberStack.peek();
            if (candidate.getItem().getId() == parentId) {
                parent = candidate;
                break;
            }
            numberStack.pop();
        }

        if (parent == null) throw new RuntimeException("Inconsistent ordering");

        String number = Integer.toString(parent.incrementChildCount());
        if (parent.getNumber() != null) {
            number = parent.getNumber() + "." + number;
        }

        NumberedItem result = new NumberedItem(current, number);

        numberStack.push(result);

        return result;
    }

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