Doubly Linked List Insert to Middle

Greenhorn

Posts: 14

posted 3 years ago

Hi there! Hoping someone can maybe help me out. I have a working doubly linked list program ready to turn in, but we were given an option for extra credit...insert in the middle. I have no idea why I'm having so many issues with it. It seems whatever I do screws up another part of my program to the point I just deleted it and am ready for a fresh try. I'm not trying to be a programmer, this is not my strong suit. I'm more into the hardware but this is required for my associates, so please bare with me in my lack of knowledge. I have included the code. I'm not looking for someone to do it for me, just maybe give me a starting point or some hints as to what to do so when I add it it doesn't affect the rest of my working program.
Thanks in advance!

public class DoublyLinkedList<T> 
{
    // node inner class
    private class Node<T> 
    {

private T data;
        private Node<T> previous, next;

public Node() 
        {
            data = null;
            previous = null;
            next = null;
        }

public Node(T newData, Node<T> previousValue, Node<T> nextValue) 
        {
            data = newData;
            previous = previousValue;
            next = nextValue;

}
    }

private Node<T> head, tail;

public DoublyLinkedList() 
    {
        head = null;
        tail = null;
    }

public DoublyLinkedList(DoublyLinkedList<T> dll) 
    {
        Node<T> node = dll.head;
        while (node != null) 
        {
            this.add(node.data);
            node = node.next;
        }
    }

public DoublyLinkedList<T> clone() 
    {
        DoublyLinkedList<T> clone = new DoublyLinkedList<T>();
        Node<T> node = head;
        while (node != null) 
        {
            clone.add(node.data);
            node = node.next;
        }
        return clone;
    }// Clone Method

public class DllIterator 
    {

Node pointer = head;

public boolean hasNext() 
        {
            if (pointer.next != null) 
            {
                return true;
            }
            return false;
        } // Iterator

public boolean hasPrevious() 
        {
            if (pointer.previous != null) 
            {
                return true;
            }
            return false;
        }

public Node next() 
        {
            if (hasNext()) 
            {
                pointer = pointer.next;
                return pointer;
            }
            return null;
        }

public Node previous() 
        {
            if (hasPrevious()) 
            {
                pointer = pointer.previous;
                return pointer;
            }
            return null;
        }

}

public void addToStart(T itemData) 
    {
        head = new Node<T>(itemData, null, head);
    }

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

public void add(T e) 
    {
        if (isEmpty()) 
        {
            tail = new Node<T>(e, null, null);
            head = tail;
        } 
        else 
        {
            tail.next = new Node<T>(e, tail, null);
            tail = tail.next;
        }
    }

public boolean deleteHeadNode() 
    {
        if (head != null) 
        {
            head = head.next;
            return true;
        } 
        else 
        {
            return false;
        }
    }
    
    public String toString()
    {
        String str = "";
        Node<T> node = head;
        while(node != null)
        {
            str = str.concat(node.data.toString() + " ");
            node = node.next;
        }
        return str;
    }
    
    public String outputBackwards()
    {
        DoublyLinkedList dll = new DoublyLinkedList();
        Node<T> node = tail;
        while(node.previous != null)
        {
            dll.add(node.data);
            node = node.previous;
        }
        dll.add(head.data);
        return dll.toString();
    }

public int size() 
    {
        int count = 0;
        Node<T> position = head;
        while (position != null) 
        {
            count++;
            System.out.println(position.data);
            position = position.next;
        }
        return count;
    }

public boolean contains(T item) 
    {
        return (find(item) != null);
    }

private Node<T> find(T target) 
    {
        Node<T> position = head;
        T itemAtPosition;
        while (position != null) 
        {
            itemAtPosition = position.data;
            if (itemAtPosition.equals(target)) 
            {
                return position;
            }
            position = position.next;
        }
        return null;
    }
}

Junilu Lacar

Marshal

Posts: 15881

265