快速排序并返回排序前的索引--Java

　　实现该功能的方法为，只需要多声明一个数组存储排序索引即可，然后在实际排序的时候，索引数组和数组同时变更。

　　需要注意的是，原本排序程序中的很多地方需要大改。

快速排序（不存储索引）：

    private static void quickSort(int[] keys, int begin, int end) {
        if (begin >= 0 && begin < keys.length && end >= 0 && end < keys.length && begin < end) {
            int i = begin, j = end;
            int vot = keys[i];
            while (i != j) {
                while(i < j && keys[j] >= vot) j--;
                if(i < j) keys[i++] = keys[j];
                while(i < j && keys[i] <= vot)  i++;
                if(i < j) keys[j--] = keys[i];
            }
            keys[i] = vot;
            quickSort(keys, begin, j-1);
            quickSort(keys, i+1, end);
        }
    }

　　由于需要存储索引数组，因此涉及到数组的初始化问题，而这又是一个递归程序，因此需要写一个函数调用该递归函数。在这个函数里面初始化索引数组，并返回排序后的索引作为函数返回结果：

    private static int[] quickSort(int[] keys) {
        int[] indices = new int[keys.length];
        for (int i = 0; i < keys.length; i++) {
            indices[i] = i;
        }
        quickSort(keys, 0, keys.length-1, indices);
        return indices;
    }

　　然后原本的

void quickSort(int[] keys, int begin, int end)

　　改为：

void quickSort(keys, 0, keys.length-1, indices)

　　另外，排序程序里面的 keys[i++]=keys[j] 应该改掉了，完整函数如下，可以体会体会

    
    private static void quickSort(int[] keys, int begin, int end, int[] indices) {
        if (begin >= 0 && begin < keys.length && end >= 0 && end < keys.length && begin < end) {
            int i = begin, j = end;
            int vot = keys[i];
            int temp = indices[i];
            while (i != j) {
                while(i < j && keys[j] >= vot) j--;
                if(i < j) {
                    keys[i] = keys[j];
                    indices[i] = indices[j];
                    i++;
                }
                while(i < j && keys[i] <= vot)  i++;
                if(i < j) {
                    keys[j] = keys[i];
                    indices[j] = indices[i];
                    j--;
                }
            }
            keys[i] = vot;
            indices[i] = temp;
            quickSort(keys, begin, j-1, indices);
            quickSort(keys, i+1, end, indices);
        }
    }

排序

    public static void main(String[] args) {
        int[] arr = {10,7,2,4,3,8,9,19};
        System.out.println("----排序前----");
        System.out.println(Arrays.toString(arr));
        int[] index = quickSort(arr);
        System.out.println("----排序后----");
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(index));

    }

结果：

----排序前----
[10, 7, 2, 4, 3, 8, 9, 19]
----排序后----
[2, 3, 4, 7, 8, 9, 10, 19]
[2, 4, 3, 1, 5, 6, 0, 7]

　　通过排序前的索引，能够找到数组排序前的位置。由于有的问题中排序只是为了解决问题而采取的一个手段，实际上并不需要排序，那么就需要找到数组排序之前的位置。