23

辞書順で 3 つの配列を並べ替えようとしています。配列は、共通の配列によって相互に関連付けられています。次の例を示すと、説明が簡単になります。

int[] record = new int[4];
String [] colors = {"blue", "yellow", "red", "black"};
String [] clothes = {"shoes", "pants", "boots", "coat"};

コンソールに出力するときは、以下のような 3 つの列に配置したいと思います。

未分類:

Record  Color   Clothes
0       blue    shoes
1       yellow  pants
2       red     boots
3       black   coat

色で並べ替え:

Record  Color   Clothes
3       black   coat
0       blue    shoes
2       red     boots
1       yellow  pants

服で並べ替え:

Record  Color   Clothes
2       red     boots
3       black   coat
1       yellow  pants
0       blue    shoes

私のシナリオに似た以前の回答を見つけましたが、文字列ではなく整数を比較していたため、compareTo()メソッドの使用とArrays.sort()目的の出力に到達するのに問題があります。

どんな助けでも大歓迎です！

4

12 に答える 12

11

場合によっては、ソートを行うためだけに新しいクラスを作成してもあまり意味がありません。

List<?>は、キー リスト ( ) に基づいて、任意の数の任意に型指定されたリスト ( ) を並べ替えるために使用できる関数ですList<T implements Comparable>。 ここにイデオンの例があります。

使用法

関数を使用して、任意のタイプの複数のリストをソートする方法の例を次に示します。

List<Integer> ids = Arrays.asList(0, 1, 2, 3);
List<String> colors = Arrays.asList("blue", "yellow", "red", "black");
List<String> clothes = Arrays.asList("shoes", "pants", "boots", "coat");

// Sort By ID
concurrentSort(ids, ids, colors, clothes);

// Sort By Color
concurrentSort(colors, ids, colors, clothes);

// Sort By Clothes
concurrentSort(clothes, ids, colors, clothes);

出力： 

// Sorted By ID:
ID:      [0, 1, 2, 3]
Colors:  [blue, yellow, red, black]
Clothes: [shoes, pants, boots, coat]

// Sorted By Color:
ID:      [3, 0, 2, 1]
Colors:  [black, blue, red, yellow]
Clothes: [coat, shoes, boots, pants]

// Sorted By Clothes:
ID:      [2, 3, 1, 0]
Colors:  [red, black, yellow, blue]
Clothes: [boots, coat, pants, shoes]

コード

パラメータの検証とテスト ケースを含むIdeone の例をここで見つけることができます。

public static <T extends Comparable<T>> void concurrentSort(
                                        final List<T> key, List<?>... lists){
    // Create a List of indices
    List<Integer> indices = new ArrayList<Integer>();
    for(int i = 0; i < key.size(); i++)
        indices.add(i);

    // Sort the indices list based on the key
    Collections.sort(indices, new Comparator<Integer>(){
        @Override public int compare(Integer i, Integer j) {
            return key.get(i).compareTo(key.get(j));
        }
    });

    // Create a mapping that allows sorting of the List by N swaps.
    // Only swaps can be used since we do not know the type of the lists
    Map<Integer,Integer> swapMap = new HashMap<Integer, Integer>(indices.size());
    List<Integer> swapFrom = new ArrayList<Integer>(indices.size()),
                  swapTo   = new ArrayList<Integer>(indices.size());
    for(int i = 0; i < key.size(); i++){
        int k = indices.get(i);
        while(i != k && swapMap.containsKey(k))
            k = swapMap.get(k);

        swapFrom.add(i);
        swapTo.add(k);
        swapMap.put(i, k);
    }

    // use the swap order to sort each list by swapping elements
    for(List<?> list : lists)
        for(int i = 0; i < list.size(); i++)
            Collections.swap(list, swapFrom.get(i), swapTo.get(i));
}

注:実行時間は、リストの長さであり、リストO(mlog(m) + mN)の数です。通常、実行時間は、キーのみをソートするよりも重要ではありません。mNm >> NO(mlog(m))

于 2014-07-11T01:12:17.937 に答える
7

とが一緒に属しているように見えるのでRecord、カスタム オブジェクトで一緒に移動することをお勧めします。ColorClothes

public class ClothesItem {
    int record;
    String color;
    String clothes;
}

次に、さまざまな を作成Comparatorして、さまざまな種類の並べ替えを実行できます。

複数の配列で現在の構造を保持する必要がある場合、@Jherico には、ソートされたインデックスの配列を取得するソート ソリューションがあります。これにより、必要な結果を簡単に得ることができます。

于 2012-08-28T18:00:19.607 に答える
3

了解しました。最終的な形は次のようになります。

// ColorClothes.java

import java.util.*;


public class ColorClothes
{
public int record;
public String color;
public String clothes;

public static void main(String[] args)
{
    Initialize();
}

public ColorClothes(int record, String color, String clothes)
{
    this.record = record;
    this.color = color;
    this.clothes = clothes;
}

public static void Initialize()
{
    List<ColorClothes> list = new ArrayList();
    list = CreateList();

    Sort(list, "Unsorted", 1);
    Sort(list, "\nSortedByColor", 2);
    Sort(list, "\nSortedByClothes", 3);
    Sort(list, "\nSortedByRecord", 4);
}


public static List<ColorClothes> CreateList()
{
    List<ColorClothes> list = new ArrayList();
    list.add(new ColorClothes(1, "blue  ", "shoes"));
    list.add(new ColorClothes(0, "yellow", "pants"));
    list.add(new ColorClothes(3, "red   ", "boots"));
    list.add(new ColorClothes(2, "black ", "coat"));

    return list;
}

public static void Print(List<ColorClothes> list)
{
    for (ColorClothes item : list)
    {
        System.out.println(item.record + "    " + item.color + "   " + item.clothes);
    }
}

public static void Sort(List<ColorClothes> list, String string, int choice)
{
    System.out.println(string + "\n");

    switch (choice)
    {
    case 1:
        break;
    case 2:
        Collections.sort(list, new ColorComparator());
        break;
    case 3:
        Collections.sort(list, new ClothesComparator());
        break;
    case 4:
        Collections.sort(list, new RecordComparator());
        break;
    }

    Print(list);
}

} // End class.

// ColorComparator.java

import java.util.Comparator;

 class ColorComparator implements Comparator
 {
public int compare(Object str1, Object str2)
{
    String str1Color = ((ColorClothes)str1).color;
    String str2Color = ((ColorClothes)str2).color;

    return str1Color.compareTo(str2Color);

}
}// End class.

// ClothesComparator.java

import java.util.Comparator;


class ClothesComparator implements Comparator
{
public int compare(Object str1, Object str2)
{
    String str1Clothes = ((ColorClothes)str1).clothes;
    String str2Clothes = ((ColorClothes)str2).clothes;

    return str1Clothes.compareTo(str2Clothes);

}
} // End class.

// RecordComparator.java

import java.util.Comparator;


public class RecordComparator implements Comparator 
{
public int compare(Object rec1, Object rec2)
{
    int rec1Rec = ((ColorClothes)rec1).record;
    int rec2Rec = ((ColorClothes)rec2).record;

    if(rec1Rec > rec2Rec)
    {
        return 1;
    }
    else if(rec1Rec < rec2Rec)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}
}// End class.

コンソール出力

Unsorted

1    blue     shoes
0    yellow   pants
3    red      boots
2    black    coat

SortedByColor

2    black    coat
1    blue     shoes
3    red      boots
0    yellow   pants

SortedByClothes

3    red      boots
2    black    coat
0    yellow   pants
1    blue     shoes

SortedByRecord

0    yellow   pants
1    blue     shoes
2    black    coat
3    red      boots
于 2012-08-29T16:17:07.533 に答える
1

これは、同じ長さの 2 つ以上の文字列配列を並べ替えて、最初の配列が順番に並べられ、他の配列がその順序に一致するようにする方法です。

public static void order(String[]... arrays)
{
    //Note: There aren't any checks that the arrays
    // are the same length, or even that there are
    // any arrays! So exceptions can be expected...
    final String[] first = arrays[0];

    // Create an array of indices, initially in order.
    Integer[] indices = ascendingIntegerArray(first.length);

    // Sort the indices in order of the first array's items.
    Arrays.sort(indices, new Comparator<Integer>()
        {
            public int compare(Integer i1, Integer i2)
            {
                return
                    first[i1].compareToIgnoreCase(
                    first[i2]);
            }
        });

    // Sort the input arrays in the order
    // specified by the indices array.
    for (int i = 0; i < indices.length; i++)
    {
        int thisIndex = indices[i];

        for (String[] arr : arrays)
        {
            swap(arr, i, thisIndex);
        }

        // Find the index which references the switched
        // position and update it with the new index.
        for (int j = i+1; j < indices.length; j++)
        {
            if (indices[j] == i)
            {
                indices[j] = thisIndex;
                break;
            }
        }
    }
    // Note: The indices array is now trashed.
    // The first array is now in order and all other
    // arrays match that order.
}

public static Integer[] ascendingIntegerArray(int length)
{
    Integer[] array = new Integer[length];
    for (int i = 0; i < array.length; i++)
    {
        array[i] = i;
    }
    return array;
}

public static <T> void swap(T[] array, int i1, int i2)
{
    T temp = array[i1];
    array[i1] = array[i2];
    array[i2] = temp;
}

他のタイプの配列でこれを行いたい場合は、これをいくらかリファクタリングする必要があります。または、整数配列を文字列配列と一緒に並べ替えるには、整数を文字列に変換できます。

于 2013-02-12T22:47:42.677 に答える
1

配列を間接的にソートします。すべての配列にインデックスを付け、目的の配列のインデックス配列のみを並べ替えます。このSO postのソリューションをご覧ください。これにより、配列の一貫性が保たれます。ただし、これを N 配列を同期して並べ替えることが簡単かどうかはわかりませんが、データを複数の配列に分散させたい場合に備えて、問題に対処する方法のアイデアが得られるはずです。何人かがすでに指摘しているように、データを単一のオブジェクトにグループ化することは良いアプローチです。

于 2012-08-28T18:17:35.497 に答える
1

一度に複数の配列を並べ替えるかどうかはわかりません。あなたが使用したユースケースを見ると、これは3つの属性すべてをオブジェクトに結合でき、オブジェクトの配列を複数の方法でソートできる候補のように見えます。

本当に 3 つのアレイが必要ですか?

の配列はColoredClothあなたのように機能しますか:

class ColoredCloth implements Comparable<ColoredCloth>{
    int id;
    String color;
    String cloth;
}

とでComparatorsソートする のカップルを定義します。colorcloth

于 2012-08-28T18:03:34.173 に答える
0

助けてくれてありがとう。

私は配列の使用とそれらの配列の並べ替えに固執していたので (それが私に必要だったので)、代わりにオブジェクトを作成することさえ考えませんでした。

この単純なプログラムを使用すると、オブジェクトを作成し、オブジェクト内のフィールドを並べ替えることができます。色や服装はあくまで一例です。

これが私の完成したコードです：

// ColorClothes.java

import java.util.*;


public class ColorClothes
{
public int record;
public String color;
public String clothes;

public static void main(String[] args)
{
    Initialize();
}

public static void Initialize()
{
    ColorClothes item[] = new ColorClothes[4];

    item[0] = new ColorClothes();
    item[0].record = 0;
    item[0].color = "blue";
    item[0].clothes = "shoes";

    item[1] = new ColorClothes();
    item[1].record = 1;
    item[1].color = "yellow";
    item[1].clothes = "pants";

    item[2] = new ColorClothes();
    item[2].record = 2;
    item[2].color = "red";
    item[2].clothes = "boots";

    item[3] = new ColorClothes();
    item[3].record = 3;
    item[3].color = "black";
    item[3].clothes = "coat";

    System.out.println("Unsorted");

    for(int i = 0; i < item.length; i++)
    {
        System.out.println(item[i].record + "     " + item[i].color + "     " + item[i].clothes);
    }

    System.out.println("\nSorted By Color\n");

    Arrays.sort(item, new ColorComparator());

    for(int i = 0; i < item.length; i++)
    {
        System.out.println(item[i].record + "     " + item[i].color + "     " + item[i].clothes);
    }

    System.out.println("\nSorted By Clothes\n");

    Arrays.sort(item, new ClothesComparator());

    for(int i = 0; i < item.length; i++)
    {
        System.out.println(item[i].record + "     " + item[i].color + "     " + item[i].clothes);
    }

}

}// End class.

// ColorComparator.java

import java.util.Comparator;

class ColorComparator implements Comparator
{
public int compare(Object str1, Object str2)
{
    String str1Color = ((ColorClothes)str1).color;
    String str2Color = ((ColorClothes)str2).color;

    return str1Color.compareTo(str2Color);

}
}// End class.

// ClothesComparator.java

import java.util.Comparator;


class ClothesComparator implements Comparator
{
public int compare(Object str1, Object str2)
{
    String str1Clothes = ((ColorClothes)str1).clothes;
    String str2Clothes = ((ColorClothes)str2).clothes;

    return str1Clothes.compareTo(str2Clothes);

}
} // End class.

コンソール出力

Unsorted
0     blue     shoes
1     yellow     pants
2     red     boots
3     black     coat

Sorted By Color

3     black     coat
0     blue     shoes
2     red     boots
1     yellow     pants

Sorted By Clothes

2     red     boots
3     black     coat
1     yellow     pants
0     blue     shoes

後でレコード/整数によるソートを可能にする別の Comparator を追加します。また、1 つの大きなブロックにならないようにコードをさらに圧縮しますが、その日の作業はほぼ完了です。

于 2012-08-28T21:16:18.243 に答える
0

他の人が示唆したように、3 つの配列を同期的に並べ替えるよりも、オブジェクトのコレクションを並べ替える方が簡単です。

何らかの理由で複数の配列の並べ替えに固執する必要がある場合は、次のアプローチを使用できます-アイデアは、1つではなく3つの配列に支えられた配列リストの独自のバリアントを実装することです。

import java.util.AbstractList;
import java.util.Collections;

public class SortMultipleArrays extends AbstractList {

    //object representing tuple from three arrays
    private static class ClothesItem implements Comparable<ClothesItem> {
        int record;
        String color;
        String clothes;

        public ClothesItem(int record, String color, String clothes) {
            this.record = record;
            this.color = color;
            this.clothes = clothes;
        }

        @Override
        public int compareTo(ClothesItem o) {
            return this.color.compareTo(o.color); //sorting by COLOR
        }
    }

    private int[] records;
    private String[] colors;
    private String[] clothes;

    public SortMultipleArrays(int[] records, String[] colors, String[] clothes) {
        this.records = records;
        this.colors = colors;
        this.clothes = clothes;
    }

    @Override
    public Object get(int index) {
        return new ClothesItem(records[index], colors[index], clothes[index]);
    }

    @Override
    public int size() {
        return records.length;
    }

    @Override
    public Object set(int index, Object element) {
        ClothesItem item = (ClothesItem) element;
        ClothesItem old = (ClothesItem) get(index);

        records[index] = item.record;
        colors[index] = item.color;
        clothes[index] = item.clothes;

        return old;
    }

    public static void main(String[] args) {
        int[] record = {0,1,2,3};
        String[] colors = {"blue", "yellow", "red", "black"};
        String[] clothes = {"shoes", "pants", "boots", "coat"};

        final SortMultipleArrays multipleArrays = new SortMultipleArrays(record, colors, clothes);
        Collections.sort(multipleArrays);

        System.out.println("Record  Color   Clothes");
        for (int i = 0; i < record.length; i++) {
            System.out.println(String.format("%8s %8s %8s", record[i], colors[i], clothes[i]));
        }
    }
}

この実装は、Collections.sort(...) に必要な List インターフェイスの実装を容易にする AbstractList に基づいています。

この実装には非効率性が隠されている可能性があることに注意してください: get( ...) メソッドとset(...)メソッドの両方がラッパー オブジェクトのインスタンスを作成しているため、大きな配列をソートするときに作成されるオブジェクトが多すぎる可能性があります。

于 2012-09-06T20:53:21.480 に答える
0

データを @SiB のようなカスタム クラスに入れます。

class ColoredClothes {
    int id;
    String color;
    String cloth;
}

次に、このクラスの各インスタンスを、色をキーとして TreeMap に配置します (または、並べ替えの基準に応じて布の名前を指定します)。

TreeMap<String,ColoredClothes> sortedCloth= new TreeMap<String,ColoredClothes>();
//loop through arrays and put new ColoredClothes into Map

次に、次のようにソートされた値を取得します。

Collection<ColoredClothes> values = sortedCloth.values();

values.iterator() を使用して、これらを順番に繰り返すことができます

于 2012-08-28T18:13:32.113 に答える
0

以下のようにクラスを作成することをお勧めします

class Dress {
  public int record;
  public String color;
  public String clothes;
}

以下のようにドレスのリストを維持します

List<Dress> dressCollection = new ArrayList<Dress>();

色と服に基づいてコンパレータを実装します。

List<Dress> resultBasedOnColor = Collections.sort(dressCollection, new Comparator<Dress>() {
   public int compareTo(Dress obj1, Dress obj2) {
     return obj1.color.compareTo(obj2.color);
 }

});

質問の所有者の演習として、服装に基づいた並べ替えを残しました。

于 2012-08-28T18:09:56.373 に答える
-4 
import java.util.Arrays;

Arrays.sort (int [])
Arrays.sort (String [])

これにより、文字列の配列がソートされます。

于 2012-08-28T18:13:08.773 に答える