Creating a preorder traversal tree for xml element tags

[jesseshaffer]

Hi guys,

I have a program that reads a given XML file. It parses the file and picks out the element opening and closing tags and places them into vectors. My next step is to create a tree of the element tags starting with the root tag. I need to use preorder traversal to read through the tree and print out the elements. This is what I have so far. This is just the code to make the tree. Can supply the other files in program if needed.


TreeNode.h

#ifndef TREENODE_H
#define	TREENODE_H



//forward declaration of class Tree (code from book)
template<typename NODETYPE> class tree;

//TreeNode class-template definition
template<typename NODETYPE>
class TreeNode{
    friend class Tree<NODETYPE>;
    
    public:
        //contrsuctor (code from book)
        TreeNode(const NODETYPE &d)
                :leftPtr ( nullptr ), //pointer to left subtree (code from book)
                        data ( d ), //tree node data (code from book)
                        rightPtr ( nullptr )//pointer to right subtree (code from book)
                {}
                //return copy of node's data (code from book)
                NODETYPE getData() const
                {
                    return data;
                }
                
                private:
                    TreeNode <NODETYPE> *leftPtr; //pointer to left subtree (code from book)
                    NODETYPE data;
                    TreeNode <NODETYPE> *rightPtr; //pointer to right subtree (code from book)
};

#endif	/* TREENODE_H */

Tree.h

#ifndef TREE_H
#define	TREE_H

#include <cstddef>
#include <iostream>
#include "TreeNode.h"


using namespace std;

template<typename NODETYPE>
class Tree {
public:
    //constructor
    Tree()
            :rootPtr(nullptr) {}
            
            //insert node into tree (code from book)
            void insertNode( const NODETYPE &value)
            {
                insertNodeHelper( &rootPtr, value);
            }
            
            //begin pre order traversal of tree
            void preOrderTraversal() const
            {
                preOrderHelper( rootPtr );
            }
            
            
            private:
                TreeNode<NODETYPE> *rootPtr;
                
                //utility function called by insertNode; receives a pointer
                //to a pointer so that the function can modify pointers value (code from book)
                void insertNodeHelper(
                TreeNode<NODETYPE> **ptr, const NODETYPE &value)
                {
                    //subtree is empty; create new TreeNode containing value (code from book)
                    if (*ptr == nullptr )
                        *ptr = new TreeNode <NODETYPE> (value);
                    else //tree is not empty (code from book)
                    {
                        //data to insert is less than data in current node (code from book)
                        if ( value > (*ptr ) -> data)
                            insertNodeHelper( &(( *ptr) -> leftPtr), value);
                        else
                        {
                            //data to insert is greater than data in current node (code from book)
                            if (value > (*ptr) -> data)
                                insertNodeHelper(&((*ptr)->rightPtr), value);
                            else //duplicate data value ignored (code from book)
                            {
                                cout<< value<< "dup"<<endl;
                            }
                        }
                    }
                }
                
                //utility function to perform preorder traversal of tree (code from book)
                void preOrderTraversal(TreeNode<NODETYPE> *ptr)const
                {
                    if (ptr != nullptr)
                    {
                        cout << ptr->data << ' '; //process node (code from book)
                        preOrderHelper(ptr-> leftPtr); //traverse left subtree (code from book)
                        preOrderHelper(ptr->rightPtr); //traverse right subtree (code from book)
                    }
                }
};


#endif	/* TREE_H */

Any help is welcome.

Thanks