/** * Add an element to the list at the specified index * * @param The index where the element should be added * @param element The element to add */ public void add(int index, E element) { // TODO: Implement this method /*if (index < 0 || index > size - 1) { throw new IndexOutOfBoundsException(); }*/ if (element == null) { throw new NullPointerException(); } LLNode<E> newNode = new LLNode<E>(element); LLNode<E> currentNode = this.head.next; while (index > 0 && currentNode.next != null) { currentNode = currentNode.next; index--; } // Re-assign pointers so currentNode -> newNode -> newNode.next newNode.next = currentNode; currentNode.prev.next = newNode; newNode.prev = currentNode.prev; currentNode.prev = newNode; // Increment list size this.size++; }
/** Create a new empty LinkedList */ public MyLinkedList() { // TODO: Implement this method this.size = 0; this.head = new LLNode<E>(null); this.tail = new LLNode<E>(null); head.next = tail; tail.prev = head; }
/** Create a new empty doublyLinkedList */ public MyLinkedList() { this.size = 0; this.head = new LLNode<E>(null); this.tail = new LLNode<E>(null); // Set the initial references head.setNext(tail); tail.setPrev(head); }
/** * Set an index position in the list to a new element * * @param index The index of the element to change * @param element The new element * @return The element that was replaced * @throws IndexOutOfBoundsException if the index is out of bounds. */ public E set(int index, E element) { // TODO: Implement this method if (element == null) throw new NullPointerException(); if (index < 0 || index > size - 1) throw new IndexOutOfBoundsException(); LLNode<E> u = getNode(index); E y = u.data; u.data = element; return y; }
@Override public String toString() { String result = "MyLinkedList{"; LLNode<E> probe = head; for (int i = 0; i < this.size; i++) { result += probe + " "; probe = probe.getNext(); } result += '}'; return result; }
/** * Add an element to the list at the specified index * * @param The index where the element should be added * @param element The element to add */ public void add(int index, E element) { // TODO: Implement this method if (element == null) throw new NullPointerException(); if (index < 0 || index > size) throw new IndexOutOfBoundsException(); LLNode<E> indexNode = getNode(index); LLNode<E> newNode = new LLNode<E>(element); newNode.prev = indexNode.prev; newNode.next = indexNode; newNode.next.prev = newNode; newNode.prev.next = newNode; size++; }
/** * Set an index position in the list to a new element * * @param index The index of the element to change * @param element The new element * @return The element that was replaced * @throws IndexOutOfBoundsException if the index is out of bounds. */ public E set(int index, E element) { if (index < 0 || index > (this.size - 1)) { throw new IndexOutOfBoundsException("Index out of bounds: " + index); } else if (element == null) { throw new NullPointerException("Null elements not supported by list."); } else { LLNode<E> node = head; while (index > 0) { node = node.next; index--; } node.data = element; return element; } }
/** * Appends an element to the end of the list * * @param element The element to add */ public boolean add(E element) { if (element == null) { throw new NullPointerException("Null elements not supported by list."); } else { final LLNode<E> node = new LLNode<>(element); if (tail.data == null) { head = tail = node; } else { tail.next = node; node.prev = tail; tail = node; } size++; return true; } }
/** * Add an element to the list at the specified index * * @param The index where the element should be added * @param element The element to add */ public void add(int index, E element) { // TODO: Implement this method if (element == null) throw new NullPointerException(); LLNode<E> elemToAdd = new LLNode<E>(element); if ((index > this.size) || (index < 0)) { throw new IndexOutOfBoundsException(); } else { int count = 0; LLNode<E> cur = this.head; while (count <= index) { cur = cur.next; count++; } LLNode<E> prevNode = cur.prev; prevNode.next = elemToAdd; cur.prev = elemToAdd; elemToAdd.next = cur; elemToAdd.prev = prevNode; this.size++; } }
/** * Appends an element to the end of the list * * @param element The element to add */ public boolean add(E element) { // TODO: Implement this method // Instantiate new node LLNode<E> newNode = new LLNode<E>(element); LLNode<E> currentNode = this.tail.prev; // Re-assign pointers for currentNode and tail to newNode newNode.next = this.tail; newNode.prev = currentNode; this.tail.prev = newNode; currentNode.next = newNode; // Increment size this.size++; return true; }
/** * Remove a node at the specified index and return its data element. * * @param index The index of the element to remove * @return The data element removed * @throws IndexOutOfBoundsException If index is outside the bounds of the list */ public E remove(int index) { // TODO: Implement this method if ((index >= this.size) || (index < 0)) { throw new IndexOutOfBoundsException(); } else { int count = 0; LLNode<E> cur = this.head; while (count <= index) { cur = cur.next; count++; } LLNode<E> prevNode = cur.prev; LLNode<E> nextNode = cur.next; prevNode.next = nextNode; nextNode.prev = prevNode; this.size--; return cur.data; } }
/** * Set an index position in the list to a new element * * @param index The index of the element to change * @param element The new element * @return The element that was replaced * @throws IndexOutOfBoundsException if the index is out of bounds. */ public E set(int index, E element) { // TODO: Implement this method if (index > size - 1 || index < 0) { throw new IndexOutOfBoundsException(); } if (this.head.next == null) { throw new NullPointerException(); } LLNode<E> currentNode = this.head.next; while (index > 0 && currentNode.next != null) { currentNode = currentNode.next; index--; } E oldElement = currentNode.data; currentNode.data = element; return oldElement; }
/** * Add an element to the list at the specified index * * @param index where the element should be added * @param element The element to add */ public void addback(int index, E element) { if (index < 0 || index > size) { throw new IndexOutOfBoundsException("Index out of bounds: " + index); } else if (element == null) { throw new NullPointerException("Null elements not supported by list."); } else if (index == 0) { final LLNode<E> node = new LLNode<>(element); node.next = head; node.prev = node; head = node; size++; } else if (index == size) { final LLNode<E> node = new LLNode<>(element); tail.next = node; node.prev = tail; tail = node; size++; } else { final LLNode<E> node = new LLNode<>(element); LLNode<E> nextNode = new LLNode<>(null); nextNode = head; while (index > 0) { nextNode = nextNode.next; index--; } nextNode.prev.next = node; node.prev = nextNode.prev; node.next = nextNode; nextNode.prev = node; size++; } }
// Return the previous node based on the referenceNode private LLNode<E> getPrev(LLNode<E> referenceNode) { if (referenceNode == head) { throw new BoundaryViolationException("Reference cannot be equal to head"); } return referenceNode.getPrev(); }
// Return the next node based on the referenceNode private LLNode<E> getNext(LLNode<E> referenceNode) { if (referenceNode == tail) { throw new BoundaryViolationException("Reference cannot be equal to tail"); } return referenceNode.getNext(); }
public void add(int index, E element) { if (index < 0 || index > size) { throw new IndexOutOfBoundsException("Index out of bounds: " + index); } else if (element == null) { throw new NullPointerException("Null elements not supported by list."); } else if (index == 0) { final LLNode<E> node = new LLNode<>(element); node.setNext(head); head.setPrev(node); head = node; size++; } else if (index == size) { final LLNode<E> node = new LLNode<>(element); tail.setNext(node); node.setPrev(tail); tail = node; size++; } else { final LLNode<E> node = new LLNode<>(element); LLNode<E> nextNode = new LLNode<>(null); nextNode = head; while (index > 0) { nextNode = nextNode.next; index--; } nextNode.prev.next = node; node.prev = nextNode.prev; node.next = nextNode; nextNode.prev = node; size++; } // This method adds an element at the specified index. // If elements exist at that index, you will move elements at that // index (and beyond) up, effectively inserting this element at that location in the list. // Although drawings are helpful for implementing any method, you will benefit heavily from // drawing out what should happen in this method before trying to code it. // You will want to throw an IndexOutOfBoundsException if the index provided is not reasonable // for // inserting an element. // Optional: After authoring this version of the add method, you could consider removing // redundant // code by having the add method you originally wrote just call this method. // To test this method, use the method in MyLinkedListTester called testAddAtIndex. }