用于AVL树C ++的Ostream运算符

Question

The agenda is to print the contents of an AVL Tree using the ostream operator. The contents have to be printed in a specific format.

The Tree is implemented using templates. A simple main implementation.

AVLTree<int, float> tree;
for(int i = 0; i < 10; i++)
   tree.insert(i, i+0.1);
cout << tree;

Ostream Operator

friend ostream&  operator<<(ostream& out, const AVLTree& v)
{   
    out << "{";
    v.print(out, v.root);
    out << "}";
    return out;
}


void print(AVLnode<KEY,INFO>* curr)const
    {
        if(curr)
        {
            print(curr->left);
            print(curr->right);
        }
    }

void print(ostream& out, AVLnode<KEY, INFO>* curr)const
    {
        if(curr)
        {
            print(out, curr->left);
            out << curr->Key_ << ": " << curr->Info_<<", ";
            print(out, curr->right);
        }
    }

I have two helper functions for printing.

The output I get is

{1:1.1, 2:2.1. 3:3.1, 4:4.1, 5:5.1, 6:6.1, 7:7.1, 8:8.1, 9:9.1, }

The required output is

{1:1.1, 2:2.1. 3:3.1, 4:4.1, 5:5.1, 6:6.1, 7:7.1, 8:8.1, 9:9.1}

The "," is not supposed to be printed, how to you detect the last element of the tree? I fail to understand the condition. It is simple but I fail to see it.

Answer 1

Introduce a simple if statement condition:

out << curr->Key_ << ": " << curr->Info_;
if (some_condition_of_yours) {
    out << ", ";
} 
else {
    out << " ";
}

Replace the condition with your internal logic.

Answer 2

Two ways I can see to accomplish this:

1.

Generate the string, store in variable, then drop the last 2 or 3 characters (depending on spacing), then append the } to close the format, then output to ostream .

2.

When entering the first print function, set a counter to 0, and increment every time handle a node. This will give you a total number of items printed. You can then compare that to the total number of items in the AVL tree. You'll have to keep track of the total number of items somewhere as well.

I would use option one, because it is easier to implement now. Also, AVL trees shouldn't be in charge of knowing how many items are in them. Also also, the larger your tree is, the slower printing will be, because there will be more if statements and count increments. Those two operations are minimal, but if you get thousands or millions of items, it'll add up.

Answer 3

I suppose you need an additional parameter in print() to know if there is something on the right.

By example (caution: not tested)

friend ostream&  operator<<(ostream& out, const AVLTree& v)
{   
    out << "{";
    v.print(out, v.root, false);
    out << "}";
    return out;
}


void print (ostream & out, AVLnode<KEY, INFO> * curr, bool proComma) const
    {
        if (curr)
        {
            bool proC2 = proComma || (NULL != curr->right);

            print(out, curr->left, proC2);

            out << curr->Key_ << ": " << curr->Info_;

            if ( proC2 )
               out << ", ";

            print(out, proComma);
        }
    }

Answer 4

Another way to think about this problem is to print the comma first , not last. This way you will never get a trailing comma, since it will be the first item printed.

That can be accomplished by introducing a bool reference variable in the helper functions (not tested):

friend ostream&  operator<<(ostream& out, const AVLTree& v)
{   
    bool firstTime = true;
    out << "{";
    v.print(out, v.root, firstTime);
    out << "}";
    return out;
}


void print(ostream& out, AVLnode<KEY, INFO>* curr, bool& firstTime) const
{
    if (curr)
    {
       print(out, curr->left, firstTime);
       out << (firstTime?"":", ") << curr->Key_ << ": " << curr->Info_;
       firstTime = false;
       print(out, curr->right, firstTime);
    }
}

The firstTime tracks whether it is the first time being printed. If this is the case, then no comma is printed, otherwise a comma is printed.

Answer 5

So after a while I figured out what the issue was and was able to come up with a simple solution, so I decided to post an answer before I forget to do so.

It is really hard to detect the last node in the tree since both the left and right sides of the trees have a NULL ending. So printing out the whole tree and deleting the extra characters did the trick quite well.

template<typename KEY, typename INFO>
void AVLTree<KEY, INFO>:: print(ostream& out, AVLnode<KEY,INFO>* curr) const{
        //sstream operator to calc the output and delete (n-1) of the output.        
        out << "{";
        std::stringstream ss;
        printHelp(ss, curr);
        std::string output = ss.str();
        if (output.length() > 1)
            output.erase(output.end()-2, output.end());

        out << output;
        out << "}";
}

template<typename KEY, typename INFO>
void AVLTree<KEY, INFO>::printHelp(std::stringstream& ss, AVLnode<KEY, INFO>* curr) const{
    if(curr){
            printHelp(ss, curr->left);  
            ss << curr->Key_<< ": " << curr->Info_ << ", ";
            printHelp(ss, curr->right);
        }
}

and then the ostream operator which uses the print function with the root node as a parameter and the ostream object.

friend ostream& operator<<(ostream& out, const AVLTree& v){
        v.print(out, v.root);
        return out;
    }

There was also another option of pushing them into a stack and poping the last characters and printing the stack entirely, this was very close to what I needed but would be very inefficient as the tree had close to 15,000 nodes on it.