Skip to content
Related Articles

Related Articles

Improve Article

Segregate Even and Odd numbers | Set 2

  • Difficulty Level : Easy
  • Last Updated : 11 Nov, 2020

Given an array arr[] of size N, the task is to segregate even and odd numbers. Print all even numbers first, and then odd numbers.

Examples: 

Input: arr[] = {8, 22, 65, 70, 33, 60, 2, 34, 43, 21} 
Output: {8, 22, 70, 60, 2, 34, 65, 33, 43, 21} 

Input: arr[] = {18, 52, 37, 70, 3, 63, 2, 34} 
Output: {18, 52, 70, 2, 34, 37, 3, 63} 

Linear Approach: This problem can be seen as a variation of the Dutch National Flag Problem. Refer to the previous post for all the linear approaches to solve the problem.



Time Complexity: O(N) 
Auxiliary Space: O(1)

Approach using stable_partition() Function: The stable_partition() algorithm arranges the sequence defined by start and end such that all elements for which the predicate, specified by user-defined predicate function, returns True, precedes the ones for which the function returns False. The partitioning is stable. Therefore, the relative ordering of the sequence is preserved.

Syntax: 

template 
BiIter stable_partition(BiIter start, BiIter end, UnPred pfn) 

Parameters:  

start: the range of elements to reorder 
end: the range of elements to reorder 
pfn: User-defined predicate function object that defines the condition to be satisfied if an element is to be classified. 
A predicate takes a single argument and returns True or False
Return Value: Returns an iterator to the beginning of the elements for which the predicate is false. 

Below is the implementation of the above approach:

C++




// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to segregate
// odd and even numbers
void segregate(vector<int> arr)
{
 
    // Using stable partition
    // with lambda expression
    stable_partition(arr.begin(),
                     arr.end(),
                     [](int a) {
                         return a % 2 == 0;
                     });
 
    // Print array after partition
    for (int num : arr)
        cout << num << " ";
}
 
// Driver Code
int main()
{
    // Given array arr[]
    vector<int> arr = { 18, 52, 37, 70,
                        3, 63, 2, 34 };
 
    // Function Call
    segregate(arr);
 
    return 0;
}


Java




// Java program to implement
// the above approach
import java.util.*;
class GFG{
   
static int[] stable_partition(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--;
    }
  }
  return arr;
}
 
// Function to segregate
// odd and even numbers
static void segregate(int[] arr)
{
  // Using stable partition
  // with lambda expression
  int []ans = stable_partition(arr);
 
  // Print array after partition
  for (int num : ans)
    System.out.print(num + " ");
}
 
// Driver Code
public static void main(String[] args)
{
  // Given array arr[]
  int[] arr = {18, 52, 37, 70,
               3, 63, 2, 34};
 
  // Function Call
  segregate(arr);
}
}
 
// This code is contributed by 29AjayKumar


Python3




# Python3 program to implement
# the above approach
 
# Function to segregate
# odd and even numbers
def segregate(arr):
     
    # Using stable partition
    # with lambda expression
    odd = []
    even = []
     
    for x in arr:
        if (x % 2 == 0):
            even.append(x)
        else:
            odd.append(x)
             
    for x in even:
        print(x, end = " ")
    for x in odd:
        print(x, end = " ")
 
# Driver Code
if __name__ == '__main__':
     
    # Given array arr[]
    arr = [ 18, 52, 37, 70, 3, 63, 2, 34 ]
 
    # Function Call
    segregate(arr)
 
# This code is contributed by SURENDRA_GANGWAR


C#




// C# program to implement
// the above approach
using System;
using System.Collections.Generic;
class GFG{
   
static void stable_partition(int []arr)
{
  // Initialize left and
  // right indexes
  List<int> odd = new List<int>();
  List<int> even = new List<int>();
 
  foreach(int i in arr)
  {
    if(i % 2 == 1)
      odd.Add(i);
    else
      even.Add(i);
  }
   
  foreach(int i in even)
    Console.Write(i +" ");
   
  foreach(int i in odd)
    Console.Write(i +" ");
}
 
// Function to segregate
// odd and even numbers
static void segregate(int[] arr)
{
  // Using stable partition
  // with lambda expression
  stable_partition(arr);
 
}
 
// Driver Code
public static void Main(String[] args)
{
  // Given array []arr
  int[] arr = {18, 52, 37, 70,
               3, 63, 2, 34};
 
  // Function Call
  segregate(arr);
}
}
 
// This code is contributed by 29AjayKumar


Output

18 52 70 2 34 37 3 63 

Time Complexity: O(N) 
Auxiliary Space: O(1) 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :