How to Reverse an Array in JavaScript Without In-Built Functions

Reversing an array is a common task in programming, and while JavaScript provides the built-in reverse() method, understanding how to reverse an array manually is essential for improving problem-solving skills. This guide explains step-by-step how to reverse an array without using any in-built functions, with code examples and outputs.

01. Understanding the Problem

The goal is to reverse the order of elements in an array without using JavaScript’s built-in reverse() method. For example:


// Input:
let arr = [1, 2, 3, 4, 5];

// Output:
[5, 4, 3, 2, 1]

02. Approach 1: Using a Temporary Array

We can create a new array and iterate through the original array in reverse order to copy elements.


// Code Example:
function reverseArray(arr) {
  let reversed = [];
  for (let i = arr.length - 1; i >= 0; i--) {
    reversed.push(arr[i]);
  }
  return reversed;
}

// Example Usage:
let arr = [1, 2, 3, 4, 5];
let result = reverseArray(arr);
console.log(result); // Output: [5, 4, 3, 2, 1]

Explanation: We loop from the last element to the first, appending each element to a new array.

03. Approach 2: Swapping Elements In-Place

This method swaps elements from the start and end of the array, working towards the center. It is more memory-efficient because it does not use extra space.


// Code Example:
function reverseArrayInPlace(arr) {
  let start = 0;
  let end = arr.length - 1;

  while (start < end) {
    // Swap elements
    let temp = arr[start];
    arr[start] = arr[end];
    arr[end] = temp;

    // Move pointers
    start++;
    end--;
  }

  return arr;
}

// Example Usage:
let arr = [1, 2, 3, 4, 5];
reverseArrayInPlace(arr);
console.log(arr); // Output: [5, 4, 3, 2, 1]

Explanation: The start pointer begins at the first element, and the end pointer starts at the last element. Elements are swapped, and the pointers move closer to each other until they meet.

04. Approach 3: Recursive Method

Reversing an array can also be done using recursion. The idea is to swap the first and last elements and recursively reverse the remaining subarray.


// Code Example:
function reverseArrayRecursive(arr, start, end) {
  if (start >= end) return arr;

  // Swap elements
  let temp = arr[start];
  arr[start] = arr[end];
  arr[end] = temp;

  // Recursive call
  return reverseArrayRecursive(arr, start + 1, end - 1);
}

// Example Usage:
let arr = [1, 2, 3, 4, 5];
reverseArrayRecursive(arr, 0, arr.length - 1);
console.log(arr); // Output: [5, 4, 3, 2, 1]

Explanation: The recursion continues until the base case is reached, where start is no longer less than end.

05. Comparing the Methods

Method	Time Complexity	Space Complexity
Using a Temporary Array	O(n)	O(n)
Swapping In-Place	O(n)	O(1)
Recursive Method	O(n)	O(n)

Note: The in-place method is the most efficient in terms of memory usage.

06. Practical Applications

Reversing arrays for algorithms like palindrome checking.
Manipulating data structures such as stacks and queues.
Improving understanding of array manipulation techniques.

Conclusion

Reversing an array in JavaScript without using in-built functions is a great way to strengthen your understanding of array manipulation and algorithm design. Each method discussed here has its own use case and efficiency. Choose the one that best fits your requirements!