द्विआधारी खोज वृक्ष क्रंमोत्तर और Preorder Traversals गलत हैं

मैं कहाँ से अग्रिम आदेश, क्रंमोत्तर, और inorder में मेरी द्विआधारी खोज वृक्ष मुद्रित करने के लिए की जरूरत है मैं इस होमवर्क पर काम कर रहा हूँ। हालांकि, यह केवल मेरे लिए inorder विधि काम कर रहा है की तरह लगता है। मैं अपने काम की जांच करने के बाद परीक्षण का मामला इस्तेमाल किया है।

http://www.theteacher99.btinternet.co.uk/theteacher/newalevel/cp4_5_4.htm

आप नीचे दिए गए मेरे कोड पर एक नज़र डालें और देखो मैं गलत क्या कर रहा जा सकता है। किसी भी मदद / अभिविन्यास सराहना की जाएगी। तुम बस मुझे पता है मैं गलत क्या कर रहा जाने मेरे लिए इसे हल करने की जरूरत नहीं है,। धन्यवाद।

#include <iostream>
#include <fstream>
#include <cstddef>
#include <string>
#include <sstream>
#include <string>

using namespace std;

struct TreeNode
{
    string item;
    TreeNode *left;
    TreeNode *right;
};

class BinarySortTree
{
public:
    BinarySortTree();
    void readFile(string fileName);
    void insert(string key);
    void preorder();
    void postorder();
    void inorder();
    void test();

private:
    TreeNode *root;
    void insert(string key, TreeNode *node);
    void preorderTraverse(TreeNode *node);
    void postorderTraverse(TreeNode *node);
    void inorderTraverse(TreeNode *node);
};


//default constructor, create new binary tree
BinarySortTree::BinarySortTree()
{
    root = NULL;
}

//reads the file and puts items in the tree
void BinarySortTree::readFile(string fileName)
{
    ifstream inputStream(fileName.c_str());

    if(inputStream.is_open())
    {
        string line;

        while( getline(inputStream, line) )
        {
            insert(line);
        }
    }
}

void BinarySortTree::insert(string key)
{
    if(root != NULL)
    {
        insert(key, root);
    }
    else
    {
        root = new TreeNode;
        root->item = key;
        root->left = NULL;
        root->right = NULL;
    }
}

void BinarySortTree::insert(string key, TreeNode *node)
{
    bool done = false;

    while(!done)
    {
        if(key.compare(node->item) < 0)
        {
            if(node->left != NULL)
            {
                node = node->left;
            }
            else
            {
                node->left = new TreeNode;
                node->left->item = key;
                node->left->left = NULL;
                node->left->right = NULL;
                done = true;
            }
        }
        else if(key.compare(node->item) > 0)
        {
            if(node->right != NULL)
            {
                node = node->right;
            }
            else
            {
                node->right = new TreeNode;
                node->right->item = key;
                node->right->left = NULL;
                node->right->right = NULL;
                done = true;
            }
        }
        else if(key.compare(node->item) == 0)
        {
            done = true;
        }
    }
}

void BinarySortTree::preorder()
{
    cout << PreOrder Traversal << endl;
    preorderTraverse(root);
    cout << endl;

}

/*
   1. Start at the root node
   2. Traverse the left subtree
   3. Traverse the right subtree
*/
void BinarySortTree::preorderTraverse(TreeNode *node)
{
    if(node != NULL)
    {
        cout << node->item <<  ;
        preorderTraverse(node->left);
        preorderTraverse(node->right);
    }

}

void BinarySortTree::postorder()
{
    cout << PostOrder Traversal << endl;
    postorderTraverse(root);
    cout << endl;
}

/*
   1. Traverse the left subtree
   2. Traverse the right subtree
   3. Visit the root node
*/
void BinarySortTree::postorderTraverse(TreeNode *node)
{
    if(node != NULL)
    {
        postorderTraverse(node->left);
        postorderTraverse(node->right);
        cout << node->item <<  ;
    }
}

void BinarySortTree::inorder()
{
    cout << InOrder Traversal << endl;
    inorderTraverse(root);
    cout << endl;
}

/*
   1. Traverse the left subtree
   2. Visit the root node
   3. Traverse the right subtree
*/
void BinarySortTree::inorderTraverse(TreeNode *node)
{
    if(node!= NULL)
    {
        inorderTraverse(node->left);
        cout << node->item <<  ;
        inorderTraverse(node->right);
    }
}

void BinarySortTree::test()
{
    cout << root->item << endl;
}


int main()
{
    string fileName = a4.txt;
    BinarySortTree bst;
    bst.readFile(fileName);
    bst.test();

    bst.preorder();
    bst.postorder();
    bst.inorder();

    return 0;
}