DoublyLinkedSortedList.java

public class DoublyLinkedSortedList implements DoublyLinkedSortedListInterface
{
    private Node first; //head
    private Node last; //tail

    //constructor 
    public DoublyLinkedSortedList()
    {
        first = null;
        last = null;
    }

    //returns first node in the list
    @Override
    public Node getFirst() 
    {
        return first;
    }

    //returns last node in the list
    @Override
    public Node getLast()
    {
        return last;
    }

    //removes a node from the list
    @Override
    public Node remove(HurricaneRowData toRemove) 
    {
        //placeholder to start from beginning
        Node currentNode = first;
        //while this currentnode is not null (i.e: not end of list)
        while(currentNode != null)
        {
            //checks if this is the node to remove
            if(currentNode.getValue().equals(toRemove))
            {
                //creates references to neighboring nodes nodes previous and next
                Node previousNode = currentNode.getPrevious();
                Node nextNode = currentNode.getNext();

                //updates previous node next pointer
                //if there is a previous node, connect it to next node
                if(previousNode != null)
                    previousNode.setNext(nextNode);
                //if there is not anything behind previous node, then remove first node and make it nextnode
                else
                    first = nextNode;
                 //updates next node's previous pointer
                 //if next node is not null, connect it to previous node
                if(nextNode != null)
                    nextNode.setPrevious(previousNode);
                else
                    //remove next node
                    last = previousNode;
                //return removed node
                return currentNode;
            }
            //move to next node in the list
            currentNode = currentNode.getNext();
        }
        //returns null if value not found
        return null;
    }

    @Override
    public void insert(HurricaneRowData newValue) 
    {
        //new node that will store the ace data
        Node node = new Node(newValue);

        //There are 4 cases to this: inserting in a null linked list, inserting at the beginning, insertion in the middle, and insertion at the end
        //inserting in an empty list
        if(first == null)
        {
            first = node;
            last = node;
            return;
        }
        //starts the search from the beginning
        Node currentNode = first;
        //while the current ace is larger
        while(currentNode != null && currentNode.getValue().getAceIndex() > newValue.getAceIndex())
        {
            currentNode = currentNode.getNext();
        }

        //insert at beginning
        if(currentNode == first)
        {
            node.setNext(first);  //new node points to old
            first.setPrevious(node); //old first points to new node
            first = node; //updates head of the list
        }
        //inserts at the end
        else if(currentNode == null)
        {
            last.setNext(node); //old last points to new node
            node.setPrevious(last); //new node points to old last
            last = node; //update tail
        }
        //inserts at the middle
        else
        {
            //gets node before insertion point
            Node previousNode = currentNode.getPrevious();
            
            //links previous node to new node
            previousNode.setNext(node);
            node.setPrevious(previousNode);

            //links new node to current node
            node.setNext(currentNode);
            currentNode.setPrevious(node);
        }
    }

    //converts linked list to a string
    @Override
    public String toString()
    {
        String result = ""; // empty string
        Node current = first; //sets current node as first node

        while(current != null)
        {
            result += current.getValue().toString() + "\n";
            current = current.getNext();
        }    
        return result;
    }
    
    //insert two public string methods here
    //this will test the insert/getfirst and remove methods
    public String testFirst()
    {
        //creates new list
        DoublyLinkedSortedList list = new DoublyLinkedSortedList();

        //insert new test data
        list.insert(new HurricaneRowData(1920, 500, 20, 2, 2));
        list.insert(new HurricaneRowData(1921, 400, 20, 2, 2));
        list.insert(new HurricaneRowData(1922, 100, 20, 2, 2));
        list.insert(new HurricaneRowData(1923, 50, 20, 2, 2));

        //checks if ace of 1920 (largest ace) is correct
        if(list.getFirst().getValue().getAceIndex() == 500)
            return "GETFIRST PASS";
        
        return "FAIL";
    }

    public String testRemove()
    {
        DoublyLinkedSortedList list = new DoublyLinkedSortedList();
        //same list as last time but with variables
        HurricaneRowData a = new HurricaneRowData(1920, 500, 20, 2, 2);
        HurricaneRowData b = new HurricaneRowData(1921, 400, 20, 2, 2);
        HurricaneRowData c = new HurricaneRowData(1922, 100, 20, 2, 2);
        HurricaneRowData d = new HurricaneRowData(1923, 50, 20, 2, 2);

        list.insert(a);
        list.insert(b);
        list.insert(c);
        list.insert(d);

        //remove 1920 ace
        list.remove(a);
        //if 1920 is top ace it passes
        if(list.getFirst().getValue().getAceIndex() == 400)
            return "REMOVE METHOD PASS";

        return "FAIL";
    }

    
}