有没有办法通过链表，而不是普通的指针是唯一的？

Question

我正在尝试用 c++ 编写二叉树，链表作为子树，唯一指针作为这些列表之间的连接。整个树分为两部分：右和左。有两个指针指向从头到左和到右叶。然后子树中的每个叶子都是一个结构，它存储下一个信息：

class Leaf{
private:
    int * leaf_value; 
    int occupancy;
    std::unique_ptr<Leaf> NextLeaf;

public:
    explicit Leaf(int);
    void AppendLeaf(int,std::unique_ptr<Leaf>);

};

Leaf::Leaf(int size) {
    leaf_value = new int (size);
    NextLeaf = nullptr;
    occupancy = 0;
}

其中leaf_value 是一个指向内存的指针，它将存储该级别上的所有数字。（因为它是一棵二叉树，我们可以知道应该为对象分配的确切大小（2 ^ current_level））。因此，我们将用数字填充该空闲空间，直到占用率小于2 ^ current_level。之后，我们将为下一行元素添加一个新的更深层次。 结构将如下所示：

               1
            /        \
         [2]         [ 3 ]
        /              \
   [4 , 5 ,6 ,7]  [8 , 9 , 10 , 11 ]

方形 bruckets 中的元素是单叶。 .我认为用 uniwue 指针将它们全部连接起来可能是个好主意，因为列表的每个节点只引用下一个节点，所以实际上所有指针都是唯一的。这是我正在尝试做的简化代码。

int main(){
     Node head;
     head.next = nullptr;
     int value;
     cin << value;
     AddNode(value , head); 
     return 0;
}

/*TreeHead - is another leaf structure that stores pointers to left and right branches 
struct SmartTree{
    int level;
    std::unique_ptr<Leaf> LeftChild = std::make_unique<Leaf>(1);
    std::unique_ptr<Leaf> RightChild = std::make_unique<Leaf>(1);

}
*/
void AddNode(int val , std::unique_ptr<SmartTree> TreeHead){
/*problem with implemantation of this part */
     Node * currentLeaf  = TreeHead;
     Node * previousLeaf = TreeHead;
     while(current != nullptr){
        previousLeaf = currentLeaf;
        currentLeaf = currentLeaf -> next ;
     }
     currentLeaf = new Leaf;
     previous -> next = currentLeaf;
     currentLeaf -> value = val; 
}

但问题是，由于唯一指针的唯一性，我无法找到正确的方法来遍历所有最小值。我不确定我是否可以使用 move(pointer) 函数来做到这一点，因为作为我知道功能起作用，它将所有权从TreeHead 借给CurrentLeafe，存储的价值可能会丢失。 所以问题是： 有没有办法通过唯一指针或者我应该使用不同类型的指针来完成该任务？ 非常感谢！

Answer 1

我通过在 normal 上更改数组叶子 [ 1 2 3 ] 稍微改变了我的方法。这意味着现在每个叶子都是一个包含一个元素的对象，所以树现在看起来不像：

                1
            /        \
         [2]         [ 3 ]
        /              \
   [4 , 5 ,6 ,7]  [8 , 9 , 10 , 11 ]

但喜欢：

               1
           /       \
          2           3
        /    \      /  \ 
       5      6    7     8 

新的树结构：

struct SmartTree {
    int value;
    int childrens;
    bool is_root = false;
    std::unique_ptr<SmartTree> LeftChild;
    std::unique_ptr<SmartTree> RightChild;
};

但我相信它也可以与以前的方法一起使用。所以我发现，在这种情况下，一个好的解决方案是递归，而不是没有帮助，现在函数遍历树并将元素添加到末尾看起来像这样：

std::unique_ptr <SmartTree> InsertLeftChild(std::unique_ptr<SmartTree> tree, std::unique_ptr<SmartTree> left_subtree){
    // left_subtree - node to insert
    tree -> childrens += 1;
    if (tree -> is_root and  tree -> LeftChild == nullptr) tree -> LeftChild = std::move(left_subtree);
    else if (tree -> is_root) tree -> LeftChild = InsertLeftChild(std::move(tree -> LeftChild) , move(left_subtree));
    else if (tree -> LeftChild == nullptr)tree -> LeftChild = std::move(left_subtree);
    else if (tree -> RightChild == nullptr) tree -> RightChild = std::move(left_subtree);
    else if (tree -> LeftChild -> childrens <= tree -> RightChild -> childrens) tree->LeftChild = InsertLeftChild(std::move(tree -> LeftChild) , std::move(left_subtree));
    else if (tree -> LeftChild -> childrens > tree -> RightChild -> childrens)  tree->RightChild = InsertLeftChild(std::move(tree -> RightChild) , std::move(left_subtree));
    return move(tree);
};

这只是为了插入左孩子而写的。所以第一个和第二个if 检查它是否是一个根，这个根是否初始化。如果它有 childs ，则调用函数 InsertLeftChilld 。传递参数，使用 move 函数将破坏先前的指针，所以在左侧我将所有权归还给 LeftChild：

tree -> LeftChild = std::move(left_subtree);

else if (tree -> LeftChild == nullptr) 检查它是否结束，如果是 - 插入新的叶子

else if (tree -> LeftChild -> childrens <= tree -> RightChild -> childrens) 检查你接下来应该将你的叶子指向哪里，以防它不水平你可以插入它 .希望这个方法能对以后的人有所帮助。谢谢大家的回答！