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

Visualization Player

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

Solution

Understanding the Problem

We are given an array, and our goal is to left rotate it by one position. This means that each element in the array should shift one position to the left, and the first element should move to the last position.

Let’s solve this step by step using an example. We'll also think like a beginner, and make sure we handle all the edge cases clearly.

Step-by-Step Example

Original Array:

[1, 2, 3, 4, 5]

Step 1: Save the first element

We store 1 in a temporary variable because it will be moved to the end later.

Step 2: Shift all other elements left

Move each element one step to the left:

[2, 3, 4, 5, _]

Step 3: Place the saved element at the end

Put 1 in the last position:

[2, 3, 4, 5, 1]

Final Result:

[2, 3, 4, 5, 1]

Edge Cases

1. Empty Array

If the array is [], there’s nothing to rotate. We return it as-is.

2. Single Element Array

If the array is [10], rotating it won't change anything since there's only one item.

3. All Elements Identical

If the array is [0, 0, 0], the result looks the same after rotation, but the operation is still performed internally.

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

C
C++
Python
Java
JS
Go
Rust
Kotlin
Swift
TS
#include <stdio.h>

void leftRotateByOne(int arr[], int n) {
    if (n == 0) return;
    int first = arr[0];
    for (int i = 1; i < n; i++) {
        arr[i - 1] = arr[i];
    }
    arr[n - 1] = first;
}

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    int n = sizeof(arr) / sizeof(arr[0]);
    leftRotateByOne(arr, n);
    printf("After Left Rotation: ");
    for (int i = 0; i < n; i++) printf("%d ", arr[i]);
    return 0;
}

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]


Comments

💬 Please keep your comment relevant and respectful. Avoid spamming, offensive language, or posting promotional/backlink content.
All comments are subject to moderation before being published.


Loading comments...