new commit

bpquigley · bpquigley · commit 86fc8de3b6c2 · 2021-06-15T22:00:13.000-04:00
diff --git a/module-2-programming-project.html b/module-2-programming-project.html
@@ -136,7 +136,7 @@
 edibleQueue.enqueue('Apples', true);
 edibleQueue.enqueue('Peas', false);
 edibleQueue.enqueue('Oranges', true);
-var foodItem = edibleQueue.dequeue();
+var foodItem = objedibleQueue.dequeue();
 //console.log(foodItem.toString());
 //console.log(foodItem);
 console.log(edibleQueue.items);
diff --git a/module-3-programming-assignment.html b/module-3-programming-assignment.html
@@ -0,0 +1,241 @@
+<!doctype html>
+<html>
+<head>
+<meta charset="utf-8">
+<title>CMPS 260: Module 3 Programming Assignment</title>
+<style>* { font-family: monospace; }</style>
+<script>
+
+// NOTE: You must implement the data structures using the no prototype approach.
+//       This is what the book uses, so you can copy it.
+//       See also: https://it.pointpark.edu/tutorials/no-prototype-vs-prototype/
+
+// NOTE: Please review the following links regularly:
+//       https://it.pointpark.edu/tutorials/arrays-vs-objects/
+//       https://it.pointpark.edu/tutorials/no-prototype-vs-prototype/
+//       https://it.pointpark.edu/tutorials/implementation-vs-interface/
+
+
+
+//--------------------------------//
+// The linked list data structure //
+//--------------------------------//
+console.log("The linked list data structure");
+
+// 1. Suppose you have an array with 1,000 elements and a linked list with 1,000
+//    elements. For both data structures, you want to retrieve the last entry.
+//    Does one data structure complete that operation before the other (i.e.,
+//    is it faster)? If yes, how much faster? If no, why does it take the same
+//    amount of time?
+
+//Answer: A linked list should be faster becasue it doesn't have to traverse
+//the entire array.
+
+//------------------------//
+// Creating a linked list //
+//------------------------//
+console.log("Creating a linked list");
+
+// We are going to implement the linked list data structure described in the
+// book. Instead of using 'let' we use 'var' everywhere. Note that this
+// implementation does not use the prototype (see homework). Here is a skeleton
+// that we will work on completing:
+
+function LinkedList() {
+
+  // helper class
+  var Node = function Node(element) {
+    this.element = element;
+    this.next = null;
+  }
+
+  // store length and head
+  var length = 0;
+  var head = null;
+
+  this.append = function(element) {
+    var node = new Node(element);
+    var current;
+
+    if (head === null) { //first node in the List
+
+      head = node;
+
+    } else {
+
+      current = head;
+      while(current.next) {
+        current = current.next;
+      }
+
+      current.next = node;
+    }
+
+    length++;
+  };
+
+  this.remove = function(element) {
+    // remove a specific element from the list
+    // ...
+  };
+
+  this.removeAt = function(position) {
+
+    if (position > -1 && position < length) {
+      var current = head;
+      var previous;
+      var index = 0;
+
+      if (position === 0) {
+
+        head = current.next;
+
+      } else {
+
+        while (index++ < position ) {
+
+          previous = current;
+          current = current.next;
+
+        }
+
+        previous.next = current.next;
+
+      }
+
+      length--;
+      return current.element;
+
+    } else {
+
+      return null;
+
+    }
+  };
+
+  this.insert = function(position, element) {
+
+    if (position >= 0 && position <= length) {
+      var node = new Node(element);
+      current = head;
+      var previous;
+      index = 0;
+
+      if (position === 0) {
+        node.next = current;
+        head = node;
+
+      } else {
+
+        while (index++ < position) {
+          previous = current;
+          current = current.next;
+        }
+      node.next = current;
+      previous.next = node;
+      }
+
+      length++;
+      return true;
+
+    } else {
+
+      return false;
+
+    }
+  }
+
+  this.toString = function() {
+    // overwrite the default toString method
+    var current = head;
+    var string = "List: ";
+    while (current) {
+      string += current.element + (current.next ? " -> " : "");
+      current = current.next;
+    }
+    return string;
+  };
+
+  this.indexOf = function(element) {
+
+    var current = head;
+    var index = -1;
+
+    while (current) {
+      if (element === current.element) {
+        return index;
+      }
+      index++;
+      current = current.next;
+    }
+    return -1;
+  }; //end of indexOf()
+
+  this.isEmpty = function() {
+    return length === 0;
+  };
+
+  this.size = function() {
+    return length;
+  };
+
+  this.getHead = function() {
+    return head;
+  };
+
+  this.print = function() {
+    // print to the console
+    console.log(this.toString());
+  };
+
+
+}; //end of function LinkedList
+
+// create a linked list to operate on
+var list = new LinkedList();
+list.append(25);
+list.append(30);
+list.append(46);
+list.append("hello world");
+list.append(99);
+list.append("pino noir");
+list.indexOf(99);
+list.size();
+list.toString();
+list.insert("malbec");
+list.toString();
+list.isEmpty();
+list.
+// 1. Write pseudo code (meaning; use comments) to describe how you would
+//    implement the append method. HINT: What two scenarios can you distinguish?
+
+
+/*
+pseudo code
+*/
+
+// 2. Translate your pseudo code into actual code and test it.
+//    HINT: Use list.print() to test your code.
+
+// 3. Repeat (1) and (2) for insert.
+
+// 4. Repeat (1) and (2) for removeAt.
+
+// 5. Repeat (1) and (2) for remove.
+
+// 6. Repeat (1) and (2) for indexOf.
+
+// 7. Repeat (1) and (2) for isEmpty.
+
+// 8. Repeat (1) and (2) for size.
+
+// 9. Repeat (1) and (2) for getHead.
+
+
+
+</script>
+</head>
+<body>
+  See console!
+</body>
+</html>
