// finds the starting node of the cycle
  public LinkedListNode findLoopStart(LinkedList list) {
    LinkedListNode slowPtr = list.getHead(), fastPtr = list.getHead();
    boolean cyclic = false;
    while (slowPtr != null && fastPtr != null) {
      fastPtr = fastPtr.getNext();
      if (fastPtr == slowPtr) {
        cyclic = true;
        break;
      }
      if (fastPtr == null) {
        cyclic = false;
        break;
      }
      fastPtr = fastPtr.getNext();
      if (fastPtr == slowPtr) {
        cyclic = true;
        break;
      }
      slowPtr = slowPtr.getNext();
    }

    // if cycle exists
    if (cyclic) {
      slowPtr = list.getHead();
      while (slowPtr != fastPtr) {
        slowPtr = slowPtr.getNext();
        fastPtr = fastPtr.getNext();
      }
      return slowPtr;
    }
    return null;
  }
Beispiel #2
0
  public void insertAfter(final LinkedListNode existingNode, final LinkedListNode newNode) {
    if (newNode.getPrevious() != null || newNode.getNext() != null) {
      // do nothing if this node is already inserted somewhere
      return;
    }

    if (existingNode == null) {
      if (this.isEmpty()) {
        this.firstNode = newNode;
        this.lastNode = newNode;
      } else {
        // if existing node is null, then insert it as a first node
        final LinkedListNode node = this.firstNode;
        node.setPrevious(newNode);
        newNode.setNext(node);
        this.firstNode = newNode;
      }
    } else if (existingNode == this.lastNode) {
      existingNode.setNext(newNode);
      newNode.setPrevious(existingNode);
      this.lastNode = newNode;
    } else {
      (existingNode.getNext()).setPrevious(newNode);
      newNode.setNext(existingNode.getNext());
      existingNode.setNext(newNode);
      newNode.setPrevious(existingNode);
    }
    this.size++;
  }
 // find length of the loop
 public int findLoopLength(LinkedList list) {
   boolean cyclic = false;
   int length = 0;
   LinkedListNode slowPtr = list.getHead(), fastPtr = list.getHead();
   while (fastPtr != null && slowPtr != null) {
     fastPtr = fastPtr.getNext();
     if (fastPtr == slowPtr) {
       cyclic = true;
       break;
     }
     if (fastPtr == null) {
       break;
     }
     fastPtr = fastPtr.getNext();
     if (fastPtr == slowPtr) {
       cyclic = true;
       break;
     }
     slowPtr = slowPtr.getNext();
   }
   if (cyclic) {
     while (slowPtr != fastPtr) {
       slowPtr = slowPtr.getNext();
       length++;
     }
   }
   return length;
 }
  private LinkedListNode getLastNode(LinkedListNode node) {

    while (node.getNext() != null) {
      node = node.getNext();
    }

    return node;
  }
 /** Remove tail node */
 public void deleteLast() {
   // set a LinkedListNode to get the current Node
   LinkedListNode<T> currentNode = head;
   // when the next to next node is null
   while (currentNode.getNext().getNext() != null) {
     currentNode = currentNode.getNext();
   }
   // set the current node to be null
   currentNode.setNext(null);
 }
 /** Get the tail node of the list. */
 public LinkedListNode<T> getLastNode() {
   // set a LinkedListNode to get the current Node
   LinkedListNode<T> currentNode = head;
   // As long as there is a node with data after the current Node
   while (currentNode.getNext() != null) {
     // shift to set the next node as the current Node
     currentNode = currentNode.getNext();
   }
   // When there is no node after the current Node return the data in the
   // current Node
   return currentNode;
 }
 // Floyd's algorithm
 public boolean isCyclic(LinkedList list) {
   LinkedListNode slowPtr = list.getHead(), fastPtr = list.getHead();
   while (fastPtr != null && slowPtr != null) {
     fastPtr = fastPtr.getNext();
     if (fastPtr == slowPtr) return true;
     if (fastPtr == null) return false;
     fastPtr = fastPtr.getNext();
     if (fastPtr == slowPtr) return true;
     slowPtr = slowPtr.getNext();
   }
   return false;
 }
Beispiel #8
0
 /**
  * Removes a <code>LinkedListNode</code> from the list. This works by attach the previous
  * reference to the child reference. When the node to be removed is the first node it calls <code>
  * removeFirst()</code>. When the node to be removed is the last node it calls <code>removeLast()
  * </code>.
  *
  * @param node The <code>LinkedListNode</code> to be removed.
  */
 public void remove(final LinkedListNode node) {
   if (this.firstNode == node) {
     removeFirst();
   } else if (this.lastNode == node) {
     removeLast();
   } else {
     node.getPrevious().setNext(node.getNext());
     (node.getNext()).setPrevious(node.getPrevious());
     this.size--;
     node.setPrevious(null);
     node.setNext(null);
   }
 }
Beispiel #9
0
 public int hashCode() {
   final int PRIME = 31;
   int result = 1;
   for (LinkedListNode node = this.firstNode; node != null; node = node.getNext()) {
     result = PRIME * result + node.hashCode();
   }
   return result;
 }
 /** Insert a new node with data after currentNode */
 public void insertAfter(LinkedListNode<T> currentNode, T data) {
   // create a new linkedListNode
   LinkedListNode<T> newNode = new LinkedListNode<T>();
   // assign that node some data
   newNode.setData(data);
   // point new node where current pointer is
   newNode.setNext(currentNode.getNext());
   // set head pointer to this new node
   currentNode.setNext(newNode);
 }
 public static void traverse(LinkedListNode head) {
   if (head == null) return;
   StringBuffer buffer = new StringBuffer();
   while (head != null) {
     buffer.append(head.getData() + "->");
     // remember to move
     head = head.getNext();
   }
   buffer.append("null");
   System.out.println(buffer.toString());
 }
 /** Return the number of nodes in this list. */
 public int size() {
   // set a LinkedListNode to get the current Node
   LinkedListNode<T> currentNode = head;
   int listSize = 0;
   // As long as there is a node with data after the current Node
   while (currentNode != null) {
     listSize = listSize + 1;
     // shift to set the next node as the current Node
     currentNode = currentNode.getNext();
   }
   return listSize;
 }
 public static LinkedListNode NumbersAddition(LinkedListNode n1, LinkedListNode n2) {
   // number 1 and number 2 may not have the same number of digits.
   if (n1 == null || n2 == null) return null;
   LinkedListNode sumHead = null;
   LinkedListNode sumTail = null;
   int advance = 0;
   while (n1 != null || n2 != null) {
     int digitSum = 0;
     if (n1 != null && n2 != null) digitSum = n1.getData() + n2.getData() + advance;
     else if (n1 == null) digitSum = n2.getData() + advance;
     else digitSum = n1.getData() + advance;
     if (digitSum >= 10) {
       advance = 1;
       digitSum = digitSum % 10;
     } else {
       advance = 0;
     }
     LinkedListNode dSum = new LinkedListNode();
     dSum.setData(digitSum);
     if (sumHead == null) sumHead = dSum;
     if (sumTail == null) {
       sumTail = dSum;
     } else {
       sumTail.setNext(dSum);
       sumTail = dSum;
     }
     // move n1 and n2 under certain conditions!
     if (n1 != null) n1 = n1.getNext();
     if (n2 != null) n2 = n2.getNext();
   }
   if (advance == 1) {
     LinkedListNode last = new LinkedListNode();
     last.setData(advance);
     sumTail.setNext(last);
     sumTail = last;
   }
   return sumHead;
 }
Beispiel #14
0
  public boolean equals(final Object object) {
    if (object == this) {
      return true;
    }

    if (object == null || !(object instanceof LinkedList)) {
      return false;
    }

    final LinkedList other = (LinkedList) object;

    if (this.size() != other.size()) {
      return false;
    }

    for (LinkedListNode thisNode = this.firstNode, otherNode = other.firstNode;
        thisNode != null && otherNode != null;
        thisNode = thisNode.getNext(), otherNode = otherNode.getNext()) {
      if (!thisNode.equals(otherNode)) {
        return false;
      }
    }
    return true;
  }
Beispiel #15
0
 /**
  * Remove the first node from the list. The next node then becomes the first node. If this is the
  * last node then both first and last node references are set to null.
  *
  * @return The first <code>LinkedListNode</code>.
  */
 public LinkedListNode removeFirst() {
   if (this.firstNode == null) {
     return null;
   }
   final LinkedListNode node = this.firstNode;
   this.firstNode = node.getNext();
   node.setNext(null);
   if (this.firstNode != null) {
     this.firstNode.setPrevious(null);
   } else {
     this.lastNode = null;
   }
   this.size--;
   return node;
 }
 /** Return a String representation of the list. */
 public String toString() {
   // set a LinkedListNode to get the current Node
   LinkedListNode<T> currentNode = head;
   String s = "{";
   // As long as there is a node with data after the current Node
   while (currentNode != null) {
     s = s + " " + currentNode.getData();
     // shift to set the next node as the current Node
     currentNode = currentNode.getNext();
   }
   // When there is no node after the current Node return the data in the
   // current Node
   s = s + "}";
   System.out.println("The list is " + s);
   return s;
 }
 /**
  * Remove node following currentNode If no node exists (i.e., currentNode is the tail), do nothing
  */
 public void deleteNext(LinkedListNode<T> currentNode) {
   // update pointer of the current node to the next next
   currentNode.setNext(currentNode.getNext().getNext());
 }
 /** Remove head node */
 public void deleteFirst() {
   // change the pointer of the head pointer
   head = head.getNext();
 }