Skip to main content

How to Reverse an Array in Batch Script

In data processing, you often need to invert a sequence, such as reversing a breadcrumb trail to find your way back, inverting a list of priorities, or displaying the most recent entries of a stack at the bottom. Array Reversal (turning a list "upside down") is a straightforward task that can be automated by swapping elements from both ends of the list simultaneously.

In this guide, we will demonstrate how to reverse an array using a single loop and two pointers.

The Strategy: The Symmetrical Swap​

To reverse an array of size N:

  1. Set a left pointer to 1.
  2. Set a right pointer to N.
  3. While left < right:
    • Swap the values at ARR[left] and ARR[right].
    • Increment left and decrement right.
note

This algorithm completes in N/2 swap operations, making it the most efficient way to reverse an array in place. If the array has an odd number of elements, the middle element remains untouched automatically.

Implementation Script​

@echo off
setlocal enabledelayedexpansion

:: 1. Define the Array
set "size=5"
set "ARR_1=A"
set "ARR_2=B"
set "ARR_3=C"
set "ARR_4=D"
set "ARR_5=E"

echo Original: !ARR_1! !ARR_2! !ARR_3! !ARR_4! !ARR_5!

:: 2. Reversal Algorithm
set "left=1"
set "right=!size!"

:reverse_loop
if !left! GEQ !right! goto :done

:: Swap values using for-loop variable conversion
:: to resolve double-dynamic variable names
for %%L in (!left!) do for %%R in (!right!) do (
    set "temp=!ARR_%%L!"
    set "ARR_%%L=!ARR_%%R!"
    set "ARR_%%R=!temp!"
)

:: Move pointers inward
set /a "left+=1"
set /a "right-=1"

goto :reverse_loop

:done
echo Reversed: !ARR_1! !ARR_2! !ARR_3! !ARR_4! !ARR_5!

endlocal
pause

Output:

Original: A B C D E
Reversed: E D C B A

Why Reverse an Array?​

  1. LIFO Logic: Converting a First-In-First-Out (FIFO) list into a Last-In-First-Out (LIFO) list for a different processing stage.
  2. Breadcrumb Trails: If your script logs every step it takes (A -> B -> C), reversing the list allows you to automatically generate an "Undo" or "Rollback" script (C -> B -> A).
  3. UI Display: Reversing a chronological list so that the newest data appears first for the user.

Important Considerations​

warning

If you use setlocal (as recommended for script isolation), all variables created during the script are destroyed when endlocal runs. If you need the reversed array to persist after the script ends, use the endlocal variable tunneling technique: endlocal & set "VAR=!value!" to pass specific values across the boundary.

  1. Midpoint: If the array has an odd number of elements (like 5), the middle element (C) stays exactly where it is. The logic if left GEQ right handles this automatically.
  2. Performance: This algorithm is very efficient (N/2 operations). It is the fastest way to reverse an array in memory.
  3. Variable Scope: If you are reversing data to be used in another window or by the user after the script ends, remember that setlocal will destroy your variables. Use the tunneling technique described above to save the results.

Best Practices​

  1. Clear Memory: If you are done with the array, loop through the indices and unset each ARR_n variable explicitly to free up the environment space.
  2. Pointer Reset: If you perform multiple reversals in one script, ensure you reset your left and right pointers every time before entering the loop.
tip

This same symmetrical swap technique works for any data type stored in the array, such as numbers, file paths, or server names. The swap logic is agnostic to the content of the values.

Conclusion​

Reversing an array is a simple but essential data transformation. By mastering the symmetrical swap technique, you can easily invert the logic and sequence of your data sets, providing flexibility for "Rollbacks," "Undo" histories, and dynamic user interfaces. This control over data orientation ensures that your scripts are always ready for the next processing step, regardless of the original order of the information.

Table of Contents