Skip to content
geeksforgeeks
  • Tutorials
    • Python
    • Java
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
    • Practice Coding Problems
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • DSA
  • Interview Questions on Array
  • Practice Array
  • MCQs on Array
  • Tutorial on Array
  • Types of Arrays
  • Array Operations
  • Subarrays, Subsequences, Subsets
  • Reverse Array
  • Static Vs Arrays
  • Array Vs Linked List
  • Array | Range Queries
  • Advantages & Disadvantages
Open In App
Next Article:
Rearrange array such that even positioned are greater than odd
Next article icon

Move all zeros to end of array

Last Updated : 18 Feb, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given an array of integers arr[], the task is to move all the zeros to the end of the array while maintaining the relative order of all non-zero elements.

Examples: 

Input: arr[] = [1, 2, 0, 4, 3, 0, 5, 0]
Output: arr[] = [1, 2, 4, 3, 5, 0, 0, 0]
Explanation: There are three 0s that are moved to the end.

Input: arr[] = [10, 20, 30]
Output: arr[] = [10, 20, 30]
Explanation: No change in array as there are no 0s.

Input: arr[] = [0, 0]
Output: arr[] = [0, 0]
Explanation: No change in array as there are all 0s.

Table of Content

  • [Naive Approach] Using Temporary Array - O(n) Time and O(n) Space
  • [Better Approach] Two Traversals
  • [Expected Approach] One Traversal
  • [Another Approach] Using Library Methods

[Naive Approach] Using Temporary Array - O(n) Time and O(n) Space

The idea is to create a temporary array of same size as the input array arr[].

  • First, copy all non-zero elements from arr[] to the temporary array.
  • Then, fill all the remaining positions in temporary array with 0.
  • Finally, copy all the elements from temporary array to arr[].

Working:

C++ 
// C++ Program to move all zeros to end using temporary array  #include <bits/stdc++.h> using namespace std;  // function to move all zeros to the end void pushZerosToEnd(vector<int> &arr) {     int n = arr.size();     vector<int> temp(n);      // to keep track of the index in temp[]     int j = 0;      // Copy non-zero elements to temp[]     for (int i = 0; i < n; i++) {         if (arr[i] != 0)             temp[j++] = arr[i];     }      // Fill remaining positions in temp[] with zeros     while (j < n) {         temp[j++] = 0;     }      // Copy all the elements from temp[] to arr[]     for (int i = 0; i < n; i++)         arr[i] = temp[i]; }  int main() {     vector<int> arr = {1, 2, 0, 4, 3, 0, 5, 0};     pushZerosToEnd(arr);      // Print the modified array     for (int num : arr) {         cout << num << " ";     }     return 0; }
C 
// C Program to move all zeros to end using temporary array  #include <stdio.h>  // function to move all zeros to the end void pushZerosToEnd(int *arr, int n) {     int temp[n];          // to keep track of the index in temp[]     int j = 0;      // Copy non-zero elements to temp[]     for (int i = 0; i < n; i++) {         if (arr[i] != 0)             temp[j++] = arr[i];     }      // Fill remaining positions in temp[] with zeros     while (j < n)         temp[j++] = 0;      // Copy all the elements from temp[] to arr[]     for (int i = 0; i < n; i++)         arr[i] = temp[i]; }  int main() {     int arr[] = {1, 2, 0, 4, 3, 0, 5, 0};     int n = sizeof(arr) / sizeof(arr[0]);          pushZerosToEnd(arr, n);      // Print the modified array     for (int i = 0; i < n; i++) {         printf("%d ", arr[i]);     }     return 0; }
Java 
// Java Program to move all zeros to end using temporary array  import java.util.Arrays;  class GfG {          // function to move all zeros to the end     static void pushZerosToEnd(int[] arr) {         int n = arr.length;         int[] temp = new int[n];          // to keep track of the index in temp[]         int j = 0;          // Copy non-zero elements to temp[]         for (int i = 0; i < n; i++) {             if (arr[i] != 0)                 temp[j++] = arr[i];         }          // Fill remaining positions in temp[] with zeros         while (j < n)             temp[j++] = 0;          // Copy all the elements from temp[] to arr[]         for (int i = 0; i < n; i++)             arr[i] = temp[i];     }      public static void main(String[] args) {         int[] arr = {1, 2, 0, 4, 3, 0, 5, 0};         pushZerosToEnd(arr);          // Print the modified array         for (int num : arr) {             System.out.print(num + " ");         }     } }
Python 
# Python Program to move all zeros to the end  # function to move all zeroes to the end def pushZerosToEnd(arr):     n = len(arr)     temp = [0] * n            # to keep track of the index in temp[]     j = 0      # Copy non-zero elements to temp[]     for i in range(n):         if arr[i] != 0:             temp[j] = arr[i]             j += 1      # Fill remaining positions in temp[] with zeros     while j < n:         temp[j] = 0         j += 1      # Copy all the elements from temp[] to arr[]     for i in range(n):         arr[i] = temp[i]  if __name__ == "__main__":     arr = [1, 2, 0, 4, 3, 0, 5, 0]     pushZerosToEnd(arr)      # Print the modified array     for num in arr:         print(num, end=" ")
C# 
// C# Program to move all zeros to end using temporary array  using System;  class GfG {          // function to move all zeros to the end     static void pushZerosToEnd(int[] arr) {         int n = arr.Length;         int[] temp = new int[n];          // to keep track of the index in temp[]         int j = 0;          // Copy non-zero elements to temp[]         for (int i = 0; i < n; i++) {             if (arr[i] != 0)                 temp[j++] = arr[i];         }          // Fill remaining positions in temp[] with zeros         while (j < n)             temp[j++] = 0;          // Copy all the elements from temp[] to arr[]         for (int i = 0; i < n; i++)             arr[i] = temp[i];     }      static void Main(string[] args) {         int[] arr = {1, 2, 0, 4, 3, 0, 5, 0};         pushZerosToEnd(arr);          // Print the modified array         foreach (int num in arr)             Console.Write(num + " ");     } }
JavaScript 
// JavaScript Program to move all zeros to end using temporary array  // function to move all zeros to the end function pushZerosToEnd(arr) {     const n = arr.length;     const temp = new Array(n);      // to keep track of the index in temp[]     let j = 0;      // Copy non-zero elements to temp[]     for (let i = 0; i < n; i++) {         if (arr[i] !== 0) {             temp[j++] = arr[i];         }     }      // Fill remaining positions in temp[] with zeros     while (j < n)         temp[j++] = 0;      // Copy all the elements from temp[] to arr[]     for (let i = 0; i < n; i++)         arr[i] = temp[i]; }  const arr = [1, 2, 0, 4, 3, 0, 5, 0]; pushZerosToEnd(arr);  // Print the modified array console.log(arr.join(" "));

Output
1 2 4 3 5 0 0 0

[Better Approach] Two Traversals

The idea is to move all the zeros by traversing the array twice.

First Traversal: Shift non-zero elements

  • Traverse the array and maintain the count of non-zero elements. This count is initialized with 0 and keeps track of where the next non-zero element should be placed in the array.
  • If the element is non-zero, place it at arr[count] and increment count by 1.
  • After traversing all the elements, all non-zero elements will be shifted to the front while maintaining their original order.

Second Traversal: Fill remaining positions with zeros

  • After the first traversal, all non-zero elements will be at the start of the array and count will store the index where the first zero should be placed.
  • Iterate from count to the end of array and fill all indices with 0.

Working:

C++ 
// C++ Program to move all zeros to end using two traversals  #include <bits/stdc++.h> using namespace std;  // Function which pushes all zeros to end  void pushZerosToEnd(vector<int>& arr) {          // Count of non-zero elements     int count = 0;        // If the element is non-zero, replace the element at     // index 'count' with this element and increment count     for (int i = 0; i < arr.size(); i++) {         if (arr[i] != 0)             arr[count++] = arr[i];     }      // Now all non-zero elements have been shifted to     // the front. Make all elements 0 from count to end.     while (count < arr.size())         arr[count++] = 0; }  int main() {     vector<int> arr = {1, 2, 0, 4, 3, 0, 5, 0};     pushZerosToEnd(arr);     for (int num : arr) {         cout << num << " ";     }     return 0; }
C 
// C Program to move all zeros to end using two traversals  #include <stdio.h>  // Function which pushes all zeros to end  void pushZerosToEnd(int* arr, int n) {          // Count of non-zero elements     int count = 0;        // If the element is non-zero, replace the element at     // index 'count' with this element and increment count     for (int i = 0; i < n; i++) {         if (arr[i] != 0)             arr[count++] = arr[i];     }      // Now all non-zero elements have been shifted to     // the front. Make all elements 0 from count to end.     while (count < n)         arr[count++] = 0; }  int main() {     int arr[] = {1, 2, 0, 4, 3, 0, 5, 0};     int size = sizeof(arr) / sizeof(arr[0]);     pushZerosToEnd(arr, size);     for (int i = 0; i < size; i++) {         printf("%d ", arr[i]);     }     return 0; }
Java 
// Java Program to move all zeros to end using two traversals  class GfG {      // Function which pushes all zeros to end of an array     static void pushZerosToEnd(int[] arr) {                  // Count of non-zero elements         int count = 0;            // If the element is non-zero, replace the element at         // index 'count' with this element and increment count         for (int i = 0; i < arr.length; i++) {             if (arr[i] != 0)                 arr[count++] = arr[i];         }          // Now all non-zero elements have been shifted to         // the front. Make all elements 0 from count to end.         while (count < arr.length)             arr[count++] = 0;     }      public static void main(String[] args) {         int[] arr = {1, 2, 0, 4, 3, 0, 5, 0};         pushZerosToEnd(arr);         for (int num : arr) {             System.out.print(num + " ");         }     } }
Python 
# Python Program to move all zeros to end using two traversals  # Function which pushes all zeros to end def pushZerosToEnd(arr):          # Count of non-zero elements     count = 0        # If the element is non-zero, replace the element at     # index 'count' with this element and increment count     for i in range(len(arr)):         if arr[i] != 0:             arr[count] = arr[i]             count += 1      # Now all non-zero elements have been shifted to     # the front. Make all elements 0 from count to end.     while count < len(arr):         arr[count] = 0         count += 1  if __name__ == "__main__":     arr = [1, 2, 0, 4, 3, 0, 5, 0]     pushZerosToEnd(arr)     for num in arr:         print(num, end=" ")
C# 
// C# Program to move all zeros to end using two traversals  using System;  class GfG {      // Function which pushes all zeros to end of an array     static void pushZerosToEnd(int[] arr) {                  // Count of non-zero elements         int count = 0;            // If the element is non-zero, replace the element at         // index 'count' with this element and increment count         for (int i = 0; i < arr.Length; i++) {             if (arr[i] != 0)                 arr[count++] = arr[i];         }          // Now all non-zero elements have been shifted to         // the front. Make all elements 0 from count to end.         while (count < arr.Length)             arr[count++] = 0;     }      static void Main() {         int[] arr = { 1, 2, 0, 4, 3, 0, 5, 0 };         pushZerosToEnd(arr);         foreach (int num in arr) {             Console.Write(num + " ");         }     } }
JavaScript 
// JavaScript Program to move all zeros to end using two traversals  // Function which pushes all zeros to end of an array function pushZerosToEnd(arr) {          // Count of non-zero elements     let count = 0;        // If the element is non-zero, replace the element at     // index 'count' with this element and increment count     for (let i = 0; i < arr.length; i++) {         if (arr[i] !== 0)             arr[count++] = arr[i];     }      // Now all non-zero elements have been shifted to     // the front. Make all elements 0 from count to end.     while (count < arr.length)         arr[count++] = 0; }  // Driver Code const arr = [1, 2, 0, 4, 3, 0, 5, 0]; pushZerosToEnd(arr); console.log(arr.join(" "));

Output
1 2 4 3 5 0 0 0

Time Complexity: O(n), as we are traversing the array only twice.
Auxiliary Space: O(1)

[Expected Approach] One Traversal

The idea is similar to the previous approach where we took a pointer, say count to track where the next non-zero element should be placed. However, on encountering a non-zero element, instead of directly placing the non-zero element at arr[count], we will swap the non-zero element with arr[count]. This will ensure that if there is any zero present at arr[count], it is pushed towards the end of array and is not overwritten.

Working:

C++ 
// C++ Program to move all zeros to end using one traversal  #include <bits/stdc++.h> using namespace std;  // Function which pushes all zeros to end of array void pushZerosToEnd(vector<int>& arr) {        // Pointer to track the position for next non-zero element     int count = 0;           for (int i = 0; i < arr.size(); i++) {          // If the current element is non-zero         if (arr[i] != 0) {                        // Swap the current element with the 0 at index 'count'             swap(arr[i], arr[count]);             // Move 'count' pointer to the next position             count++;         }     } }  int main() {     vector<int> arr = {1, 2, 0, 4, 3, 0, 5, 0};     pushZerosToEnd(arr);     for (int num : arr) {         cout << num << " ";     }     return 0; }
C 
// C Program to move all zeros to end using one traversal  #include <stdio.h>  // Function which pushes all zeros to end of array void pushZerosToEnd(int arr[], int n) {        // Pointer to track the position for next non-zero element     int count = 0;           for (int i = 0; i < n; i++) {          // If the current element is non-zero         if (arr[i] != 0) {                        // Swap the current element with the 0 at index 'count'             int temp = arr[i];             arr[i] = arr[count];             arr[count] = temp;                        // Move 'count' pointer to the next position             count++;         }     } }  int main() {     int arr[] = {1, 2, 0, 4, 3, 0, 5, 0};     int size = sizeof(arr) / sizeof(arr[0]);          pushZerosToEnd(arr, size);          for (int i = 0; i < size; i++) {         printf("%d ", arr[i]);     }          return 0; }
Java 
// Java Program to move all zeros to end using one traversal  import java.util.Arrays;  class GfG {      // Function which pushes all zeros to end of array     static void pushZerosToEnd(int[] arr) {          // Pointer to track the position for next non-zero element         int count = 0;          for (int i = 0; i < arr.length; i++) {              // If the current element is non-zero             if (arr[i] != 0) {                  // Swap the current element with the 0 at index 'count'                 int temp = arr[i];                 arr[i] = arr[count];                 arr[count] = temp;                  // Move 'count' pointer to the next position                 count++;             }         }     }      public static void main(String[] args) {         int[] arr = {1, 2, 0, 4, 3, 0, 5, 0};         pushZerosToEnd(arr);         for (int num : arr) {             System.out.print(num + " ");         }     } }
Python 
# Python Program to move all zeros to end using one traversal  # Function which pushes all zeros to end of array def pushZerosToEnd(arr):          # Pointer to track the position for next non-zero element     count = 0          for i in range(len(arr)):                  # If the current element is non-zero         if arr[i] != 0:                          # Swap the current element with the 0 at index 'count'             arr[i], arr[count] = arr[count], arr[i]                          # Move 'count' pointer to the next position             count += 1  if __name__ == "__main__":     arr = [1, 2, 0, 4, 3, 0, 5, 0]     pushZerosToEnd(arr)     for num in arr:         print(num, end=" ")
C# 
// C# Program to move all zeros to end using one traversal  using System;  class GfG {          // Function which pushes all zeros to end of array     static void pushZerosToEnd(int[] arr) {                  // Pointer to track the position for next non-zero element         int count = 0;          for (int i = 0; i < arr.Length; i++) {                          // If the current element is non-zero             if (arr[i] != 0) {                                // Swap the current element with the 0 at index 'count'                 int temp = arr[i];                 arr[i] = arr[count];                 arr[count] = temp;                  // Move 'count' pointer to the next position                 count++;             }         }     }      static void Main() {         int[] arr = { 1, 2, 0, 4, 3, 0, 5, 0 };         pushZerosToEnd(arr);         foreach (int num in arr) {             Console.Write(num + " ");         }     } }
JavaScript 
// JavaScript Program to move all zeros to end using one traversal  // Function which pushes all zeros to end of array function pushZerosToEnd(arr) {          // Pointer to track the position for next non-zero element     let count = 0;          for (let i = 0; i < arr.length; i++) {                  // If the current element is non-zero         if (arr[i] !== 0) {                          // Swap the current element with the 0 at index 'count'             [arr[i], arr[count]] = [arr[count], arr[i]];                          // Move 'count' pointer to the next position             count++;         }     } }  const arr = [1, 2, 0, 4, 3, 0, 5, 0]; pushZerosToEnd(arr); console.log(arr.join(" "));

Output
1 2 4 3 5 0 0 0

Time Complexity: O(n), as we are traversing the array only once.
Auxiliary Space: O(1)

[Another Approach] Using Library Methods

In C++, there exists a method stable_parition() that we can directly use here to implement the above method.

C++ 
// C++ Program to move zeros to the end using Library Methods  #include <algorithm> #include <iostream> #include <vector> using namespace std;  void pushZerosToEnd(vector<int> &arr) {     stable_partition(arr.begin(), arr.end(), [](int n) {                                         return n != 0; }); }  int main() {     vector<int> arr = {1, 2, 0, 4, 3, 0, 5, 0};     pushZerosToEnd(arr);     for (int i : arr)         cout << i << ' ';     return 0; }

Output
1 2 4 3 5 0 0 0



Next Article
Rearrange array such that even positioned are greater than odd

C

Chandra Prakash
Improve
Article Tags :
  • DSA
  • Arrays
  • Amazon
  • Samsung
  • Paytm
  • Linkedin
  • SAP Labs
  • Bloomberg
Practice Tags :
  • Amazon
  • Bloomberg
  • Linkedin
  • Paytm
  • Samsung
  • SAP Labs
  • Arrays

Similar Reads

    Array Data Structure
    Complete Guide to ArraysLearn more about Array in DSA Self Paced CoursePractice Problems on ArraysTop Quizzes on Arrays What is Array?An array is a collection of items stored at contiguous memory locations. The idea is to store multiple items of the same type together. This makes it easier to calcul
    3 min read
    What is Array?
    Array is a linear data structure where all elements are arranged sequentially. It is a collection of elements of same data type stored at contiguous memory locations. For simplicity, we can think of an array as a flight of stairs where on each step is placed a value (let's say one of your friends).
    2 min read
    Getting Started with Array Data Structure
    Array is a collection of items of the same variable type that are stored at contiguous memory locations. It is one of the most popular and simple data structures used in programming. Basic terminologies of ArrayArray Index: In an array, elements are identified by their indexes. Array index starts fr
    14 min read
    Applications, Advantages and Disadvantages of Array
    Array is a linear data structure that is a collection of data elements of same types. Arrays are stored in contiguous memory locations. It is a static data structure with a fixed size. Applications of Array Data Structure:Arrays mainly have advantages like random access and cache friendliness over o
    2 min read
    Subarrays, Subsequences, and Subsets in Array
    What is a Subarray?A subarray is a contiguous part of array, i.e., Subarray is an array that is inside another array. In general, for an array of size n, there are n*(n+1)/2 non-empty subarrays. For example, Consider the array [1, 2, 3, 4], There are 10 non-empty sub-arrays. The subarrays are: (1),
    10 min read

    Basic operations in Array

    Searching in Array
    Searching is one of the most common operations performed in an array. Array searching can be defined as the operation of finding a particular element or a group of elements in the array. There are several searching algorithms. The most commonly used among them are: Linear Search Binary Search Ternar
    4 min read
    Array Reverse - Complete Tutorial
    Given an array arr[], the task is to reverse the array. Reversing an array means rearranging the elements such that the first element becomes the last, the second element becomes second last and so on.Examples: Input: arr[] = {1, 4, 3, 2, 6, 5} Output: {5, 6, 2, 3, 4, 1}Explanation: The first elemen
    15+ min read
    Rotate an Array by d - Counterclockwise or Left
    Given an array of integers arr[] of size n, the task is to rotate the array elements to the left by d positions.Examples:Input: arr[] = {1, 2, 3, 4, 5, 6}, d = 2Output: {3, 4, 5, 6, 1, 2}Explanation: After first left rotation, arr[] becomes {2, 3, 4, 5, 6, 1} and after the second rotation, arr[] bec
    15+ min read
    Array after K Rotations
    Given an array arr[] and an integer k, rotate the array in place k times to the right (clockwise). In each rotation, the last element moves to the front, and all other elements shift one position to the right. Modify the array in place, do not return anything.Examples : Input: arr[] = [1, 2, 3, 4, 5
    12 min read
    Search, Insert, and Delete in an Unsorted Array | Array Operations
    In this post, a program to search, insert, and delete operations in an unsorted array is discussed.Search Operation:In an unsorted array, the search operation can be performed by linear traversal from the first element to the last element. Coding implementation of the search operation:C++// C++ prog
    15+ min read
    Search, Insert, and Delete in an Sorted Array | Array Operations
    How to Search in a Sorted Array?In a sorted array, the search operation can be performed by using binary search.Below is the implementation of the above approach:C++// C++ program to implement binary search in sorted array #include <bits/stdc++.h> using namespace std; int binarySearch(int arr[
    15+ min read
    Array Sorting - Practice Problems
    Sorting an array means arranging the elements of the array in a certain order. Generally sorting in an array is done to arrange the elements in increasing or decreasing order. Problem statement: Given an array of integers arr, the task is to sort the array in ascending order and return it, without u
    9 min read
    Generating All Subarrays
    Given an array arr[], the task is to generate all the possible subarrays of the given array.Examples: Input: arr[] = [1, 2, 3]Output: [ [1], [1, 2], [2], [1, 2, 3], [2, 3], [3] ]Input: arr[] = [1, 2]Output: [ [1], [1, 2], [2] ]Iterative ApproachTo generate a subarray, we need a starting index from t
    8 min read

    Easy problems on Array

    Largest three distinct elements in an array
    Given an array arr[], the task is to find the top three largest distinct integers present in the array.Note: If there are less than three distinct elements in the array, then return the available distinct numbers in descending order.Examples :Input: arr[] = [10, 4, 3, 50, 23, 90]Output: [90, 50, 23]
    6 min read
    Second Largest Element in an Array
    Given an array of positive integers arr[] of size n, the task is to find second largest distinct element in the array.Note: If the second largest element does not exist, return -1. Examples:Input: arr[] = [12, 35, 1, 10, 34, 1]Output: 34Explanation: The largest element of the array is 35 and the sec
    14 min read
    Move all zeros to end of array
    Given an array of integers arr[], the task is to move all the zeros to the end of the array while maintaining the relative order of all non-zero elements.Examples: Input: arr[] = [1, 2, 0, 4, 3, 0, 5, 0]Output: arr[] = [1, 2, 4, 3, 5, 0, 0, 0]Explanation: There are three 0s that are moved to the end
    15 min read
    Rearrange array such that even positioned are greater than odd
    Given an array arr[], sort the array according to the following relations: arr[i] >= arr[i - 1], if i is even, ∀ 1 <= i < narr[i] <= arr[i - 1], if i is odd, ∀ 1 <= i < nFind the resultant array.[consider 1-based indexing]Examples: Input: arr[] = [1, 2, 2, 1]Output: [1 2 1 2] Expla
    9 min read
    Rearrange an array in maximum minimum form using Two Pointer Technique
    Given a sorted array of positive integers, rearrange the array alternately i.e first element should be a maximum value, at second position minimum value, at third position second max, at fourth position second min, and so on. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7} Output: arr[] = {7, 1, 6, 2
    6 min read
    Segregate even and odd numbers using Lomuto’s Partition Scheme
    Given an array arr[] of integers, segregate even and odd numbers in the array such that all the even numbers should be present first, and then the odd numbers.Examples: Input: arr[] = {7, 2, 9, 4, 6, 1, 3, 8, 5}Output: 2 4 6 8 7 9 1 3 5Input: arr[] = {1, 3, 2, 4, 7, 6, 9, 10}Output: 2 4 6 10 7 1 9 3
    6 min read
    Reversal algorithm for Array rotation
    Given an array arr[] of size N, the task is to rotate the array by d position to the left. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7}, d = 2Output: 3, 4, 5, 6, 7, 1, 2Explanation: If the array is rotated by 1 position to the left, it becomes {2, 3, 4, 5, 6, 7, 1}.When it is rotated further by 1
    15 min read
    Print left rotation of array in O(n) time and O(1) space
    Given an array of size n and multiple values around which we need to left rotate the array. How to quickly print multiple left rotations?Examples : Input : arr[] = {1, 3, 5, 7, 9}k1 = 1k2 = 3k3 = 4k4 = 6Output : 3 5 7 9 17 9 1 3 59 1 3 5 73 5 7 9 1Input : arr[] = {1, 3, 5, 7, 9}k1 = 14 Output : 9 1
    15+ min read
    Sort an array which contain 1 to n values
    We are given an array that contains 1 to n elements, our task is to sort this array in an efficient way. We are not allowed to simply copy the numbers from 1 to n.Examples : Input : arr[] = {2, 1, 3};Output : {1, 2, 3}Input : arr[] = {2, 1, 4, 3};Output : {1, 2, 3, 4} Native approach - O(n Log n) Ti
    7 min read
    Count Possible Triangles
    Given an unsorted array of positive integers, the task is to find the number of triangles that can be formed with three different array elements as three sides of triangles. For a triangle to be possible from 3 values as sides, the sum of the two values (or sides) must always be greater than the thi
    15+ min read
    Print all Distinct (Unique) Elements in given Array
    Given an integer array arr[], print all distinct elements from this array. The given array may contain duplicates and the output should contain every element only once.Examples: Input: arr[] = {12, 10, 9, 45, 2, 10, 10, 45}Output: {12, 10, 9, 45, 2}Input: arr[] = {1, 2, 3, 4, 5}Output: {1, 2, 3, 4,
    11 min read
    Unique Number I
    Given an array of integers, every element in the array appears twice except for one element which appears only once. The task is to identify and return the element that occurs only once.Examples: Input: arr[] = [2, 3, 5, 4, 5, 3, 4]Output: 2 Explanation: Since 2 occurs once, while other numbers occu
    8 min read
    Leaders in an array
    Given an array arr[] of size n, the task is to find all the Leaders in the array. An element is a Leader if it is greater than or equal to all the elements to its right side. Note: The rightmost element is always a leader. Examples: Input: arr[] = [16, 17, 4, 3, 5, 2]Output: [17 5 2]Explanation: 17
    10 min read
    Subarray with Given Sum
    Given a 1-based indexing array arr[] of non-negative integers and an integer sum. You mainly need to return the left and right indexes(1-based indexing) of that subarray. In case of multiple subarrays, return the subarray indexes which come first on moving from left to right. If no such subarray exi
    10 min read

    Intermediate problems on Array

    Rearrange an array such that arr[i] = i
    Given an array of elements of length n, ranging from 0 to n - 1. All elements may not be present in the array. If the element is not present then there will be -1 present in the array. Rearrange the array such that arr[i] = i and if i is not present, display -1 at that place.Examples: Input: arr[] =
    13 min read
    Alternate Rearrangement of Positives and Negatives
    An array contains both positive and negative numbers in random order. Rearrange the array elements so that positive and negative numbers are placed alternatively. A number of positive and negative numbers need not be equal. If there are more positive numbers they appear at the end of the array. If t
    11 min read
    Reorder an array according to given indexes
    Given two integer arrays of the same length, arr[] and index[], the task is to reorder the elements in arr[] such that after reordering, each element from arr[i] moves to the position index[i]. The new arrangement reflects the values being placed at their target indices, as described by index[] arra
    15+ min read
    Find the smallest missing number
    Given a sorted array of n distinct integers where each integer is in the range from 0 to m-1 and m > n. Find the smallest number that is missing from the array. Examples: Input: {0, 1, 2, 6, 9}, n = 5, m = 10 Output: 3 Input: {4, 5, 10, 11}, n = 4, m = 12 Output: 0 Input: {0, 1, 2, 3}, n = 4, m =
    15 min read
    Difference Array | Range update query in O(1)
    You are given an integer array arr[] and a list of queries. Each query is represented as a list of integers where:[1, l, r, x]: Adds x to all elements from arr[l] to arr[r] (inclusive).[2]: Prints the current state of the array.You need to perform the queries in order.Examples : Input: arr[] = [10,
    10 min read
    Stock Buy and Sell – Max 2 Transactions Allowed
    In the stock market, a person buys a stock and sells it on some future date. Given the stock prices of n days in an array prices[ ]. Find out the maximum profit a person can make in at most 2 transactions. A transaction is equivalent to (buying + selling) of a stock and a new transaction can start o
    15+ min read
    Smallest subarray with sum greater than a given value
    Given an array arr[] of integers and a number x, the task is to find the smallest subarray with a sum strictly greater than x.Examples:Input: x = 51, arr[] = [1, 4, 45, 6, 0, 19]Output: 3Explanation: Minimum length subarray is [4, 45, 6]Input: x = 100, arr[] = [1, 10, 5, 2, 7]Output: 0Explanation: N
    15+ min read
    Count Inversions of an Array
    Given an integer array arr[] of size n, find the inversion count in the array. Two array elements arr[i] and arr[j] form an inversion if arr[i] > arr[j] and i < j.Note: Inversion Count for an array indicates that how far (or close) the array is from being sorted. If the array is already sorted
    15+ min read
    Merge Two Sorted Arrays Without Extra Space
    Given two sorted arrays a[] and b[] of size n and m respectively, the task is to merge both the arrays and rearrange the elements such that the smallest n elements are in a[] and the remaining m elements are in b[]. All elements in a[] and b[] should be in sorted order.Examples: Input: a[] = [2, 4,
    15+ min read
    Majority Element
    You are given an array arr, and your task is to find the majority element an element that occurs more than half the length of the array (i.e., arr.size() / 2). If such an element exists return it, otherwise return -1, indicating that no majority element is present.Examples : Input : arr[] = [1, 1, 2
    15+ min read
    Two Pointers Technique
    Two pointers is really an easy and effective technique that is typically used for Two Sum in Sorted Arrays, Closest Two Sum, Three Sum, Four Sum, Trapping Rain Water and many other popular interview questions. Given a sorted array arr (sorted in ascending order) and a target, find if there exists an
    11 min read
    3 Sum - Triplet Sum in Array
    Given an array arr[] of size n and an integer sum, the task is to check if there is a triplet in the array which sums up to the given target sum.Examples: Input: arr[] = [1, 4, 45, 6, 10, 8], target = 13Output: true Explanation: The triplet [1, 4, 8] sums up to 13Input: arr[] = [1, 2, 4, 3, 6, 7], t
    15 min read
    Equilibrium Index
    Given an array arr[] of size n, the task is to return an equilibrium index (if any) or -1 if no equilibrium index exists. The equilibrium index of an array is an index such that the sum of all elements at lower indexes equals the sum of all elements at higher indexes. Note: When the index is at the
    15 min read

    Hard problems on Array

    MO's Algorithm (Query Square Root Decomposition) | Set 1 (Introduction)
    Let us consider the following problem to understand MO's Algorithm. We are given an array and a set of query ranges, we are required to find the sum of every query range.Example: Input: arr[] = {1, 1, 2, 1, 3, 4, 5, 2, 8}; query[] = [0, 4], [1, 3] [2, 4]Output: Sum of arr[] elements in range [0, 4]
    15+ min read
    Square Root (Sqrt) Decomposition Algorithm
    Square Root Decomposition Technique is one of the most common query optimization techniques used by competitive programmers. This technique helps us to reduce Time Complexity by a factor of sqrt(N) The key concept of this technique is to decompose a given array into small chunks specifically of size
    15+ min read
    Sparse Table
    Sparse table concept is used for fast queries on a set of static data (elements do not change). It does preprocessing so that the queries can be answered efficiently.Range Minimum Query Using Sparse TableYou are given an integer array arr of length n and an integer q denoting the number of queries.
    15+ min read
    Range sum query using Sparse Table
    We have an array arr[]. We need to find the sum of all the elements in the range L and R where 0 <= L <= R <= n-1. Consider a situation when there are many range queries. Examples: Input : 3 7 2 5 8 9 query(0, 5) query(3, 5) query(2, 4) Output : 34 22 15Note : array is 0 based indexed and q
    8 min read
    Range LCM Queries
    Given an array arr[] of integers of size N and an array of Q queries, query[], where each query is of type [L, R] denoting the range from index L to index R, the task is to find the LCM of all the numbers of the range for all the queries.Examples: Input: arr[] = {5, 7, 5, 2, 10, 12 ,11, 17, 14, 1, 4
    15+ min read
    Jump Game - Minimum Jumps to Reach End
    Given an array arr[] of non-negative numbers. Each number tells you the maximum number of steps you can jump forward from that position.For example:If arr[i] = 3, you can jump to index i + 1, i + 2, or i + 3 from position i.If arr[i] = 0, you cannot jump forward from that position.Your task is to fi
    15+ min read
    Space optimization using bit manipulations
    There are many situations where we use integer values as index in array to see presence or absence, we can use bit manipulations to optimize space in such problems.Let us consider below problem as an example.Given two numbers say a and b, mark the multiples of 2 and 5 between a and b using less than
    12 min read
    Maximum value of Sum(i*arr[i]) with array rotations allowed
    Given an array arr[], the task is to determine the maximum possible value of the expression i*arr[i] after rotating the array any number of times (including zero).Note: In each rotation, every element of the array shifts one position to the right, and the last element moves to the front.Examples : I
    12 min read
    Construct an array from its pair-sum array
    Given a pair-sum array construct the original array. A pair-sum array for an array is the array that contains sum of all pairs in ordered form, i.e., pair[0] is sum of arr[0] and arr[1], pair[1] is sum of arr[0] and arr[2] and so on. Note that if the size of input array is n, then the size of pair a
    5 min read
    Maximum equilibrium sum in an array
    Given an array arr[]. Find the maximum value of prefix sum which is also suffix sum for index i in arr[].Examples : Input : arr[] = {-1, 2, 3, 0, 3, 2, -1}Output : 4Explanation : Prefix sum of arr[0..3] = Suffix sum of arr[3..6]Input : arr[] = {-3, 5, 3, 1, 2, 6, -4, 2}Output : 7Explanation : Prefix
    11 min read
    Smallest Difference Triplet from Three arrays
    Three arrays of same size are given. Find a triplet such that maximum - minimum in that triplet is minimum of all the triplets. A triplet should be selected in a way such that it should have one number from each of the three given arrays. If there are 2 or more smallest difference triplets, then the
    9 min read
    Top 50 Array Coding Problems for Interviews
    Array is one of the most widely used data structure and is frequently asked in coding interviews to the problem solving skills. The following list of 50 array coding problems covers a range of difficulty levels, from easy to hard, to help candidates prepare for interviews.Easy ProblemsSecond Largest
    2 min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences