Java-整理数组

Question

I am encountering some slight and stupid issue while trying to sort out my arrays. So here's what I'm doing and what I want to do :

I generate an array of ints (good ol' t = new int[];) filled with random generated numbers from -1 to 9. The size of the array is irrelevant. I would like to make so that each "-1" will get to the end of the array while every other will get "pushed" to take the place.

As I'm not a native english speaker it's really hard to express myself correctly on this.

Example : my array is : 9 2 -1 4 6 -1 I want : 9 2 4 6 -1 -1

I currrently managed to get this BUT it won't work if there are two consecutives -1 cause the second one will get swapped.

Ex : Initial : 9 2 -1 -1 4 6 After modif : 9 2 -1 4 6 -1

As I said the problem is probably really near from being solved but I really can't find a fix right now.

Here's my code :

    for(int i=0;i<NB_CARD;i++)
    {
        t[i]=randomGenerator.nextInt(10)-1;
        System.out.print("t["+i+"]= "+t[i]+"\t\t");
        if(i==4){System.out.println("");}
    }

    //each -1 should be at the end of array
    for(int i=0;i<NB_CARD;i++)
    {
        int tmp=0;

        if(t[i]==-1) 
        {
            for(int y=i;y<NB_CARD-1;y++)
            {
                    tmp=t[y+1];
                    t[y+1]=t[y];
                    t[y]=tmp;
            }
        }
    }

    for(int i=0;i<NB_CARD;i++)
    {
        System.out.print("t["+i+"]= "+t[i]+"\t\t");
        if(i==4){System.out.println("");}
    }

Thank you in advance for every tip/help that could lead me to solve this

Answer 1

A more efficient way of doing this with one loop is.

int j = 0;
// copy all the non -1 values down.
for (int i = 0; i < NB_CARD; i++)
    if (t[i] != -1)
       t[j++] = t[i];
// fill the rest with -1
Arrays.fill(t, j, NB_CARD, -1);

if NB_CARD == t.length you can do

int[] t = {3, -1, -1, -1, 4, 5, 6, -1, -1};
int j = 0;
// copy all the non -1 values down.
for (int i : t)
    if (i != -1)
       t[j++] = i;
// fill the rest with -1
Arrays.fill(t, j, t.length, -1);

System.out.println(Arrays.toString(t));

prints

[3, 4, 5, 6, -1, -1, -1, -1, -1]

In Java 8 you can do this

int[] t = {6, -1, -1, -1, 4, 5, 3, -1, -1};
List<Integer> sorted = IntStream.of(t).boxed()
        .sorted((a, b) -> (a > -1 ? 1 : 0) - (b > -1 ? 1 : 0))
        .collect(Collectors.toList());
for (int i = 0; i < t.length; i++)
    t[i] = sorted.get(i);
System.out.println(Arrays.toString(t));

which prints

[6, 4, 5, 3, -1, -1, -1, -1, -1]

though it is O(N log N) instead of O(N) and has more code.

Answer 2

我将使用Arrays.sort（T [] a，Comparator c） ，提供您自己的Comparator，它将-1放在输出的末尾。

Answer 3

You can convert the array into list, iterate over list and remove all -1, counting how many you removed. Then add that many at the end of the list. If the end result has to be an array, you can use List.toArray method to convert it back.

public static void main(String[] args) {
    Integer[] t = {3, -1, -1, -1, 4, 5, 6, -1, -1};

    List<Integer> list = new ArrayList<>();
    Collections.addAll(list, t);

    int numberOfMinusOnes = 0;
    for (Integer number : list) {
        if (number == -1) {
            numberOfMinusOnes++;
        }
    }

    list.removeAll(Arrays.asList(-1));

    for (int i = 0; i < numberOfMinusOnes; i++) {
        list.add(-1);
    }

    list.toArray(t);

    System.out.println(Arrays.toString(t));
}

Some of boiler plate code can be simplified using google collections library. I would also advise to extract some parts into separate methods to increase readability.

Answer 4

If I am understanding the code correctly, if you find a -1 , you eventually bubble it up to the end.

What you could do, would be to store the location of the current last element, which at the beginning would be n - 1 .

When you find a -1 , you could replace the i th element with the current last element and then, decrease the value of current by 1. This should allow you to always put any new -1 elements you encounter at the end.

Code wise:

    int[] t = new int[5];
    t[0] = -1; t[1] = -1; t[2] = 4;

    t[3] = -1;  //Just for demonstration purposes
    t[4] = -1;  //Just for demonstration purposes

    int currentLast = 0;

    for(int i = t.length - 1; i >=0; i--)
    {
        if(t[i] == -1)            
            currentLast = i - 1;
        else
            break;
    }

    for(int i = 0; i < t.length; i++)
        System.out.println(t[i]);

    System.out.println("After");


    for(int i = 0; i < currentLast; i++)
    {
        if(t[i] == -1)
        {   
            int temp = t[currentLast];
            t[currentLast] = t[i];
            t[i] = temp;
            currentLast--;
        }
    }

     for(int i = 0; i < t.length; i++)
        System.out.println(t[i]);
}

Yields:

-1
-1
4
-1
-1
After
4
-1
-1
-1
-1

Answer 5

Using bubble sort

package com.appkart.collections;

import java.util.Random;

public class Test {

    public void fillRandomNumber(int a[]) {
        Random random = new Random();
        for (int i = 0; i < a.length; i++) {
            a[i] = random.nextInt(10)-1;
        }
    }

    public void printNumber(int a[]) {
        for (int i = 0 ; i < a.length ;i++) {
            System.out.print(a[i] +" ");
        }
    }

    //Using bubble sort
    public void sortRandomNumber(int a[]) {
        int length = a.length;
        int temp;

        for (int i = 0; i < length; i++) {
            for (int j = 1; j < length - i; j++) {
                if (a[j - 1] < a[j]) {
                    temp = a[j - 1];
                    a[j - 1] = a[j];
                    a[j] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {

        int a[] = new int[10];
        Test test = new Test();
        test.fillRandomNumber(a);
        System.out.println("Random Number bofore sort");
        test.printNumber(a); 
        test.sortRandomNumber(a);
        System.out.println("\n Random Number after sort");
        test.printNumber(a); 
    }
}

Answer 6

You can use something like this:

int[] a = { 9, 2, -1, 4, 6, -1 };
for(int i=a.length-1; i>0; i--)
{
    for(int j=0; j<i; j++)
    {
        if(a[i] < a[j])
        {
            int jvalue = a[j];
            a[j] = a[i];
            a[i] = jvalue;
        }
    }
}