FibonacciHeap | A Fibonacci Heap implementation | Learning library

You actually have the correct condition for exit in your code that is when current==sink. You cannot impose any other exit condition. The algorithm necessarily needs to run until the destination node is visited because only at this point you can fix the value of the shortest path to the destination. Because of this condition, the complexity of finding the single source single destination shortest path is the same as that of the single source all nodes shortest paths. So your early exit condition is correct and you should remove all the neighbor condition checks.

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).

Can't pinpoint the exact bug. But, I can tell you from experience that you should not find the minimum while consolidating. You consolidate and then you find the new minimum. You might get into trouble when you have multiple nodes with the same key and the one pointed to by min doesn't end up in the root list.

Also, while testing, don't use a random function. Create an array of arbitrary numbers and insert elements from the array into the heap.

I also don't understand how your implementation handles there being only one heap ordered tree in the Fib heap. What happens when you do an extract-min then?

You can find my Python implementation here if you need it.

Your class FibonacciHeap is generic actually, so its inner private class Node is generic too as mentioned in the first comment.

If you think your Node class should not be generic, you can either make it inner static class using Object val: