保持两个数组String []和int []与合并排序并行

Question

I'm having trouble with keeping two arrays in parallel within my Merge Sorting algorithm. Suppose I have array defMergeSort and intMergeSort2.

I would like to lexicographically order String defMergeSort,

String[] defMergeSort = {"Echo", "Alpha", "Charlie", "Beta", "Alpha", "Echo"};

Array intMergeSort2 represents the element position in parallel to defMergeSort. (Ex: defMergeSort[0] = Echo contingent to intMergeSort2[0] = 0, defMergeSort[3] = Beta contingent to intMergeSort2[3] = 3) intMergeSort2 is to be rearranged in parallel to defMergeSort, although not numerically sorted,

int[] intMergeSort2 = {0,1,2,3,4,5};

The end result should look similar to this (Not sure if parallel ordering for intMergeSort2[] in my example is correct for duplicate Strings in defMergeSort[]):

• defMergeSort[0] Alpha = intMergeSort2[1] 1
• defMergeSort[1] Alpha = intMergeSort2[4] 4
• defMergeSort[2] Beta = intMergeSort2[3] 3
• defMergeSort[3] Charlie = intMergeSort2[2] 2
• defMergeSort[4] Echo = intMergeSort2[0] 0
• defMergeSort[5] Echo = intMergeSort2[5] 5

The following merge sort algorithm can lexicographically order defMergeSort, although I cannot figure out how to keep defMergeSort in parallel as stipulated above:

//mergeSort code found at:
//http://www.buildingjavaprograms.com/code-files/2ed/ch13/MergeSort.java
public static void mergeSort(String[] defMergeSort, int[] intMergeSort2) {
    if (defMergeSort.length > 1) {
        // split array into two halves
        String[] left = leftHalf(defMergeSort);
        String[] right = rightHalf(defMergeSort);
        // recursively sort the two halves
        mergeSort(left, intMergeSort2);
        mergeSort(right, intMergeSort2);
        // merge the sorted halves into a sorted whole
        merge(defMergeSort, intMergeSort2, left, right);
    }
}

// Returns the first half of the given array.
public static String[] leftHalf(String[] defMergeSort) {
    int size1 = defMergeSort.length / 2;
    String[] left = new String[size1];
    for (int i = 0; i < size1; i++) {
        left[i] = defMergeSort[i];
    }
    return left;
}

// Returns the second half of the given array.
public static String[] rightHalf(String[] defMergeSort) {
    int size1 = defMergeSort.length / 2;
    int size2 = defMergeSort.length - size1;
    String[] right = new String[size2];
    for (int i = 0; i < size2; i++) {
        right[i] = defMergeSort[i + size1];
    }
    return right;
}

// Merges the given left and right arrays into the given
// result array.  Second, working version.
// pre : result is empty; left/right are sorted
// post: result contains result of merging sorted lists;
public static void merge(String[] defMergeSort, int[] intMergeSort2,
String[] left, String[] right){
    int i1 = 0;   // index into left array
    int i2 = 0;   // index into right array
    for(int i = 0; i < defMergeSort.length; i++){
        if (i2 >= right.length || (i1 < left.length &&
        left[i1].compareTo(right[i2]) <= 0)) {
            defMergeSort[i] = left[i1];
            i1++;
        } else {
            defMergeSort[i] = right[i2];
            i2++;
        }
    }
}

Answer 1

Define an object containing your integer and string values, have a single array of that object, sort that array.

ie

class DataElement {
    final String str;
    final int i;

    //Add constructor here
}

DataElement[] array; // sort this array

Note that you will either need to implement Comparable in the DataElement or specify a Comparator to the sort method in order to control the sorting.

Answer 2

Tim B's answer is probably the best approach, I would just like to mention that since the class is just an int and a string, you can use the predefined datastructure std::pair. Just have an array of these pairs and sort by the string. To do this you can use std::sort() defined in , if I'm not wrong std::sort is a MergeSort. You can override the compare function defined with your own.

I find it extremely convenient to use pair in such situations as yours. Make sure you include .

Look into http://www.cplusplus.com/reference/utility/pair/ for reference.

Look into http://www.cplusplus.com/reference/algorithm/sort/ for reference.