6 JavaScript data structures you must know

// Creating an array
const fruits = ["Apple", "Banana", "Cherry"];
// Accessing elements in the array
console.log(fruits[0]); // Output: Apple
console.log(fruits[1]); // Output: Banana
// Adding elements to the array
fruits.push("Mango");
console.log(fruits); // Output: ["Apple", "Banana", "Cherry", "Mango"]
// Removing the last element
const removedFruit = fruits.pop();
console.log(removedFruit); // Output: Mango
console.log(fruits); // Output: ["Apple", "Banana", "Cherry"]
// Removing the first element
const firstFruit = fruits.shift();
console.log(firstFruit); // Output: Apple
console.log(fruits); // Output: ["Banana", "Cherry"]
// Adding an element at the start
fruits.unshift("Orange");
console.log(fruits); // Output: ["Orange", "Banana", "Cherry"]
// Iterating over the array
fruits.forEach((fruit, index) => {
  console.log(`Fruit at index ${index}: ${fruit}`);
});
// Output:
// Fruit at index 0: Orange
// Fruit at index 1: Banana
// Fruit at index 2: Cherry
// Checking the length of the array
console.log(`Total fruits: ${fruits.length}`); // Output: Total fruits: 3
// Finding an element
const hasBanana = fruits.includes("Banana");
console.log(`Is Banana in the list? ${hasBanana}`); // Output: Is Banana in the list? true
// Modifying an element
fruits[1] = "Grapes";
console.log(fruits); // Output: ["Orange", "Grapes", "Cherry"]

class Queue {
  constructor() {
    this.items = [];
  }
  // Add an element to the back of the queue
  enqueue(element) {
    this.items.push(element);
    console.log(`${element} added to the queue.`);
  }
  // Remove an element from the front of the queue
  dequeue() {
    if (this.isEmpty()) {
      console.log("Queue is empty.");
      return null;
    }
    const removed = this.items.shift();
    console.log(`${removed} removed from the queue.`);
    return removed;
  }
  // Peek at the front element without removing it
  front() {
    if (this.isEmpty()) {
      console.log("Queue is empty.");
      return null;
    }
    return this.items[0];
  }
  // Check if the queue is empty
  isEmpty() {
    return this.items.length === 0;
  }
  // Get the size of the queue
  size() {
    return this.items.length;
  }
  // Print the queue elements
  printQueue() {
    console.log("Queue contents:", this.items.join(" -> "));
  }
}
// Example usage
const queue = new Queue();
queue.enqueue(10); // Output: 10 added to the queue.
queue.enqueue(20); // Output: 20 added to the queue.
queue.enqueue(30); // Output: 30 added to the queue.
queue.printQueue(); // Output: Queue contents: 10 -> 20 -> 30
queue.dequeue(); // Output: 10 removed from the queue.
console.log("Front element:", queue.front()); // Output: Front element: 20
console.log("Queue size:", queue.size()); // Output: Queue size: 2
queue.printQueue(); // Output: Queue contents: 20 -> 30

// Define a Node class
class Node {
  constructor(value) {
    this.value = value; // The value of the node
    this.next = null;   // Pointer to the next node
  }
}
// Define a LinkedList class
class LinkedList {
  constructor() {
    this.head = null; // Start of the list
    this.size = 0;    // Number of nodes in the list
  }
  // Add a new node to the end of the list
  append(value) {
    const newNode = new Node(value);
    if (this.head === null) {
      // If the list is empty, set head to the new node
      this.head = newNode;
    } else {
      // Traverse to the end and add the new node
      let current = this.head;
      while (current.next !== null) {
        current = current.next;
      }
      current.next = newNode;
    }
    this.size++;
  }
  // Add a new node to the beginning of the list
  prepend(value) {
    const newNode = new Node(value);
    newNode.next = this.head;
    this.head = newNode;
    this.size++;
  }
  // Remove a node with the given value
  remove(value) {
    if (!this.head) return null;
    // If the head is the node to be removed
    if (this.head.value === value) {
      this.head = this.head.next;
      this.size--;
      return;
    }
    // Traverse the list to find and remove the node
    let current = this.head;
    let previous = null;
    while (current !== null && current.value !== value) {
      previous = current;
      current = current.next;
    }
    if (current === null) return null; // Node not found
    previous.next = current.next;
    this.size--;
  }
  // Print the list as an array for visualization
  printList() {
    const elements = [];
    let current = this.head;
    while (current !== null) {
      elements.push(current.value);
      current = current.next;
    }
    console.log(elements);
  }
  // Get the size of the list
  getSize() {
    return this.size;
  }
  // Search for a value in the list
  search(value) {
    let current = this.head;
    while (current !== null) {
      if (current.value === value) {
        return true; // Value found
      }
      current = current.next;
    }
    return false; // Value not found
  }
}
// Example usage of LinkedList
const list = new LinkedList();
list.append(10); // List: [10]
list.append(20); // List: [10, 20]
list.append(30); // List: [10, 20, 30]
list.prepend(5); // List: [5, 10, 20, 30]
list.printList(); // Output: [5, 10, 20, 30]
console.log("Is 20 in the list?", list.search(20)? "Yes":"No"); // Output: true
console.log("Size of the list:", list.getSize());   // Output: 4
list.remove(10); // Remove node with value 10
list.printList(); // Output: [5, 20, 30]
list.remove(5); // Remove node with value 5
list.printList(); // Output: [20, 30]

class TreeNode {
  constructor(value) {
    this.value = value;     // Value stored in the node
    this.children = [];     // Array to hold child nodes
  }
  // Add a child node
  addChild(child) {
    this.children.push(child);
  }
  // Remove a child node by value
  removeChild(value) {
    this.children = this.children.filter(child => child.value !== value);
  }
}
class Tree {
  constructor(rootValue) {
    this.root = new TreeNode(rootValue); // The root node of the tree
  }
  // Depth-First Search (DFS) to traverse the tree
  traverseDFS(node = this.root) {
    if (!node) return;
    console.log(node.value); // Process the current node
    node.children.forEach(child => this.traverseDFS(child)); // Recursively traverse children
  }
  // Breadth-First Search (BFS) to traverse the tree
  traverseBFS() {
    const queue = [this.root]; // Initialize a queue with the root node
    while (queue.length > 0) {
      const currentNode = queue.shift(); // Dequeue the front node
      console.log(currentNode.value); // Process the current node
      // Enqueue all child nodes
      queue.push(...currentNode.children);
    }
  }
}
// Create a tree with a root node
const tree = new Tree("Root");
// Add child nodes to the root
const child1 = new TreeNode("Child 1");
const child2 = new TreeNode("Child 2");
tree.root.addChild(child1);
tree.root.addChild(child2);
// Add grandchildren to "Child 1"
const grandchild1 = new TreeNode("Grandchild 1");
const grandchild2 = new TreeNode("Grandchild 2");
child1.addChild(grandchild1);
child1.addChild(grandchild2);
// Add grandchildren to "Child 2"
const grandchild3 = new TreeNode("Grandchild 3");
child2.addChild(grandchild3);
// Traverse the tree using Depth-First Search (DFS)
console.log("DFS Traversal:");
tree.traverseDFS(); 
// Output:
// Root
// Child 1
// Grandchild 1
// Grandchild 2
// Child 2
// Grandchild 3
// Traverse the tree using Breadth-First Search (BFS)
console.log("\nBFS Traversal:");
tree.traverseBFS();
// Output:
// Root
// Child 1
// Child 2
// Grandchild 1
// Grandchild 2
// Grandchild 3

class Graph {
  constructor() {
    this.adjacencyList = {}; // Object to store the graph as an adjacency list
  }
  // Add a vertex (node) to the graph
  addVertex(vertex) {
    if (!this.adjacencyList[vertex]) {
      this.adjacencyList[vertex] = [];
    }
  }
  // Add an edge between two vertices
  addEdge(vertex1, vertex2) {
    if (this.adjacencyList[vertex1]) {
      this.adjacencyList[vertex1].push(vertex2);
    }
    if (this.adjacencyList[vertex2]) {
      this.adjacencyList[vertex2].push(vertex1); // Remove this for a directed graph
    }
  }
  // Remove an edge between two vertices
  removeEdge(vertex1, vertex2) {
    this.adjacencyList[vertex1] = this.adjacencyList[vertex1].filter(v => v !== vertex2);
    this.adjacencyList[vertex2] = this.adjacencyList[vertex2].filter(v => v !== vertex1);
  }
  // Remove a vertex and all associated edges
  removeVertex(vertex) {
    while (this.adjacencyList[vertex]?.length) {
      const adjacentVertex = this.adjacencyList[vertex].pop();
      this.removeEdge(vertex, adjacentVertex);
    }
    delete this.adjacencyList[vertex];
  }
  // Depth-First Search (DFS) - Recursive
  dfsRecursive(start, visited = {}, result = []) {
    if (!start) return result;
    visited[start] = true;
    result.push(start);
    this.adjacencyList[start].forEach(neighbor => {
      if (!visited[neighbor]) {
        this.dfsRecursive(neighbor, visited, result);
      }
    });
    return result;
  }
  // Breadth-First Search (BFS) - Iterative
  bfsIterative(start) {
    const queue = [start];
    const visited = {};
    const result = [];
    visited[start] = true;
    while (queue.length) {
      const current = queue.shift();
      result.push(current);
      this.adjacencyList[current].forEach(neighbor => {
        if (!visited[neighbor]) {
          visited[neighbor] = true;
          queue.push(neighbor);
        }
      });
    }
    return result;
  }
}
// Create a new graph
const graph = new Graph();
// Add vertices
graph.addVertex("A");
graph.addVertex("B");
graph.addVertex("C");
graph.addVertex("D");
graph.addVertex("E");
graph.addVertex("F");
// Add edges
graph.addEdge("A", "B");
graph.addEdge("A", "C");
graph.addEdge("B", "C");
graph.addEdge("B", "D");
graph.addEdge("C", "D");
graph.addEdge("D", "E");
graph.addEdge("D", "F");
// Display adjacency list
console.log("Adjacency List:", graph.adjacencyList);
// Output:
// Adjacency List: { A: [ 'B', 'C' ], B: [ 'A', 'D' ], C: [ 'A', 'E' ], D: [ 'B', 'E' ], E: [ 'C', 'D' ] }
// Perform Depth-First Search (DFS)
console.log("DFS Traversal:", graph.dfsRecursive("A"));
// Output: DFS Traversal: [ 'A', 'B', 'D', 'E', 'C' ]
// Perform Breadth-First Search (BFS)
console.log("BFS Traversal:", graph.bfsIterative("A"));
// Output: BFS Traversal: [ 'A', 'B', 'C', 'D', 'E' ]

class HashEntry {
  constructor(key, value) {
    this.key = key;         // Key for the entry
    this.value = value;     // Value associated with the key
    this.next = null;       // Reference to the next entry in the chain
  }
}
class HashTable {
  constructor(slots = 10) {
    this.slots = slots;                  // Number of slots in the hash table
    this.size = 0;                       // Current number of entries
    this.bucket = new Array(this.slots).fill(null); // Array of buckets
  }
  // Hash function
  getIndex(key) {
    return key % this.slots;             // Compute index using modulo operation
  }
  // Add key-value pair
  add(key, value) {
    const index = this.getIndex(key);    // Compute the hash index
    const newEntry = new HashEntry(key, value);
    if (this.bucket[index] === null) {
      this.bucket[index] = newEntry;   // Insert entry if bucket is empty
    } else {
      let current = this.bucket[index];
      while (current !== null) {
        if (current.key === key) {   // Key already exists, update value
          current.value = value;
          return;
        }
        if (current.next === null) break; // Traverse to the end of the chain
        current = current.next;
      }
      current.next = newEntry;        // Add new entry at the end of the chain
    }
    this.size++;                         // Increment size
  }
  // Search for a key
  search(key) {
    const index = this.getIndex(key);    // Compute the hash index
    let current = this.bucket[index];   // Retrieve the chain at the index
    while (current !== null) {           // Traverse the chain
      if (current.key === key) {       // Key found
        return current.value;        // Return the associated value
      }
      current = current.next;          // Move to the next entry
    }
    return null;                         // Key not found
  }
    // Delete a key-value pair
  delete(key) {
    const index = this.getIndex(key);    // Compute the hash index
    let current = this.bucket[index];
    let prev = null;
    while (current !== null) {
      if (current.key === key) {       // Key found
        if (prev === null) {
          this.bucket[index] = current.next; // Remove first entry
        } else {
          prev.next = current.next; // Skip the current entry
        }
        this.size--;                  // Decrement size
        return true;                  // Successfully deleted
      }
      prev = current;
      current = current.next;           // Move to the next entry
    }
    return false;                         // Key not found
  }
}
// Test the Hash Table implementation
const ht = new HashTable();
ht.add(1, "Educative");
ht.add(11, "JavaScript");
ht.add(21, "HashTable");
// Search for a key
console.log(ht.search(11));  // Output: JavaScript
// Delete a key
console.log(ht.delete(11));  // Output: true
// Try to search for the deleted key
console.log(ht.search(11));  // Output: null