React project

03-javascript/datastructures/queue/queue.mjs

@@ -1,34 +1,67 @@
+import { Stack } from "../stack/stack.mjs";
 // Queue class for basic queue operations
-class Queue {
+
+export class Queue {
   constructor() {
     this.items = [];
   }
 
   enqueue(element) {
-    // Implement enqueue operation
+    return this.items.push(element)
   }
 
   dequeue() {
-    // Implement dequeue operation
+    return this.items.shift()
   }
 
   peek() {
-    // Implement peek operation
+    if (this.items.length != 0){
+     return this.items[0]
+    }
+    else{
+      return 'Queue is empty'
+    }
   }
 
   isEmpty() {
-    // Implement isEmpty operation
+    if (this.items.length == 0){
+      return true
+    }
+    else{
+      return false
+    }
   }
 }
 
 // Function to reverse a queue
-function reverseQueue(queue) {
-  // Implement reverseQueue function
+export function reverseQueue(queue) {
+  const stack = new Stack();
+  const obj = new Queue()
+  for(let i in queue){
+    obj.enqueue(queue[i])
+  }
+  while (!obj.isEmpty()) {
+    stack.push(obj.dequeue());
+  }
+  const reversed = [];
+  while (!stack.isEmpty()) {
+    reversed.push(stack.pop());
+  }
+  return reversed;
 }
-
 // Function to check if a string is a palindrome using a queue
-function isPalindrome(input) {
-  // Implement isPalindrome function
+export function isPalindrome(input) {
+  const strSplit = [...input]
+  console.log(typeof(strSplit))
+  console.log(typeof(reverseQueue(input)))
+  console.log(strSplit)
+  console.log(reverseQueue(input))
+  if (strSplit == reverseQueue(input)){
+    return 'it is a palindrone'
+  }
+  else{
+    return 'it is not a palindrone'
+  }
 }
 
 // CircularQueue class for implementing a circular queue
@@ -66,11 +99,4 @@ function simulateQueue(customers, serviceTime) {
   // Implement simulateQueue function
 }
 
-// Exporting the classes and functions for use
-export default {
-  Queue,
-  reverseQueue,
-  isPalindrome,
-  CircularQueue,
-  simulateQueue,
-};
+// Exporting the classes and functions for use

03-javascript/datastructures/queue/scratch.mjs

@@ -0,0 +1,11 @@
+import { reverseQueue } from "./queue.mjs";
+import { Queue } from "./queue.mjs";
+import { isPalindrome } from "./queue.mjs";
+const input = [1,2,3,4,5,6,7]
+console.log(input)
+console.log(reverseQueue(input))
+
+console.log(isPalindrome('aisha'))
+console.log(isPalindrome('racecar'))
+console.log(isPalindrome('madam'))
+console.log(isPalindrome('level'))

03-javascript/datastructures/stack/scratch.mjs

@@ -0,0 +1,8 @@
+import { reverseString } from "./stack.mjs";
+import { isBalanced } from "./stack.mjs";
+import { sortStack } from "./stack.mjs";
+//console.log(reverseString("harsh"))
+//console.log(typeof(reverseString("harsh")))
+//console.log(isBalanced('{)'))
+const input = [5,8,7,9,3,4]
+console.log(sortStack(input))

03-javascript/datastructures/stack/stack.mjs

@@ -0,0 +1,125 @@
+// Stack class for basic stack operations
+export class Stack {
+  constructor() {
+    this.items = [];
+  }
+
+  push(element) {
+    this.items.push(element)
+  }
+
+  pop() {
+    if (this.items.length != 0){
+      return this.items.pop()
+     }
+     else{
+       return 'Stack is empty'
+     }
+  }
+
+  peek() {
+    if (this.items.length != 0){
+      return this.items[this.items.length -1]
+     }
+     else{
+       return 'Stack is empty'
+     }
+  }
+
+  isEmpty() {
+    return this.items.length === 0
+  }
+}
+//const stack = new Stack()
+
+// Function to reverse a string using a stack
+export function reverseString(input) {
+  const stack = new Stack()
+
+  for(let i in input){
+    stack.push(input[i])
+  }
+  const reverse = []
+  while (!stack.isEmpty()){
+    reverse.push(stack.pop())
+  }
+  return reverse.join("")
+}
+
+// Function to check if parentheses are balanced
+export function isBalanced(input) {
+  if (input == reverseString(input)){
+    return true
+  }
+  else{
+    return false
+  }
+}
+// not able to do this one. still trying
+
+// MinStack class to support retrieving the minimum element
+class MinStack extends Stack {
+  constructor() {
+    super();
+    this.minStack = []
+  }
+
+  push(element) {
+    super.push(element)
+    if (this.minStack.length === 0){
+      this.minStack.push(element)
+    }
+    else{
+      if (element <= this.minStack[this.minStack.length -1]){
+        this.minStack.push(element)
+      }
+      else{
+        this.minStack.push(this.minStack[this.minStack.length -1])
+      }
+    }
+  }
+
+  pop() {
+    if (this.length == 0){
+      return 'stack and Minstack is empty'
+    }
+    else{
+      super.pop()
+      this.minStack.pop()
+    }
+  }
+
+  getMin() {
+    if (this.minStack.length === 0){
+      return 'minstack is empty'
+    }
+    else{
+      return this.minStack[this.minStack.length -1]
+    }
+  }
+}
+
+// Function to evaluate a postfix expression
+function evaluatePostfix(expression) {
+  // Implement evaluatePostfix function
+}
+
+// Function to sort a stack using only stack operations
+export function sortStack(stack) {
+  const obj = new Stack();
+  for (let i in stack) {
+    obj.push(stack[i]);
+  }
+  const auxiliaryStack = [];
+  while (!obj.isEmpty()) {
+    let temp = obj.pop(); 
+    while (auxiliaryStack.length > 0 && auxiliaryStack[auxiliaryStack.length - 1] > temp) {
+      let moved = auxiliaryStack.pop();
+      obj.push(moved);
+    }
+    auxiliaryStack.push(temp);
+  }
+  return auxiliaryStack;
+}
+
+// Exporting the functions and classes for use

03-javascript/datastructures/tree/README.md

@@ -74,55 +74,64 @@ In this example:
 ## Practice Assignments 🎯
 
 ### Assignment 1: Tree Height Calculator
+
 **Difficulty: Easy**
 
 **Objective:** Create a function to calculate the height of a binary tree.
 
 **Instructions:**
+
 - Implement a function `getTreeHeight(root)` that takes the root node as input
 - Return the maximum height (depth) of the tree
 - Return 0 for an empty tree
 
 ### Assignment 2: Node Counter
+
 **Difficulty: Easy**
 
 **Objective:** Count the total number of nodes in a binary tree.
 
 **Instructions:**
+
 - Create a function `countNodes(root)` that takes the root node as input
 - Count and return the total number of nodes in the tree
 - Include both leaf nodes and internal nodes in the count
 
 ### Assignment 3: Leaf Node Finder
+
 **Difficulty: Medium**
 
 **Objective:** Find and print all leaf nodes in a binary tree.
 
 **Instructions:**
+
 - Implement a function `findLeafNodes(root)` that takes the root node as input
 - Return an array containing all leaf nodes (nodes with no children)
 - Maintain the order of leaves from left to right
 
 ### Assignment 4: Level Order Traversal
+
 **Difficulty: Medium**
 
 **Objective:** Print nodes level by level, from top to bottom.
 
 **Instructions:**
+
 - Create a function `levelOrderTraversal(root)` that takes the root node as input
 - Print nodes at each level on a new line
 - Use a queue to manage the level-by-level traversal
 
 ### Assignment 5: Tree Mirror
+
 **Difficulty: Medium**
 
 **Objective:** Create a mirror image of a binary tree.
 
 **Instructions:**
+
 - Implement a function `mirrorTree(root)` that takes the root node as input
 - Swap left and right children of all nodes
 - Return the root node of the mirrored tree
 - The original tree structure should be modified in place
 
 Each assignment builds upon the basic binary tree concepts and helps understand different tree operations and traversal techniques.
-