Question

如何排序数组

int[] A = {0,1,1,0,1,0,1,1,0}

Answer 1

您实际上只能通过遍历数组一次对此数组进行排序。

以下是我的代码片段：

    int arr[] = {1,1,1,1,0,   0,1,0,1,1,1};
    int arrb[] = new int[arr.length];
    int zeroInsertIndex = 0;
    int oneInsertIndex =arrb.length-1;

    for(int i=0; i<arr.length; i++){
        if(arr[i] == 1) 
            arrb[oneInsertIndex--] = 1;
        else if (arr[i] == 0) 
            arrb[zeroInsertIndex++] = 0;
    }
    for(int i=0;i<arrb.length;i++)
        System.out.print(arrb[i] + " ");

Answer 2

虽然Arrays.sort是一个明显的，简单的O（n log n）解决方案，但是针对这种特殊情况有一个O（n）解决方案：

计算零的数量，zeroCount。
将第一个zeroCount元素填充为0，其余元素填充为1。

这只需要两次遍历数组。

更一般地说，任何只有少量不同值的数组都可以通过计算每个值出现的次数进行排序，然后相应地填充数组。

Answer 3

使用任何排序算法来完成它。初学者使用冒泡排序（易于理解）
请参阅Wiki

public static void bubble_srt( int a[], int n ){
  int i, j,t=0;
  for(i = 0; i < n; i++){
    for(j = 1; j < (n-i); j++){
      if(a[j-1] > a[j]){
        t = a[j-1];
        a[j-1]=a[j];
        a[j]=t;
      }
    }
  }
}

<强> EDITED
正如@Pradeep所说：你肯定可以使用Array.sort（）

Answer 4

你的数组只包含0和1，所以对数组中的所有元素求和，然后用最后的那些'1'重置数组，并在开头休息'0'。时间复杂度也是具有恒定空间的O（n）。所以这似乎是最好和最容易的。

 public static void main(String[] args) {
    int[] A = { 0, 1, 1, 0, 1, 0, 1, 1, 0 };
    int sum = 0;
    for (int i = 0; i < A.length; i++)
        sum = sum + A[i];

    Arrays.fill(A, A.length - sum, A.length, 1);
    Arrays.fill(A, 0, A.length - sum, 0);
    System.out.println(Arrays.toString(A));

  }

试试这个我实现了上面的算法。

输出：

[0, 0, 0, 0, 1, 1, 1, 1, 1]

Answer 5

您可以使用Arrays课程中的Arrays.sort方法：

int[] A = {0,1,1,0,1,0,1,1,0};
Arrays.sort(A);
System.out.println(A);

Answer 6

Arrays.sort（A，Collections.reverseOrder（））;

Answer 7

USE

 Arrays.sort(A);

对数组进行排序的方法。

Answer 8

实际上，标准的现成排序算法通常适用于O（n * log（n））。添加所有值（即1的数量）后，您可以直接运行数组。假设你把它放在count1中。然后再次在阵列上设置第一个count1位置为1，其余位置为0.需要2个步骤。

当然，正如其他海报所说的那样：这种优化就是你在检测到瓶颈时所做的，而不是在你开始时立即开始。

Answer 9

您也可以尝试这样

public static void main(String[] args) {
    int inputArray[] = { 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0 };
    formatInputArray(inputArray);

}

private static void formatInputArray(int[] inputArray) {
    int count = 0;
    for (int i = 0; i < inputArray.length; i++) {
        if (inputArray[i] == 0) {
            count++;
        }
    }
    // System.out.println(count);
    for (int i = 0; i < inputArray.length; i++) {
        if (i < count) {
            inputArray[i] = 0;
        }

        else {
            inputArray[i] = 1;
        }
    }
    for (int i = 0; i < inputArray.length; i++) {
        System.out.print(inputArray[i] + " , ");
    }

}

Answer 10

仅包含0,1和2的排序数组

import java.util.*;
public class HelloWorld {

static void sort012(int []a, int length) {
    int start = 0;
    int mid = 0;
    int end = length - 1;
    int temp;
    while(mid<=end) {
        switch(a[mid]) {
            case 0:
                temp = a[start];
                a[start] = a[mid];
                a[mid] = temp;
                start++;
                mid++;
                break;
            case 1:
                mid++;
                break;
            case 2: 
              temp = a[end];
                a[end] = a[mid];
                a[mid] = temp;
                end--;
                break;
        }


    }

}

 public static void main(String []args){
     Scanner sc = new Scanner(System.in);
     int n = sc.nextInt();

    int a[] = new int[n];
    for (int i =0;i<n; i++)
    a[i] = sc.nextInt();

     HelloWorld.sort012(a, n);
    // Print the sorted Array
    for (int i =0;i<n; i++)
    System.out.println(a[i]);

 }
 }

Answer 11

var binaryArr = [1,1,1,0,1,0,1,0,1,1,1,1,1,1,1,1,0,0,1,0,1,0,0,0,0];

//i - starting index
//j - ending index
function binarySort(arr){
   var i=0,j=arr.length-1;
   for(;i!=j;){
       if(arr[i] == 1){
           if(arr[j] == 0){
               arr[i] = 0;
               arr[j] = 1;
               j--;
               i++;
           } else {
               j--;
           }
       }else{
         i++;
       }
   }
}
binarySort(binaryArr);

Answer 12

使用以下代码对0和1数组进行排序：

public static int[] sortArray(int[] array){
        int first = 0;
        int last = array.length-1;
        while(first<last){
            if(array[first]==0){
                first++;
            }else if(array[last] == 0){
                int temp = array[last];
                array[last] = array[first];
                array[first] = temp;
                first++;
            }else{
                last--;
            }
        }
        return array;
    }

Answer 13

public static void sort(int a[]) {
        int sum=0;
        int b[]= new int [a.length];
        for(int i=0;i<a.length;i++) {
            sum=sum+a[i];
        }
        System.out.println(sum);
        int j=b.length-1;
        while(sum>0) {
            b[j]=1;
            sum--;
            j--;
        }
        
        System.out.println(Arrays.toString(b));

    }

Answer 14

以下代码将对您的数组进行排序。请注意，它是在原地执行的 - 因此它会修改内存中的对象而不是返回一个新对象。

在 Python 中

arr=[0,1,0,0,1,1,1,0,1,1,0]
arr.sort()
print(arr)

在 Java 中

public class test{
public static void main(String[] args){
int[] arr= {0,1,0,0,1,1,1,0,1,1,0};
Arrays.sort(arr); 
System.out.println(Arrays.toString(arr));
}}

Answer 15

public class Test {
 public static void main(String[] args) {
    int[] arr = {0, 1, 0, 1, 0, 0, 1, 1, 1, 0};
    int start = 0;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == 0) {
            arr[start] = 0;
            if (i != start) {  // should not override same value with 1
                arr[i] = 1;
            }
            start++;
        }
    }

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

//复杂度为O(n)

在java中为仅包含0和1的数组排序

16 个答案: