Question

//implement the binomial heap please
import java.util.LinkedList;
import java.util.NoSuchElementException;

/**
 * Binomial Heap Implementation
 *
 * @author First Last
 * @since ${date}
 */
public class BinomialHeap<T extends Comparable<? super T>>  implements binomialHeapInterface<T> {


    private static final int DEFAULT = 5; // default size for the binomial heap
    public Node<T>[] forest;
    private int n;
    private boolean isMaxHeap;

    /**
     * Node Class for nodes in Binomial Heap
     */
    protected class Node<T> {
        private T value;
        private int degree;
        private LinkedList<Node<T>> children;

        /**
         * Node Constructor
         * @param x -> key value of the node
         */
        public Node(T x) {
            /* TODO */
        }

        /**
         * method to add children to node
         * @param node the new child of this node
         */
        public void addChild(Node node) {
            /* TODO */
        }

        /**
         * Getter method for degree
         *
         * @return degree of the current node
         */
        public int getDegree() {
            /* TODO */
            return 0;
        }

        /**
         * Getter method for the value of the node
         * @return value of the node
         */
        public T getValue() {
            /* TODO */
            return null;
        }

        /**
         * getter method for the children
         * @return the children of a node
         */
        public LinkedList<Node<T>> getChildren() {
            /* TODO */
            return null;
        }
    }

    /**
     * Initializes a binomial max heap with capacity = 5
     */
    public BinomialHeap() {
        /* TODO */
    }

    /**
     * Initializes a binomial max heap with a given initial capacity.
     *
     * @param heapSize The initial capacity of the heap.
     */
    public BinomialHeap(int heapSize) {
        /* TODO */
    }

    /**
     * Initializes a binomial heap (with a given value for d), with a given
     * initial capacity.
     *
     * @param heapSize The initial capacity of the heap.
     * @param isMaxHeap indicates whether the heap should be max or min
     */
    public BinomialHeap(int heapSize, boolean isMaxHeap) {
        /* TODO */
    }

    /**
     * size of the heap
     * @return number of elements in heap
     */
    public int size() {
        /* TODO */
        return 0;
    }

    /**
     * clears the Binomial Heap
     */
    public void clear() {
        /* TODO */
    }

    /**
     * Add element to the binomial Heap
     * @param o The element to add.
     * @throws NullPointerException if o is null
     */
    public void add(T o) {
        /* TODO */
    }

    /**
     * Helper Method for inserting elements into the Binomial Heap
     * @param node node to insert into forest
     */
    private void insertHelper(Node<T> node) {
        /* TODO */
        // hint 1: the 'node' of degree k is going to be placed at forest[k]
        // hint 2: consider how this helper can be used in the add and remove method
        // attempt to place 'node' in forest degree of the Node (for the rest, assume degree of 'node' is k)
            // if forest[k] is empty, place 'node' at forest[k]
            // if forest[k] contains a Node:
                // compare 'node' and forest[k] -> one of these becomes the child of the other 
                // (consider using the addChild method of Node)
                // 'node' <-- the non-child of the either 'node' and forest[k]
                // return back to the first step of trying to place 'node' into forest
                    // note: because I have added a child, the degree of 'node' has increased by 1
        // if my forest wasn't big enough for the 'node' (consider how I can tell if this is true):
            // resize the forest & place the 'node' in the appropriate spot. 
    }

    /**
     * compareTo wrapper to take care of Max Heap & Min Heap Implementation
     *
     * @param node1 first node
     * @param node2 second node
     * @return compareTo values between node1 and node2 relative to the Heap type
     */
    private Boolean compareToWrapper(Node<T> node1, Node<T> node2) {
        /* TODO */
        return false;
    }

    /**
     * remove method for binomial heap
     * @return removes the min/max from the heap
     * @throws NoSuchElementException if heap is empty
     */
    public T remove() throws NoSuchElementException {
        /* TODO */
        return null;
    }

    /**
     * Find the index of extrema
     * @return index of extrema
     */
    private int findExtrema() {
        /* TODO */
        return 0;
    }

    /**
     * resizes the forest
     */
    private void resize() {
        /* TODO */
    }

    /**
     * looks at top element
     * @return returns min/max relative to heap type
     * @throws NoSuchElementException if heap is empty
     */
    public T element() throws NoSuchElementException {
        /* TODO */
        return null;
    }

import java.util.NoSuchElementException;

public interface binomialHeapInterface<T extends java.lang.Comparable<? super T>> {

    /**
     * Returns the number of elements stored in the heap.
     *
     * @return The number of elements stored in the heap.
     */
    int size();

    /**
     * Removes and returns the element at the root. If the
     * heap is empty, then this method throws a NoSuchElementException.
     *
     * @return The element at the root stored in the heap.
     * @throws java.util.NoSuchElementException if the heap is empty
     */

    T remove() throws NoSuchElementException;

    /**
     * Adds the specified element to the heap; o cannot be null.
     * Resizes the storage if full.
     *
     * @param o The element to add.
     * @throws NullPointerException if o is null.
     */
    void add( T o ) throws NullPointerException;

    /**
     * Clears all the items in the heap
     * Heap will be empty after this call returns
     */
    public void clear();

    /**
     * Retrieves, but does not remove, the element at the root.
     * @return item at the root of the heap
     * @throws NoSuchElementException - if this heap is empty
     */
    public T element() throws NoSuchElementException;

}

Answer 1

please give thumbs up if the solution is useful to you.
import java.util.Scanner;

class BinomialHeapNode {
        int key, degree;
        BinomialHeapNode parent;
        BinomialHeapNode sibling;
        BinomialHeapNode child;

        public BinomialHeapNode(int k) {
                key = k;
                degree = 0;
                parent = null;
                sibling = null;
                child = null;
        }

        public BinomialHeapNode reverse(BinomialHeapNode sibl) {
                BinomialHeapNode ret;
                if (sibling != null)
                        ret = sibling.reverse(this);
                else
                        ret = this;
                sibling = sibl;
                return ret;
        }

        public BinomialHeapNode findMinNode() {
                BinomialHeapNode x = this, y = this;
                int min = x.key;

                while (x != null) {
                        if (x.key < min) {
                                y = x;
                                min = x.key;
                        }
                        x = x.sibling;
                }

                return y;
        }

        public BinomialHeapNode findANodeWithKey(int value) {
                BinomialHeapNode temp = this, node = null;

                while (temp != null) {
                        if (temp.key == value) {
                                node = temp;
                                break;
                        }
                        if (temp.child == null)
                                temp = temp.sibling;
                        else {
                                node = temp.child.findANodeWithKey(value);
                                if (node == null)
                                        temp = temp.sibling;
                                else
                                        break;
                        }
                }

                return node;
        }

public int getSize() {
                return (1 + ((child == null) ? 0 : child.getSize()) + ((sibling == null) ? 0 : sibling.getSize()));
        }
}

class BinomialHeap {
        private BinomialHeapNode Nodes;
        private int size;

        public BinomialHeap() {
                Nodes = null;
                size = 0;
        }

        public boolean isEmpty() {
                return Nodes == null;
        }

        public int getSize() {
                return size;
        }

        public void makeEmpty() {
                Nodes = null;
                size = 0;
        }

        public void insert(int value) {
                if (value > 0) {
                        BinomialHeapNode temp = new BinomialHeapNode(value);
                        if (Nodes == null) {
                                Nodes = temp;
                                size = 1;
                        } else {
                                unionNodes(temp);
                                size++;
                        }
                }
        }

        private void merge(BinomialHeapNode binHeap) {
                BinomialHeapNode temp1 = Nodes, temp2 = binHeap;

                while ((temp1 != null) && (temp2 != null)) {
                        if (temp1.degree == temp2.degree) {
                                BinomialHeapNode tmp = temp2;
                                temp2 = temp2.sibling;
                                tmp.sibling = temp1.sibling;
                                temp1.sibling = tmp;
                                temp1 = tmp.sibling;
                        } else {
                                if (temp1.degree < temp2.degree) {
                                        if ((temp1.sibling == null) || (temp1.sibling.degree > temp2.degree)) {
                                                BinomialHeapNode tmp = temp2;
                                                temp2 = temp2.sibling;
                                                tmp.sibling = temp1.sibling;
                                                temp1.sibling = tmp;
                                                temp1 = tmp.sibling;
                                        } else {
                                                temp1 = temp1.sibling;
                                        }
                                } else {
                                        BinomialHeapNode tmp = temp1;
                                        temp1 = temp2;
                                        temp2 = temp2.sibling;
                                        temp1.sibling = tmp;
                                        if (tmp == Nodes) {
                                                Nodes = temp1;
                                        } else {

                                        }
                                }
                        }
                }
                if (temp1 == null) {
                        temp1 = Nodes;
                        while (temp1.sibling != null) {
                                temp1 = temp1.sibling;
                        }
                        temp1.sibling = temp2;
                } else {

                }
        }

private void unionNodes(BinomialHeapNode binHeap) {
                merge(binHeap);

                BinomialHeapNode prevTemp = null, temp = Nodes, nextTemp = Nodes.sibling;

                while (nextTemp != null) {
                        if ((temp.degree != nextTemp.degree)
                                        || ((nextTemp.sibling != null) && (nextTemp.sibling.degree == temp.degree))) {
                                prevTemp = temp;
                                temp = nextTemp;
                        } else {
                                if (temp.key <= nextTemp.key) {
                                        temp.sibling = nextTemp.sibling;
                                        nextTemp.parent = temp;
                                        nextTemp.sibling = temp.child;
                                        temp.child = nextTemp;
                                        temp.degree++;
                                } else {
                                        if (prevTemp == null) {
                                                Nodes = nextTemp;
                                        } else {
                                                prevTemp.sibling = nextTemp;
                                        }
                                        temp.parent = nextTemp;
                                        temp.sibling = nextTemp.child;
                                        nextTemp.child = temp;
                                        nextTemp.degree++;
                                        temp = nextTemp;
                                }
                        }
                        nextTemp = temp.sibling;
                }
        }

        public int findMinimum() {
                return Nodes.findMinNode().key;
        }

        public void delete(int value) {
                if ((Nodes != null) && (Nodes.findANodeWithKey(value) != null)) {
                        decreaseKeyValue(value, findMinimum() - 1);
                        extractMin();
                }
        }

        public void decreaseKeyValue(int old_value, int new_value) {
                BinomialHeapNode temp = Nodes.findANodeWithKey(old_value);
                if (temp == null)
                        return;
                temp.key = new_value;
                BinomialHeapNode tempParent = temp.parent;

                while ((tempParent != null) && (temp.key < tempParent.key)) {
                        int z = temp.key;
                        temp.key = tempParent.key;
                        tempParent.key = z;

                        temp = tempParent;
                        tempParent = tempParent.parent;
                }
        }

        public int extractMin() {
                if (Nodes == null)
                        return -1;

                BinomialHeapNode temp = Nodes, prevTemp = null;
                BinomialHeapNode minNode = Nodes.findMinNode();

                while (temp.key != minNode.key) {
                        prevTemp = temp;
                        temp = temp.sibling;
                }

                if (prevTemp == null) {
                        Nodes = temp.sibling;
                } else {
                        prevTemp.sibling = temp.sibling;
                }

                temp = temp.child;
                BinomialHeapNode fakeNode = temp;

                while (temp != null) {
                        temp.parent = null;
                        temp = temp.sibling;
                }

                if ((Nodes == null) && (fakeNode == null)) {
                        size = 0;
                } else {
                        if ((Nodes == null) && (fakeNode != null)) {
                                Nodes = fakeNode.reverse(null);
                                size = Nodes.getSize();
                        } else {
                                if ((Nodes != null) && (fakeNode == null)) {
                                        size = Nodes.getSize();
                                } else {
                                        unionNodes(fakeNode.reverse(null));
                                        size = Nodes.getSize();
                                }
                        }
                }

                return minNode.key;
        }

        public void displayHeap() {
                System.out.print("\nHeap : ");
                displayHeap(Nodes);
                System.out.println("\n");
        }

        private void displayHeap(BinomialHeapNode r) {
                if (r != null) {
                        displayHeap(r.child);
                        System.out.print(r.key + " ");
                        displayHeap(r.sibling);
                }
        }
}

public class JavaBinomialHeapExample {

        public static void main(String[] args) {
                Scanner scan = new Scanner(System.in);
                System.out.println("Binomial Heap Test\n\n");

                BinomialHeap bh = new BinomialHeap();

                char ch;

                do {
                        System.out.println("\nBinomialHeap Operations\n");
                        System.out.println("1. insert ");
                        System.out.println("2. delete ");
                        System.out.println("3. size");
                        System.out.println("4. check empty");
                        System.out.println("5. clear");

                        int choice = scan.nextInt();
                        switch (choice) {
                        case 1:
                                System.out.println("Enter integer element to insert");
                                bh.insert(scan.nextInt());
                                break;
                        case 2:
                                System.out.println("Enter element to delete ");
                                bh.delete(scan.nextInt());
                                break;
                        case 3:
                                System.out.println("Size = " + bh.getSize());
                                break;
                        case 4:
                                System.out.println("Empty status = " + bh.isEmpty());
                                break;
                        case 5:
                                bh.makeEmpty();
                                System.out.println("Heap Cleared\n");
                                break;
                        default:
                                System.out.println("Wrong Entry \n ");
                                break;
                        }

                        bh.displayHeap();

                        System.out.println("\nDo you want to continue (Type y or n) \n");
                        ch = scan.next().charAt(0);
                } while (ch == 'Y' || ch == 'y');
        }
}