Question

How to rank elements of an integer vector based on their sorted order in C++

Answer 1

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>

using std::vector;

/*
    FUNCTION: printVector
    ----------------------
    Prints the contents of an integer vector.
*/
void printVector(const vector<int>& vec) {
    std::cout << "Vector: [ ";
    for (int v : vec) std::cout << v << " ";
    std::cout << "]\n";
}

/*
    FUNCTION: copyVector
    ----------------------
    Returns a copy of the input vector.
*/
vector<int> copyVector(const vector<int>& vec) {
    return vector<int>(vec.begin(), vec.end());
}

/*
    FUNCTION: sortVector
    ----------------------
    Sorts the vector in ascending order.
*/
void sortVector(vector<int>& vecCopy) {
    std::sort(vecCopy.begin(), vecCopy.end());
}

/*
    FUNCTION: buildRankMap
    -----------------------
    Builds a map of value → rank based on sorted order.

    Ranking rules:
    - Lowest value gets rank 1
    - Equal values share the same rank
    - Rank increases only when encountering a new unique value
*/
std::map<int, int> buildRankMap(const vector<int>& sortedVec) {

    std::map<int, int> rankMap;

    int rank = 1;
    int previous = sortedVec[0];

    rankMap[previous] = rank;

    for (size_t i = 1; i < sortedVec.size(); i++) {
        if (sortedVec[i] != previous) {
            rank++;
        }
        rankMap[sortedVec[i]] = rank;
        previous = sortedVec[i];
    }

    return rankMap;
}

/*
    FUNCTION: applyRanks
    ---------------------
    Converts the original vector into a vector of ranks
    using the value → rank map.
*/
vector<int> applyRanks(const vector<int>& original,
                       const std::map<int, int>& rankMap) {

    vector<int> ranked(original.size());

    for (size_t i = 0; i < original.size(); i++) {
        ranked[i] = rankMap.at(original[i]);
    }

    return ranked;
}

/*
    FUNCTION: rankVector
    ---------------------
    Main ranking workflow:
    1. Print original vector
    2. Copy vector
    3. Sort the copy
    4. Build rank map
    5. Apply ranks to original order
*/
void rankVector(const vector<int>& vec) {

    printVector(vec);

    if (vec.empty())
        return;

    vector<int> vecCopy = copyVector(vec);

    sortVector(vecCopy);

    std::map<int, int> rankMap = buildRankMap(vecCopy);

    vector<int> ranked = applyRanks(vec, rankMap);

    std::cout << "Rank: [ ";
    for (int r : ranked) std::cout << r << " ";
    std::cout << "]\n";
}

/*
    MAIN PROGRAM
*/
int main() {

    vector<int> vec = {33, 99, 10, 25, 47, 11, 77};

    rankVector(vec);
}


/*
run:

Vector: [ 33 99 10 25 47 11 77 ]
Rank: [ 4 7 1 3 5 2 6 ]

*/

 

70+ SQL courses for beginners and professionals