C++ btree程序可能由于指针而崩溃

我试图按级别顺序打印b树，但它一直崩溃。我不确定真正的原因是什么，但我认为它崩溃是因为指针。我试着使用我在网上找到的一个函数，它可以遍历每一个级别，将其放入队列并打印，但我遇到了这个问题。如果有人有其他方法，请告诉我

// C++ program for B-Tree insertion
    #include<iostream>
    #include <queue>
    using namespace std;
    int ComparisonCount = 0;
    // A BTree node
    class BTreeNode
    {
        int *keys;  // An array of keys
        int t;      // Minimum degree (defines the range for number of keys)
        BTreeNode **C; // An array of child pointers
        int n;     // Current number of keys
        bool leaf; // Is true when node is leaf. Otherwise false
    public:
        BTreeNode(int _t, bool _leaf);   // Constructor

                                         // A utility function to insert a new key in the subtree rooted with
                                         // this node. The assumption is, the node must be non-full when this
                                         // function is called
        void insertNonFull(int k);

        // A utility function to split the child y of this node. i is index of y in
        // child array C[].  The Child y must be full when this function is called
        void splitChild(int i, BTreeNode *y);

        // A function to traverse all nodes in a subtree rooted with this node
        void traverse();

        // A function to search a key in subtree rooted with this node.
        BTreeNode *search(int k);   // returns NULL if k is not present.

                                    // Make BTree friend of this so that we can access private members of this
                                    // class in BTree functions
        friend class BTree;
    };

    // A BTree
    class BTree
    {
        BTreeNode *root; // Pointer to root node
        int t;  // Minimum degree
    public:
        // Constructor (Initializes tree as empty)
        BTree(int _t)
        {
            root = NULL;  t = _t;
        }

        // function to traverse the tree
        void traverse()
        {
            if (root != NULL) root->traverse();
        }

        // function to search a key in this tree
        BTreeNode* search(int k)
        {
            return (root == NULL) ? NULL : root->search(k);
        }

        // The main function that inserts a new key in this B-Tree
        void insert(int k);
    };

    // Constructor for BTreeNode class
    BTreeNode::BTreeNode(int t1, bool leaf1)
    {
        // Copy the given minimum degree and leaf property
        t = t1;
        leaf = leaf1;

        // Allocate memory for maximum number of possible keys
        // and child pointers
        keys = new int[2 * t - 1];
        C = new BTreeNode *[2 * t];

        // Initialize the number of keys as 0
        n = 0;
    }

    // Function to traverse all nodes in a subtree rooted with this node
    /*void BTreeNode::traverse()
    {
        // There are n keys and n+1 children, travers through n keys
        // and first n children
        int i;
        for (i = 0; i < n; i++)
        {
            // If this is not leaf, then before printing key[i],
            // traverse the subtree rooted with child C[i].
            if (leaf == false)
            {
                ComparisonCount++;
                C[i]->traverse();
            }
            cout << " " << keys[i];
        }

        // Print the subtree rooted with last child
        if (leaf == false)
        {
            ComparisonCount++;
            C[i]->traverse();
        }
    }*/

    // Function to search key k in subtree rooted with this node
    BTreeNode *BTreeNode::search(int k)
    {
        // Find the first key greater than or equal to k
        int i = 0;
        while (i < n && k > keys[i])
            i++;

        // If the found key is equal to k, return this node
        if (keys[i] == k)
        {
            ComparisonCount++;
            return this;
        }
        // If key is not found here and this is a leaf node
        if (leaf == true)
        {
            ComparisonCount++;
            return NULL;
        }

        // Go to the appropriate child
        return C[i]->search(k);
    }

    // The main function that inserts a new key in this B-Tree
    void BTree::insert(int k)
    {
        // If tree is empty
        if (root == NULL)
        {
            ComparisonCount++;
            // Allocate memory for root
            root = new BTreeNode(t, true);
            root->keys[0] = k;  // Insert key
            root->n = 1;  // Update number of keys in root
        }
        else // If tree is not empty
        {
            // If root is full, then tree grows in height
            if (root->n == 2 * t - 1)
            {
                ComparisonCount++;
                // Allocate memory for new root
                BTreeNode *s = new BTreeNode(t, false);

                // Make old root as child of new root
                s->C[0] = root;

                // Split the old root and move 1 key to the new root
                s->splitChild(0, root);

                // New root has two children now.  Decide which of the
                // two children is going to have new key
                int i = 0;
                if (s->keys[0] < k)
                {
                    ComparisonCount++;
                    i++;
                }s->C[i]->insertNonFull(k);

                // Change root
                root = s;
            }
            else  // If root is not full, call insertNonFull for root
                root->insertNonFull(k);
        }
    }

    // A utility function to insert a new key in this node
    // The assumption is, the node must be non-full when this
    // function is called
    void BTreeNode::insertNonFull(int k)
    {
        // Initialize index as index of rightmost element
        int i = n - 1;

        // If this is a leaf node
        if (leaf == true)
        {
            ComparisonCount++;
            // The following loop does two things
            // a) Finds the location of new key to be inserted
            // b) Moves all greater keys to one place ahead
            while (i >= 0 && keys[i] > k)
            {
                keys[i + 1] = keys[i];
                i--;
            }

            // Insert the new key at found location
            keys[i + 1] = k;
            n = n + 1;
        }
        else // If this node is not leaf
        {
            // Find the child which is going to have the new key
            while (i >= 0 && keys[i] > k)
                i--;

            // See if the found child is full
            if (C[i + 1]->n == 2 * t - 1)
            {
                ComparisonCount++;
                // If the child is full, then split it
                splitChild(i + 1, C[i + 1]);

                // After split, the middle key of C[i] goes up and
                // C[i] is splitted into two.  See which of the two
                // is going to have the new key
                if (keys[i + 1] < k)
                    i++;
            }
            C[i + 1]->insertNonFull(k);
        }
    }

    // A utility function to split the child y of this node
    // Note that y must be full when this function is called
    void BTreeNode::splitChild(int i, BTreeNode *y)
    {
        // Create a new node which is going to store (t-1) keys
        // of y
        BTreeNode *z = new BTreeNode(y->t, y->leaf);
        z->n = t - 1;

        // Copy the last (t-1) keys of y to z
        for (int j = 0; j < t - 1; j++)
            z->keys[j] = y->keys[j + t];

        // Copy the last t children of y to z
        if (y->leaf == false)
        {
            ComparisonCount++;
            for (int j = 0; j < t; j++)
                z->C[j] = y->C[j + t];
        }

        // Reduce the number of keys in y
        y->n = t - 1;

        // Since this node is going to have a new child,
        // create space of new child
        for (int j = n; j >= i + 1; j--)
            C[j + 1] = C[j];

        // Link the new child to this node
        C[i + 1] = z;

        // A key of y will move to this node. Find location of
        // new key and move all greater keys one space ahead
        for (int j = n - 1; j >= i; j--)
            keys[j + 1] = keys[j];

        // Copy the middle key of y to this node
        keys[i] = y->keys[t - 1];

        // Increment count of keys in this node
        n = n + 1;
    }
    void BTreeNode::traverse()
    {
        std::queue<BTreeNode*> queue;
        queue.push(this);
        while (!queue.empty())
        {
            BTreeNode* current = queue.front();
            queue.pop();
            int i;
            for (i = 0; i < n; i++)
            {
                if (leaf == false)
                    queue.push(current->C[i]);
                    cout << " " << current->keys[i] << endl;
            }
            if (leaf == false)
                queue.push(current->C[i]);
        }
    }

    // Driver program to test above functions
    int main()
    {
        BTree t(4); // A B-Tree with minium degree 4
        srand(29324);
        for (int i = 0; i<200; i++)
        {
            int p = rand() % 10000;
            t.insert(p);
        }

        cout << "Traversal of the constucted tree is ";
        t.traverse();

        int k = 6;
        (t.search(k) != NULL) ? cout << "\nPresent" : cout << "\nNot Present";

        k = 28;
        (t.search(k) != NULL) ? cout << "\nPresent" : cout << "\nNot Present";

        cout << "There are " << ComparisonCount << " comparison." << endl;
        system("pause");
        return 0;
    }

“B-ToE插入”代码> //C++程序 #包括 #包括 使用名称空间std； int ComparisonCount=0； //树节点 B类再入节点 { int*keys；//一个键数组 int t；//最小度数（定义键数的范围） BTreeNode**C；//子指针数组 int n；//当前的键数 bool leaf；//当节点为leaf时为true，否则为false 公众： BTreeNode（int _t，bool _leaf）；//构造函数 //一个实用函数，用于在以 //此节点。假设为，当此 //函数被调用 void insertNonFull（int k）； //用于拆分此节点的子y的实用函数。i是中y的索引 //子数组C[]。调用此函数时，子数组y必须已满 void splitChild（int i，b绿色节点*y）； //用于遍历以该节点为根的子树中的所有节点的函数 无效遍历（）； //在以该节点为根的子树中搜索键的函数。 BTreeNode*search（int k）；//如果k不存在，则返回NULL。 //让BTree成为这个的朋友，这样我们就可以访问它的私有成员 //B树函数中的类 朋友类树； }; //树 B类树 { BTreeNode*root；//指向根节点的指针 int t；//最小度 公众： //构造函数（将树初始化为空） 树（内部） { root=NULL；t=\u t； } //函数遍历树 无效遍历（） { 如果（root！=NULL）根->遍历（）； } //函数来搜索此树中的键 B重节点*搜索（整数k） { 返回（root==NULL）？NULL:root->search（k）； } //在此B树中插入新键的主函数 空白插入（int k）； }; //BTreeNode类的构造函数 BTreeNode:：BTreeNode（int t1，bool leaf1） { //复制给定的最小度数和叶属性 t=t1； 叶=叶1； //为可能的最大键数分配内存 //和子指针 密钥=新的整数[2*t-1]； C=新的B节点*[2*t]； //将密钥数初始化为0 n=0； } //函数遍历以该节点为根的子树中的所有节点 /*void BTreeNode:：traverse（） { //有n个键和n+1个子键，遍历n个键 //和前n个孩子 int i； 对于（i=0；itraverse（）； } cout键[i]） i++； //如果找到的键等于k，则返回此节点 如果（键[i]==k） { ComparisonCount++； 归还这个； } //如果在这里找不到键，并且这是一个叶节点 if（leaf==true） { ComparisonCount++； 返回NULL； } //去找合适的孩子 返回C[i]->搜索（k）； } //在此B树中插入新键的主函数 void BTree:：insert（int k） { //如果树是空的 if（root==NULL） { ComparisonCount++； //为根目录分配内存 根=新的B重节点（t，真）； 根->键[0]=k；//插入键 root->n=1；//更新root中的键数 } else//如果树不是空的 { //若根长满了，那个么树就会长得很高 如果（根->n==2*t-1） { ComparisonCount++； //为新根目录分配内存 BTreeNode*s=新的BTreeNode（t，false）； //将旧根作为新根的子根 s->C[0]=根； //拆分旧根并将一个关键点移动到新根 s->splitChild（0，根）； //新根现在有两个子级。请决定 //两个孩子将有一把新钥匙 int i=0； 如果（s->键[0]C[i]->insertNonFull（k）； //换根 根=s； } else//如果root未满，则为root调用insertNonFull 根->插入不完整（k）； } } //用于在此节点中插入新密钥的实用程序函数 //假设是，当发生此情况时，节点必须是非满的 //函数被调用 void BTreeNode:：insertNonFull（int k） { //将索引初始化为最右边元素的索引 int i=n-1； //如果这是一个叶节点 if（leaf==true） { ComparisonCount++； //下面的循环做两件事 //a）查找要插入的新密钥的位置 //b）将所有较大的键移到前面的一个位置 while（i>=0&&keys[i]>k） { 键[i+1]=键[i]；

    while (!queue.empty())
    {
        BTreeNode* current = queue.front();
        queue.pop();
        int i;
        for (i = 0; i < current->n; i++)  //*
        {
            if (current->leaf == false)  //*
                queue.push(current->C[i]);
                cout << " " << current->keys[i] << endl;
        }
        if (current->leaf == false)  //*
            queue.push(current->C[i]);
    }