fix: redo linkedlists, stacks and queues (careercup#61)

This commit fixes the implementations for stacks,
linked lists (singly) and queues, across
Chapter 2, 3, 4 and 7.

Maintains the previous interface for b/c.

Author: profnandaa

chapter02/util/LinkedListX.js

@@ -68,7 +68,9 @@ class LinkedList {
         let first = this.head;
         if (this.head && this.head.next) {
             this.head = this.head.next;
+            first.next = null;
         }
+        else this.head = null;
         return first;
     }
 

chapter03/util/LinkedList.js

@@ -1,6 +1,84 @@
-var LinkedList = function(value) {
-  this.value = value;
-  this.next = null;
-};
+// moved from chapter 2 (/util/LinkedListX.js)
 
-module.exports = LinkedList;
+class Node {
+  constructor(value) {
+      this.value = value
+      this.next = null;
+  }
+}
+
+class LinkedList {
+  constructor() {
+      this.head = null;
+      this.tail = null;
+  }
+
+  append(value) {
+      let node = new Node(value);
+      // if list is empty
+      if (!this.head) {
+          this.head = node;
+          this.tail = node;
+      }
+      else {
+          this.tail.next = node;
+          this.tail = node;
+      }
+  }
+
+  prepend(value) {
+      let node = new Node(value);
+      node.next = this.head;
+      this.head = node;
+  }
+
+  pop() {
+      let cur = this.head;
+
+      // only one or no item exists
+      if (!cur) return null;
+      if (!cur.next) {
+          this.head = null;
+          return cur;
+      }
+      // move till the 2nd last
+      while (cur.next.next)
+          cur = cur.next;
+      
+      let last = this.tail;
+      this.tail = cur;
+      this.tail.next = null;
+      return last;
+  }
+
+  popFirst() {
+      let first = this.head;
+      if (this.head && this.head.next) {
+          this.head = this.head.next;
+          first.next = null;
+      }
+      else this.head = null;
+      return first;
+  }
+
+  head() {
+      return this.head;
+  }
+
+  tail() {
+      return this.tail;
+  }
+
+  _toArray() {
+      let arr = [];
+      let cur = this.head;
+      while (cur) {
+          arr.push(cur.value);
+          cur = cur.next;
+      }
+
+      return arr;
+  }
+}
+
+module.exports = LinkedList;

chapter03/util/Queue.js

@@ -1,41 +1,36 @@
 // implement a queue using linkedLists
 var LinkedList = require('./LinkedList');
 
-var Queue = function() {
-  this.front = null;
-  this.back = null;
-};
-
-Queue.prototype.add = function(value) {
-  var node = new LinkedList(value);
-  if (this.front === null) {
-    this.front = node;
-    this.back = node;
-  } else {
-    var prevBack = this.back;
-    this.back = node;
-    prevBack.next = this.back;
+class Queue {
+  constructor() {
+    this._list = new LinkedList();
   }
-};
-
-Queue.prototype.remove = function() {
-  var removed = this.front;
-  if (this.front === this.back) {
-    this.front = null;
-    this.back = null;
-  } else {
-    this.front = this.front.next;
+
+  enqueue(value) {
+    this._list.append(value);
+  }
+
+  dequeue() {
+    let node = this._list.popFirst();
+    return node.value;
+  }
+
+  peek() {
+    return this._list.head ? this._list.head.value : null;
+  }
+
+  isEmpty() {
+    return this._list.head == null;
   }
-  return removed !== null ? removed.value : null;
-};
 
-Queue.prototype.peek = function() {
-  return this.front !== null ? this.front.value : null;
-};
+  _toArray() {
+    return this._list._toArray();
+  }
+}
 
-Queue.prototype.isEmpty = function() {
-  return this.front === null;
-};
+// alias
+Queue.prototype.add = Queue.prototype.enqueue;
+Queue.prototype.remove = Queue.prototype.dequeue;
 
 module.exports = Queue;
 
@@ -44,8 +39,10 @@ module.exports = Queue;
 // q.add('a');
 // q.add('b');
 // q.add('c');
+// console.log(q._toArray());
 // console.log(q.remove(), 'a');
 // console.log(q.peek(), 'b');
 // console.log(q.remove(), 'b');
 // console.log(q.remove(), 'c');
 // console.log(q.isEmpty(), true);
+// console.log(q._toArray());

chapter03/util/Stack.js

@@ -1,31 +1,40 @@
-// implement a stack using linkedLists
-var LinkedList = require('./LinkedList');
-
-var Stack = function() {
-  this.top = null;
-};
-
-Stack.prototype.push = function(value) {
-  var node = new LinkedList(value);
-  node.next = this.top;
-  this.top = node;
-};
-
-Stack.prototype.pop = function() {
-  var popped = this.top;
-  if (this.top !== null) {
-    this.top = this.top.next;
+// simple implementation of a stack 
+// using an Array
+
+/*
+Interface:
+- push(value)
+- pop()
+- peek()
+- isEmpty()
+- size()
+*/
+class Stack {
+  constructor() {
+    this._data = [];
   }
-  return popped.value;
-};
 
-Stack.prototype.peek = function() {
-  return this.top !== null ? this.top.value : null;
-};
+  size() {
+    return this._data.length;
+  }
+
+  isEmpty() {
+    return this.size() == 0;
+  }
+
+  push(value) {
+    this._data.push(value);
+  }
+
+  pop() {
+    return this._data.pop();
+  }
 
-Stack.prototype.isEmpty = function() {
-  return this.top === null;
-};
+  peek() {
+    if (this.isEmpty()) return null;
+    return this._data[this.size() - 1];
+  }
+}
 
 module.exports = Stack;
 
@@ -39,4 +48,4 @@ module.exports = Stack;
 // console.log(s.peek(), 'b');
 // console.log(s.pop(), 'b');
 // console.log(s.pop(), 'a');
-// console.log(s.isEmpty(), true);
+// console.log(s.isEmpty(), true);

chapter04/util/LinkedList.js

@@ -1,6 +1,84 @@
-var LinkedList = function(value) {
-  this.value = value;
-  this.next = null;
-};
+// moved from chapter 2 (/util/LinkedListX.js)
 
-module.exports = LinkedList;
+class Node {
+  constructor(value) {
+      this.value = value
+      this.next = null;
+  }
+}
+
+class LinkedList {
+  constructor() {
+      this.head = null;
+      this.tail = null;
+  }
+
+  append(value) {
+      let node = new Node(value);
+      // if list is empty
+      if (!this.head) {
+          this.head = node;
+          this.tail = node;
+      }
+      else {
+          this.tail.next = node;
+          this.tail = node;
+      }
+  }
+
+  prepend(value) {
+      let node = new Node(value);
+      node.next = this.head;
+      this.head = node;
+  }
+
+  pop() {
+      let cur = this.head;
+
+      // only one or no item exists
+      if (!cur) return null;
+      if (!cur.next) {
+          this.head = null;
+          return cur;
+      }
+      // move till the 2nd last
+      while (cur.next.next)
+          cur = cur.next;
+      
+      let last = this.tail;
+      this.tail = cur;
+      this.tail.next = null;
+      return last;
+  }
+
+  popFirst() {
+      let first = this.head;
+      if (this.head && this.head.next) {
+          this.head = this.head.next;
+          first.next = null;
+      }
+      else this.head = null;
+      return first;
+  }
+
+  head() {
+      return this.head;
+  }
+
+  tail() {
+      return this.tail;
+  }
+
+  _toArray() {
+      let arr = [];
+      let cur = this.head;
+      while (cur) {
+          arr.push(cur.value);
+          cur = cur.next;
+      }
+
+      return arr;
+  }
+}
+
+module.exports = LinkedList;