如何在二叉树结构中创建获取节点父编号的方法

如何解决如何在二叉树结构中创建获取节点父编号的方法

在我的二叉树数据结构中：

//Every node has value and index
class Node<T> {
    Node<T> left,right;
    int index;
    T value;
    
    Node(T value,int index){
        this.index = index;
        this.value = value;
    }
}

class Tree<T> {
    int depth;
    Node<T> root;
    
    //Create an empty binary tree
    private static Tree<Object> empty = new Tree<>();
    
    @SuppressWarnings("unchecked")
    public static <K> Tree<K> empty(){
        return (Tree<K>) Tree.empty;
    }
    
    //creating a binary tree by taking depth as input
    public static <K> Tree<K> depth(int deepest){
      if(deepest > 0) {
          Tree<K> tree =  Tree.empty();
          tree.root = new Node<>(null,0);
          tree.addLevel(tree.root,deepest,0);
          return tree;
       } 
      else {
          throw new Error();
       }
    }
    
    private void addLevel(Node<T> node,int depth,int deepest,int index){
        if (depth == deepest - 1) {
                return;
            } else {
        node.left = new Node<>(node.value,index*2+1);
        node.right = new Node<>(node.value,index*2+2);
        addLevel(node.left,depth+1,index*2+1);
        addLevel(node.right,index*2+2);
        }
    }
    
    public void getAllElem(Node<T> node,List<HashMap<T,Integer>> list) {
        if (node == null) {
            return;
        } 
        else {
        HashMap<T,Integer> pairs = new HashMap<T,Integer>();
        getAllElem(node.left,list);
        pairs.put(node.value,node.index);
        list.add(pairs);
        getAllElem(node.right,list);        
    }}

那种情况下，我想创建一个方法getParent(int index)，当用户将索引号传递给该方法时，它会返回父节点的值。例如，当输入的 index = 3 时，它会得到 node(index = 1) 的值。但我不知道如何做到这一点，有什么建议吗？谢谢！

解决方法

一个简单的算法是从父节点检查叶子索引并在找到所需的叶子索引后立即返回父值，即：

T getParent(int index,Node<T> node){
     if(node == null)
        return null;
     else if(node.left != null && node.left.index == index  || node.right != null && node.right.index == index)
         return node.value;
     else{
         T value = getParent(index,node.left);
         return (value != null) ? value : getParent(index,node.right);
    }
}

该算法在最坏的情况下会具有时间复杂度 N，因此效率很低。但是，如果根据当前的父索引仅在右侧或左侧叶子上进行搜索，则可以尝试将其改进为 O(log2N)。为此，需要找到一个表达式，让人们知道继续搜索的叶子。

解决这个问题最有效的算法是 O(1)。由于对于索引为 n 的给定节点，它们的叶子将位于索引 2n + 1 和 2n + 2 处，因此您可以制作一个小表格并尝试找出公式（基于叶索引返回父索引）：

index | parent 
0     | no parent 
1     | 0
2     | 0
3     | 1
4     | 1
5     | 2
6     | 2
7     | 3
8     | 3
9     | 4
10    | 4

基于该表，可以从代码上推断出，可以使用公式 (i-1)/2 和 i > 0 获得父索引，i 开始叶的索引一个正在寻找：

i = 2 -> (2-1)/2 = 0  (the value will be rounded down)
i = 3 -> (3-1)/2 = 1
i = 4 -> (4-1)/2 = 1 (the value will be rounded down)
....
i = 10 -> (10-1)/2 = 4  (the value will be rounded down)

所以代码会很简单：

int getParentIndex(int index){
    return (index == 0) ? -1 : (index - 1) / 2;
}

但是，要使该算法起作用，您需要有一个额外的结构来按索引存储节点，以便您可以在 O(1) 中访问它们的值。例如，使用 ArrayList：

private static List<Node<T>> nodes = new ArrayList<>();

当您向树中添加节点时，您也将其添加到该列表中。然后使用 getParentIndex 方法可以访问列表中的索引，并检索节点值。

这是用于 Binary Heap 的典型方法。