-1

3 つのリストがあるとします。

 a = {a, b, c, d, e}  
 b = {A, B, C}  
 c = {aa, bb, cc, dd}

ここで、各リストから 3 つの要素を取得し、リスト a から c までの新しいリストに挿入する必要があります。したがって、新しいリストは次のようになります。

newlist = {a, b, c, A, B, C, aa, bb, cc, d, e, dd}

Javaでこれを行う最速の方法は何ですか?

[更新]
要件をより明確にするためにデータ型を統一します。

4

1 に答える 1

0

を使用するIterables.concat(Iterable<T> ...)と、すべてのイテラブルのライブビューが作成され、1つに連結されます（イテラブルを変更すると、連結バージョンも変更されます）。次に、連結されたiterableをでラップしIterables.unmodifiableIterable(Iterable<T>)ます（以前は読み取り専用の要件を見ていませんでした）。

JavaDocsからIterables.concat( .. )：

複数のイテラブルを1つのイテラブルに結合します。返されるイテレータには、入力内の各イテレータの要素をトラバースするイテレータがあります。入力イテレータは、必要になるまでポーリングされません。返されたイテレータのイテレータは、対応する入力イテレータがremove（）をサポートしている場合、remove（）をサポートします。

これはこれがライブビューであることを明示的に示していませんが、最後の文はそれがライブビューであることを意味します（Iterator.remove()バッキングイテレータがサポートしている場合にのみメソッドをサポートすることは、ライブビューを使用しない限り不可能です）

サンプルコード：

final List<Integer> first  = Lists.newArrayList(1, 2, 3);
final List<Integer> second = Lists.newArrayList(4, 5, 6);
final List<Integer> third  = Lists.newArrayList(7, 8, 9);
final Iterable<Integer> all =
    Iterables.unmodifiableIterable(
        Iterables.concat(first, second, third));
System.out.println(all);
third.add(9999999);
System.out.println(all);

出力：

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 999, 9999]

結果を取得した後、単一のリストを並べ替えることができます。

マージソートは本当に簡単です。

/**
 * Mergesort algorithm.
 * @param a an array of Comparable items.
 */
public static void mergeSort( Comparable [ ] a ) {
    Comparable [ ] tmpArray = new Comparable[ a.length ];
    mergeSort( a, tmpArray, 0, a.length - 1 );
}

/**
 * Internal method that makes recursive calls.
 * @param a an array of Comparable items.
 * @param tmpArray an array to place the merged result.
 * @param left the left-most index of the subarray.
 * @param right the right-most index of the subarray.
 */
private static void mergeSort( Comparable [ ] a, Comparable [ ] tmpArray,
        int left, int right ) {
    if( left < right ) {
        int center = ( left + right ) / 2;
        mergeSort( a, tmpArray, left, center );
        mergeSort( a, tmpArray, center + 1, right );
        merge( a, tmpArray, left, center + 1, right );
    }
}

/**
 * Internal method that merges two sorted halves of a subarray.
 * @param a an array of Comparable items.
 * @param tmpArray an array to place the merged result.
 * @param leftPos the left-most index of the subarray.
 * @param rightPos the index of the start of the second half.
 * @param rightEnd the right-most index of the subarray.
 */
private static void merge( Comparable [ ] a, Comparable [ ] tmpArray,
        int leftPos, int rightPos, int rightEnd ) {
    int leftEnd = rightPos - 1;
    int tmpPos = leftPos;
    int numElements = rightEnd - leftPos + 1;

    // Main loop
    while( leftPos <= leftEnd && rightPos <= rightEnd )
        if( a[ leftPos ].compareTo( a[ rightPos ] ) <= 0 )
            tmpArray[ tmpPos++ ] = a[ leftPos++ ];
        else
            tmpArray[ tmpPos++ ] = a[ rightPos++ ];

    while( leftPos <= leftEnd )    // Copy rest of first half
        tmpArray[ tmpPos++ ] = a[ leftPos++ ];

    while( rightPos <= rightEnd )  // Copy rest of right half
        tmpArray[ tmpPos++ ] = a[ rightPos++ ];

    // Copy tmpArray back
    for( int i = 0; i < numElements; i++, rightEnd-- )
        a[ rightEnd ] = tmpArray[ rightEnd ];
}
于 2013-01-16T05:48:58.683 に答える