# Shift All The Zeroes To The End Of An Array

## Problem Statement

You are given an array of integers, and you need to move all zeroes to the end of the array. But, you are not allowed to change the order of the non-zero elements.

## Approach 1

A simple way to solve this problem is to go through the array from left to right, and every time you encounter a zero, you search the rest of the array for a non-zero to swap with it. Time Complexity : O(N^2) & Space Complexity : O(1). It's an easy algorithm and needs no extra space but it's too slow. Here is a code sample for the algorithm in C#:
1. class Program
2. {
3.     static void Main(string[] args)
4.     {
5.         int[] array = new int[] { 3, 0, 0, 1, 2, 0, 4, 0 };
6.         int[] result = Approach1(array);
7.         //result is [ 3, 1, 2, 4, 0, 0, 0, 0 ]
8.     }
9.     static int[] Approach1(int[] array)
10.     {
11.         for (int i = 0; i < array.Length; i++)
12.         {
13.             //skip non-zero elements
14.             if (array[i] != 0)
15.                 continue;
16.             //look for the nearest non-zero
17.             for (int j = i + 1; j < array.Length; j++)
18.             {
19.                 if (array[j] == 0)
20.                     continue;
21.                 //swap it with our zero
22.                 array[i] = array[j];
23.                 array[j] = 0;
24.                 break;
25.             }
26.         }
27.         return array;
28.     }
29. }

## Approach 2

Another way to solve this question is to create a new array, and place all non-zero elements into it. Then fill the remaining positions in the new array with zeroes. Time Complexity : O(N) & Space Complexity : O(N). It's a fast algorithm but it's not an ideal one because it needs extra space. Given below is a code sample illustrating this algorithm in C#,
1. class Program
2. {
3.     static void Main(string[] args)
4.     {
5.         int[] array = new int[] { 3, 0, 0, 1, 2, 0, 4, 0 };
6.         int[] result = Approach2(array);
7.         //result is [ 3, 1, 2, 4, 0, 0, 0, 0 ]
8.     }
9.     static int[] Approach2(int[] array)
10.     {
11.         int newArrayIndex = 0;
12.         int[] newArray = new int[array.Length];
13.         foreach (var element in array)
14.         {
15.             //skip all zeroes
16.             if (element == 0)
17.                 continue;
18.             //add non-zero element to new array
19.             newArray[newArrayIndex] = element;
20.             newArrayIndex++;
21.         }
22.         //fill in the rest of the new array with zeroes
23.         for (int i = newArrayIndex; i < array.Length; i++)
24.             newArray[i] = 0;
25.         return newArray;
26.     }
27. }

## Approach 3

The ideal solution to this problem is to go through the array and move all non-zero elements to the left. This can be done by keeping the count of non-zero elements found so far. Time Complexity : O(N) & Space Complexity : O(1). This is an ideal solution to this interview question which takes minimum time and needs no extra space. This algorithm is implemented in the C# code below,
1. class Program
2. {
3.     static void Main(string[] args)
4.     {
5.         int[] array = new int[] { 3, 0, 0, 1, 2, 0, 4, 0 };
6.         int[] result = Approach3(array);
7.         //result is [ 3, 1, 2, 4, 0, 0, 0, 0 ]
8.     }
9.     static int[] Approach3(int[] array)
10.     {
11.         int nonZeroIndex = 0;
12.         //the number of non-zero elements we've seen so far
13.         for (int i = 0; i < array.Length; i++)
14.         {
15.             //skip all zeroes
16.             if (array[i] == 0)
17.                 continue;
18.             //put this element to the index we're tracking
19.             array[nonZeroIndex] = array[i];
20.             nonZeroIndex++;
21.         }
22.
23.         //fill the end of the array with zeroes.
24.         for (int i = nonZeroIndex; i < array.Length; i++)
25.             array[i] = 0;
26.         return array;
27.     }
28. }