Sorting an Array by Index: Unlocking the Mystery with C++

Sorting arrays is a fundamental task in programming, but what if you only need the indexes of the sorted values rather than the sorted values themselves? This common problem has piqued the interest of many developers, particularly those using C or C++. In this post, we’ll unravel how to sort an array by value while returning the indexes of elements in the sorted order.

The Challenge

Imagine you have an array of integers, and your goal is to sort it in ascending order. However, instead of returning the sorted numbers themselves, you want an array that indicates the original indices of these sorted numbers. For example, given the input array:

Input:  1, 3, 4, 9, 6

The output should reflect the indices of the sorted values:

Output: 1, 2, 3, 5, 4

A Twist on Sorting

You’re probably using a sorting algorithm like the shell sort procedure mentioned in the query. However, certain programming implementations can lead to errors, particularly when dealing with pointers. This post aims to clarify how to work with arrays in C/C++ and create a sorting function that meets the specified requirements.

Step 1: Create an Array of Pointers

To facilitate sorting without losing positional information, we can create an array of pointers that point to the elements of the original array. This way, when we sort the pointers, we indirectly sort the original array values while retaining the index map. Here’s how you can do it:

int* intArray; // This will be initialized with your integer values.
int arrayLen;  // Length of the integer array.

int** pintArray = new int*[arrayLen]; // Create an array of pointers.
for(int i = 0; i < arrayLen; ++i)
{
    pintArray[i] = &intArray[i]; // Point to the respective elements.
}

Step 2: Sort the Array of Pointers

Once you have the pointers ready, you can apply any sort algorithm (like shell sort) to sort the pointers based on the values they point to. Here is a simple demonstration:

SortIntPointers(pintArray, arrayLen); // Sorts the pointer array based on values.

Step 3: Assign Sorted Indexes

After sorting the pointers, you can then traverse through them and assign their corresponding sorted position back to the original pointer array. This ensures you get the appropriate indexes.

for(int i = 0; i < arrayLen; ++i)
{
    *pintArray[i] = i; // Assign sorted index positions.
}

Full Implementation Example

Putting it all together, here’s a complete example following the steps outlined above:

void SortIntPointers(int** pArray, int ArrayLength) {
    int flag = 1;    
    int* temp;    
    
    for (int i = 1; (i <= ArrayLength) && flag; i++)
    {
        flag = 0;
        for (int j = 0; j < ArrayLength - 1; j++)
        {
            if (*pArray[j + 1] < *pArray[j]) // Change to ascending order
            { 
                temp = pArray[j]; // Swap elements
                pArray[j] = pArray[j + 1];
                pArray[j + 1] = temp;
                flag = 1; // A swap occurred.
            }
        }
    }
}

// Initialize and sort your pointers as demonstrated earlier.

Conclusion

Sorting arrays by index without losing track of their original positions can be tricky, especially with pointers in C/C++. By creating an array of pointers and sorting it, you can effectively manage this challenge. Remember to implement error handling and consider edge cases for more robust code. Happy coding!