बाइनरी खोज वृक्ष विभाजन गलती

यह प्रोग्राम इनपुट फ़ाइल से स्ट्रिंग लेने के लिए है, हस्ताक्षर करने के लिए उन्हें वर्णानुक्रमित क्रमबद्ध करें, फिर बीएसटी नोड के लिए हस्ताक्षर डालें। हस्ताक्षर शब्द को तब से बनाया गया था जब कुंजी से जुड़े तारों के वेक्टर में संग्रहीत किया जाता है। किसी भी शब्द के बाद हस्ताक्षर कौन है, वही वेक्टर पर वापस धकेल दिया जाता है, आदि। मुझे एक सेगमेंटेशन गलती मिल रही है, नीचे सही स्थान दिखाएगी।

BST.h

#ifndef BST_H
#define BST_H
#include 
#include 
#include 

using namespace std;

class Node;

class BST {
  private:
   class Node {
     public:
      string key;
      Node *left, *right;
      vector data;
     Node(string k, Node *l, Node *r, vector d) : key{k}, left{l}, right{r}, data{d} {};
   };
   Node *root;
   void traverse(void (*f)(const string& key, vector& value), Node* root);
  public:
   BST();
   ~BST();
   Node* find(Node* root, const string& key);
   void insert(Node *&root, const string& key);
   vector& operator[](const string& key);
   void traverse(void (*f)(const string& key, vector& value));
};

#endif

BST.cc

#include "BST.h"

BST::BST()
{
   root = nullptr;
}

BST::~BST()
{
   delete root;
}

BST::Node* BST::find(Node* root, const string& key)
{
   if(!root) return nullptr;
   if(root->key == key) return root;
   else if(root->key > key) return BST::find(root->left, key);
   else return BST::find(root->right, key);
}

void BST::insert(Node *&root,const string& key)
{
   if(!root)
   {
      vector data;
      root=new Node(key, nullptr, nullptr, data);
   }
   else if(root->key >= key) BST::insert(root->left, key);
   else BST::insert(root->right, key);
}

vector& BST::operator[](const string& key)
{
   Node* temp=BST::find(root, key);
   if(temp!=nullptr)
   {
      return temp->data;
   }
   else
   {
      BST::insert(root, key);
      return (BST::find(root, key))->data;
   }
}

निम्नलिखित 2 सदस्य फ़ंक्शंस सेगमेंटेशन गलती होती है

void BST::traverse(void (*f)(const string& key, vector& value))
{
   Node* tRoot=root;
   if(tRoot)
      traverse(*f, tRoot);
}


void BST::traverse(void (*f)(const string& key, vector& value), Node* root)
{
   string& key=root->key;
   vector value(root->data);
   if(root)
   {
      traverse(*f, root->left);
      f(key, value);
      traverse(*f, root->right);
   }
}

मुख्य कार्यक्रम

#include "BST.h"
#include 
#include 

using namespace std;

// Computes the signature of the string, which is the original string                                                                                                                                                                                                         
// arranged in alphabetical order.                                                                                                                                                                                                                                            
//                                                                                                                                                                                                                                                                            
// Assumes that the string w consists of only upper case letters.                                                                                                                                                                                                             
string signature(const string& w);

// prints all the anagrams in the BST                                                                                                                                                                                                                                         
void printAnagrams(const string& key, vector& value);

int main(void)
{
  string w, s;
  BST signatureList;
  vector temp;
  ifstream myfile;
  myfile.open("words.txt");

  //read all words                                                                                                                                                                                                                                                            
  while(getline(myfile, w)) {
    //compute signature and store it into the list                                                                                                                                                                                                                          
     s = signature(w);
     temp = signatureList[s];
     temp.push_back(w);
  }

  myfile.close();

 //print the results
  //this call specifically gives the seg fault                                                                                                                                                                                                                                                 
   signatureList.traverse(*printAnagrams);

  return 0;
}

// Computes the signature of the string, which is the original string                                                                                                                                                                                                         
// arranged in alphabetical order.                                                                                                                                                                                                                                            
//                                                                                                                                                                                                                                                                            
// Assumes that the string w consists of only upper case letters.                                                                                                                                                                                                             
string signature(const string& w)
{
  string s = w;
  sort(s.begin(), s.end());
  return s;
}

// prints all the anagrams in the BST                                                                                                                                                                                                                                        
void printAnagrams(const string& key, vector& value)
{
   cout << key << endl;
   for(string s : value)
       cout << s << ' ';
   cout << endl;
}

किसी भी मदद के लिए धन्यवाद, इस पर काम कर रहे valgrind प्राप्त नहीं कर सकते हैं। जो मैं बता सकता हूं उससे मेरे मुद्दे से स्पष्ट रूप से कोई प्रश्न नहीं हैं, अगर मैं मामला नहीं चाहता हूं तो मैं क्षमा चाहता हूं।

0
जीडीबी संलग्न करें या जो भी आपका डीबगर आपके प्लेटफ़ॉर्म पर है और यह पता लगाएं कि कौन सी रेखा seg दोषपूर्ण है। यह जानना आपके ट्रैवर्स फ़ंक्शन में पर्याप्त नहीं है।
जोड़ा लेखक Stephan van den Heuvel, स्रोत
क्या लाइन/फ़ंक्शन/मान यह गलती है?
जोड़ा लेखक Fiddling Bits, स्रोत

1 उत्तर

आप नल में बहुत देर हो चुकी है traverse में। सशर्त प्रारंभिकरण को सशर्त के अंदर ले जाएं, या पूरी तरह से उन्हें खत्म करें:

void BST::traverse(void (*f)(const string&, vector&), Node* root)
{
   if(root)
   {
      traverse(f, root->left);
      f(root->key, root->data);
      traverse(f, root->right);
   }
}
0
जोड़ा
मैं सोच रहा था कि एक नल कहीं कहीं फेंक रहा था। यह हल हो गया, मैं कम से कम हस्ताक्षर मुद्रित कर सकते हैं। धन्यवाद!
जोड़ा लेखक user2950936, स्रोत