Question

我知道你们会抱怨一次又一次地问这个问题。抱歉，我在Google / Stackoverflow /论坛等找不到答案

我正在用Java创建一个数组二进制树（它不是搜索树）。

1）我的节点具有以下属性：parent，left和right。哪个是父，左子和右子的索引数。我的教授告诉我这样做，我不知道为什么因为你可以用公式找到父母和孩子的索引，我想有人告诉我如何添加父/左/右的指数帮助我完成操作的复杂性。

2）当你有一个指向数组中节点的指针时，我无法找到删除操作的复杂性。我正在考虑在删除节点时将所有节点移动到左侧。我认为这是O（n），我不知道如何改进它。我读过有些人用O（log n）实现这个操作。但他们没有说怎么做。（我很感激Java中的任何代码片段。）

*请记住我正在使用Java中的ArrayList。

一些代码：

public class ArrayBinaryTree<E> implements BinaryTree<E> {
    private class BTPos<T> implements Position<T> {
        private T element;
        private int parent;
        private int left;
        private int right;
        private int index;

        /** Main constructor */
        public BTPos(T element, int index, int parent, int left, int right) {
            setIndex(index);
            setElement(element);
            setParent(parent);
            setLeft(left);
            setRight(right);
        }

        /** Returns the index */
        public int getIndex() {
            return index;
        }

        /** Sets the index */
        public void setIndex(int i) {
            index = i;
        }

        /** Returns the element stored at this position */
        public T getElement() {
            return element;
        }

        /** Sets the element stored at this position */
        public void setElement(T o) {
            element = o;
        }

        /** Returns the parent */
        public int getParent() {
            return parent;
        }

        /** Sets the index */
        public void setParent(int i) {
            parent = i;
        }

        /** Returns the left */
        public int getLeft() {
            return left;
        }

        /** Sets the left */
        public void setLeft(int i) {
            left = i;
        }

        /** Returns the right */
        public int getRight() {
            return right;
        }

        /** Sets the right */
        public void setRight(int i) {
            right = i;
        }
    }
    private List<BTPos<E>> tree;
    private int size;
    private final int MAX_SIZE;

    /** Creates an empty binary tree. */
    public ArrayBinaryTree() {
        this.MAX_SIZE = 100;
        this.tree = new ArrayList<BTPos<E>>(this.MAX_SIZE);
        this.size = 0;
    }
}

Answer 1

1）如果你有一个固定的布局，只有索引公式才有效。但是，如果您没有平衡树，则这是阵列中的空间浪费。 2）解决O（log n）上的删除需要一个平衡的树（如果不是BST - 我不确定）。您可以使用Google轻松找到解释如何轻松完成此操作;）。

Answer 2

1）将父/左/右索引存储在节点中只会浪费内存，因为无论如何都可以使用公式来实现它。

2）如果你已经有一个指向要删除的节点的指针，那么删除的复杂性为O（1），你可以简单地用特殊符号标记该节点，将其表示为已删除而不是移动所有节点向左转。通过这种方式，您可以在插入时重用节点（也就是说您没有创建BST，那么可以在已删除的节点中完成任何插入）。

删除数组二进制树中的操作

2 个答案: