Changed code and added test

Author: Tejaswgupta

src/main/java/com/williamfiset/algorithms/datastructures/fibonacci_heap/Fibonacci.java renamed to src/main/java/com/williamfiset/algorithms/datastructures/fibonacciheap/FibonacciHeap.java

@@ -1,3 +1,8 @@
+package com.williamfiset.algorithms.datastructures.fibonacciheap;
+
+//Disclaimer: implementation based on "http://staff.ustc.edu.cn/~csli/graduate/algorithms/book6/chap21.htm"
+//Credits to the respective owner for code 
+
 import static java.lang.Math.floor;
 import static java.lang.Math.log;
 import static java.lang.Math.sqrt;
@@ -13,84 +18,37 @@
 import java.util.Set;
 import java.util.Stack;
 
-/**
- * A Fibonacci Heap implementation based on
- * <a href="http://staff.ustc.edu.cn/~csli/graduate/algorithms/book6/chap21.htm">University of Science and Technology of
- * China</a> lesson.
- *
- * <p><b>Note 1</b>: this class is NOT thread safe!</p>
- *
- * <p><b>Note 2</b>: this class doesn't support {@code null} values</p>
- *
- * @param <E> the type of elements held in this collection.
- */
+
 public final class FibonacciHeap<E>
     implements Queue<E>
 {
 
-    /**
-     * The <i>Phi</i> constant value.
-     */
+
     private static final double LOG_PHI = log( ( 1 + sqrt( 5 ) ) / 2 );
 
-    /**
-     * A simple index of stored elements.
-     */
     private final Set<E> elementsIndex = new HashSet<E>();
 
-    /**
-     * The comparator, or null if priority queue uses elements'
-     * natural ordering.
-     */
     private final Comparator<? super E> comparator;
 
-    /**
-     * The number of nodes currently in {@code H} is kept in {@code n[H]}.
-     */
     private int size = 0;
 
-    /**
-     * {@code t(H)} the number of trees in the root list.
-     */
     private int trees = 0;
 
-    /**
-     * {@code m(H)} the number of marked nodes in {@code H}.
-     */
     private int markedNodes = 0;
 
-    /**
-     * The root of the tree containing a minimum key {@code min[H]}.
-     */
     private FibonacciHeapNode<E> minimumNode;
 
-    /**
-     * Creates a {@link FibonacciHeap} that orders its elements according to their natural ordering.
-     */
     public FibonacciHeap()
     {
         this( null );
     }
 
-    /**
-     * Creates a {@link FibonacciHeap} that orders its elements according to the specified comparator.
-     *
-     * @param comparator the comparator that will be used to order this queue.
-     *                   If null, the natural ordering of the elements will be used.
-     */
+
     public FibonacciHeap( /* @Nullable */Comparator<? super E> comparator )
     {
         this.comparator = comparator;
     }
 
-    /**
-     * Moves the target node in the {@code H} root nodes.
-     *
-     * @param node the node has to be moved in the {@code H} root nodes
-     * @see #add(Object)
-     * @see #consolidate()
-     * @see #cut(FibonacciHeapNode, FibonacciHeapNode)
-     */
     private void moveToRoot( FibonacciHeapNode<E> node )
     {
         // 8'  if min[H] = NIL
@@ -119,21 +77,6 @@ private void moveToRoot( FibonacciHeapNode<E> node )
         }
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * <pre>FIB-HEAP-INSERT(H, x)
-     * 1  degree[x] &larr; 0
-     * 2  p[x] &larr; NIL
-     * 3  child[x] &larr; NIL
-     * 4  left[x] &larr; x
-     * 5  right[x] &larr; x
-     * 6  mark[x] &larr; FALSE
-     * 7  concatenate the root list containing x with root list H
-     * 8  if min[H] = NIL or key[x] &lt; key[min[H]]
-     * 9     then min[H] &larr; x
-     * 10  n[H] &larr; n[H] + 1</pre>
-     */
     public boolean add( E e )
     {
         if ( e == null )
@@ -311,23 +254,6 @@ public E peek()
         return minimumNode.getElement();
     }
 
-    /**
-     * {@inheritDoc}
-     *
-     * <pre>FIB-HEAP-EXTRACT-MIN(H)
-     * 1  z &larr; min[H]
-     * 2  if z &ne; NIL
-     * 3      then for each child x of z
-     * 4               do add x to the root list of H
-     * 5                  p[x] &larr; NIL
-     * 6           remove z from the root list of H
-     * 7           if z = right[z]
-     * 8              then min[H] &larr; NIL
-     * 9              else min[H] &larr; right[z]
-     * 10                   CONSOLIDATE(H)
-     * 11           n[H] &larr; n[H] - 1
-     * 12  return z</pre>
-     */
     public E poll()
     {
         // 2  if z &ne; NIL
@@ -400,30 +326,6 @@ public E remove()
         return poll();
     }
 
-    /**
-     * Implements the {@code CONSOLIDATE(H)} function.
-     *
-     * <pre>CONSOLIDATE(H)
-     * 1 for i &larr; 0 to D(n[H])
-     * 2      do A[i] &larr; NIL
-     * 3 for each node w in the root list of H
-     * 4      do x &larr; w
-     * 5         d &larr; degree[x]
-     * 6         while A[d] &ne; NIL
-     * 7            do y &larr; A[d]
-     * 8               if key[x] &gt; key[y]
-     * 9                  then exchange x &harr; y
-     * 10                FIB-HEAP-LINK(H,y,x)
-     * 11                A[d] &larr; NIL
-     * 12                d &larr; d + 1
-     * 13         A[d] &larr; x
-     * 14 min[H] &larr; NIL
-     * 15 for i &larr; 0 to D(n[H])
-     * 16      do if A[i] &ne; NIL
-     * 17            then add A[i] to the root list of H
-     * 18                 if min[H] = NIL or key[A[i]] &le; key[min[H]]
-     * 19                    then min[H] &larr; A[i]</pre>
-     */
     private void consolidate()
     {
         if ( isEmpty() )
@@ -525,17 +427,6 @@ private void consolidate()
         }
     }
 
-    /**
-     * Implements the {@code FIB-HEAP-LINK(H, y, x)} function.
-     *
-     * <pre>FIB-HEAP-LINK(H, y, x)
-     * 1  remove y from the root list of H
-     * 2  make y a child of x, incrementing degree[x]
-     * 3  mark[y]  FALSE</pre>
-     *
-     * @param y the node has to be removed from the root list
-     * @param x the node has to to become fater of {@code y}
-     */
     private void link( FibonacciHeapNode<E> y, FibonacciHeapNode<E> x )
     {
         // 1 remove y from the root list of H
@@ -566,18 +457,6 @@ private void link( FibonacciHeapNode<E> y, FibonacciHeapNode<E> x )
         markedNodes++;
     }
 
-    /**
-     * Implements the {@code CUT(H,x,y)} function.
-     *
-     * <pre>CUT(H,x,y)
-     * 1  remove x from the child list of y, decrementing degree[y]
-     * 2  add x to the root list of H
-     * 3  p[x] &larr; NIL
-     * 4  mark[x] &larr; FALSE</pre>
-     *
-     * @param x the node has to be removed from {@code y} children
-     * @param y the node has to be updated
-     */
     private void cut( FibonacciHeapNode<E> x, FibonacciHeapNode<E> y )
     {
         // add x to the root list of H
@@ -593,19 +472,6 @@ private void cut( FibonacciHeapNode<E> x, FibonacciHeapNode<E> y )
         markedNodes--;
     }
 
-    /**
-     * Implements the {@code CASCADING-CUT(H,y)} function.
-     *
-     * <pre>CASCADING-CUT(H,y)
-     * 1  z &larr; p[y]
-     * 2  if z &ne; NIL
-     * 3     then if mark[y] = FALSE
-     * 4             then mark[y] &larr; TRUE
-     * 5             else CUT(H,y,z)
-     * 6                  CASCADING-CUT(H,z)</pre>
-     *
-     * @param y the target node to apply CASCADING-CUT
-     */
     private void cascadingCut( FibonacciHeapNode<E> y )
     {
         // z <- p[y]
@@ -631,26 +497,12 @@ private void cascadingCut( FibonacciHeapNode<E> y )
         }
     }
 
-    /**
-     * The potential of Fibonacci heap {@code H} is then defined by
-     * {@code t(H) + 2m(H)}.
-     *
-     * @return The potential of this Fibonacci heap.
-     */
     public int potential()
     {
         return trees + 2 * markedNodes;
     }
 
-    /**
-     * Compare the given objects according to to the specified comparator if not null,
-     * according to their natural ordering otherwise.
-     *
-     * @param o1 the first {@link FibonacciHeap} node to be compared
-     * @param o2 the second {@link FibonacciHeap} node to be compared
-     * @return a negative integer, zero, or a positive integer as the first argument is
-     *         less than, equal to, or greater than the second
-     */
+
     private int compare( FibonacciHeapNode<E> o1, FibonacciHeapNode<E> o2 )
     {
         if ( comparator != null )

src/main/java/com/williamfiset/algorithms/datastructures/fibonacciheap/FibonacciNode.java

@@ -0,0 +1,118 @@
+package com.williamfiset.algorithms.datastructures.fibonacciheap;
+
+//Credits to the respective owner for the code
+
+final class FibonacciHeapNode<E>
+{
+
+
+    private final E element;
+
+    private FibonacciHeapNode<E> parent;
+
+    private FibonacciHeapNode<E> left = this;
+
+    private FibonacciHeapNode<E> right = this;
+
+    private FibonacciHeapNode<E> child;
+
+    private int degree;
+
+    private boolean marked;
+
+    public FibonacciHeapNode( E element )
+    {
+        // 1  degree[x] &larr; 0
+        degree = 0;
+        // 2  p[x] <- NIL
+        setParent( null );
+        // 3  child[x] <- NIL
+        setChild( null );
+        // 4  left[x] <- x
+        setLeft( this );
+        // 5  right[x] <- x
+        setRight( this );
+        // 6  mark[x] <- FALSE
+        setMarked( false );
+
+        // set the adapted element
+        this.element = element;
+    }
+
+    public FibonacciHeapNode<E> getParent()
+    {
+        return parent;
+    }
+
+    public void setParent( FibonacciHeapNode<E> parent )
+    {
+        this.parent = parent;
+    }
+
+    public FibonacciHeapNode<E> getLeft()
+    {
+        return left;
+    }
+
+    public void setLeft( FibonacciHeapNode<E> left )
+    {
+        this.left = left;
+    }
+
+    public FibonacciHeapNode<E> getRight()
+    {
+        return right;
+    }
+
+    public void setRight( FibonacciHeapNode<E> right )
+    {
+        this.right = right;
+    }
+
+    public FibonacciHeapNode<E> getChild()
+    {
+        return child;
+    }
+
+    public void setChild( FibonacciHeapNode<E> child )
+    {
+        this.child = child;
+    }
+
+    public int getDegree()
+    {
+        return degree;
+    }
+
+    public void incraeseDegree()
+    {
+        degree++;
+    }
+
+    public void decraeseDegree()
+    {
+        degree--;
+    }
+
+    public boolean isMarked()
+    {
+        return marked;
+    }
+
+    public void setMarked( boolean marked )
+    {
+        this.marked = marked;
+    }
+
+    public E getElement()
+    {
+        return element;
+    }
+
+    @Override
+    public String toString()
+    {
+        return element.toString();
+    }
+
+}