added few more challenged

Author: varun93

tree.js

@@ -0,0 +1,79 @@
+class Node {
+  constructor(value) {
+    this.value = value;
+    this.children = [];
+  }
+}
+
+// const current_level = parent_level + 1;
+const listNodesAtLevel = (root, level) => {
+  const list = [];
+  const queue = [];
+};
+
+//can do via bfs too
+const countSum = root => {
+  if (root === null) {
+    return 0;
+  }
+  let sum = 0;
+  const { children } = root;
+
+  sum = sum + root.value;
+
+  for (let index = 0; index < children.length; index++) {
+    sum += countSum(children[index]);
+  }
+
+  return sum;
+};
+
+const leavesCount = root => {
+  if (root === null) return 0;
+
+  let count = 0;
+
+  const { children } = root;
+
+  if (children.length === 0) return 1;
+
+  for (let index = 0; index < children.length; index++) {
+    count += leavesCount(children[index]);
+  }
+  return count;
+};
+
+const leavesCountBfs = root => {
+  const queue = [];
+  let leavesCount = 0;
+  queue.push(root);
+  while (queue.length) {
+    const front = queue.shift();
+    const { children } = front;
+    if (children.length === 0) {
+      leavesCount++;
+    } else {
+      children.forEach(child => {
+        queue.push(child);
+      });
+    }
+  }
+
+  return leavesCount;
+};
+
+const root = new Node(2);
+
+const children = [];
+
+const one = new Node(3);
+const two = new Node(4);
+const three = new Node(5);
+
+children.push(one);
+children.push(two);
+children.push(three);
+
+root.children = children;
+
+console.log(countSum(root));

tuts/data-structures/heap/index.js

@@ -0,0 +1,29 @@
+const swap = (heap, aIndex, bIndex) => {
+  const temp = heap[aIndex];
+  heap[aIndex] = heap[bIndex];
+  heap[bIndex] = temp;
+};
+
+const insert = (heap, element) => {
+  const parentIndex = Math.floor((index - 1) / 2);
+  let swapIndex = null;
+
+  heap[index] = element;
+
+  if (heap[parentIndex] !== undefined && heap[parentIndex] < heap[index]) {
+    swap(heap, parentIndex, index);
+    swapIndex = index;
+  }
+
+  if (swapIndex) {
+    insert(heap, swapIndex, heap[swapIndex]);
+  }
+};
+
+const heap = [];
+insert(heap, 2);
+insert(heap, 1);
+insert(heap, 5);
+insert(heap, 9);
+
+console.log(heap);

tuts/data-structures/queue/.crossbar/key.priv

@@ -0,0 +1,7 @@
+Crossbar.io node private key - KEEP THIS SAFE!
+
+creator: root@2085fffc81f2
+created-at: 2019-03-18T18:44:35.881Z
+machine-id: 2085fffc81f2
+public-key-ed25519: c395bd0430dc7bd103b4b12c3cac4595a7ea511ab4d39d84dbe4c4e2bb9c12fd
+private-key-ed25519: 652050d2f7b8de15f0cd54afed4c6a41c99962bbfc564f133431fcbee5388b3c

tuts/data-structures/queue/.crossbar/key.pub

@@ -0,0 +1,6 @@
+Crossbar.io node public key
+
+creator: root@2085fffc81f2
+created-at: 2019-03-18T18:44:35.881Z
+machine-id: 2085fffc81f2
+public-key-ed25519: c395bd0430dc7bd103b4b12c3cac4595a7ea511ab4d39d84dbe4c4e2bb9c12fd

tuts/data-structures/queue/index.js

@@ -0,0 +1,18 @@
+class RingBuffer {
+  constructor() {
+    this.head = -1;
+    this.tail = -1;
+    this.size = 7;
+    this.buffer = [];
+  }
+  read() {
+    if(this.tail)
+  }
+  write(data) {
+    this.head = (this.head + 1) % this.size;
+     
+  }
+}
+
+const ringBuffer = new RingBuffer();
+ringBuffer.write(1);

tuts/data-structures/ring-buffer/solution.js

@@ -0,0 +1,44 @@
+class Stack {
+  constructor(capacity = 5) {
+    this.top = -1;
+    this.data = new Array(capacity);
+  }
+
+  isEmpty() {
+    return this.top === -1;
+  }
+
+  isFull() {
+    return this.top === this.data.length;
+  }
+
+  push(value) {
+    if (this.isFull()) {
+      return;
+    }
+    this.data[++this.top] = value;
+  }
+
+  pop() {
+    if (this.isEmpty()) {
+      return false;
+    }
+    return this.data[this.top--];
+  }
+
+  peek() {
+    return this.data[this.top];
+  }
+}
+
+const stack = new Stack(5);
+stack.push(1);
+console.log(stack.peek());
+stack.push(2);
+console.log(stack.peek());
+stack.push(3);
+console.log(stack.peek());
+stack.push(4);
+console.log(stack.peek());
+stack.push(5);
+console.log(stack.peek());