first commit

Author: David Alimazoya

BinarySearchTree.js

@@ -0,0 +1,17 @@
+/*
+ * Is a tree like data structure
+**Rules**
+    *It starts with a root node
+    *each node ca have at most 2 nodes
+    *descreasing items are placed in the left
+    *Ascending items are placed at the right
+    *it uses divide and conquer mode of operation
+    log node = 2^height 
+**Tpes**
+    *Balanced:
+        *each node has 2 siblings 
+        *it is O(log N)
+    *Unbalanced:
+        *each node has unqual siblings
+        *it is O(N)
+ */

DoublyLinkedList.js

@@ -0,0 +1,86 @@
+class DoublyLinkedList {
+    constructor(value) {
+      this.head = {
+        value: value,
+        next: null,
+        prev: null
+      };
+      this.tail = this.head;
+      this.length = 1;
+    }
+    append(value) {
+      const newNode = {
+        value: value,
+        next: null,
+        prev: null
+      }
+      console.log(newNode)
+      newNode.prev = this.tail
+      this.tail.next = newNode;
+      this.tail = newNode;
+      this.length++;
+      return this;
+    }
+    prepend(value) {
+      const newNode = {
+        value: value,
+        next: null,
+        prev: null
+      }
+      newNode.next = this.head;
+      this.head.prev = newNode
+      this.head = newNode;
+      this.length++;
+      return this;
+    }
+    printList() {
+      const array = [];
+      let currentNode = this.head;
+      while(currentNode !== null){
+        array.push(currentNode.value)
+        currentNode = currentNode.next
+      }
+      return array;
+    }
+    insert(index, value){
+      //Check for proper parameters;
+      if(index >= this.length) {
+        return this.append(value);
+      }
+      
+      const newNode = {
+        value: value,
+        next: null,
+        prev: null
+      }
+      const leader = this.traverseToIndex(index-1);
+      const follower = leader.next;
+      leader.next = newNode;
+      newNode.prev = leader;
+      newNode.next = follower;
+      follower.prev = newNode;
+      this.length++;
+      console.log(this)
+      return this.printList();
+    }
+    traverseToIndex(index) {
+      //Check parameters
+      let counter = 0;
+      let currentNode = this.head;
+      while(counter !== index){
+        currentNode = currentNode.next;
+        counter++;
+      }
+      return currentNode;
+    }
+  }
+  
+  let myLinkedList = new DoublyLinkedList(10);
+  myLinkedList.append(5)
+  myLinkedList.append(16)
+  myLinkedList.prepend(1)
+  myLinkedList.insert(2, 99)
+  // myLinkedList.insert(20, 88)
+  // myLinkedList.printList()
+  // myLinkedList.remove(2)
+  // myLinkedList.reverse()

QueueWithLinkedList.js

@@ -0,0 +1,62 @@
+class Node {
+    constructor(value){
+      this.value = value;
+      this.next = null;
+    }
+  }
+  
+  class Queue {
+    constructor(){
+      this.first = null;
+      this.last = null;
+      this.length = 0;
+    }
+    peek() {
+      return this.first;
+    }
+    enqueue(value){
+      const newNode = new Node(value);
+      if (this.length === 0) {
+        this.first = newNode;
+        this.last = newNode;
+      } else {
+        this.last.next = newNode;
+        this.last = newNode;
+      }
+      this.length++;
+      return this.printList();
+    }
+    dequeue(){
+      if (!this.first) {
+        return null;
+      }
+      if (this.first === this.last) {
+        this.last = null;
+      }
+      const holdingPointer = this.first;
+      this.first = this.first.next;
+      this.length--;
+      return this;
+    }
+    printList(){
+        let current = this.first;
+        let array =[]
+        while (current) {
+            array.push(current.value)
+            current = current.next
+        }
+        return array
+    }
+    //isEmpty;
+  }
+  
+  const myQueue = new Queue();
+  myQueue.peek();
+  myQueue.enqueue('Joy');
+  myQueue.enqueue('Matt');
+  console.log(myQueue.enqueue('Pavel'))
+//   myQueue.peek();
+//   myQueue.dequeue();
+//   myQueue.dequeue();
+//   myQueue.dequeue();
+//   myQueue.peek();

SinglyLiinkedList.js

@@ -0,0 +1,79 @@
+// add a method remove() to the linked list that deletes a node to the specified index.
+
+class LinkedList {
+    constructor(value) {
+      this.head = {
+        value: value,
+        next: null
+      };
+      this.tail = this.head;
+      this.length = 1;
+    }
+    append(value) {
+      const newNode = {
+        value: value,
+        next: null
+      }
+      this.tail.next = newNode;
+      this.tail = newNode;
+      this.length++;
+      return this;
+    }
+    prepend(value) {
+      const newNode = {
+        value: value,
+        next: null
+      }
+      newNode.next = this.head;
+      this.head = newNode;
+      this.length++;
+      return this;
+    }
+    printList() {
+      const array = [];
+      let currentNode = this.head;
+      while(currentNode !== null){
+          array.push(currentNode.value)
+          currentNode = currentNode.next
+      }
+      return array;
+    }
+    insert(index, value){
+      //Check for proper parameters;
+      if(index >= this.length) {
+        console.log('yes')
+        return this.append(value);
+      }
+      
+      const newNode = {
+        value: value,
+        next: null
+      }
+      const leader = this.traverseToIndex(index-1);
+      const holdingPointer = leader.next;
+      leader.next = newNode;
+      newNode.next = holdingPointer;
+      this.length++;
+      return this.printList();
+    }
+    traverseToIndex(index) {
+      //Check parameters
+      let counter = 0;
+      let currentNode = this.head;
+      while(counter !== index){
+        currentNode = currentNode.next;
+        counter++;
+      }
+      return currentNode;
+    }
+  }
+  
+  let myLinkedList = new LinkedList(10);
+  myLinkedList.append(5);
+  myLinkedList.append(16);myLinkedList.prepend(1);
+  myLinkedList.insert(2, 99);
+  myLinkedList.insert(20, 88);
+  
+  
+  
+  

StackWithArrays.js

@@ -0,0 +1,34 @@
+//LIFO
+
+class Stack {
+    constructor(){
+      this.data = [];
+    }
+    peek() {
+       return this.data[this.data.length-1]
+    }
+    push(value){
+        this.data.push(value);
+        return this.data;
+    }
+    pop(){
+       this.data.pop();
+       return this.printList()
+    }
+    printList(){
+       return this.data
+    }
+    isEmpty(){
+        if(this.data.length == 0) return true;
+        return false;
+    }
+  }
+  
+  const myStack = new Stack();
+  myStack.push(12)
+  myStack.push(16)
+  myStack.push(19)
+  //console.log(myStack.printList())
+ // console.log(myStack.peek())
+ console.log(myStack.isEmpty())
+ console.log(myStack.peek())

StackWithLinkedList.js

@@ -0,0 +1,58 @@
+class Node {
+    constructor(value){
+      this.value = value;
+      this.next = null;
+    }
+  }
+  
+  class Stack {
+    constructor(){
+      this.top = null;
+      this.bottom = null;
+      this.length = 0;
+    }
+    peek() {
+      return this.top;
+    }
+    push(value){
+      const newNode = new Node(value);
+      if (this.length === 0) {
+        this.top = newNode;
+        this.bottom = newNode;
+      } else {
+        const holdingPointer = this.top;
+        this.top = newNode;
+        this.top.next = holdingPointer;
+      }
+      this.length++;
+      return this;
+    }
+    pop(){
+      if (!this.top) {
+        return null;
+      }
+      if (this.top === this.bottom) {
+        this.bottom = null;
+      }
+      const holdingPointer = this.top;
+      this.top = this.top.next;
+      this.length--;
+      return this;
+    }
+    //isEmpty
+  }
+  
+  const myStack = new Stack();
+  myStack.peek();
+  myStack.push('google');
+  myStack.push('udemy');
+  myStack.push('discord');
+  myStack.peek();
+  myStack.pop();
+  myStack.pop();
+  myStack.pop();
+  
+  
+  //Discord
+  //Udemy
+  //google

firstRecurringCharacter.js

@@ -0,0 +1,30 @@
+//Google Question
+//Given an 
+//let array = [2,5,1,2,3,5,1,2,4];
+//It should return 2
+
+//Given an 
+// let array = [2,1,1,2,3,5,1,2,4];
+//It should return 1
+
+//Given an 
+let array = [2,3,4,5];
+//It should return undefined
+
+
+function firstRecurringCharacter(input) {
+    let set = new Set();
+    let dup = [];
+    for (let i = 0; i < input.length; i++) {
+       if(set.has(input[i])){
+            dup.push(input[i])
+       } else{
+            set.add(input[i])
+       }
+    }
+    return dup[0]
+}
+
+console.log(firstRecurringCharacter(array))
+
+//O(n)