Segregate Even and Odd numbers

Given an array A[], write a function that segregates even and odd numbers. The functions should put all even numbers first, and then odd numbers.

Example

Input  = {12, 34, 45, 9, 8, 90, 3}
Output = {12, 34, 8, 90, 45, 9, 3} 

In the output, the order of numbers can be changed, i.e., in the above example, 34 can come before 12 and 3 can come before 9.

The problem is very similar to our old post Segregate 0s and 1s in an array, and both of these problems are variation of famous Dutch national flag problem.


Algorithm: segregateEvenOdd()
1) Initialize two index variables left and right:  
            left = 0,  right = size -1 
2) Keep incrementing left index until we see an odd number.
3) Keep decrementing right index until we see an even number.
4) If lef < right then swap arr[left] and arr[right]

Implementation:

C/C++



filter_none

edit
close

play_arrow

link
brightness_4
code

// C program to segregate even and odd elements of array
#include<stdio.h>
  
/* Function to swap *a and *b */
void swap(int *a, int *b);
  
void segregateEvenOdd(int arr[], int size)
{
    /* Initialize left and right indexes */
    int left = 0, right = size-1;
    while (left < right)
    {
        /* Increment left index while we see 0 at left */
        while (arr[left]%2 == 0 && left < right)
            left++;
  
        /* Decrement right index while we see 1 at right */
        while (arr[right]%2 == 1 && left < right)
            right--;
  
        if (left < right)
        {
            /* Swap arr[left] and arr[right]*/
            swap(&arr[left], &arr[right]);
            left++;
            right--;
        }
    }
}
  
/* UTILITY FUNCTIONS */
void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}
  
/* driver program to test */
int main()
{
    int arr[] = {12, 34, 45, 9, 8, 90, 3};
    int arr_size = sizeof(arr)/sizeof(arr[0]);
    int i = 0;
  
    segregateEvenOdd(arr, arr_size);
  
    printf("Array after segregation ");
    for (i = 0; i < arr_size; i++)
        printf("%d ", arr[i]);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to segregate even and odd elements of array
import java.io.*;
  
class SegregateOddEven
{
    static void segregateEvenOdd(int arr[])
    {
        /* Initialize left and right indexes */
        int left = 0, right = arr.length - 1;
        while (left < right)
        {
            /* Increment left index while we see 0 at left */
            while (arr[left]%2 == 0 && left < right)
                left++;
  
            /* Decrement right index while we see 1 at right */
            while (arr[right]%2 == 1 && left < right)
                right--;
  
            if (left < right)
            {
                /* Swap arr[left] and arr[right]*/
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                left++;
                right--;
            }
        }
    }
  
    /* Driver program to test above functions */
    public static void main (String[] args)
    {
        int arr[] = {12, 34, 45, 9, 8, 90, 3};
  
        segregateEvenOdd(arr);
  
        System.out.print("Array after segregation ");
        for (int i = 0; i < arr.length; i++)
            System.out.print(arr[i]+" ");
    }
}
/*This code is contributed by Devesh Agrawal*/

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python program to segregate even and odd elements of array
  
def segregateEvenOdd(arr):
  
    # Initialize left and right indexes
    left,right = 0,len(arr)-1
  
    while left < right:
  
        # Increment left index while we see 0 at left
        while (arr[left]%2==0 and left < right):
            left += 1
  
        # Decrement right index while we see 1 at right
        while (arr[right]%2 == 1 and left < right):
            right -= 1
  
        if (left < right):
              # Swap arr[left] and arr[right]*/
              arr[left],arr[right] = arr[right],arr[left]
              left += 1
              right = right-1
  
  
# Driver function to test above function
arr = [12, 34, 45, 9, 8, 90, 3]
segregateEvenOdd(arr)
print ("Array after segregation "),
for i in range(0,len(arr)):
    print arr[i],
# This code is contributed by Devesh Agrawal

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to segregate even
// and odd elements of array
using System;
  
class GFG
{
    static void segregateEvenOdd(int []arr)
    {
        /* Initialize left and right indexes */
        int left = 0, right = arr.Length - 1;
        while (left < right)
        {
            /* Increment left index while we see 0 at left */
            while (arr[left]%2 == 0 && left < right)
                left++;
  
            /* Decrement right index while we see 1 at right */
            while (arr[right]%2 == 1 && left < right)
                right--;
  
            if (left < right)
            {
                /* Swap arr[left] and arr[right]*/
                int temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
                left++;
                right--;
            }
        }
    }
  
    /* Driver program to test above functions */
    public static void Main ()
    {
        int []arr = {12, 34, 45, 9, 8, 90, 3};
  
        segregateEvenOdd(arr);
  
        Console.Write("Array after segregation ");
        for (int i = 0; i < arr.Length; i++)
            Console.Write(arr[i]+" ");
    }
}
  
//This code is contributed by Sam007

chevron_right


Output:

Array after segregation 12 34 90 8 9 45 3 

Time Complexity: O(n)

Alternate Implementation (Lomuto partition):

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// A Lomuto partition based scheme to segregate
// even and odd numbers.
#include <iostream>
using namespace std;
  
// fuction is rearrange the array in given way.
void rearrangeEvenAndOdd(int arr[], int n)
{
    // variables
    int j = -1;
  
    // quick sort method
    for (int i = 0; i < n; i++) {
  
        // if array of element
        // is odd then swap
        if (arr[i] % 2 == 0) {
  
            // increment j by one
            j++;
  
            // swap the element
            swap(arr[i], arr[j]);
        }
    }
}
  
int main()
{
    int arr[] = { 12, 10, 9, 45, 2, 10, 10, 45 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    rearrangeEvenAndOdd(arr, n);
  
    for (int i = 0; i < n; i++)
        cout << arr[i] << " ";
}
// This code is contributed by devagarwalmnnit

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// A Lomuto partition based scheme to segregate
// even and odd numbers.
import java.io.*;
  
class GFG 
{
    // fuction is rearrange the array in given way.
    static void rearrangeEvenAndOdd(int arr[], int n)
    {
        // variables
        int j = -1,temp;
      
        // quick sort method
        for (int i = 0; i < n; i++) {
      
            // if array of element
            // is odd then swap
            if (arr[i] % 2 == 0) {
      
                // increment j by one
                j++;
      
                // swap the element
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
      
    // Driver code
    public static void main(String args[])
    {
        int arr[] = { 12, 10, 9, 45, 2, 10, 10, 45 };
        int n = arr.length;
      
        rearrangeEvenAndOdd(arr, n);
      
        for (int i = 0; i < n; i++)
            System.out.print(arr[i] + " ");
    }
}
  
// This code is contributed by Nikita Tiwari.

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# A Lomuto partition based scheme to 
# segregate even and odd numbers.
  
# fuction is rearrange the 
# array in given way.
def rearrangeEvenAndOdd(arr, n) :
    # variables
    j = -1
  
    # quick sort method
    for i in range(0, n) :
          
        # if array of element
        # is odd then swap
        if (arr[i] % 2 == 0) :
            # increment j by one
            j = j + 1
  
            # swap the element
            temp = arr[i]
            arr[i] = arr[j]
            arr[j] = temp
          
  
# Driver code        
arr = [ 12, 10, 9, 45, 2, 10, 10, 45 ]
n = len(arr)
  
rearrangeEvenAndOdd(arr, n)
  
for i in range(0,n) :
    print( arr[i] ,end= " ")
      
          
# This code is contributed by Nikita Tiwari.

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// A Lomuto partition based scheme 
// to segregate even and odd numbers.
using System;
  
class GFG
{
    // fuction is rearrange
    // the array in given way.
    static void rearrangeEvenAndOdd(int []arr,
                                        int n)
    {
        // variables
        int j = -1, temp;
      
        // quick sort method
        for (int i = 0; i < n; i++) {
      
            // if array of element
            // is odd then swap
            if (arr[i] % 2 == 0) {
      
                // increment j by one
                j++;
      
                // swap the element
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
      
    // Driver code
    public static void Main()
    {
        int []arr = { 12, 10, 9, 45, 2, 
                            10, 10, 45 };
        int n = arr.Length;
      
        rearrangeEvenAndOdd(arr, n);
      
        for (int i = 0; i < n; i++)
            Console.Write(arr[i] + " ");
    }
}
  
// This code is contributed by Sam007

chevron_right


Output:

12 10 2 10 10 45 9 45

Time Complexity: O(n)

References:
http://www.csse.monash.edu.au/~lloyd/tildeAlgDS/Sort/Flag/

Please write comments if you find the above code/algorithm incorrect, or find better ways to solve the same problem.



My Personal Notes arrow_drop_up


Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.