C++ 二叉搜索树输出

我在输出二进制搜索树时遇到问题。我必须建立这棵树，然后把树上所有的双精度矩阵按顺序放入一个向量，然后按顺序输出这个向量。我遇到的问题是将它放入向量并输出它。当我刚刚输出树时，一切都按照它应该的方式工作。向量应该被排序，std:：vector*sort（）应该返回指向向量的指针。我遇到的问题是，我有一个分割错误，我不知道为什么。如有任何建议，将不胜感激。这是我的密码：

#include <vector>

struct ordered_set {
private:
    class node {
    public:
        double val;
        node* left;
        node* right;

        node(double v, node* l, node* r): val(v), left(l), right(r) { }
    };

    node* root;
    int size;

public:
    ordered_set();
    void insert(double x);
    std::vector<double>* sort();
    std::vector<double>* order(node*);
};

#include <vector>
#include <iostream>

#include "ordered_set.hpp"

ordered_set::ordered_set()
{
    root = 0;
    size = 0;
}

void ordered_set::insert(double x)
{
    node* data = new node(x, 0, 0);
    node* parent;
    parent = 0;

    if(root == 0)
        root = data;
    else
    {
        node* curr = root;
        while (curr)
        {
            parent = curr;
            if(data->val > curr->val)
                curr = curr->right;
            else
                curr = curr->left;
        }
        if(data->val < parent->val)
            parent->left = data;
        else
            parent->right = data;
    }
    ++size;
}

std::vector<double>* ordered_set::sort()
{
    node* ndptr = root;
    return order(ndptr);
}

std::vector<double>* ordered_set::order(node* top)
{
    node* curr = top;
    std::vector<double>* set;
    std::vector<double>::iterator it = set->begin();

    if(curr != 0)
    {
        order(curr->left);
        set->insert(it, curr->val);
        ++it;
        order(curr->right);
    }
    else return set;
}

#包括
结构有序集合{
私人：
类节点{
公众：
双val；
节点*左；
节点*右；
节点（双v，节点*l，节点*r）：val（v），左（l），右（r）{}
};
节点*根；
整数大小；
公众：
有序_集（）；
空白插入（双x）；
std:：vector*sort（）；
std：：向量*顺序（节点*）；
};
#包括
#包括
#包括“订购的_set.hpp”
有序集合：：有序集合（）
{
根=0；
尺寸=0；
}
无效有序集合：：插入（双x）
{
节点*数据=新节点（x，0，0）；
节点*父节点；
父项=0；
如果（根==0）
根=数据；
其他的
{
节点*curr=root；
while（curr）
{
父项=当前值；
如果（数据->值>当前->值）
当前=当前->右侧；
其他的
当前=当前->左侧；
}
如果（数据->值<父项->值）
父->左=数据；
其他的
父->右=数据；
}
++大小；
}
std:：vector*有序_集：：排序（）
{
node*ndptr=root；
退货订单（ndptr）；
}
标准：：向量*有序集合：：有序（节点*顶部）
{
节点*curr=top；
std：：向量*集；
std:：vector:：iterator it=set->begin（）；
如果（电流！=0）
{
订单（当前->左侧）；
设置->插入（it，curr->val）；
++它；
订单（当前->右侧）；
}
else返回集；
}

这里有几个问题

首先，您从不定义

set

所指向的向量

例如：

std::vector<double>* set;
std::vector<double>::iterator it = set->begin();

最后，您需要重新定义

order（）

，以便对树进行顺序递归遍历（与前顺序遍历或后顺序遍历相比）。这意味着它将递归地首先转到最左边的子节点，然后以树的最右边的子节点结束，按顺序处理每个节点：

void ordered_set::order(node* top, std::vector<double>& set)
{
    node* curr = top;

    if(curr == 0)
    {
        return;
    }

    //go to the left-most child
    order(curr->left, set);

    //at this point we've now processed all children to the 
    //left of this node ... so we can now process this node itself
    set.push_back(curr->val);

    //now process all children to the right of this node
    order(curr->right, set);

    return;
}

void ordered\u set:：order（节点*top，标准：：向量和集）
{
节点*curr=top；
如果（当前==0）
{
返回；
}
//到最左边的孩子那儿去
订单（当前->左侧，设置）；
//此时，我们已将所有子项处理到
//这个节点的左边…所以我们现在可以处理这个节点本身
设置。向后推（当前->值）；
//现在处理此节点右侧的所有子节点
订单（当前->右侧，设置）；
返回；
}

谢谢您的解释。在你说了之后，我说：“不，谢谢你！”！

void ordered_set::order(node* top, std::vector<double>& set)
{
    node* curr = top;

    if(curr == 0)
    {
        return;
    }

    //go to the left-most child
    order(curr->left, set);

    //at this point we've now processed all children to the 
    //left of this node ... so we can now process this node itself
    set.push_back(curr->val);

    //now process all children to the right of this node
    order(curr->right, set);

    return;
}