C++ 递归函数c+上的分段错误+；

我在研究预购遍历二叉树算法。但我遇到了分割错误：11错误。代码如下所示

我想知道为什么会发生这种错误。顺便说一下，我已经尝试过非递归算法

preorder（）

，分割错误仍然会发生

环境： 马科斯，克朗-800.0.38

struct Node{
    char val;
    Node* left;
    Node* right;
};

void preorder(Node *T){
    if(T!=NULL){
        cout << T->val;
        preorder(T->left);
        preorder(T->right);
    }
}

int main(){
    Node *T = (Node *)malloc(sizeof(Node));
    Node *p = T;
    p->val = 'A';
    p->left = (Node *)malloc(sizeof(Node));
    p->left->val = 'B';
    p->right = (Node *)malloc(sizeof(Node));
    p->right->val = 'C'; 
    preorder(T);
    return 0;
}

struct节点{
char-val；
节点*左；
节点*右；
};
无效预订单（节点*T）{
如果（T！=NULL）{
库特瓦尔；
预订单（T->左）；
预订单（T->右）；
}
}
int main（）{
Node*T=（Node*）malloc（sizeof（Node））；
节点*p=T；
p->val='A'；
p->left=（Node*）malloc（sizeof（Node））；
p->left->val='B'；
p->right=（Node*）malloc（sizeof（Node））；
p->right->val='C'；
前序（T）；
返回0；
}

您需要将节点的

左

和

右

成员变量初始化为空指针

---

无论如何，如果你使用C++，使用C++而不是C构造。这是代码的示例性C++14版本：

#include <iostream>
#include <memory>

struct Node{
   Node(char a) : val(a) { };
   char val;
   std::unique_ptr<Node> left, right;
};

void preorder(Node* p) {
   if (p) {
      std::cout << p->val;
      preorder(p->left.get());
      preorder(p->right.get());
   }
}

int main() {
   auto root = std::make_unique<Node>('A');
   root->left = std::make_unique<Node>('B');
   root->right = std::make_unique<Node>('C');

   preorder(root.get());
}

#包括
#包括
结构节点{
节点（字符a）：val（a）{}；
char-val；
std：：唯一的左、右ptr；
};
无效预订单（节点*p）{
如果（p）{
标准：cout-val；
预排序（p->left.get（））；
预排序（p->right.get（））；
}
}
int main（）{
auto root=std：：使_唯一（'A'）；
root->left=std:：使_唯一（'B'）；
root->right=std:：使_唯一（'C'）；
预排序（root.get（））；
}

您需要将节点的

左

和

右

成员变量初始化为空指针

---

无论如何，如果你使用C++，使用C++而不是C构造。这是代码的示例性C++14版本：

#include <iostream>
#include <memory>

struct Node{
   Node(char a) : val(a) { };
   char val;
   std::unique_ptr<Node> left, right;
};

void preorder(Node* p) {
   if (p) {
      std::cout << p->val;
      preorder(p->left.get());
      preorder(p->right.get());
   }
}

int main() {
   auto root = std::make_unique<Node>('A');
   root->left = std::make_unique<Node>('B');
   root->right = std::make_unique<Node>('C');

   preorder(root.get());
}

#包括
#包括
结构节点{
节点（字符a）：val（a）{}；
char-val；
std：：唯一的左、右ptr；
};
无效预订单（节点*p）{
如果（p）{
标准：cout-val；
预排序（p->left.get（））；
预排序（p->right.get（））；
}
}
int main（）{
auto root=std：：使_唯一（'A'）；
root->left=std:：使_唯一（'B'）；
root->right=std:：使_唯一（'C'）；
预排序（root.get（））；
}

问题在于您的左、右子节点未初始化为NULL。由于之前存储在该内存位置的值，程序在

if（T！=nullptr）

语句中遇到非空值，并执行if块

struct Node{
    char val;
    Node* left;
    Node* right;
};

void preorder(Node *T){
    if(T!=nullptr){
        cout << T->val;
        preorder(T->left);
        preorder(T->right);
    }
}

int main(){
    Node *T = (Node *)malloc(sizeof(Node));
    Node *p = T;
    p->val = 'A';
    p->left = (Node *)malloc(sizeof(Node));
    p->left->val = 'B';
    p->left->left = nullptr;   //Initialize to NULL
    p->left->right = nullptr;  //Initialize to NULL
    p->right = (Node *)malloc(sizeof(Node));
    p->right->val = 'C'; 
    p->right->left = nullptr;  //Initialize to NULL
    p->right->right = nullptr; //Initialize to NULL
    preorder(T);
    return 0;
}

struct节点{
char-val；
节点*左；
节点*右；
};
无效预订单（节点*T）{
如果（T！=nullptr）{
库特瓦尔；
预订单（T->左）；
预订单（T->右）；
}
}
int main（）{
Node*T=（Node*）malloc（sizeof（Node））；
节点*p=T；
p->val='A'；
p->left=（Node*）malloc（sizeof（Node））；
p->left->val='B'；
p->left->left=NULL ptr；//初始化为NULL
p->left->right=NULL ptr；//初始化为NULL
p->right=（Node*）malloc（sizeof（Node））；
p->right->val='C'；
p->right->left=NULL ptr；//初始化为NULL
p->right->right=nullptr；//初始化为NULL
前序（T）；
返回0；
}

问题在于您的左、右子节点未初始化为NULL。由于之前存储在该内存位置的值，程序在

if（T！=nullptr）

语句中遇到非空值，并执行if块

struct Node{
    char val;
    Node* left;
    Node* right;
};

void preorder(Node *T){
    if(T!=nullptr){
        cout << T->val;
        preorder(T->left);
        preorder(T->right);
    }
}

int main(){
    Node *T = (Node *)malloc(sizeof(Node));
    Node *p = T;
    p->val = 'A';
    p->left = (Node *)malloc(sizeof(Node));
    p->left->val = 'B';
    p->left->left = nullptr;   //Initialize to NULL
    p->left->right = nullptr;  //Initialize to NULL
    p->right = (Node *)malloc(sizeof(Node));
    p->right->val = 'C'; 
    p->right->left = nullptr;  //Initialize to NULL
    p->right->right = nullptr; //Initialize to NULL
    preorder(T);
    return 0;
}

struct节点{
char-val；
节点*左；
节点*右；
};
无效预订单（节点*T）{
如果（T！=nullptr）{
库特瓦尔；
预订单（T->左）；
预订单（T->右）；
}
}
int main（）{
Node*T=（Node*）malloc（sizeof（Node））；
节点*p=T；
p->val='A'；
p->left=（Node*）malloc（sizeof（Node））；
p->left->val='B'；
p->left->left=NULL ptr；//初始化为NULL
p->left->right=NULL ptr；//初始化为NULL
p->right=（Node*）malloc（sizeof（Node））；
p->right->val='C'；
p->right->left=NULL ptr；//初始化为NULL
p->right->right=nullptr；//初始化为NULL
前序（T）；
返回0；
}

malloc不会为您清空内存。这意味着，

节点

malloc-ed的左右两侧可能都是非空的，因此

preorder（）

将错误地遍历到无效的内存位置。在使用C++时，为什么不为类编写构造函数，而使用<代码>新< /代码>，而不是使用<代码> MALLC/<代码>？两个答案都指出了原因。将来你可以在这里进行自我诊断：malloc不会为你清空内存。这意味着，

节点

malloc-ed的左右两侧可能都是非空的，因此

preorder（）

将错误地遍历到无效的内存位置。在使用C++时，为什么不为类编写构造函数，而使用<代码>新< /代码>，而不是使用<代码> MALLC/<代码>？两个答案都指出了原因。将来您可以在这里进行自我诊断：sry是为了提问，但这不是简单的

c++11

？处于良好的位置，能够始终使用最新的功能。我记不清版本了。你的回答是：）谢谢你的提问，但是这不是很简单的

c++11

？，它处于一个很好的位置，能够始终使用最新的功能。我记不清版本了。答案是：）