chapter 05: [LinkedLists]

Author: loiane

src/ts/data-structures/circular-linked-list.ts

@@ -3,7 +3,6 @@ import LinkedList from './linked-list';
 import { Node } from './models/linked-list-models';
 
 export default class CircularLinkedList<T> extends LinkedList<T> {
-
   constructor(protected equalsFn: IEqualsFunction<T> = defaultEquals) {
     super(equalsFn);
   }
@@ -24,9 +23,7 @@ export default class CircularLinkedList<T> extends LinkedList<T> {
       this.head = node;
     } else {
       current = this.getLastElement();
-      if (current != null) {
-        current.next = node;
-      }
+      current.next = node;
     }
 
     // set node.next to head - to have circular list
@@ -35,7 +32,7 @@ export default class CircularLinkedList<T> extends LinkedList<T> {
     this.count++;
   }
 
-  insert(index: number, element: T) {
+  insert(element: T, index: number) {
     if (index >= 0 && index <= this.count) {
       const node = new Node(element);
       let current = this.head;
@@ -50,16 +47,12 @@ export default class CircularLinkedList<T> extends LinkedList<T> {
           current = this.getLastElement();
           // update last element
           this.head = node;
-          if (current != null) {
-            current.next = this.head;
-          }
+          current.next = this.head;
         }
       } else {
         const previous = this.getElementAt(index - 1);
-        if (previous != null) {
-          node.next = previous.next;
-          previous.next = node;
-        }
+        node.next = previous.next;
+        previous.next = node;
       }
       this.count++;
       return true;
@@ -78,28 +71,18 @@ export default class CircularLinkedList<T> extends LinkedList<T> {
           this.head = undefined;
         } else {
           current = this.getLastElement();
-          if (this.head != null) {
-            this.head = this.head.next;
-          }
-          if (current != null) {
-            current.next = this.head;
-          }
+          this.head = this.head.next;
+          current.next = this.head;
           current = removed;
         }
       } else {
         // no need to update last element for circular list
         const previous = this.getElementAt(index - 1);
-        if (previous != null) {
-          current = previous.next;
-          if (current != null) {
-            previous.next = current.next;
-          }
-        }
-      }
-      if (current != null) {
-        this.count--;
-        return current.element;
+        current = previous.next;
+        previous.next = current.next;
       }
+      this.count--;
+      return current.element;
     }
     return undefined;
   }

src/ts/data-structures/doubly-linked-list.ts

@@ -18,16 +18,14 @@ export default class DoublyLinkedList<T> extends LinkedList<T> {
       this.tail = node; // NEW
     } else {
       // attach to the tail node // NEW
-      if (this.tail != null) {
-        this.tail.next = node;
-        node.prev = this.tail;
-        this.tail = node;
-      }
+      this.tail.next = node;
+      node.prev = this.tail;
+      this.tail = node;
     }
     this.count++;
   }
 
-  insert(index: number, element: T) {
+  insert(element: T, index: number) {
     if (index >= 0 && index <= this.count) {
       const node = new DoublyNode(element);
       let current = this.head;
@@ -46,23 +44,17 @@ export default class DoublyLinkedList<T> extends LinkedList<T> {
         // last item // NEW
 
         current = this.tail; // {2}
-        if (current != null) {
-          current.next = node;
-          node.prev = current;
-          this.tail = node;
-        }
+        current.next = node;
+        node.prev = current;
+        this.tail = node;
       } else {
         const previous = this.getElementAt(index - 1);
-        if (previous != null) {
-          current = previous.next;
-          node.next = current;
-          previous.next = node;
-
-          if (current != null) {
-            current.prev = node; // NEW
-            node.prev = previous; // NEW
-          }
-        }
+        current = previous.next;
+        node.next = current;
+        previous.next = node;
+
+        current.prev = node; // NEW
+        node.prev = previous; // NEW
       }
       this.count++;
       return true;
@@ -75,44 +67,28 @@ export default class DoublyLinkedList<T> extends LinkedList<T> {
       let current = this.head;
 
       if (index === 0) {
-        if (this.head != null) {
-          this.head = this.head.next; // {1}
-          // if there is only one item, then we update tail as well //NEW
-          if (this.count === 1) {
-            // {2}
-            this.tail = undefined;
-          } else {
-            if (this.head != null) {
-              this.head.prev = undefined; // {3}
-            }
-          }
+        this.head = this.head.next; // {1}
+        // if there is only one item, then we update tail as well //NEW
+        if (this.count === 1) {
+          // {2}
+          this.tail = undefined;
+        } else {
+          this.head.prev = undefined; // {3}
         }
       } else if (index === this.count - 1) {
         // last item //NEW
         current = this.tail; // {4}
-        if (current != null) {
-          this.tail = current.prev;
-          if (this.tail) {
-            this.tail.next = undefined;
-          }
-        }
+        this.tail = current.prev;
+        this.tail.next = undefined;
       } else {
         current = this.getElementAt(index);
-        if (current != null) {
-          const previous = current.prev;
-          if (previous != null) {
-            // link previous with current's next - skip it to remove
-            previous.next = current.next; // {6}
-            if (current != null && current.next != null) {
-              current.next.prev = previous; // NEW
-            }
-          }
-        }
-      }
-      if (current != null) {
-        this.count--;
-        return current.element;
+        const previous = current.prev;
+        // link previous with current's next - skip it to remove
+        previous.next = current.next; // {6}
+        current.next.prev = previous; // NEW
       }
+      this.count--;
+      return current.element;
     }
     return undefined;
   }

src/ts/data-structures/linked-list.ts

@@ -1,20 +1,18 @@
-import { defaultCompare, defaultEquals, ICompareFunction, IEqualsFunction } from '../util';
+import { defaultEquals, IEqualsFunction } from '../util';
 import { Node } from './models/linked-list-models';
 
 export default class LinkedList<T> {
   protected count = 0;
   protected head: Node<T> | undefined;
 
-  constructor(
-    protected equalsFn: IEqualsFunction<T> = defaultEquals,
-    protected compareFn: ICompareFunction<T> = defaultCompare
-  ) {}
+  constructor(protected equalsFn: IEqualsFunction<T> = defaultEquals) {}
 
   push(element: T) {
     const node = new Node(element);
     let current;
 
-    if (this.head == null) { // catches null && undefined
+    if (this.head == null) {
+      // catches null && undefined
       this.head = node;
     } else {
       current = this.head;
@@ -31,17 +29,15 @@ export default class LinkedList<T> {
   getElementAt(index: number) {
     if (index >= 0 && index <= this.count) {
       let node = this.head;
-      for (let i = 0; i < index; i++) {
-        if (node != null) {
-          node = node.next;
-        }
+      for (let i = 0; i < index && node != null; i++) {
+        node = node.next;
       }
       return node;
     }
     return undefined;
   }
 
-  insert(index: number, element: T) {
+  insert(element: T, index: number) {
     if (index >= 0 && index <= this.count) {
       const node = new Node(element);
       const current = this.head;
@@ -51,61 +47,28 @@ export default class LinkedList<T> {
         this.head = node;
       } else {
         const previous = this.getElementAt(index - 1);
-        if (previous != null) {
-          node.next = previous.next;
-          previous.next = node;
-        }
+        node.next = previous.next;
+        previous.next = node;
       }
       this.count++;
       return true;
     }
     return false;
   }
 
-  insertSorted(element: T) {
-    if (this.isEmpty()) {
-      this.push(element);
-    } else {
-      const index = this.getIndexNextSortedElement(element);
-      this.insert(index, element);
-    }
-  }
-
-  private getIndexNextSortedElement(element: T) {
-    let current = this.head;
-
-    for (let i = 0; i < this.size() && current; i++) {
-      const comp = this.compareFn(element, current.element);
-      if (comp >= 0) {
-        return i;
-      }
-      current = current.next;
-    }
-
-    return -1;
-  }
-
   removeAt(index: number) {
     if (index >= 0 && index < this.count) {
       let current = this.head;
 
       if (index === 0) {
-        if (this.head != null) {
-          this.head = this.head.next;
-        }
+        this.head = current.next;
       } else {
         const previous = this.getElementAt(index - 1);
-        if (previous != null) {
-          current = previous.next;
-          if (current != null) {
-            previous.next = current.next;
-          }
-        }
-      }
-      if (current != null) {
-        this.count--;
-        return current.element;
+        current = previous.next;
+        previous.next = current.next;
       }
+      this.count--;
+      return current.element;
     }
     return undefined;
   }

src/ts/data-structures/sorted-linked-list.ts

@@ -0,0 +1,43 @@
+import { Compare, defaultCompare, defaultEquals, ICompareFunction, IEqualsFunction } from '../util';
+import LinkedList from './linked-list';
+
+export default class SortedLinkedList<T> extends LinkedList<T> {
+  constructor(
+    protected equalsFn: IEqualsFunction<T> = defaultEquals,
+    protected compareFn: ICompareFunction<T> = defaultCompare
+  ) {
+    super(equalsFn);
+  }
+
+  push(element: T) {
+    if (this.isEmpty()) {
+      super.push(element);
+    } else {
+      const index = this.getIndexNextSortedElement(element);
+      super.insert(element, index);
+    }
+  }
+
+  insert(element: T, index: number = 0) {
+    if (this.isEmpty()) {
+      return super.insert(element, 0);
+    }
+    index = this.getIndexNextSortedElement(element);
+    return super.insert(element, index);
+  }
+
+  private getIndexNextSortedElement(element: T) {
+    let current = this.head;
+    let i = 0;
+
+    for (; i < this.size() && current; i++) {
+      const comp = this.compareFn(element, current.element);
+      if (comp === Compare.LESS_THAN) {
+        return i;
+      }
+      current = current.next;
+    }
+
+    return i;
+  }
+}

src/ts/index.ts

@@ -1,8 +1,10 @@
+import * as _util from './util';
+
 export { default as CircularLinkedList } from './data-structures/circular-linked-list';
 export { default as DoublyLinkedList } from './data-structures/doubly-linked-list';
 export { default as LinkedList } from './data-structures/linked-list';
+export { default as SortedLinkedList } from './data-structures/sorted-linked-list';
 
-import * as _util from './util';
 export const util = _util;
 
 /* import { hotPotato } from './others/hot-potato';