BST的递归插入

Question

我已经制作了一个使用循环插入 BST 的函数，它工作得非常好。 现在，当我使用递归编写它时，我不知道为什么它不能正常工作，但是根据我的逻辑是正确的。似乎没有新节点被添加到 BST 树中，并且在退出插入函数后树的头部再次变为 NULL。

#include <iostream>
using namespace std;

class node{
public:
   int data;
   node *right;
   node *left;
   node(){
      data=0;
      right=NULL;
      left=NULL;
   }
};

class tree{
   node *head;
   int maxheight;
   void delete_tree(node *root);
public:
   tree(){head=0;maxheight=-1;}
   void pre_display(node* root);
   node* get_head(){return head;}
   void insert(int key,node* current);
};

void tree::insert(int key,node *current){
   if(current==NULL)
   {
      node *newnode=new node;
      newnode->data=key;
      current=newnode;
   }
   else{
      if(key<current->data)
         insert(key,current->left);
      else
         insert(key,current->right);
   }
   return;
}

void tree::pre_display(node *root){
   if(root!=NULL)
   {
      cout<<root->data<<" ";
      pre_display(root->left);
      pre_display(root->right);
   }
}

int main(){
   tree BST;
   int arr[9]={17,9,23,5,11,21,27,20,22},i=0;

   for(i=0;i<9;i++)
   BST.insert(arr[i],BST.get_head());

   BST.pre_display(BST.get_head());
   cout<<endl;

   system("pause");
   return 0;
}

请告诉我我应该对算法进行哪些更改才能使其正常工作。

Answer 1

在您的插入函数中

void tree::insert(int key,node *current){
    if(current==NULL)
    {
        node *newnode=new node;
        newnode->data=key;
        current=newnode;
    }
    else{
        if(key<current->data)
            insert(key,current->left);
        else
            insert(key,current->right);
    }
    return;
}

您分配了一个新节点，但从未将 BST::head 设置为新分配的头。所以 BST::get_head 总是会返回 null。

解决这个问题的一种方法是插入返回一个节点。在您的情况下，这将是根节点，并将 BST::head 设置为此值。

Answer 2

您的递归看起来不错，但实际上您并没有在任何地方添加节点！您只需在树中递归。

编辑您可以更改insert 方法以获取指向指针的指针，如下所示：

void tree::insert(int key, node **current)
{
    if(*current == NULL)
    {
        node *newnode = new node;
        newnode->data = key;
        *current = newnode;
    }
    else 
    {
        if(key < (*current)->data)
            insert(key, &(*current)->left);
        else
            insert(key, &(*current)->right);
    }
}

在 main 中这样称呼它：

BST.insert(arr[i], &BST.get_head());  // Note the ampersand (&)

Answer 3

你应该试试这个

             node  tree:: insert ( int key , node * current )  {

                     if ( ! current ) {
                           node * newnode = new node ;
                           newnode -> key = key;
                           current = newnode ;
                      }
                    else if ( key < current -> key )  {
                        current -> left = insert ( key , current ->left 
                         }
                    else 
                       current -> right = insert ( key , current->right )
                return current ;
               }

它工作正常....每次插入新节点时更新头节点，它将返回更新的当前节点。

Answer 4

只需将您的功能更改为

void tree::insert(int key,node*& current){
  if(current==NULL)
  {
    node *newnode=new node;
    newnode->data=key;
    current=newnode;
  }
  else{
    if(key<current->data)
      insert(key,current->left);
    else
      insert(key,current->right);
  }
  return;
}

将您的输入指针作为参考参数。

Answer 5

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

node* root=NULL;

node* create(node* head,int val){
    if(head==NULL){
        node* nn=new node;
        nn->data=val;
        nn->left=NULL;
        nn->right=NULL;
        head=nn;
    }
    else if(val<head->data)
        head->left=create(head->left,val);
    else if(val>head->data)
        head->right=create(head->right,val);
    return head;
}

int main(){
    int num=0;
    cout<<"Enter value in tree or press -1 to Exit\n";
    while(num!=-1){
        cin>>num;
        if(num==-1){
            cout<<"\nTree Created\n";
            break;
        }
        else{
            root=create(root,num);
        }
    }
}

希望这段代码能解决你的问题

Answer 6

void insertNode_recursive(int value, TreeNode *current)
{
    if (current == NULL)
    {
        if (current == NULL && isEmpty())
        {
            TreeNode *new_node = new TreeNode(value);
            current = new_node;
            root = new_node;
        }
        else
        {
            TreeNode *new_node = new TreeNode(value);
            current = new_node;
        }
    }
    else
    {
        if (value < current->getValue())
        {
            insertNode_recursive(value, current->getLeft());
        }
        else if (value > current->getValue())
        {
            insertNode_recursive(value, current->getRight());
        }
        else
        {
            cout << "\nDuplicate Value are Not Allowed\n";
        }
    }
}

此代码对于递归打印树节点很有用