All geek questions in one place

An array of even and odd sort

I have an array where I have some numbers. Now I want to sort even numbers in a separate array and odd numbers in a separate one. Is there any API for this. I tried like this

int[] array_sort={5,12,3,21,8,7,19,102,201};
int [] even_sort;
int i;
for(i=0;i<8;i++)
{

if(array_sort[i]%2==0)
{
     even_sort=Arrays.sort(array_sort[i]);//error in sort

System.out.println(even_sort);
}
}
+3
source share
7 answers

Plain and simple.

int[] array_sort = {5, 12, 3, 21, 8, 7, 19, 102, 201 };

List<Integer> odd = new ArrayList<Integer>();
List<Integer> even = new ArrayList<Integer>();
for (int i : array_sort) {
    if ((i & 1) == 1) {
        odd.add(i);
    } else {
        even.add(i);
    }
}
Collections.sort(odd);
Collections.sort(even);
System.out.println("Odd:" + odd);
System.out.println("Even:" + even);
+9
source

Easier to do this with Guava.

  • Use Ints.asListto create a view List<Integer>in real-timeint[]
  • Define Function<Integer,Boolean> isOdd
  • Use Orderingthat compares onResultOf(isOdd)naturally (i.e. falsefirst, then true)
  • If necessary compound, that withOrdering.natural()

Here's a snippet:

    int[] nums = {5,12,3,21,8,7,19,102,201};
    Function<Integer,Boolean> isOdd = new Function<Integer,Boolean>() {
        @Override
        public Boolean apply(Integer i) {
            return (i & 1) == 1;
        }
    };
    Collections.sort(
        Ints.asList(nums),
        Ordering.natural().onResultOf(isOdd)
            .compound(Ordering.natural())
    );
    System.out.println(Arrays.toString(nums));
    // [8, 12, 102, 3, 5, 7, 19, 21, 201]

, , . .

+2

, , , . , , , -. , :

int[] input = {5, 12, 3, 21, 8, 7, 19, 102, 201};
List<Integer> evens = new ArrayList<Integer>();
List<Integer> odds = new ArrayList<Integer>();
for (int i : input) {
    if (i % 2 == 0) {
        evens.add(i);
    } else {
        odds.add(i);
    }
}

Integer , int :

List<Integer> list ...
int[] array = new int[list.size()];
for (int i = 0; i < array.length; i++) {
    array[i] = list.get(i);
}
Arrays.sort(array);

List<Integer> - , , :

Collections.sort(list);
+2

:

  • . int[] even_sort = new int[3];
  • java . , , . . Java, "" java-.
  • Arrays.sort() . array_sort[i] int
  • Arrays.sort() , .

( ), - , :

int[] even_sort = new int[3]{1, 2, 3};
int[] temp = new int[4];
System.arraycopy(even_sort, 0, temp, 0, even_sort.length);
even_sort = temp;
even_sort[3] = 4;

- , :

import java.lang.reflect.Array;

public Object resizeArray(Object originalArray, int newSize){
    int originalSize = Array.getLength(originalArray);
    Class arrayType = originalArray.getClass().getComponentType();
    Object newArray = Array.newInstance(arrayType, newSize);
    System.arraycopy(originalArray, 0, newArray, 0, Math.min(originalSize, newSize));
    return newArray;
}

, - ( ), , .

int[] arrayToFilterAndSort = {5, 12, 3, 21, 8, 7, 19, 102, 201};
int[] sortedEvens = new int[0];
for(int current : arrayToFilterAndSort){
    if((current & 1) == 1){
        sortedEvens = resizeArray(sortedEvens, sortedEvens.length + 1);
        sortedEvens[sortedEvens.length - 1] = current;
    }
}
Arrays.sort(sortedEvens);

:

+1
source 
package com.java.util.collection;

import java.util.Arrays;

/**
 * Given n random numbers. Move all even numbers on left hand side and odd numbers on right hand side and 
 * then sort the even numbers in increasing order and odd numbers in decreasing order For example, 
 * i/p : 3 6 9 2 4 10 34 21 5 
 * o/p: 2 4 6 10 34 3 5 9 21
 * @author vsinha
 *
 */
public class EvenOddSorting {

    public static void eventOddSort(int[] arr) {
        int i =0;
        int j =arr.length-1;
        while(i<j) {
            if(isEven(arr[i]) && isOdd(arr[j])) {
                i++;
                j--;
            } else if(!isEven(arr[i]) && !isOdd(arr[j])) {
                swap(i,j,arr);
            } else if(isEven(arr[i])){
                i++;
            } else{
                j--;
            }

        }   
        display(arr);
        // even number sorting
        Arrays.sort(arr,0,i);
        Arrays.sort(arr,i,arr.length);
        // odd number sorting
        display(arr);

    }

    public static void display(int[] arr) {
        System.out.println("\n");
        for(int val:arr){
            System.out.print(val +"  ");
        }
    }

    private static void swap(int pos1, int pos2, int[] arr) {
        int temp = arr[pos1];
        arr[pos1]= arr[pos2];
        arr[pos2]= temp;
    }

    public static boolean isOdd(int i) {
        return (i & 1) != 0;
    }
    public static boolean isEven(int i) {
        return (i & 1) == 0;
    }
    public static void main(String[] args) {
        int arr[]={3, 6, 9 ,2, 4, 10, 34, 21, 5};
        eventOddSort(arr);
    }
}
+1
source 
package srikanth dukuntla;

public class ArrangingArray {

    public static void main(String[] args) {
        int j=0;
        int []array={1,2,3,5,4,55,32,0};
        System.out.println(array.length);
        int n=array.length/2;
        for (int i=0; i<array.length; i++){

            if(array[i]%2!=0){
                j=1;

                int temp=array[array.length-j];
            if(temp % 2!=0){

                while((array[array.length-(j+1)]%2!=0) && (array.length-(j+1)>n)){
                        j++;
                }
                    int temp2=array[array.length-(j+1)];
                     array[array.length-(j+1)] =array[i];
                      array[i]=temp2;

                }else // inner if
                {
                 array[array.length-j] =array[i];
                  array[i]=temp;
                }

            }else //main if
            {
                //nothing needed

            }

        }

        for(int k=0;k<array.length;k++) {
            System.out.print(" "+ array[k]);
        }

    }

}
-1
source 
List < Integer > odd = new ArrayList < Integer > ();

List < Integer > even = new ArrayList < Integer > ();

int a [] = {0,2,3,98,1,6546,45323,1134564};

int i;
for (i = 0; i < a.length; i++) {

    if (a[i] % 2 == 0) {

        even.add(a[i]);

    } else {

        odd.add(a[i]);

    }
}

System.out.print("Even: " + even + "\n");
System.out.print("Uneven: " + odd + "\n");
}
}
-1
source

Source: https://habr.com/ru/post/1769488/

More articles:


All Articles