C++ 尝试使用预排序打印二叉树的俯视图

下面两个代码应该以相同的方式工作，但给出不同的输出。我试着尽可能地调试代码，但找不到bug

代码1：-

#include<iostream>
#include<stack>
#include<map>

using namespace std;

struct node {
    int data;
    struct node* left;
    struct node* right;
};

typedef struct label
{
    struct node* root;
    int disp;
}label;

int main() {

    struct node* n1 = (struct node*) malloc(sizeof(struct node));
    struct node* n2 = (struct node*) malloc(sizeof(struct node));
    struct node* n3 = (struct node*) malloc(sizeof(struct node));
    struct node* n4 = (struct node*) malloc(sizeof(struct node));
    struct node* n5 = (struct node*) malloc(sizeof(struct node));
    struct node* n6 = (struct node*) malloc(sizeof(struct node));
    struct node* n7 = (struct node*) malloc(sizeof(struct node));
    struct node* n8 = (struct node*) malloc(sizeof(struct node));
    struct node* n9 = (struct node*) malloc(sizeof(struct node));
    struct node* n10 = (struct node*) malloc(sizeof(struct node));
    struct node* n11 = (struct node*) malloc(sizeof(struct node));
    struct node* n12 = (struct node*) malloc(sizeof(struct node));
    struct node* n13 = (struct node*) malloc(sizeof(struct node));
    n1->data = 1;
    n2->data = 2;
    n3->data = 3;
    n4->data = 4;
    n5->data = 5;
    n6->data = 6;
    n7->data = 7;
    n8->data = 8;
    n9->data = 9;
    n10->data = 10;
    n11->data = 11;
    n12->data = 12;
    n13->data = 13;
    n1 -> left = n2;
    n1 -> right = n3;
    n2 -> left = n4;
    n2 -> right = n5;
    n4 -> left = n4 -> right = NULL;
    n5 -> left = n5 -> right = NULL;
    n3 -> left = n6;
    n3 -> right = n7;
    n6 -> left = n6 -> right = NULL;
    n7 -> left = n8;
    n7 -> right = NULL;
    n8 -> left = n9;
    n8 -> right = NULL;
    n9 -> left = n10;
    n9 -> right = NULL;
    n10 -> left = n11;
    n10 -> right = NULL;
    n11 -> left = n12;
    n11 -> right = NULL;
    n12 -> left = n13;
    n12 -> right = NULL;
    n13 -> left = NULL;
    n13 -> right = NULL;



    node* root = n1;

    stack<label*> s;
    map<int, int> m;

    label* var = new label();
    var -> root = root;
    var -> disp = 0;

    label* var1 = new label();

    s.push(var);

    while(!s.empty()) {
        m.insert( pair <int, int> ( var -> disp, var -> root -> data) );

        s.pop();
        if( var -> root -> right != NULL ) {
            var1 -> root = var -> root -> right;
            var1 -> disp = var -> disp + 1;
            s.push(var1);

        }
        if( var -> root -> left != NULL ) {
            var1 -> root = var -> root -> left;
            var1 -> disp = var -> disp - 1;
            s.push(var1);

        }
        if(!s.empty()) {

            var -> root = s.top() -> root;
            var -> disp = s.top() -> disp;
        }
    }
    map<int, int> :: iterator itr;
    for( itr = m.begin(); itr != m.end(); itr++ ) {
        cout<< itr -> second << endl;
    }

}

#包括
#包括
#包括
使用名称空间std；
结构节点{
int数据；
结构节点*左；
结构节点*右；
};
typedef结构标签
{
结构节点*根；
int disp；
}标签；
int main（）{
结构节点*n1=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n2=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n3=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n4=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n5=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n6=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n7=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n8=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n9=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n10=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n11=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n12=（结构节点*）malloc（sizeof（结构节点））；
结构节点*n13=（结构节点*）malloc（sizeof（结构节点））；
n1->data=1；
n2->data=2；
n3->data=3；
n4->data=4；
n5->data=5；
n6->data=6；
n7->data=7；
n8->data=8；
n9->data=9；
n10->数据=10；
n11->数据=11；
n12->数据=12；
n13->数据=13；
n1->左=n2；
n1->右=n3；
n2->左=n4；
n2->右=n5；
n4->left=n4->right=NULL；
n5->left=n5->right=NULL；
n3->左=n6；
n3->右=n7；
n6->left=n6->right=NULL；
n7->左=n8；
n7->right=NULL；
n8->左=n9；
n8->right=NULL；
n9->左=n10；
n9->right=NULL；
n10->左=n11；
n10->right=NULL；
n11->左=n12；
n11->right=NULL；
n12->左=n13；
n12->right=NULL；
n13->左=空；
n13->right=NULL；
节点*root=n1；
堆栈s；
地图m；
label*var=新标签（）；
var->root=root；
var->disp=0；
label*var1=新标签（）；
s、 推力（var）；
而（！s.empty（））{
m、 插入（对（变量->显示，变量->根->数据））；
s、 pop（）；
如果（变量->根->右！=NULL）{
var1->root=var->root->right；
var1->disp=var->disp+1；
s、 推（var1）；
}
如果（变量->根->左！=NULL）{
var1->root=var->root->left；
var1->disp=var->disp-1；
s、 推（var1）；
}
如果（！s.empty（））{
var->root=s.top（）->root；
var->disp=s.top（）->disp；
}
}
迭代器itr；
对于（itr=m.begin（）；itr！=m.end（）；itr++）{
coutseconddata=1；
n2->data=2；
n3->data=3；
n4->data=4；
n5->data=5；
n6->data=6；
n7->data=7；
n8->data=8；
n9->data=9；
n10->数据=10；
n11->数据=11；
n12->数据=12；
n13->数据=13；
n1->左=n2；
n1->右=n3；
n2->左=n4；
n2->右=n5；
n4->left=n4->right=NULL；
n5->left=n5->right=NULL；
n3->左=n6；
n3->右=n7；
n6->left=n6->right=NULL；
n7->左=n8；
n7->right=NULL；
n8->左=n9；
n8->right=NULL；
n9->左=n10；
n9->right=NULL；
n10->左=n11；
n10->right=NULL；
n11->左=n12；
n11->right=NULL；
n12->左=n13；
n12->right=NULL；
n13->左=空；
n13->right=NULL；
节点*root=n1；
堆栈s；
地图m；
label*var=新标签（）；
var->root=root；
var->disp=0；
s、 推力（var）；
而（！s.empty（））{
m、 插入（对（变量->显示，变量->根->数据））；
s、 pop（）；
如果（变量->根->右！=NULL）{
label*var1=新标签（）；
var1->root=var->root->right；
var1->disp=var->disp+1；
s、 推（var1）；
}
如果（变量->根->左！=NULL）{
label*var2=新标签（）；
var2->root=var->root->left；
var2->disp=var->disp-1；
s、 推（var2）；
}
如果（！s.empty（））{
var->root=s.top（）->root；
var->disp=s.top（）->disp；
}
}
迭代器itr；
对于（itr=m.begin（）；itr！=m.end（）；itr++）{
第二，你可以说，在CODE2中你创建了两个局部变量。虽然从技术上讲，你是对的，但我想这有点误解：

看线

label* var1 = new label();

在您的循环中：
在堆上创建一个局部变量和数据（通过
new label（）
分配的内存）。即使在下一次迭代中，该内存仍保留在那里

然后将指向该分配内存的指针推送到堆栈上。
您可能认为分配的内存的内容被复制/推送到堆栈上。
事实并非如此。
复制到堆栈上的是指向内存的指针的副本。
分配的内存不会以任何方式被触及

由于在CODE2中，每次迭代循环时都会分配新内存，因此堆栈上的指针指向不同的内存区域（标签的不同实例）

在CODE1中，您不会每次都创建内存，只需分配一次，并在每次迭代中重用相同的内存位置

将指针（在
var1
中）推送到堆栈上的该位置，但由于它始终是同一个指针，堆栈上的所有指针都指向同一内存地址（标签的同一实例）

无论何时你做你的工作

var1 -> root = var -> root -> right;
var1 -> disp = var -> disp + 1;

由于
var1
总是指向同一个内存，因此您只需在一段时间内覆盖同一个位置
var1 -> root = var -> root -> right;
var1 -> disp = var -> disp + 1;

struct node {
    int data;
    struct node* left;
    struct node* right;
};

int main() {
    node a{1};
    node c{3};
    node b{2, &a, &c};
}