/**
  * This class implements a singly linked list of floats in Java.
  * @author  Jon Schlegel
  * @version 1.0
  */

public class FloatLinkedList 
{
	
	protected Node head;
        protected Node tail;

       /**
        * Constructs a new singly linked list object.
       */
        public FloatLinkedList()
	{
		head = null;
                tail = null;
	}


        /**
          * Removes all of the elements from the linked list.
          */
        public void removeAllElements()
        {
                head = null;
                tail = null;
        }

	/**
         * Adds a node containing the float to the beginning of the 
         * list.  
         * @param f The float to be added to the list.
         */
	public void addNode(float f)
	{
		Node new_node = new Node(f);
		// If the list is empty, set the head and tail correctly.
		if (head == null) {
			head = new_node;
                        tail = head;
			return;
		}
		
                tail.setNext(new_node);
                tail = new_node;         
	}

  
	/**
     * Deletes the ith node in the list.
     * @param i The number of the node in the list to delete.
     * @return True if the deletion was successful, false if the ith node
     *         could not be deleted (e.g. if the list contains less than
     *         i nodes).
     */		
	public boolean deleteNodeAt(int i)
	{
		// Handle the empty list and negative values of i.  
		if (head == null || i<0)
			return false;

		// Delete the head of the list
		if (i==0) {
			head = head.getNext();
                        if (head == null)
                                tail = null;
			return true;
		}


		Node temp = head;
		for (int node_num = 0;node_num<i-1;node_num++)
		{				
			temp = temp.getNext();			
			if (temp == null)
				return false;
		}

		// next_node is the node to be deleted
		Node next_node = temp.getNext();
		if (next_node == null)
			return false;
		// Change the pointers so we jump over next_node
		temp.setNext(next_node.getNext());
                if (next_node.getNext() == null)
                        tail = temp;
		return true;
	}


     /**
     * Gets the float found in the ith node of the list.  The list
     * starts with node 0 and ends with node countNodes()-1.  
     * @param i The number of the node in the list from which the
     *          data should be retrieved.
     * @return The float found in the ith node of the list, or
     *         -1 if the list has less than i nodes.
     * 
     */
        public float getNodeAt(int i)
	{
		// Deal with empty list and case when i is negative
		if (head == null | i<0)
			return -1;

		Node temp = head;
		for (int node_num=0;node_num<i;node_num++)
		{
			temp = temp.getNext();
			if (temp == null)
				return -1;
		}
		return temp.getData();
	}


       /**
        * Prints all of the characters in the list.
        */
	public void print()
	{
		// This method doesn't work for a list with loops, but
		// that's ok because I said we could assume there weren't any =).
		Node temp = head;
		while (temp != null)
		{
                        System.out.print(temp.getData() + " ");
			temp = temp.getNext();
		}
		System.out.println("");
	}

        /**
         * Tells whether or not the linked list is empty.
         * @return True if the list is empty, false if the list is not
empty.
         */
	public boolean isEmpty()
	{
		return (head == null);
	}


        /**
          * Sorts the linked list using the mergesort algorithm.
          * Only linked lists are used for storing intermediate
          * values.  No arrays are used by this algorithm.
          */
	
	//the function that is called from, calls mergeSort
    public void sort()
    {
		
    }

	

}