2

次のようなJavaの 2 次元配列があります。

各要素/ジョブには次のものがあります。

  • index[0]にあるジョブ番号;
  • index[1]にあるジョブ到着時刻。と
  • インデックスのジョブ バースト時間[2]
jobs[0][0] = 1
jobs[0][1] = 0
jobs[0][2] = 5

jobs[1][0] = 2
jobs[1][1] = 2
jobs[1][2] = 19

jobs[2][0] = 3
jobs[2][1] = 4
jobs[2][2] = 10

最初に、インデックス [1]による到着時間に従ってそれらを並べ替えたかったのですが、幸いなことに、次のコードを使用して行いました。

Arrays.sort(jobs, new Comparator<int[]>(){
    public int compare(int[] a, int[] b) {
        return a[1] - b[1];
    }
});

さて、私の問題は、インデックス[2]によるバースト時間に従ってソートしたいということです。これが TWIST です...最初の要素をスキップして、バースト時間 (インデックス [2]) に従って並べ替えるにはどうすればよいですか? job[0] を配列の上に残し、残りの要素を index[2] - バースト時間で並べ替えたいと思います。このような：

jobs[0][0] = 1
jobs[0][1] = 0
jobs[0][2] = 5

jobs[1][0] = 3
jobs[1][1] = 4
jobs[1][2] = 10

jobs[2][0] = 2
jobs[2][1] = 2
jobs[2][2] = 19

ジョブは、ジョブ 1 が一番上にあるバースト時間で並べ替えられています。上記で提供したコードで実装すると、はるかに優れたものになります。ありがとう

4

5 に答える 5

5

まず、配列ではなくコレクションを使用する必要があります。次に、オブジェクトを使用できる場合は配列を使用しないでください。

public class Job {
    private int number;
    private int arrival;
    private int burst;

    // constructor and getters omitted for brevity.
}

List<Job>の代わりに , を持つことができますint[][]。構造体の型を見るだけで、すでにより明確で読みやすくなっています。さまざまなタイプの可能性のある名前付き属性を持ち、メソッドで動作を追加できることは、オブジェクト指向のすべての一部です。よりもはるかに読みやすく、安全で、保守が容易int[]です。

幸いなことに、リストには配列よりもはるかに多くの機能があります。したがって、たとえば、subList を取得して、その subList を並べ替えることができます。

List<Job> jobsExceptFirstOne = allJobs.subList(1);
Collections.sort(jobsExceptFirstOne, new Comparator<Job>() {
    @Override
    public int compare(Job left, Job right) {
        return Integer.compare(left.getBurst(), right.getBurst());
    }
});

ほら。問題が解決しました。

于 2013-08-16T07:12:01.903 に答える
1

他の人が述べたように、配列ではなくよりスマートなコレクションを使用する必要があります。現在のコードを本当に使用したい場合は、次のようなものを使用できます。

final int[][] jobs = new int[][]{{1,0,5},{2,2,19},{3,4,10}};

 Arrays.sort(jobs, new Comparator<int[]>(){
    public int compare(int[] a, int[] b) {
        if(Arrays.equals(a, jobs[0]))
         return -1;
        else
         return a[2] - b[2];
    }
});

System.out.println(jobs[0][2]);
System.out.println(jobs[1][2]);
System.out.println(jobs[2][2]);

唯一の欠点は、配列が である必要があることfinalです。

于 2013-08-16T07:22:27.187 に答える
0

最初のジョブのジョブ番号を記憶する Comparator を使用し、それをバースト時間をチェックする前の最小値と見なします。

public class MyComparator implements Comparator<int[]> {

    private final int firstJob;

    public MyComparator(int firstJob) {
        this.firstJob = firstJob;
    }

    public int compare(int[] a, int[] b) {
        if (a[0] == b[0]) {
            return 0;
        }
        if (a[0] == firstJob) {
            return -1;
        }
        if (b[0] == firstJob) {
            return 1;
        }
        return Integer.compare(a[2], b[2]);
    }
}
于 2013-08-16T07:17:10.310 に答える
0

たぶん、これを使用する方法があるでしょう：

final Integer job1 = Integer.valueOf(jobs[0][0]);
final Integer job2 = Integer.valueOf(jobs[0][1]);

return job1.compareTo(job2);

valueOf(jobs[0][0]) が valueOf(jobs[0][1]) よりも大きいかどうかはよくわかりません。また、それらが互いにどのように対応しているかはよくわかりませんが、違いがあるに違いありません。それらを使用すると、返された数値がジョブ[0] [0]、ジョブ[1] [0]などの数値よりも大きいか小さいかに従ってソートできるはずです。

于 2013-08-16T07:14:25.330 に答える