C++ 对二维向量进行排序并保持对原始索引的跟踪

我想按x对n维点列表进行排序，并存储其原始索引：

original=[(3,2,3)(1,2,1)(5,1,5)]

排序后：

[(1,2,1)(3,2,3)(5,1,5)]

以及索引：

store=[1,0,2]

我使用

vector

存储n维点：

a[0][0] = x, a[0][1] = y, a[0][2] = z, ... 

我编写了一个mergesort来完成它，通过引用传输

源代码
调用
并通过引用调用来传输
结果
以获取索引

我遇到一个问题，如果我想打印结果，程序将关闭

#include <vector>
#include <cmath>
#include <cfloat>
#include <iostream>
#include <algorithm>
using namespace std;

void merge(vector< vector<double> >& source, vector< int >& result, int lmin, int lmax, int rmin, int rmax){
    int i = lmin, j = rmin;
    while(i <= lmin && j <= rmin){
        //left > right
        if(source[i][0] > source[j][0]){
            source[i].swap(source[j]);
            //exchange result
            int temp = result[j];
            result[j] = result[i];
            result[i] = temp;

            i ++;
        }
        else if(source[i][0] < source[j][0])
            source[i].swap(source[j]);

            j ++;
        }

}

void merge_sort(vector< vector<double> >& source, vector< int >& result, int min, int max){
    if(max - min == 0){
            result[min] = min;
            return;
    }
    int median = (max - min) / 2;
    merge_sort(source, result, min , median);
    merge_sort(source, result, median + 1 , max);
    merge(source, result, min, median, median + 1, max);
}

int main(){

       vector < vector<double> >test (8, vector<double>(3));
       vector < int >result (8);
       vector < vector<double> >ttt;
    test[0][0]= 10;
    test[0][1]= 20;
    test[0][2]= 30;
    //(1,2,3)
    test[1][0]= 1;
    test[1][1]= 2;
    test[1][2]= 3;
    //(1000,2000,3000)
    test[2][0]= 1000;
    test[2][1]= 2000;
    test[2][2]= 3000;
    //(100,200,300)
    test[3][0]= 100;
    test[3][1]= 200;
    test[3][2]= 300;
    //(100,200,300)
    test[4][0]= 100;
    test[4][1]= 200;
    test[4][2]= 302;
    //(100,200,300)
    test[5][0]= 100;
    test[5][1]= 200;
    test[5][2]= 3030;
    //(100,200,300)
    test[6][0]= 1000000;
    test[6][1]= 2000000;
    test[6][2]= 3000000;
    test[7][0]= 10;
    test[7][1]= 20;
    test[7][2]= 30.5;
    merge_sort(test, result, 0 , 7);

    for (int i = 0; i < test.size(); i ++){
        for(int j = 0; j < test[i].size(); j ++){
            cout << test[i][j] << endl;
        }
    }

    for(int i = 0; i < result.size(); i ++)cout << result[i] << endl;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
无效合并（向量源、向量结果、int-lmin、int-lmax、int-rmin、int-rmax）{
int i=lmin，j=rmin；
而（i来源[j][0]）{
来源[i].掉期（来源[j]）；
//交换结果
int temp=结果[j]；
结果[j]=结果[i]；
结果[i]=温度；
i++；
}
else if（source[i][0]源、向量结果、int最小值、int最大值）{
如果（最大-最小==0）{
结果[min]=min；
返回；
}
整数中值=（最大-最小）/2；
合并排序（源、结果、最小值、中值）；
合并排序（源、结果、中值+1、最大值）；
合并（源、结果、最小值、中值、中值+1、最大值）；
}
int main（）{
向量<向量>测试（8，向量（3））；
向量结果（8）；
向量ttt；
测试[0][0]=10；
测试[0][1]=20；
测试[0][2]=30；
//(1,2,3)
测试[1][0]=1；
测试[1][1]=2；
测试[1][2]=3；
//(1000,2000,3000)
测试[2][0]=1000；
测试[2][1]=2000；
试验[2][2]=3000；
//(100,200,300)
测试[3][0]=100；
试验[3][1]=200；
试验[3][2]=300；
//(100,200,300)
测试[4][0]=100；
试验[4][1]=200；
测试[4][2]=302；
//(100,200,300)
测试[5][0]=100；
试验[5][1]=200；
试验[5][2]=3030；
//(100,200,300)
测试[6][0]=1000000；
试验[6][1]=2000000；
试验[6][2]=3000000；
测试[7][0]=10；
试验[7][1]=20；
试验[7][2]=30.5；
合并排序（测试，结果，0，7）；
对于（int i=0；icout你一定要学会如何使用调试工具。一步一步地去看看哪里会发生意外情况。如果你还不知道如何使用，试着在这里和那里插入
cout
s。通过将变量的值打印到屏幕上来观察它们。我相信在这种情况下，你将手动调试
*：）通过打印值，您可以逐步了解算法的工作原理。这是一种很好的做法

int median = (max - min) / 2;

我相信你应该找到像
无符号整数中值=（int）floor（（max+min）/2）；

说
max=3
和
min=2
。根据您的代码，中位数将是
0
，这是不相关的。此时，当您使用此参数调用mergesort时，（min=2，max=median=0）下一个中位数将作为负指数计算。因此，使用
unsigned int
作为中位数将帮助您检测问题。请参阅，仔细选择类型实际上有助于您，这种情况就是一个很好的例子

通过修复您的错误，您的程序将终止。
首先：

int median = (max - min) / 2;

应该是

int median = (max + min) / 2;

你可以从

还有，如果你发布你收到的实际错误消息，你将来可能会得到更多有用的响应。
你有没有试过在调试器中运行它？它在哪里崩溃？还有，试着做一个较小的崩溃测试，然后进行调查。对不起，我从来没有使用过，我以后会学习。你知道吗需要编写自己的合并排序吗？我想您可以使用索引的std:：vector，并使用带有适当函数对象的std:：sort对该向量进行排序。@梁玉潘查看gdb教程（例如unix/linux机器上的ur.dnt knw abt windows）这里排序：谢谢你的建议，我将开始学习并尝试修复它。你能给我一些提示为什么我的算法不能正常排序吗？