/** * Will add a new item to the start of the deque. Will throw an error if an empty item is passed * through. If this is the first item that has been added to the deque, then this will also set * the last item in the deque to be the first. * * @param item The item to add to the start of the deque */ public void addFirst(Item item) { if (item == null) { throw new NullPointerException("Woah, you can't add nothing"); } Node previousFirst = first; first = new Node(); first.item = item; first.previous = null; if (previousFirst == null) { // This is the first time something has been added to the deque first.next = null; } else { first.next = previousFirst; previousFirst.previous = first; } // Is this the only node in the deque? if (last == null) { last = first; } N++; }
void add(int num) { Node newNode = new Node(); newNode.contents = num; if (first == null) { first = newNode; return; } assert first != null; if (first.contents >= num) { first.previous = newNode; newNode.next = first; first = newNode; return; } assert first.contents < num; Node tmp = first; while (tmp.contents < num && tmp.next != null) tmp = tmp.next; assert tmp != null; if (tmp.contents < num && tmp.next == null) { tmp.next = newNode; newNode.previous = tmp; } else { assert tmp.contents >= num; assert tmp.previous.contents < num; newNode.previous = tmp.previous; newNode.previous.next = newNode; newNode.next = tmp; newNode.next.previous = newNode; } }
/** Move node to the front of the list. */ public void setHead(Node node) { node.next = head; node.previous = null; if (head != null) { head.previous = node; } head = node; if (end == null) { end = head; } }
public boolean removeNode(Node node) { if (null == node) { return false; } Node previousNode = node.previous; Node nextNode = node.next; // VB: Alternate way to check if head == node && tail == node if (null == previousNode) { if (null == nextNode) { tail = head = null; node = null; return true; } nextNode.previous = null; head = nextNode; node = null; return true; } // VB: Use else if which will improve readability if (null == nextNode) { previousNode.next = null; tail = previousNode; node = null; return true; } return false; }
public boolean removeNode(T data) { if (null == head) return false; if (head.data.equals(data)) { Node n = head; head = head.next; head.previous = null; // VB: This will throw NULL Pointer exception of there is only one elemnt in the // linkedlist before removal n = null; return true; } if (tail.data.equals(data)) { Node n = tail; tail = tail.previous; // VB : Same here tail.next = null; n = null; return true; } Node n = head; while (null != n) { if (n.data.equals(data)) { n.previous.next = n.next; n.next.previous = n.previous; n = null; return true; } n = n.next; } return false; }
/** Constructor for BufferPool */ public BufferPool() { size = 0; head = new Node<K, V>(); tail = new Node<K, V>(); head.next = tail; tail.previous = head; }
public void insert(int valueToInsertAfter, int value) { Node newNode = new Node(value); ++size; Node nodeToInsertAfter = getNodeByValue(valueToInsertAfter); if (nodeToInsertAfter.next == null) { newNode.previous = nodeToInsertAfter; nodeToInsertAfter.next = newNode; tail = newNode; return; } newNode.previous = nodeToInsertAfter; newNode.next = nodeToInsertAfter.next; nodeToInsertAfter.next.previous = newNode; nodeToInsertAfter.next = newNode; }
/** Add the item to the stack. */ public void push(Item item) { Node previous = head; head = new Node(); head.item = item; head.previous = previous; N++; assert check(); }
public void addFront(String item) { if (header == null) header = new Node(null, item, null); else { Node n = new Node(null, item, header); header.previous = n; header = n; } }
// @param capacity, an integer public LRUcache(int capacity) { // write your code here this.capacity = capacity; this.map = new HashMap<Integer, Node>(); this.head = new Node(-1, -1); this.tail = new Node(-1, -1); head.next = tail; tail.previous = head; }
/** * Insert a new key-value pair into the pool * * @param key * @param value */ public void insert(K key, V value) { Node<K, V> newNode = new Node<K, V>(key, value); newNode.next = head.next; newNode.previous = head; head.next.previous = newNode; head.next = newNode; size++; // if the number of elements exceeds the limit, delete the node at the // end. if (size > CAPACITY) { Node<K, V> last = tail.previous; tail.previous = last.previous; tail.previous.next = tail; last.previous = null; last.next = null; size--; } }
// remove last element public void removeLast() { Node last = findLast(); if (last != null && last.previous == null) { last = null; } else if (last != null) { last.previous.next = null; last.previous = null; last = null; } }
/** * remove and return the item from the front * * @return removed generic item */ public Item removeFirst() { if (size() == 0) throw new java.util.NoSuchElementException(); Node currentNode = firstNode; firstNode = currentNode.next; if (firstNode != null) { firstNode.previous = null; } else { lastNode = null; } N--; return currentNode.item; }
public void insertAtHead(int value) { Node newNode = new Node(value); ++size; if (head == null) { head = newNode; tail = newNode; return; } newNode.next = head; head.previous = newNode; head = newNode; // no need to update tail }
public void preAddNode(Node n, String value) { Node newNode; if (n == null) { // List is empty newNode = new Node(null, value, null); } else if (n.previous == null) { // n is the first node addFront(value); } else { newNode = new Node(n.previous, value, n); n.previous.next = newNode; n.previous = newNode; } }
// @param key, an integer // @param value, an integer // @return nothing public void set(int key, int value) { // write your code here if (!map.containsKey(key)) { if (map.size() == capacity) { Node previous = tail.previous; tail.previous = previous.previous; tail.previous.next = tail; map.remove(previous.key); } } else { Node node = map.get(key); Stack<Integer> stack = new Stack<Integer>(); node.previous.next = node.next; node.next.previous = node.previous; } Node newNode = new Node(key, value); newNode.next = head.next; head.next = newNode; newNode.next.previous = newNode; newNode.previous = head; map.put(key, newNode); }
// @return an integer public int get(int key) { // write your code here if (!map.containsKey(key)) return -1; Node node = map.get(key); node.previous.next = node.next; node.next.previous = node.previous; node.next = head.next; head.next = node; node.next.previous = node; node.previous = head; return node.value; }
public boolean insert(T data) { if (null == head) { head = tail = new Node(data); return true; } Node newNode = new Node(data); newNode.previous = tail; tail.next = newNode; tail = newNode; return true; }
public boolean insert(int index, T data) { if ((index > size()) || (index < 0)) { return false; } Node n = new Node(data); if (index == 0) { if (null == head) { head = tail = n; return true; } head.previous = n; n.next = head; head = n; return true; } if (index == size()) { tail.next = n; n.previous = tail; tail = n; return true; } Node pNode = head; for (int i = 0; i < index; i++) { pNode = pNode.next; } pNode = pNode.previous; pNode.next.previous = n; n.next = pNode.next; n.previous = pNode; pNode.next = n; return true; }
/** * add the item to the end * * @param item generic item ready to add to deque */ public void addLast(Item item) { if (item == null) throw new java.lang.NullPointerException(); Node currentNode = new Node(); currentNode.item = item; currentNode.previous = lastNode; if (isEmpty()) { firstNode = currentNode; } else { lastNode.next = currentNode; } lastNode = currentNode; N++; }
public void addFirst(Item item) { if (item == null) { throw new java.lang.NullPointerException(); } Node newNode = new Node(); newNode.item = item; newNode.next = this.front; newNode.previous = null; if (!isEmpty()) this.front.previous = newNode; else this.rear = newNode; this.front = newNode; size++; }
/** Adds a new item at the start of the sequence. */ public void insertFirst(Object o) { // There is a special case when the sequence is empty. // Then the both the head and tail pointers needs to be // initialised to reference the new node. if (listHead == null) { listHead = new Node(o, listHead, null); listTail = listHead; } // In the general case, we simply add a new node at the start // of the list via the head pointer. else { listHead.previous = new Node(o, listHead, null); listHead = listHead.previous; } }
/** * Get the value associated with the key. * * @param key * @return the value associated with the key. null if the key doesn't exist */ public V get(K key) { Node<K, V> current = head.next; // traver the list and find a match. On found, move this match to the // top of this list. while (current != tail) { if (current.key.equals(key)) { current.previous.next = current.next; current.next.previous = current.previous; current.next = head.next; current.previous = head; head.next.previous = current; head.next = current; return current.value; } current = current.next; } return null; }
public void addFirst(Item item) throws NullPointerException { // null item addition if (item == null) { throw new NullPointerException(); } Node oldFirst = this.first; this.first = new Node(); this.first.previous = null; this.first.item = item; this.first.next = oldFirst; if (this.size++ == 0) { // in the case of an empty queue oldFirst == null && last = first this.last = this.first; } else { // it is the non-empty queue case so the oldFirst != null... oldFirst.previous = this.first; } }
/** Removes the item at the start of the sequence. */ public void deleteFirst() throws SequenceDLListException { // Check there is something in the sequence to delete. if (listHead == null) { throw new SequenceDLListException("Sequence Underflow"); } // There is a special case when there is just one item in the // sequence. Both pointers then need to be reset to null. if (listHead.next == null) { listHead = null; listTail = null; } // In the general case, we just unlink the first node of the // list. else { listHead = listHead.next; listHead.previous = null; } }
public boolean remove(int position) { if ((position < 0) || (position >= size())) return false; if (null == head) return false; if (position == 0) { if (null == head.next) { head = tail = null; return true; } Node n = head; n = null; head = head.next; head.previous = null; return true; } if (position == (size() - 1)) { Node n = tail; tail.previous.next = null; tail = tail.previous; n = null; return true; } Node n = head; for (int i = 0; i < position; i++) { n = n.next; } n = n.previous; n.previous.next = n.next; // VB : Dont do multiple references as you usually miss null check. Please use // temporary variable and do null check n.next.previous = n.previous; // VB: Not necessary but good to mark the deleted node's next and prev pointer as null n = null; // VB: no need to mark n as null, as n is local variable return true; }
void remove(int num) { if (first == null) return; assert first != null; if (first.contents == num) { first = first.next; if (first != null) first.previous = null; } assert first.contents != num; Node tmp = first; while (tmp != null && tmp.contents < num) tmp = tmp.next; if (tmp == null) return; assert tmp != null; if (tmp.contents > num) return; assert tmp.contents <= num; tmp.previous.next = tmp.next; if (tmp.next != null) tmp.next.previous = tmp.previous; }
/** * Removes the item from the start of the deque. Will throw an exception if the deque is empty. * After the successful removal, this function will return the item that just got removed. * * @return The item that just got removed */ public Item removeFirst() { if (isEmpty()) { throw new NoSuchElementException(); } Item itemToReturn = first.item; first = first.next; // Clear whatever previous value we might have if (first != null && first.previous != null) { first.previous = null; } // Have we just emptied out the deque? if (first == null) { last = null; } N--; return itemToReturn; }
/** Adds a new item at a specified position in the sequence. */ public void insert(Object o, int index) throws SequenceDLListException { // Check the index is positive. if (index < 0) { throw new SequenceDLListException("Indexed Element out of Range"); } // There is a special case when the sequence is empty. // Then the both the head and tail pointers needs to be // initialised to reference the new node. if (listHead == null) { if (index == 0) { listHead = new Node(o, listHead, null); listTail = listHead; } else { throw new SequenceDLListException("Indexed element is out of range"); } } // There is another special case for insertion at the head of // the sequence. else if (index == 0) { listHead.previous = new Node(o, listHead, null); listHead = listHead.previous; } // In the general case, we need to chain down the linked list // from the head until we find the location for the new // list node. If we reach the end of the list before finding // the specified location, we know that the given index was out // of range and throw an exception. else { Node nodePointer = listHead; int i = 1; while (i < index) { nodePointer = nodePointer.next; i += 1; if (nodePointer == null) { throw new SequenceDLListException("Indexed Element out of Range"); } } // Now we've found the node before the position of the // new one, so we 'hook in' the new Node. nodePointer.next = new Node(o, nodePointer.next, nodePointer); // set the previous Node on the Node one above the new Node // ensure that this doesn't occur when adding to the last entry in // the list if (nodePointer.next.next != null) { nodePointer.next.next.previous = nodePointer.next; } // Finally we need to check that the tail pointer is // correct. Another special case occurs if the new // node was inserted at the end, in which case, we need // to update the tail pointer. if (nodePointer == listTail) { listTail = listTail.next; } } }