public static void main(String[] args) {
DoublyLinkedList linkedList = new DoublyLinkedList();
linkedList.print();
linkedList.add(1, 1);
linkedList.add(2, 2);
linkedList.print();
linkedList.remove(1);
linkedList.print();
linkedList.add(3, 2);
linkedList.add(4, 3);
linkedList.print();
linkedList.reversePrint();
/*linkedList.print();
linkedList.reverseWithIteration();
linkedList.print();
linkedList.reverseWithRecursion(linkedList.getHead());
linkedList.print();
System.out.println("Printed using recursion List: ");
linkedList.printWithRecursion(linkedList.getHead());
System.out.println("Print list reverse recursively without actually reversing the list \nList: ");
linkedList.printReverseWithRecursion(linkedList.getHead());*/
/*linkedList.remove(1);
linkedList.print();
linkedList.remove(3);
linkedList.print();*/
}
public static void main(String[] args) {
DoublyLinkedList<Number> doublyLinkedList = new DoublyLinkedList<>();
for (int i = 0; i < 1000000; i++) {
doublyLinkedList.add(i);
}
LinkedList<Number> numbers = new LinkedList<>();
for (int i = 0; i < 1000000; i++) {
numbers.add(i);
}
Timer timer = new Timer();
System.out.println("Addition/remove to/from the beggining test");
System.out.println("==============================");
timer.start();
doublyLinkedList.add(0, 45);
System.out.println("DoublyLinkedList.add(e): " + timer.getElapsedTime());
timer.start();
numbers.add(0, 45);
System.out.println("LinkedList.add(e): " + timer.getElapsedTime());
System.out.println("------------");
timer.start();
doublyLinkedList.remove(0);
System.out.println("DoublyLinkedList.remove(e): " + timer.getElapsedTime());
timer.start();
numbers.remove(0);
System.out.println("LinkedList.remove(e): " + timer.getElapsedTime());
System.out.println("==============================");
System.out.println("Addition/remove to/from the middle test");
System.out.println("==============================");
timer.start();
doublyLinkedList.add(500000, 45);
System.out.println("DoublyLinkedList.add(e): " + timer.getElapsedTime());
timer.start();
numbers.add(500000, 45);
System.out.println("LinkedList.add(e): " + timer.getElapsedTime());
System.out.println("------------");
timer.start();
doublyLinkedList.remove(500000);
System.out.println("DoublyLinkedList.remove(e): " + timer.getElapsedTime());
timer.start();
numbers.remove(500000);
System.out.println("LinkedList.remove(e): " + timer.getElapsedTime());
System.out.println("==============================");
System.out.println("Addition/remove to/from the end test");
System.out.println("==============================");
timer.start();
doublyLinkedList.add(doublyLinkedList.size() - 1, 222);
System.out.println("DoublyLinkedList.add(e): " + timer.getElapsedTime());
timer.start();
numbers.add(numbers.size() - 1, 222);
System.out.println("LinkedList.add(e): " + timer.getElapsedTime());
System.out.println("------------");
timer.start();
doublyLinkedList.remove(doublyLinkedList.size() - 1);
System.out.println("DoublyLinkedList.remove(e): " + timer.getElapsedTime());
timer.start();
numbers.remove(numbers.size() - 1);
System.out.println("LinkedList.remove(e): " + timer.getElapsedTime());
}
public static void main(String[] args) {
DoublyLinkedList<Integer, String> list = new DoublyLinkedList<Integer, String>();
list.add(5, "James");
System.out.println(list.size());
System.out.println(list.get(5));
list.add(5, "Thomas");
System.out.println(list.size());
System.out.println(list.get(5));
}
public Iterable<DirectedEdge> edges() {
DoublyLinkedList<DirectedEdge> list = new DoublyLinkedList<DirectedEdge>();
for (int v = 0; v < V; v++) {
for (DirectedEdge e : adj(v)) {
list.add(e);
}
}
return list;
}
public void testBasicBuildAndGet() {
for (int size = 0; size < 15; ++size) {
final DoublyLinkedList<Integer> list = new DoublyLinkedList<Integer>();
DoublyLinkedList.LinkNode<Integer> prevLinkNode = null;
for (int i = 0; i < size; ++i) {
final DoublyLinkedList.LinkNode<Integer> linkNode = list.add(i);
assertEquals(i, linkNode.getIndex());
assertEquals("i=" + i, (Integer) i, linkNode.getElt());
assertEquals(prevLinkNode, linkNode.getPrev());
assertNull(linkNode.getNext());
assertEquals(i + 1, list.size());
prevLinkNode = linkNode;
}
assertEquals("size=" + size, size, list.size());
for (int i = 0; i < size; ++i) {
assertEquals("i=" + i, (Integer) i, list.get(i));
}
}
}
public void testInsertAndRemove() {
final DoublyLinkedList<Integer> list = new DoublyLinkedList<Integer>();
// 2 5 8
// 1* b2 5 8
// 1 2a *3 5 8
// 1 2 3 4* b5 8
// 1 2 3 4 5 7* b8
// 1 2 3 4 5 6* b7 8
// 1 2 3 4 5 6 7 8a *9
// 1 2 3 4 5 6 7 8 9a *10
// 0* b1 2 3 4 5 6 7 8 9 10
list.add(2).add(5).add(8);
final DoublyLinkedList.LinkNode<Integer> node2 = list.find(2);
node2.push(1);
final DoublyLinkedList.LinkNode<Integer> node3 = node2.add(3);
node3.getNext().push(4).find(8).add(9);
list.add(10);
list.getFirst().push(0);
list.find(8).push(7).push(6);
list.getLast().add(12);
list.add(11, 11);
list.add(13, 13);
assertEquals(14, list.size());
for (int i = 0; i <= 13; ++i) {
assertEquals("i=" + i, (Integer) i, list.get(i));
final DoublyLinkedList.LinkNode<Integer> node = list.getLinkNode(i);
assertEquals(i, node.getIndex());
assertEquals((Integer) i, node.getElt());
}
// test findNext
final DoublyLinkedList.LinkNode<Integer> secondNode2 = list.add(2);
final DoublyLinkedList.LinkNode<Integer> foundSecondNode2 = node2.findNext();
assertEquals(secondNode2, foundSecondNode2);
assertNull(secondNode2.findNext());
secondNode2.add(3); // 0 1 2 3 4 5 6 7 8 9 10 11 12 13 2 3
assertNull(secondNode2.findNext());
// test remove
assertEquals(16, list.size());
assertEquals((Integer) 2, list.remove(14));
assertEquals(15, list.size());
assertEquals((Integer) 3, list.remove(14));
assertEquals(14, list.size());
for (int i = 0; i <= 13; ++i) {
assertEquals("i=" + i, (Integer) i, list.get(i));
final DoublyLinkedList.LinkNode<Integer> node = list.getLinkNode(i);
assertEquals(i, node.getIndex());
assertEquals((Integer) i, node.getElt());
}
// completely drain the list
for (int i = 0; i < 14; ++i) {
assertEquals("i=" + i, (Integer) i, list.remove(0));
assertEquals(13 - i, list.size());
}
}
