Java中的数组排序

用Java编写一个静态方法：

public static void sortByFour (int[] arr)

它接收一个充满非负数（零或正数）的数组作为参数，并按以下方式对数组进行排序：

• 在数组的开头，将显示所有可被4整除的数字

• 在它们之后，将出现数组中所有被4除1余数的数字

• 在它们之后，将显示数组中所有被4除2余数的数字

• 在数组的末尾，将显示所有剩余的数字（被4除以剩余3的数字）

（每组中数字的顺序并不重要。）

这种方法必须尽可能有效

以下是我写的，但不幸的是，它没有很好地工作(

公共静态无效交换（int[]arr，int left，int right）
{
内部温度=arr[左]；
arr[左]=arr[右]；
arr[右]=温度；
}
公共静态无效排序四（int[]arr）
{
int左=0；
int right=（arr.length-1）；
int mid=（arr.length/2）；
while（左<右）
{
如果（（arr[左]%4）>（arr[右]%4））
{
交换（arr、左、右）；
对--；
}
如果（（arr[左]%4）==（arr[右]%4））
左++；
其他的
左++；
}
}

如何修复或重写代码以使其正常工作？

阅读本页

---

从长远来看，这对你的帮助最大。这也很有趣！

我会用psuedocode为你做这件事，但用代码做这件事会给你答案，这是家庭作业，你可以自己做工作。=p

下面是如何在没有列表的情况下完成此操作。此示例根据需求进行了限制，但在编写代码后即可使用

int bucketSize = (arr.length() / 4) + 1;

int bucket1[bucketSize];
int bucket2[bucketSize];
int bucket3[bucketSize];
int bucket4[bucketSize];

for (int i=0; i<arr.length; i++) {
    if ((arr[i] % 4) == 0)
        put arr[i] in bucket 1
    else if ((arr[i] % 4) == 1)
        put arr[i] in bucket 2
    else if ((arr[i] % 4) == 2)
        put arr[i] in bucket 3
    else
        put arr[i] in bucket 4
}

for (int i=0; i<4; i++) {
    this will go for each bucket
    for (int j=0; j<bucketSize; j++) {
        do sort of your choice here to sort the given bucket
        the sort you used in your code will do fine (the swapping)
    }
}

int bucketSize=（arr.length（）/4）+1；
内码bucket1[bucketSize]；
整数bucket2[bucketSize]；
整数bucket3[bucketSize]；
内码bucket4[bucketSize]；
对于（int i=0；i您可以这样处理问题：

选择要使用的排序算法。看起来您正在尝试编程，但也可以使用
识别算法中比较输入数组中两个值的点。例如，在Wikipedia文章中气泡排序的伪代码中，唯一的比较是行
，如果A[i]>A[i+1]，则…
找出一种比较两个数字的方法，这样一个被4除时余数为0的数字s被认为小于一个被4除时余数为1的数字t。用您的计算替换算法的比较操作（例如，
如果myIsGreater（a[i]，a[i+1]），那么…
）
对于第3步，通过考虑模运算符，您肯定走上了正确的轨道。
我将重申Daniel所说的：您可以选择排序算法。如果这是要求的话，请使用到目前为止您在本课程中介绍过的最有效的算法。但是当您到达算法中两个项目被比较的点时红色，比较它们的值mod 4。因此类似于
如果A[i]>A[j]
的值变成
如果A[i]%4>如果A[j]%4
。然后继续执行算法指定的对该数组元素执行的任何操作。交换它，使其冒泡，返回它，无论调用什么

System.out.println(-1 % 2); // prints "-1"

关于你发布的代码，我认为它不适合快速修复。它应该使用哪种算法？mid

是干什么用的？我认为，一旦你知道你打算使用哪种算法，并找出哪行代码包含比较，你就能够快速看到并编写解决方案

一般来说，对于这类事情，如果你在担心效率之前专注于获得一个有效的解决方案，它会有所帮助。我第一次不得不做这样的问题时使用了选择排序。我建议先尝试一下，然后使用获得的经验来做一个合并排序，即O（n log n）.

线性时间解 要做到这一点，最渐进有效的方法是使用

• 您有4个存储桶，每个存储桶对应于模4的同余数类
• 扫描数组中的数字一次
  • 把每个数字放在正确的桶里
• 然后构造输出数组
  • 首先放入存储桶0中的所有数字，然后放入存储桶1中的所有数字，然后放入存储桶2，最后放入存储桶3

因此，这将对

O（N）

中的数字进行排序，这是最优的。这里的关键是，通过对模4的数字进行排序，实际上只有4个数字需要排序：0、1、2、3

---

带有

List

下面是上述算法的一个实现（对于一般模

M

），为清晰起见，使用和实现每个算法。忽略未检查的强制转换警告，只需专注于理解算法

import java.util.*;

public class BucketModulo {
    public static void main(String[] args) {
        final int M = 4;
        List<Integer> nums = Arrays.asList(13,7,42,1,6,8,1,4,9,12,11,5);
        List<Integer>[] buckets = (List<Integer>[]) new List[M];
        for (int i = 0; i < M; i++) {
            buckets[i] = new ArrayList<Integer>();
        }
        for (int num : nums) {
            buckets[num % M].add(num);
        }
        nums = new ArrayList<Integer>();
        for (List<Integer> bucket : buckets) {
            nums.addAll(bucket);
        }
        System.out.println(nums);
        // prints "[8, 4, 12, 13, 1, 1, 9, 5, 42, 6, 7, 11]"
    }
}

工具书类

---

这里有一个类似Java的方法

    Arrays.sort(arr,new Comparator<Integer>(){
      public int compare(Integer a,Integer b)
      {
        return (a % 4) - (b % 4);
      }
    });

Arrays.sort（arr，新的比较器（）{
公共整数比较（整数a、整数b）
{
返回（a%4）-（b%4）；
}
});

我读了它…实际上对我没有帮助。如果有人能帮助我修复代码，使其正常工作，我将非常感激。我已经在这个问题上纠缠了好几个小时了。如果我们只是修复代码，而你不理解为什么它不工作，它对你没有帮助。我知道，但当我有了修复的代码，我会检查它为什么不工作以前不起作用。解释为什么它不起作用会对我帮助更大。@user:你的代码不起作用，因为它是错误的。就这么简单。没有简单的解决方法。就像：嘿，我有这个打印报告系统，这就是我目前拥有的

system.out.println（“地狱世界”）

请帮我修好它，让我做剩下的事情。@VeeArr很好，很明显。但这是一个好问题。没错，但我试图解决它，但它不起作用，这就是我寻求帮助的原因。为什么你是y

    Arrays.sort(arr,new Comparator<Integer>(){
      public int compare(Integer a,Integer b)
      {
        return (a % 4) - (b % 4);
      }
    });