Help implementing some methods getting errors

        public boolean toss(E value) {
                if (root == null) {
                        root = new Node(value);
                        // False indicates no toss took place.
                        return false;
                } else {
                        Node newNode = new Node(value);
                        Node freeParent = getFreeParent();
                        newNode.parent = freeParent;
                        if (freeParent.left == null) {
                                freeParent.left = newNode;
                        } else {
                                freeParent.right = newNode;
                        }// end second else
                        return true;
                }// end first else
 
        }// end toss()
 

Select allOpen in new window

import java.util.*;
 
/**
 * The purpose of this program is to formulate a tree-based heap instead of the
 * typical array based heap. The toss method may be utilized to add nodes
 * containing integers to the tree-based heap. Nodes may be continuously tossed
 * onto the heap one by one. Once it is time to restore the heap to proper heap
 * specifications, the method heapRestore is then called.
 * 
 * @author Vince Guadalue
 */
 
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
 
public class treeHeap<Element extends Comparable<Element>> {
 
	Node root;
 
	/**
	 * This method will create an empty tree Heap for nodes to be inserted on
	 */
 
	public treeHeap() {
		root = null;
	}
 
	/**
	 * The purpose of this method is to create a tree heap with a specific node,
	 * setting the node as the root value
	 */
 
	public treeHeap(Element data) {
		root = new Node(data);
	}
 
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
 
	/**
	 * This class serves as container for an element in the tree heap
	 */
 
	private class Node {
		Element data;
		Node parent;
		Node leftChild;
		Node rightChild;
 
		/**
		 * This is the constructor for the node class it will set the parent,
		 * left and right child to null
		 */
		Node(Element value) {
			this.data = value;
			parent = null;
			leftChild = null;
			rightChild = null;
		}// end Constructor
 
		/**
		 * This method will compare node objects to help determine if they are in the
		 * correct order. This is utilized in the heapRestore method
		 */
		int compareThem(Node node) {
			return (data.compareTo(node.data));
		}// end compareTo()
	}// end class Node
 
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
 
	/**
	 * This method works hand-and-hand with the toss method. Before an item can
	 * be tossed onto the tree heap an open parent for the tossed node must be
	 * located to attach itself too.
	 */
 
	private Node openParent() {
		Queue<Node> queue = new LinkedList<Node>();
		queue.add(root);
		Node temp;
		while (queue.peek() != null) {
			if (queue.peek().leftChild != null
					&& queue.peek().rightChild != null) {
				temp = queue.remove();
				queue.add(temp.leftChild);
				queue.add(temp.rightChild);
			} else
				return queue.peek();
		}
		return null;
	}
 
	/**
	 * Toss is going to add a new node to the tree heap utilizing the openParent
	 * method. Once an open parent is located the new node is inserted.
	 */
 
	public boolean toss(Element value) {
		if (root == null) {
			root = new Node(value);
		} else {
			Node newNode = new Node(value);
			Node freeParent = openParent();
			newNode.parent = freeParent;
			if (freeParent.leftChild == null) {
				freeParent.leftChild = newNode;
			} else {
				freeParent.rightChild = newNode;
			}
			restoreHeap(newNode);
		}
		return true;
	}
 
	/**
	 * This method is utilized to swap values within the tree heap when called
	 * by the restoreHeap method. It helps maintain the correct structure of a
	 * heap after items are randomly tossed in.
	 */
	void swapNodes(Node one, Node two) {
		Element temp = one.data;
		one.data = two.data;
		two.data = temp;
	}// end swapNodes()
 
	/**
	 * When a new node is added to the heap it must then be directed to its
	 * correct location following the properties of heaps. restoreHeap is
	 * utilized in the toss method after a node is randomly attached to the
	 * first open parent. restoreHeap will find the tossed nodes final and
	 * correct location on the tree heap.
	 */
 
	private void restoreHeap(Node node) {
		if (node != root && node.compareThem(node.parent) > 0) {
			swapNodes(node, node.parent);
			restoreHeap(node.parent);
		}// end if clause
	}// end restoreHeap()
}
 
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////

Select allOpen in new window

class treeHeapApp {
	public static void main(String[] args) {
		
toss(#);
toss(#);
toss(#);
toss(#);
restoreHeap();
 
	} // end main()
} // end class treeHeapApp

Select allOpen in new window

private void inOrder(Node localRoot)
{
if(localRoot !=null)
{
inorder(LocalRoot.leftChild);
inOrder(Localroot.rightChild);
}
}

Select allOpen in new window

       public boolean toss(E value) {
                // Track a result boolean
       		boolean bResult;
 
                // We are always going to need a new node,
                // so only ask once.
                Node newNode = new Node(value);
 
		// If the root is empty, then the new node
		// is the root.
                if (root == null) {
                        root = newNode;
	                // False indicates no toss took place.
                        bResult = false;
                } else {
                	// The new nodes parent is the last
                	// node we added.
                        newNode.parent = lastNewNode;
                        
                        // Determine if the new node is a left
                        // or right child of its parent.
                        if (lastNewNode.left == null) {
                                lastNewNode.left = newNode;
                        } else {
                                lastNewNode.right = newNode;
                        }// end second else
                        
                        bResult = true;
                }// end first else
 
                // Tell the heap where to send new nodes in future.
                lastNewNode = newNode;
 
		// Return the result.
                return bResult;
        }// end toss()

Select allOpen in new window

This is Array:
 
This is Tree-Based
	void swapValues(Node p, Node q) {
		E temp = p.value;
		p.value = q.value;
		q.value = temp;
	}
 
 
This is Array-Based
    public static final void swapReferences( Object [ ] a, int index1, int index2 )
    {
        Object tmp = a[ index1 ];
        a[ index1 ] = a[ index2 ];
        a[ index2 ] = tmp;
    }

Select allOpen in new window