合并排序-向量不排序

Question

I'm trying to perform a merge sort on a std::vector<int> . Each int in the vector corresponds to an index in another vector std::vector<Node> . Each node has a depth. I am trying to sort based on depth.

I am using some merge sort code that I found. It works fine using an array of integers, so I figured it would work fine in my code. Here is a shortened version of my code:

.h file:

class Log{
public:
    static std::vector<int> a;
};

.cpp file:

std::vector<int> Log::a;

int getNodeDepth (int index, std::vector<cv::ml::DTrees::Node::Node> nodeList, std::vector<int> treeList) {
    //returns the node's depth
}

void exchange(int i, int j) {
    int t = Log::a[i];
    Log::a[i] = Log::a[j];
    Log::a[j] = t;
}

void compare(int i, int j, std::vector<cv::ml::DTrees::Node::Node> nodeList) {
    if (getNodeDepth(nodeList[Log::a[i]], nodeList) > (getNodeDepth(nodeList[Log::a[j]], nodeList)))
    exchange(i, j);
}

/**
 * lo is the starting position and
 * n is the length of the piece to be merged,
 * r is the distance of the elements to be compared
 */
void oddEvenMerge(int lo, int n, int r, std::vector<cv::ml::DTrees::Node::Node> nodeList) {
    int m = r * 2;
    if (m < n) {
        oddEvenMerge(lo, n, m, nodeList); // even subsequence
        oddEvenMerge(lo + r, n, m, nodeList); // odd subsequence
        for (int i = lo + r; i + r < lo + n; i += m)
            compare(i, i + r, nodeList);
    } else
        compare(lo, lo + r, nodeList);
}

/**
 * sorts a piece of length n of the array
 * starting at position lo
 */
void oddEvenMergeSort(int lo, int n, std::vector<cv::ml::DTrees::Node::Node> nodeList) {
    if (n > 1) {
        int m = n / 2;
        oddEvenMergeSort(lo, m, nodeList);
        oddEvenMergeSort(lo + m, m, nodeList);
        oddEvenMerge(lo, n, 1, nodeList);
    }
}

int mergeSort(std::vector<int> treeList, std::vector<cv::ml::DTrees::Node::Node> nodeList) {
    Log::a = treeList;
    int i, n = sizeof(Log::a) / sizeof(Log::a[0]);
    for (i = 0; i < n; i++)
        std::cout << std::setw(3) << Log::a[i];
    std::cout << std::endl;
    oddEvenMergeSort(0, n, nodeList);
    //print sorted list
    for (i = 0; i < Log::a.size(); i++)
        std::cout << Log::a[i] << "  *   ";
    std::cout << std::endl;

    return(0);
}

Note that the variable nodeList is just there because the depth method needs it. The output looks like only the first half of the vector is touched. No items on the second half of the vector ever get swapped. I double checked to make sure the depths are correct, and that the correct things are being swapped. It just doesn't finish the job. Any ideas why?

Answer 1

sizeof(Log::a) / sizeof(Log::a[0]);

This does not get the number of elements in Log::a ! It gets the size (in bytes) of the std::vector type, which has nothing to do with the number of contained elements, then divides by the size of an element. This gives you some garbage.

This idiom is for arrays , and std::size is better, but not standard yet - you can easily write it yourself like this:

template <typename T, std::size_t N>
std::size_t arraySize(T (&)[N])
{
    return N;
}

(There are more convoluted versions if you need it as a compile time constant.)

Use Log::a.size(); to get the size of a std::vector .

(I may be missing other problems, but this one stands out.)