Question

我正在处理一个问题，我有一个未排序的数组。我需要处理这个数组，以便生成一个索引数组，就像它按升序排序一样。

示例1：

让我说我有一个未排序的数组[9,7,8,6,12]

作为输出，我需要一个索引数组[3,1,2,0,4]。

示例2：

未排序数组：[10,9,11,8,12] 索引数组应为：[2,1,3,0,4]

截至目前，我正在做的就像旧的＆＃34;冒泡排序＆＃34;我在哪里比较每一种可能性。我想知道如何快速实现它。

Answer 1

如果您不担心额外空间，请执行以下操作：

制作一对(value, index)
按升序对值（第一个成员）进行排序
从已排序的数组

以您的数据为例，您可以得到：

[{9,0}, {7,1}, {8,2}, {6,3}, {12,4}] // Step 1
[{6,3}, {7,1}, {8,2}, {9,0}, {12,4}] // Step 2
[   3,     1,     2,     0,      4 ] // Step 3

（注释）我需要的是未排序数组的索引，就像它们按升序排序一样。

您也可以使用步骤3中的数组生成此输出。使用您的第二个示例，您可以得到：

[{10,0},  {9,1}, {11,2},  {8,3}, {12,4}]
[ {8,3},  {9,1}, {10,0}, {11,2}, {12,4}]
[    3,      1,      0,      2,      4 ]

现在创建输出数组，遍历索引数组（即[3,1,0,2,4]）并将每个项目的索引设置为由值确定的结果中的位置，即索引3将得到0，因为3是在索引0，索引1将得1，因为1为1，索引0将得2，因为0为2，依此类推。

以下是该附加步骤的说明：

int position[] = {3, 1, 0, 2, 4};
int res[5];
for (int i = 0 ; i != 5 ; i++) {
    res[position[i]] = i;
}

这会生成以下数组：

[2, 1, 3, 0, 4]

Answer 2

“快速”意味着您需要一个排序数据结构，其复杂度为O（log n），用于插入（当然还有查找）。所以二叉树会这样做。

Answer 3

您将索引创建为位置数组，并将其初始化为现有顺序：idx = [0,1,2，....，n-1]。
然后使用您喜欢的排序算法对索引数组进行排序，但是每当执行比较时，您都使用值作为位置来引用原始数组，而不是直接比较它们。例如，要比较项目i和j，执行cmp（arr [idx [i]]，arr [idx [j]]）而不是cmp（idx [i]，idx [j]）。

Answer 4

您是否尝试过Radix Sort：

* Approach:
 *   radix sort, like counting sort and bucket sort, is an integer based
 *   algorithm (i.e. the values of the input array are assumed to be
 *   integers). Hence radix sort is among the fastest sorting algorithms
 *   around, in theory. The particular distinction for radix sort is that it
 *   creates a bucket for each cipher (i.e. digit); as such, similar to
 *   bucket sort, each bucket in radix sort must be a growable list that may
 *   admit different keys.

 ***************************************************************************/
import java.io.IOException;


public class RadixSort {

    public static void sort( int[] a)
    {
        int i, m = a[0], exp = 1, n = a.length;
        int[] b = new int[10];
        for (i = 1; i < n; i++)
            if (a[i] > m)
                m = a[i];
        while (m / exp > 0)
        {
            int[] bucket = new int[10];

            for (i = 0; i < n; i++)
                bucket[(a[i] / exp) % 10]++;
            for (i = 1; i < 10; i++)
                bucket[i] += bucket[i - 1];
            for (i = n - 1; i >= 0; i--)
                b[--bucket[(a[i] / exp) % 10]] = a[i];
            for (i = 0; i < n; i++)
                a[i] = b[i];
            exp *= 10;        
        }
    } 

    public static void main(String[] args) throws IOException {

        int[] aa={9,7,8,6,12};
        for (int i = 0; i < aa.length; i++) {
            System.out.print(aa[i]+"  ");
        }
        System.out.println();
        sort(aa);
        for (int i = 0; i < aa.length; i++) {
            System.out.print(aa[i]+"  ");
        }
    }


}

创建未排序数组索引的最快方法

4 个答案: