├── math ├── factorial-recursive.js ├── factorial.js ├── fibonacci-recursive.js ├── fibonacci.js ├── power-of-two.js └── prime.js ├── misc ├── cartesian-product.js ├── climbing-staircase.js └── tower-of-hanoi.js ├── readme.md ├── search ├── binary-search-recursive.js ├── binary-search.js └── linear-search.js └── sorting ├── bubble-sort.js ├── insertion-sort.js ├── merge-sort.js ├── quick-sort-in-place.js └── quick-sort.js /math/factorial-recursive.js: -------------------------------------------------------------------------------- 1 | function recursiveFactorial(n) { 2 | if (n === 0) { 3 | return 1 4 | } 5 | return n * recursiveFactorial(n - 1) 6 | } 7 | 8 | console.log(recursiveFactorial(0)) // 1 9 | console.log(recursiveFactorial(1)) // 1 10 | console.log(recursiveFactorial(5)) // 120 11 | -------------------------------------------------------------------------------- /math/factorial.js: -------------------------------------------------------------------------------- 1 | function factorial(n) { 2 | let result = 1 3 | for (let i = 2; i <= n; i++) { 4 | result = result * i 5 | } 6 | return result 7 | } 8 | 9 | console.log(factorial(0)) // 1 10 | console.log(factorial(1)) // 1 11 | console.log(factorial(5)) // 120 12 | -------------------------------------------------------------------------------- /math/fibonacci-recursive.js: -------------------------------------------------------------------------------- 1 | function recursiveFibonacci(n) { 2 | if (n < 2) { 3 | return n 4 | } 5 | return recursiveFibonacci(n - 1) + recursiveFibonacci(n - 2) 6 | } 7 | 8 | console.log(recursiveFibonacci(0)) // 0 9 | console.log(recursiveFibonacci(1)) // 1 10 | console.log(recursiveFibonacci(7)) // 8 11 | -------------------------------------------------------------------------------- /math/fibonacci.js: -------------------------------------------------------------------------------- 1 | function fibonacci(n) { 2 | const fib = [0, 1] 3 | for (let i = 2; i <= n; i++) { 4 | fib[i] = fib[i - 1] + fib[i - 2] 5 | } 6 | return fib 7 | } 8 | 9 | console.log(fibonacci(2)) // [0,1] 10 | console.log(fibonacci(3)) // [0,1,1] 11 | console.log(fibonacci(7)) // [0,1,1,2,3,5,8] 12 | -------------------------------------------------------------------------------- /math/power-of-two.js: -------------------------------------------------------------------------------- 1 | function isPowerOfTwo(n) { 2 | if (n < 1) { 3 | return false 4 | } 5 | while (n > 1) { 6 | if (n % 2 !== 0) { 7 | return false 8 | } 9 | n = n / 2 10 | } 11 | return true 12 | } 13 | 14 | function isPowerOfTwoBitWise(n) { 15 | if (n < 1) { 16 | return false 17 | } 18 | return (n & (n - 1)) === 0 19 | } 20 | 21 | console.log(isPowerOfTwo(1)) // true 22 | console.log(isPowerOfTwo(2)) // true 23 | console.log(isPowerOfTwo(5)) // false 24 | -------------------------------------------------------------------------------- /math/prime.js: -------------------------------------------------------------------------------- 1 | function isPrime(n) { 2 | if (n < 2) { 3 | return false 4 | } 5 | for (let i = 2; i <= Math.sqrt(n); i++) { 6 | // if n is divisible by any number then it is not prime 7 | if (n % i === 0) { 8 | return false 9 | } 10 | } 11 | return true 12 | } 13 | 14 | console.log(isPrime(1)) // false 15 | console.log(isPrime(5)) // true 16 | console.log(isPrime(4)) // false 17 | -------------------------------------------------------------------------------- /misc/cartesian-product.js: -------------------------------------------------------------------------------- 1 | function cartesianProduct(arr1, arr2) { 2 | const result = [] 3 | for (let i = 0; i < arr1.length; i++) { 4 | for (let j = 0; j < arr2.length; j++) { 5 | result.push([arr1[i], arr2[j]]) 6 | } 7 | } 8 | return result 9 | } 10 | 11 | const arr1 = [1, 2] 12 | const arr2 = [3, 4, 5] 13 | console.log(cartesianProduct(arr1, arr2)) // [[1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5]] 14 | -------------------------------------------------------------------------------- /misc/climbing-staircase.js: -------------------------------------------------------------------------------- 1 | function climbingStaircase(n) { 2 | const noOfWays = [1, 2] 3 | for (let i = 2; i <= n; i++) { 4 | noOfWays[i] = noOfWays[i - 1] + noOfWays[i - 2] 5 | } 6 | return noOfWays[n - 1] 7 | } 8 | 9 | console.log(climbingStaircase(1)) 10 | console.log(climbingStaircase(2)) 11 | console.log(climbingStaircase(3)) 12 | console.log(climbingStaircase(4)) 13 | console.log(climbingStaircase(5)) 14 | -------------------------------------------------------------------------------- /misc/tower-of-hanoi.js: -------------------------------------------------------------------------------- 1 | function towerOfHanoi(n, fromRod, toRod, usingRod) { 2 | if (n === 1) { 3 | console.log(`Move disk 1 from ${fromRod} to ${toRod}`) 4 | return 5 | } 6 | towerOfHanoi(n - 1, fromRod, usingRod, toRod) 7 | console.log(`Move disk ${n} from ${fromRod} to ${toRod}`) 8 | towerOfHanoi(n - 1, usingRod, toRod, fromRod) 9 | } 10 | 11 | towerOfHanoi(3, 'A', 'C', 'B') 12 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | Source code related to the JavaScript Algorithms tutorial series on YouTube 2 | -------------------------------------------------------------------------------- /search/binary-search-recursive.js: -------------------------------------------------------------------------------- 1 | function recursiveBinarySearch(arr, target) { 2 | return search(arr, target, 0, arr.length - 1) 3 | } 4 | 5 | function search(arr, target, leftIndex, rightIndex) { 6 | if (leftIndex > rightIndex) { 7 | return -1 8 | } 9 | 10 | let middleIndex = Math.floor((leftIndex + rightIndex) / 2) 11 | if (target === arr[middleIndex]) { 12 | return middleIndex 13 | } 14 | 15 | if (target < arr[middleIndex]) { 16 | return search(arr, target, leftIndex, middleIndex - 1) 17 | } else { 18 | return search(arr, target, middleIndex + 1, rightIndex) 19 | } 20 | } 21 | 22 | console.log(recursiveBinarySearch([-5, 2, 4, 6, 10], 10)) // 4 23 | console.log(recursiveBinarySearch([-5, 2, 4, 6, 10], 6)) // 3 24 | console.log(recursiveBinarySearch([-5, 2, 4, 6, 10], 20)) // -1 25 | -------------------------------------------------------------------------------- /search/binary-search.js: -------------------------------------------------------------------------------- 1 | function binarySearch(arr, target) { 2 | let leftIndex = 0 3 | let rightIndex = arr.length - 1 4 | 5 | while (leftIndex <= rightIndex) { 6 | let middleIndex = Math.floor((leftIndex + rightIndex) / 2) 7 | if (target === arr[middleIndex]) { 8 | return middleIndex 9 | } 10 | if (target < arr[middleIndex]) { 11 | rightIndex = middleIndex - 1 12 | } else { 13 | leftIndex = middleIndex + 1 14 | } 15 | } 16 | return -1 17 | } 18 | 19 | console.log(binarySearch([-5, 2, 4, 6, 10], 10)) // 4 20 | console.log(binarySearch([-5, 2, 4, 6, 10], 6)) // 3 21 | console.log(binarySearch([-5, 2, 4, 6, 10], 20)) // -1 22 | -------------------------------------------------------------------------------- /search/linear-search.js: -------------------------------------------------------------------------------- 1 | function linearSearch(arr, target) { 2 | for (let i = 0; i < arr.length; i++) { 3 | if (arr[i] === target) { 4 | return i 5 | } 6 | } 7 | return -1 8 | } 9 | 10 | console.log(linearSearch([-5, 2, 10, 4, 6], 10)) // 2 11 | console.log(linearSearch([-5, 2, 10, 4, 6], 6)) // 4 12 | console.log(linearSearch([-5, 2, 10, 4, 6], 20)) // -1 13 | -------------------------------------------------------------------------------- /sorting/bubble-sort.js: -------------------------------------------------------------------------------- 1 | function bubbleSort(arr) { 2 | let swapped 3 | do { 4 | swapped = false 5 | for (let i = 0; i < arr.length - 1; i++) { 6 | if (arr[i] > arr[i + 1]) { 7 | let temp = arr[i] 8 | arr[i] = arr[i + 1] 9 | arr[i + 1] = temp 10 | swapped = true 11 | } 12 | } 13 | } while (swapped) 14 | } 15 | 16 | const arr = [8, 20, -2, 4, -6] 17 | bubbleSort(arr) 18 | console.log(arr) // [-6, -2, 4, 8, 20] 19 | -------------------------------------------------------------------------------- /sorting/insertion-sort.js: -------------------------------------------------------------------------------- 1 | function insertionSort(arr) { 2 | for (let i = 1; i < arr.length; i++) { 3 | let numberToInsert = arr[i] 4 | let j = i - 1 5 | while (j >= 0 && arr[j] > numberToInsert) { 6 | arr[j + 1] = arr[j] 7 | j = j - 1 8 | } 9 | arr[j + 1] = numberToInsert 10 | } 11 | } 12 | 13 | const arr = [8, 20, -2, 4, -6] 14 | insertionSort(arr) 15 | console.log(arr) // [-6, -2, 4, 8, 20] 16 | -------------------------------------------------------------------------------- /sorting/merge-sort.js: -------------------------------------------------------------------------------- 1 | function mergesort(arr) { 2 | if (arr.length < 2) { 3 | return arr 4 | } 5 | const mid = Math.floor(arr.length / 2) 6 | const leftArr = arr.slice(0, mid) 7 | const rightArr = arr.slice(mid) 8 | return merge(mergesort(leftArr), mergesort(rightArr)) 9 | } 10 | 11 | function merge(leftArr, rightArr) { 12 | const sortedArr = [] 13 | while (leftArr.length && rightArr.length) { 14 | if (leftArr[0] <= rightArr[0]) { 15 | sortedArr.push(leftArr.shift()) 16 | } else { 17 | sortedArr.push(rightArr.shift()) 18 | } 19 | } 20 | const resultArr = [...sortedArr, ...leftArr, ...rightArr] 21 | return resultArr 22 | } 23 | 24 | const arr = [8, 20, -2, 4, -6] 25 | console.log(mergesort(arr)) // [-6, -2, 4, 8, 20] 26 | -------------------------------------------------------------------------------- /sorting/quick-sort-in-place.js: -------------------------------------------------------------------------------- 1 | function quickSort(arr, left = 0, right = arr.length - 1) { 2 | if (left < right) { 3 | const pivot = partition(arr, left, right) 4 | quickSort(arr, left, pivot - 1) 5 | quickSort(arr, pivot + 1, right) 6 | } 7 | return arr 8 | } 9 | 10 | function partition(arr, left, right) { 11 | const pivot = arr[right] 12 | let i = left 13 | for (let j = left; j < right; j++) { 14 | if (arr[j] < pivot) { 15 | swap(arr, i, j) 16 | i++ 17 | } 18 | } 19 | swap(arr, i, right) 20 | return i 21 | } 22 | 23 | function swap(arr, i, j) { 24 | const temp = arr[i] 25 | arr[i] = arr[j] 26 | arr[j] = temp 27 | } 28 | 29 | const arr = [8, 20, -2, 4, -6] 30 | quickSort(arr) 31 | console.log(arr) // [-6, -2, 4, 8, 20] 32 | -------------------------------------------------------------------------------- /sorting/quick-sort.js: -------------------------------------------------------------------------------- 1 | function quickSort(arr) { 2 | if (arr.length < 2) return arr 3 | let pivot = arr[arr.length - 1] 4 | let left = [] 5 | let right = [] 6 | for (let i = 0; i < arr.length - 1; i++) { 7 | if (arr[i] < pivot) { 8 | left.push(arr[i]) 9 | } else { 10 | right.push(arr[i]) 11 | } 12 | } 13 | return [...quickSort(left), pivot, ...quickSort(right)] 14 | } 15 | 16 | const arr = [8, 20, -2, 4, -6] 17 | console.log(quickSort(arr)) // [-6, -2, 4, 8, 20] 18 | --------------------------------------------------------------------------------