C++ 与Windows相比，Linux上的分数不同。。。记忆障碍？

这是我在这里的第一篇文章，我想为我的英语道歉。 我的C++很差，我写了这个代码，没有很多C++的研究。 尽管如此，我还是实现了我的目标，并且取得了正确的成绩。。。仅适用于Windows 10（代码块）。 当我尝试在Linux中调试时，分数是不同的。例如，使用以下输入：

5 
5 0 
3 0 
3 5
5 1
3 3

在Windows上，我得到了正确的结果：

2
4
5
1
3

但在Linux或（可能是Linux服务器？）上，我得到：

在我看来，这个问题是在记忆中。。。但我已经找了好几个小时的错误，却没有结果

#include <iostream>
#include <list>
#include <stack>

using namespace std;
class node
{
public:
    int id=0;
    int klucz=0;
    int rodzic=0;
    int idzzerem=0;
    int ilezzerem=0;
    list<int> dzieci;
};
bool spr(node a, node b)
{
    return a.klucz<b.klucz;
}
int ilezzerem(node drzewo[],int korzen,int pom=0)
{
    if(drzewo[korzen].ilezzerem==0)
           return 0;
    else if(drzewo[korzen].ilezzerem==1)
        return drzewo[korzen].ilezzerem + ilezzerem(drzewo,drzewo[korzen].idzzerem);
    else
    {
        while(!drzewo[korzen].dzieci.empty())
        {
            int a = drzewo[korzen].dzieci.front();
            drzewo[korzen].dzieci.pop_front();
            pom+= ilezzerem(drzewo,a,pom);
        }
        return pom+drzewo[korzen].ilezzerem;
    }
}
int main()
{
    ios_base::sync_with_stdio(false);
    int rodzic,klucz,nIloscWezlow,a;
    std::stack<int> P,K,M;
    int i=1;
    cin>>nIloscWezlow;
    node drzewo[nIloscWezlow+1];
    bool klucze[nIloscWezlow+1];
    klucze[0]=false;
    bool niejedn[nIloscWezlow+1];
    niejedn[0]=false;
    while(i<=nIloscWezlow)
    {
        cin>>rodzic>>klucz;
        if(klucz>0)
        {
            klucze[klucz]=true;
            drzewo[i].klucz=klucz;
        }
        drzewo[i].id=i;
        if(i==rodzic&&klucz==0)
                drzewo[rodzic].klucz=1;
        else
            drzewo[i].rodzic=rodzic;
        if(klucz==0)
        {
            drzewo[rodzic].dzieci.push_front(i);
            drzewo[rodzic].idzzerem=i;
            drzewo[rodzic].ilezzerem++;
            klucze[klucz]=false;
        }
        niejedn[i]=false;
        i++;
    }
    for(int k=nIloscWezlow;k>0;k--)
    {
        if(klucze[k]==false)
        {
            P.push(k);
            K.push(k);
        }
    }
    list<node> listaIDPoddrzewDoBadania;
    for (int k = 1;k<=nIloscWezlow;k++)
    {
        node obecny1 = drzewo[k];
        if(obecny1.ilezzerem>0&&obecny1.klucz!=0)
            listaIDPoddrzewDoBadania.push_front(obecny1);
    }
    listaIDPoddrzewDoBadania.sort(spr);
    while(!listaIDPoddrzewDoBadania.empty()&&!P.empty())
    {
        node obecny = listaIDPoddrzewDoBadania.front();
        listaIDPoddrzewDoBadania.pop_front();
        int idobecnego = obecny.id;
        int ilezdjackluczy = ilezzerem(drzewo,idobecnego);
        while(ilezdjackluczy!=0)
        {
            int kluczdowlozeniawM = K.top();
            K.pop();
            M.push(kluczdowlozeniawM);
            ilezdjackluczy--;
        }
        int elementzeszczytu=0;
        if(!K.empty())
            elementzeszczytu = K.top();
        if(elementzeszczytu>obecny.klucz ||K.empty())
        {
            node current = obecny;
            while(current.ilezzerem==1)
            {
                int dowstawienia = M.top();
                M.pop();
                drzewo[current.idzzerem].klucz=dowstawienia;
                if(drzewo[current.idzzerem].klucz==0)
                    break;
                current=drzewo[current.idzzerem];
            }
            int pomDlaP = P.top();
            while(pomDlaP<obecny.klucz && !P.empty())
            {
                P.pop();
                if(!P.empty())
                    pomDlaP= P.top();
            }
        }
        else if(elementzeszczytu<obecny.klucz)
        {
            int pomDlaP = P.top();
            while(pomDlaP<obecny.klucz && !P.empty())
            {
                niejedn[pomDlaP]=true;
                P.pop();
                if(!P.empty())
                    pomDlaP= P.top();
            }
        }
        else
            continue;
    }
    for (int koniec = 1;koniec<=nIloscWezlow;koniec++)
    {
        if(niejedn[drzewo[koniec].klucz])
            cout<<0<<endl;
        else
            cout<<drzewo[koniec].klucz<<endl;
    }
}

#包括
#包括
#包括
使用名称空间std；
类节点
{
公众：
int id=0；
int-klucz=0；
int-rodzic=0；
int-idzzerem=0；
int-ilezzerem=0；
罗列捷克西；
};
bool spr（节点a、节点b）
{
返回a.klucz>niloswezlow；
节点drzewo[niloswezlow+1]；
布尔·克鲁泽[Niloswezlow+1]；
klucze[0]=假；
布尔·尼耶顿[Niloswezlow+1]；
niejedn[0]=假；
而（i>rodzic>>klucz；
如果（klucz>0）
{
klucze[klucz]=真；
drzewo[i].klucz=klucz；
}
drzewo[i].id=i；
如果（i==rodzic&&klucz==0）
drzewo[rodzic].klucz=1；
其他的
drzewo[i].rodzic=rodzic；
如果（klucz==0）
{
drzewo[rodzic].dzieci.push_front（i）；
drzewo[rodzic].idzzerem=i；
drzewo[rodzic].ilezzerem++；
klucze[klucz]=假；
}
niejedn[i]=假；
i++；
}
对于（int k=niloskewzlow；k>0；k--）
{
if（klucze[k]==false）
{
P.push（k）；
K.推（K）；
}
}
列表AIDPODDRZEWDOBADANIA；
对于（int k=1；k0&&obecny1.klucz！=0）
listaIDPoddrzewDoBadania.向前推（obecny1）；
}
listaIDPoddrzewDoBadania.sort（spr）；
而（！listaIDPoddrzewDoBadania.empty（）&&！P.empty（））
{
node obecny=listaIDPoddrzewDoBadania.front（）；
listaIDPoddrzewDoBadania.pop_front（）；
int idobecnego=obecny.id；
int ilezdjackluczy=ilezzerem（drzewo，idobecnego）；
而（ilezdjackluczy！=0）
{
int-kluczdollozeniawm=K.top（）；
K.pop（）；
M.push（kluczdollozeniawm）；
伊莱兹德拉齐——；
}
int elementzeszczytu=0；
如果（！K.empty（））
elementzeszczytu=K.top（）；
if（elementzeszczytu>obecny.klucz | | K.empty（））
{
节点电流=1；
while（current.ilezzerem==1）
{
int-dowstawienia=M.top（）；
M.pop（）；
drzewo[current.idzzerem].klucz=dowstawienia；
if（drzewo[current.idzzerem].klucz==0）
打破
current=drzewo[current.idzzerem]；
}
int pomDlaP=P.top（）；
虽然（POMDLAP针对完全相同的输入在不同的系统上产生不同的结果，这通常意味着未定义的行为。您可能需要确保不超出任何数组的界限。还需要学习如何使用调试器，以便在监视变量及其值的同时一步一步地执行代码语句。这有助于调试如果将中间结果存储在临时变量中，看到不同的结果，则表明运行代码中某个地方存在bug或未定义的行为。所显示的代码中包含了不安全的编程实践，如缺少边界检查，以及基于1的数组索引，这是C++的常见错误源。用（你所有的数组）。用C++来代替，从所谓的“竞争”站点学习C++，取而代之，不太明显的是，<代码> NIEJEND（或者其他数组）的所有元素都是显而易见的。有确定的值。另一方面：放弃调整为基于一个封闭区间索引的习惯。这只会让你更难学习这门语言。
#include <iostream>
#include <list>
#include <stack>

using namespace std;
class node
{
public:
    int id=0;
    int klucz=0;
    int rodzic=0;
    int idzzerem=0;
    int ilezzerem=0;
    list<int> dzieci;
};
bool spr(node a, node b)
{
    return a.klucz<b.klucz;
}
int ilezzerem(node drzewo[],int korzen,int pom=0)
{
    if(drzewo[korzen].ilezzerem==0)
           return 0;
    else if(drzewo[korzen].ilezzerem==1)
        return drzewo[korzen].ilezzerem + ilezzerem(drzewo,drzewo[korzen].idzzerem);
    else
    {
        while(!drzewo[korzen].dzieci.empty())
        {
            int a = drzewo[korzen].dzieci.front();
            drzewo[korzen].dzieci.pop_front();
            pom+= ilezzerem(drzewo,a,pom);
        }
        return pom+drzewo[korzen].ilezzerem;
    }
}
int main()
{
    ios_base::sync_with_stdio(false);
    int rodzic,klucz,nIloscWezlow,a;
    std::stack<int> P,K,M;
    int i=1;
    cin>>nIloscWezlow;
    node drzewo[nIloscWezlow+1];
    bool klucze[nIloscWezlow+1];
    klucze[0]=false;
    bool niejedn[nIloscWezlow+1];
    niejedn[0]=false;
    while(i<=nIloscWezlow)
    {
        cin>>rodzic>>klucz;
        if(klucz>0)
        {
            klucze[klucz]=true;
            drzewo[i].klucz=klucz;
        }
        drzewo[i].id=i;
        if(i==rodzic&&klucz==0)
                drzewo[rodzic].klucz=1;
        else
            drzewo[i].rodzic=rodzic;
        if(klucz==0)
        {
            drzewo[rodzic].dzieci.push_front(i);
            drzewo[rodzic].idzzerem=i;
            drzewo[rodzic].ilezzerem++;
            klucze[klucz]=false;
        }
        niejedn[i]=false;
        i++;
    }
    for(int k=nIloscWezlow;k>0;k--)
    {
        if(klucze[k]==false)
        {
            P.push(k);
            K.push(k);
        }
    }
    list<node> listaIDPoddrzewDoBadania;
    for (int k = 1;k<=nIloscWezlow;k++)
    {
        node obecny1 = drzewo[k];
        if(obecny1.ilezzerem>0&&obecny1.klucz!=0)
            listaIDPoddrzewDoBadania.push_front(obecny1);
    }
    listaIDPoddrzewDoBadania.sort(spr);
    while(!listaIDPoddrzewDoBadania.empty()&&!P.empty())
    {
        node obecny = listaIDPoddrzewDoBadania.front();
        listaIDPoddrzewDoBadania.pop_front();
        int idobecnego = obecny.id;
        int ilezdjackluczy = ilezzerem(drzewo,idobecnego);
        while(ilezdjackluczy!=0)
        {
            int kluczdowlozeniawM = K.top();
            K.pop();
            M.push(kluczdowlozeniawM);
            ilezdjackluczy--;
        }
        int elementzeszczytu=0;
        if(!K.empty())
            elementzeszczytu = K.top();
        if(elementzeszczytu>obecny.klucz ||K.empty())
        {
            node current = obecny;
            while(current.ilezzerem==1)
            {
                int dowstawienia = M.top();
                M.pop();
                drzewo[current.idzzerem].klucz=dowstawienia;
                if(drzewo[current.idzzerem].klucz==0)
                    break;
                current=drzewo[current.idzzerem];
            }
            int pomDlaP = P.top();
            while(pomDlaP<obecny.klucz && !P.empty())
            {
                P.pop();
                if(!P.empty())
                    pomDlaP= P.top();
            }
        }
        else if(elementzeszczytu<obecny.klucz)
        {
            int pomDlaP = P.top();
            while(pomDlaP<obecny.klucz && !P.empty())
            {
                niejedn[pomDlaP]=true;
                P.pop();
                if(!P.empty())
                    pomDlaP= P.top();
            }
        }
        else
            continue;
    }
    for (int koniec = 1;koniec<=nIloscWezlow;koniec++)
    {
        if(niejedn[drzewo[koniec].klucz])
            cout<<0<<endl;
        else
            cout<<drzewo[koniec].klucz<<endl;
    }
}