Question

好吧，我现在已经调试了几个小时而且无处可去。我试图使用二叉树来测试一个简单的递归。

测试时，我在main的print_attributes函数中进行第三次调用时出现堆栈溢出（如下所示）。对callstack的快速检查表明，它已经完成了对binTree的binTree高度（节点＆lt; T＆gt; *节点）的数百次调用（也在下面说明）。当我＆＃34;去...＆＃34;来自调用栈的调用，它需要调整大小（节点＆lt; T＆gt; *节点）的leftside = size（node-＆gt; left）调用（也在下面说明）。我不知道那些应该表明什么，因为这些功能都没有相互呼唤。

这是编译器在堆栈溢出发生时所说的正确图像（我使用的是VS2013）： http://puu.sh/ca3ti/e00f653282.png

然后，在打破并单击调用堆栈中的任何height（）调用之后，这里是编译器的图像：http://puu.sh/ca2Qz/d35348ccce.png

考虑到它（似乎是）在使用bintree的height（）和/或size（）函数之前将节点插入树中，我不知道为什么同一个函数在这里开始出现问题。我很抱歉无法更清楚地解释问题所在。我已经编写了几年但我真的迷失了。我试图提供尽可能多的信息。非常感谢那些花时间来帮助解决这个问题的人。

节点类：

#include "340.h"

#ifndef H_NODE
#define H_NODE

// definition for class of nodes in bin tree

template < class T > class binTree; // forward declaration

template < class T >
class Node {
friend class binTree < T >;         // binTree is friend
public:
    // default constructor
    Node ( const T& x = T ( ), Node < T >* l = 0, Node < T >* r = 0 ) :
        data ( x ), left ( l ), right ( r ) { }
private:
    T data;                         // data component
    Node < T > *left, *right;       // left and right links
};
#endif

NodeTree类：

#include "Node.h"

#ifndef H_TREE
#define H_TREE

template < class T > class binTree {
public:
    binTree(Node < T >* emptyroot = nullptr) : // default constructor
        root(emptyroot) { }

    bool empty() const // checks if tree empty
    {
        if (root == 0)
            return true;
        else
            return false;
    }

    unsigned size() const // returns no of nodes
    {
        if (root == 0)
            return 0;
        else
            return size(root);
    }

    unsigned height() const // returns height of tree
    {
        if (root == 0)
            return 0;
        else
            return height(root);
    }

    virtual void insert(const T& t) // inserts a node in shortest subtree
    {
        if (empty())
        {
            Node< T >* n = new Node< T >;
            n->data = t;
            root = n;
        }
        else
            insert(root, t);
    }
protected:
    Node < T >* root; // root of tree
private:
    unsigned size(Node < T >* node) const // private version of size ( )
    {
        unsigned leftside;
        unsigned rightside;

        if (node->left == 0)
            leftside = 0;
        else
            leftside = size(node->left); //******issue(?) here******

        if (node->right == 0)
            rightside = 0;
        else
            rightside = size(node->right);

        return(leftside + rightside + 1);
    }

    unsigned height(Node < T >* node) const // private version of height ( ) 
//*****issue(?) here************
    {
        unsigned leftside;
        unsigned rightside;

        if (node->left == 0)
            leftside = 0;
        else
            leftside = height(node->left);

        if (node->right == 0)
            rightside = 0;
        else
            rightside = height(node->right);

        return 1 + max(leftside, rightside);
    }

    void insert(Node < T >* node, const T& t) // private version of insert ( )
    {
        if (node->left == 0)
        {
            Node< T >* n = new Node< T >;
            n->data = t;
            root = n;

            node->left = n;
            return;
        }
        else if (node->right == 0)
        {
            Node< T >* n = new Node< T >;
            n->data = t;
            root = n;

            node->right = n;
            return;
        }

        unsigned lefth = height(node->left);
        unsigned righth = height(node->right);

        if (lefth <= righth)
        {
            insert(node->left, t);
        }
        else
        {
            insert(node->right, t);
        }       
    }
};

#endif

主要

#include "binTree.h"

// vectors used in testing
const vector < int > A { 1, -2, 3, -4, 5, -6, 7, -8, 9, -10, 11, -12,
        13, -14, 15 };

// prints out val passed as argument
template < class T > void print ( T& x ) { cout << x << ' '; }

// increments val passed as argument
template < class T > void increment ( T& x ) { x++; }

// decrements val passed as argument
template < class T > void decrement ( T& x ) { x--; }

// prints out attributes, such as size and height of bin tree,
// and prints out data val in each node in inorder, preorder,
// and postorder

template < class T >
void print_attributes ( binTree < T >& tree, const string& name )
{
    cout << name; // print name of tree

    // check if tree is empty
    cout << ": tree is " << ( tree.empty ( ) ? "" : "not " ) << "empty\n";

    // print size and height of tree
    cout << "\tno of nodes    = " << setw ( 2 ) << tree.size ( )
         << "\n\theight of tree = " << setw ( 2 ) << tree.height ( )
         << endl << endl; //*******issue here************

    system("pause");
    return 0;
}

Answer 1

首先，在您的班级binTree中，size()和height()方法都包含以下内容：

if (root = 0)

显然这应该是==。

实际的堆栈溢出问题似乎是由insert函数引起的。它通过引用获取第一个参数node。因此，当您使用insert(root, t)进行调用时，node最终会作为对root的引用。在insert中分配新节点时，root设置为指向新节点，这也会更改node引用。

如果您使用调试器在insert功能的顶部设置断点并逐步执行，则可以观察值的变化。

这意味着root和node是相同的，所以当您设置node->left = n或node->right = n时，节点最终会指向自身。

要修复它，您需要做的就是将insert的定义更改为按值传递node而不是引用：

void insert(Node < T >* node, const T& t) // private version of insert ( )

C ++二进制树堆栈溢出

1 个答案: