fibonacci_heap | Fibonacci heap implementation in Rust

Using a std::list would not cause any double deletes, as long as you don't manually delete nodes, and let the actual unique_ptr pointers in child_list members handle that. You would just need to be careful to avoid using a dangling pointer after a Node has been destroyed. But this way still doesn't give a good way to quickly remove a Node* from the appropriate child_list.

Instead, you could maybe use std::list leaf_list;. This is relatively safe since inserts and erases on a std::list do not invalidate any iterators (except of course iterators to erased elements).

Though since you still have an invariant to follow, that the iterators in leaf_list belong to the appropriate child_list, it would be good to help code follow it. Depending on the intended usage and generality of the class, that might mean just putting notes in comments within or just before the struct Node definition. Or it might mean making Node a proper class with private members and a safer public interface - I might consider creating custom iterators using boost::iterator_adaptor to allow iteration over the leaf nodes without as much danger of breaking the invariant. If you don't expect much reuse, but then find it would be useful again in more contexts or projects, you could of course change these sorts of decisions later (unless too much code gets written using the raw way).

There is an error in the original C code that you’re repeating in Java. Specifically, look at your adapted Java code:

So I could have two Nodes with the exact same state and different addresses.

If that's all that your problem was, the answer would simply be a matter of using a unordered_set instead of just newing Nodes, and make sure that your Node class has a proper hash function associated with it. This will take care of dedupping your nodes.

The next question is: How much of that latent search space are you expecting to traverse? On paper, it's always possible that you'll hit a degenerate case where you need to traverse more nodes than you can fit in memory, which is going to be a problem.

To address this, there are two main approaches:

1. Choose an arbitrary number of nodes to open / memory to consume before giving up on the search and treat it as an effectively unsolvable case.

2. Actually search through that latent search space until a solution is found. In that case, A* is not going to cut it, and you'll need a more memory efficient algorithm such as Iterative-deepening A*.