Left Rotate an Array by One Place using Loop - Optimal Algorithm

Contents

ProblemExamplesVisualizationSolutionAlgorithmCodeTimeSpace Detailed Exmpl

Problem Statement❯

Given an array of integers, your task is to left rotate the array by 1 position. This means that each element moves one place to the left, and the first element is moved to the end of the array.

The operation should be performed in-place using an optimal solution, without using extra space for a new array.

If the array is empty or contains only one element, it should remain unchanged after rotation.

Examples❯

Input Array Output Array (After 1 Left Rotation) Description
[1, 2, 3, 4, 5] [2, 3, 4, 5, 1] Normal case – first element moved to the endVisualization
[10] [10] Single-element array remains the sameVisualization
[] [] Empty array remains unchangedVisualization
[5, 10, 15] [10, 15, 5] All elements shifted left once, first element placed lastVisualization
[7, 8] [8, 7] Two-element array rotationVisualization
[0, 0, 0] [0, 0, 0] All elements are the same; rotation does not change the appearanceVisualization

Visualization Player

Solution❯

To left rotate an array by one position means that we shift every element one step to the left, and move the very first element to the last position. Let's understand how this transformation looks and what different scenarios can occur.

Understanding with a Simple Example

Take the array [1, 2, 3, 4, 5]. After left rotating it once, every element moves left and 1 (the first element) goes to the last place. The result becomes [2, 3, 4, 5, 1].

What Happens Internally?

We can perform this efficiently in one pass:

  • Store the first element in a temporary variable (say first).
  • Shift all elements from index 1 to the end, one step to the left.
  • Finally, place first at the end of the array.

This approach ensures the rotation happens in-place without using additional space, and it runs in linear time O(n).

Special Cases to Consider

  • Empty Array: If the array has no elements, there's nothing to rotate. We return the array as is.
  • Single Element: For an array like [10], rotating it doesn’t change anything because there's only one item.
  • Identical Elements: Arrays like [0, 0, 0] look unchanged even after rotation, but internally, the positions are updated.

Why This Approach is Optimal

This technique avoids the use of any additional arrays or lists. It performs the operation in-place with constant space and only one traversal through the array. It's the most efficient way to left rotate an array by one position.

Algorithm Steps❯

  1. Given an array arr of size n.
  2. Store the first element in a temporary variable first.
  3. Shift all elements of the array one position to the left (from index 1 to n-1).
  4. Assign first to the last index of the array.
  5. The array is now left-rotated by one place.

Code

Python
JavaScript
Java
C++
C
def left_rotate_by_one(arr):
    if not arr:
        return arr
    first = arr[0]
    for i in range(1, len(arr)):
        arr[i - 1] = arr[i]
    arr[-1] = first
    return arr

# Sample Input
arr = [10, 20, 30, 40, 50]
print("After Left Rotation:", left_rotate_by_one(arr))

Time Complexity

CaseTime ComplexityExplanation
Best CaseO(n)Every element (except the first) needs to be shifted one position to the left, which takes linear time regardless of input.
Average CaseO(n)In all scenarios, the array is traversed once to shift elements, resulting in linear time complexity.
Worst CaseO(n)Even in the worst case, each element is moved exactly once, making the operation linear in the number of elements.

Space Complexity

O(1)

Explanation: Only one temporary variable is used to store the first element. No additional space is required proportional to input size.

Detailed Step by Step Example❯

Let's left rotate the array by one position.

{ "array": [10,20,30,40,50], "showIndices": true }

Store the first element 10 in a temporary variable.

Shift index 1

Move 20 from index 1 to index 0.

{ "array": [20,20,30,40,50], "showIndices": true, "highlightIndices": [0], "labels": { "0": "updated" } }

Shift index 2

Move 30 from index 2 to index 1.

{ "array": [20,30,30,40,50], "showIndices": true, "highlightIndices": [1], "labels": { "1": "updated" } }

Shift index 3

Move 40 from index 3 to index 2.

{ "array": [20,30,40,40,50], "showIndices": true, "highlightIndices": [2], "labels": { "2": "updated" } }

Shift index 4

Move 50 from index 4 to index 3.

{ "array": [20,30,40,50,50], "showIndices": true, "highlightIndices": [3], "labels": { "3": "updated" } }

Place the first element at the end

Set 10 to index 4.

{ "array": [20,30,40,50,10], "showIndices": true, "highlightIndices": [4], "labels": { "4": "rotated" } }

Final Result:

Array after left rotation: [20, 30, 40, 50, 10]