JavaScript Data Structures and Algorithms

JavaScript is a versatile programming language that is widely used in web development and beyond. It supports various data structures and algorithms that developers can use to create efficient and scalable applications.

Data Structures in JavaScript:

1. Arrays: An array is a collection of elements of the same data type. In JavaScript, arrays are dynamic, which means that their size can be changed during runtime.

2. Linked Lists: A linked list is a collection of nodes, where each node contains a data element and a pointer to the next node in the list.

3. Stacks: A stack is a collection of elements that follows a last-in, first-out (LIFO) order. In JavaScript, stacks can be implemented using arrays.

4. Queues: A queue is a collection of elements that follows a first-in, first-out (FIFO) order. In JavaScript, queues can be implemented using arrays.

5. Trees: A tree is a hierarchical data structure that consists of nodes connected by edges. In JavaScript, trees can be implemented using objects or arrays.

Algorithms in JavaScript:

1. Sorting Algorithms: JavaScript supports several sorting algorithms, including bubble sort, insertion sort, selection sort, merge sort, and quicksort.

2. Searching Algorithms: JavaScript supports several searching algorithms, including linear search, binary search, and interpolation search.

3. Recursion: Recursion is a powerful programming technique where a function calls itself to solve a problem. In JavaScript, recursion can be used to implement algorithms such as the factorial, Fibonacci sequence, and Tower of Hanoi.

4. Graph Algorithms: Graph algorithms are used to solve problems that involve graphs, such as finding the shortest path between two nodes. In JavaScript, graph algorithms can be implemented using adjacency lists or adjacency matrices.

5. Dynamic Programming: Dynamic programming is a technique used to solve problems that involve subproblems that overlap. In JavaScript, dynamic programming can be used to solve problems such as the longest common subsequence or the knapsack problem.

In conclusion, JavaScript supports several data structures and algorithms that developers can use to create efficient and scalable applications. By understanding these data structures and algorithms, developers can write more efficient and effective code, leading to better-performing applications.

Arrays:

scss
let myArray = [1, 2, 3, 4, 5];

// Add an element to the end of the array
myArray.push(6);

// Remove the last element from the array
myArray.pop();

// Accessing an element in the array
console.log(myArray[0]); // output: 1

// Iterating over the array using for loop
for (let i = 0; i < myArray.length; i++) {
  console.log(myArray[i]);
}

Linked Lists:

kotlin
class Node {
  constructor(data) {
    this.data = data;
    this.next = null;
  }
}

class LinkedList {
  constructor() {
    this.head = null;
    this.size = 0;
  }

  // Add element to the end of the linked list
  add(data) {
    let node = new Node(data);

    if (!this.head) {
      this.head = node;
    } else {
      let current = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = node;
    }
    this.size++;
  }

  // Remove element from the linked list
  remove(data) {
    let current = this.head;
    let prev = null;

    while (current) {
      if (current.data === data) {
        if (prev === null) {
          this.head = current.next;
        } else {
          prev.next = current.next;
        }
        this.size--;
        return current.data;
      }
      prev = current;
      current = current.next;
    }
    return null;
  }

  // Get the size of the linked list
  getSize() {
    return this.size;
  }

  // Iterate over the linked list and print each element
  print() {
    let current = this.head;
    while (current) {
      console.log(current.data);
      current = current.next;
    }
  }
}

let myList = new LinkedList();
myList.add(1);
myList.add(2);
myList.add(3);
myList.remove(2);
console.log(myList.getSize()); // output: 2
myList.print(); // output: 1, 3

Sorting Algorithms:

scss
// Bubble Sort
function bubbleSort(arr) {
  let len = arr.length;

  for (let i = 0; i < len - 1; i++) {
    for (let j = 0; j < len - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        let temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
  return arr;
}

let myArray = [5, 4, 3, 2, 1];
console.log(bubbleSort(myArray)); // output: [1, 2, 3, 4, 5]

// Merge Sort
function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }

  let middle = Math.floor(arr.length / 2);
  let leftArr = arr.slice(0, middle);
  let rightArr = arr.slice(middle);

  return merge(mergeSort(leftArr), mergeSort(rightArr));
}

function merge(leftArr, rightArr) {
  let result = [];
  let leftIndex = 0;
  let rightIndex = 0;

  while (leftIndex < leftArr.length && rightIndex < rightArr.length)