segementation fault in main() believe its in the switch cases. HELP Please I'm lost

[macl229]

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
using namespace std;

class TreeNode
{
public:

	char data;
	TreeNode *left, *right;
        TreeNode(char data)

        {

            this->data = data;

            this->left = NULL;

            this->right = NULL;

        }

};       

class StackNode
{
public:

	TreeNode *treeNode;
	StackNode *next;

        StackNode(TreeNode *treeNode)//Constructor of Class

           {
            this->treeNode = treeNode;

            next = NULL;
             }

};

class ExpressionTree
{
private:
	StackNode *top;

public:	        

	        ExpressionTree()//Constructor for the tree

	        {

	            top = NULL;

	        }
 
        //Function to clear the tree for a new equation
	        void clear()

	        {

	            top = NULL;

	        }
//Push a node 

	        void push(TreeNode *ptr)

	        {

	            if (top == NULL)

	                top = new StackNode(ptr);

	            else

	            {

	                StackNode *new_ptr = new StackNode(ptr);

	                new_ptr->next = top;

	                top = new_ptr;

	            }

	        }
 
    

           TreeNode *pop()

           {
            if (top == NULL)

              {

                 cout<<"Underflow"<<endl;

	            }

	            else

                    {
                TreeNode *ptr = top->treeNode;

	                top = top->next;
	                return ptr;

	            }

	        }

   //Get the top Node

	        TreeNode *peek()

	        {

	            return top->treeNode;

	        }
 

//Inserts characters

	        void insert(char val)
	        {

	            if (Digit(val))

	            {

	                TreeNode *new_ptr = new TreeNode(val);

	                push(new_ptr);
	
	            }

	            else if (Operator(val))

	            {

	                TreeNode *new_ptr = new TreeNode(val);

	                new_ptr->left = pop();

	                new_ptr->right = pop();

	                push(new_ptr);

	            }

	            else

	            {

	                cout<<"Invalid Expression"<<endl;

	                return;

	            }

	        } 

	        //check to see if a number

	        bool Digit(char ch)

	        {

	            return ch >= '0' && ch <= '9';
	        }
 

        //check if an operator is present

	        bool Operator(char ch)

	        {

	            return ch == '+' || ch == '-' || ch == '*' || ch == '/';

	        }
 
 

	   

	        int to_Digit(char ch)

	        {

	            return ch - '0';

	        }
 

   //builds the tree
 

	        void buildTree(string equation)

	        {
			for (int i = equation.length() - 1; i>=0; i--)
			{
				insert(equation[i]);
			}

	    	}

 

	        // calculates the function

	        double evaluate()

	        {

	            return evaluate(peek());

	        }

	 

	        //calculates the tree

	        double evaluate(TreeNode *ptr)

	        {

	            if (ptr->left == NULL && ptr->right == NULL)

	                return to_Digit(ptr->data);

	            else

	            {

	                double result = 0.0;

	                double left = evaluate(ptr->left);

	                double right = evaluate(ptr->right);

	                char op = ptr->data;

	                switch (op)

	                {

                case '+': 

	                    result = left + right; 

	                    break;
	
                case '-': 

	                    result = left - right; 

	                    break;

                     case '*': 

	                    result = left * right; 

	                    break;

	                case '/': 

	                    result = left / right; 

	                    break;

	                default: 

	                    result = left + right; 

	                    break;

	                }

	                return result;

	            }

	        }

 

        //gets the postfix expression

	        void postfix()
	        {

	            postOrder(peek());

	        }

 

        // postorder traversal

	        void postOrder(TreeNode *ptr)
	        {

	            if (ptr != NULL)
	            {

	                postOrder(ptr->left);            

	                postOrder(ptr->right);

	                cout<<ptr->data;            

	            }    

	        }

 

        //gets infix expression

	        void infix()
	        {

	            inOrder(peek());

	        }


        //inorder traversal
        void inOrder(TreeNode *ptr)
        {

	            if (ptr != NULL)

	            {

	                inOrder(ptr->left);

	                cout<<ptr->data;   

	                inOrder(ptr->right);            

	            }    

        }

 

        //gets prefix expression
        void prefix()

	        {

	            preOrder(peek());

	        }

 

        //preorder traversal

	        void preOrder(TreeNode *ptr)

	        {

	            if (ptr != NULL)

	            {

	                cout<<ptr->data;

	                preOrder(ptr->left);

	                preOrder(ptr->right);            

	            }    

	        }

	};
//main function that displays to the user
int main()

	{

	int selection;	

	while(selection < 6)
	{
	cout<<"Selections: "<<endl;

	cout<<"1.Read an expression."<<endl;
	cout<<"2.Display the prefix expression."<<endl;
	cout<<"3.Display the infix expression."<<endl;
	cout<<"4.Display the postfix expression."<<endl;
	cout<<"5.Evaluate the expression using postfix notation."<<endl;
	cout<<"6.Exit"<<endl;


	cout<<"Your selection: ";
	
	    string s;
       	cin >> selection;
	    ExpressionTree et;

		switch(selection)
		{

			case 1:

			    cout<<"\nEnter an Expression: ";

	   		     cin>>s;

	   		      et.buildTree(s);
	 		
			 break;
			
			case 2:
	  		
				 cout<<"\nPrefix  : ";

	   			 et.prefix();

				break;


			case 3:

			   cout<<"\n\nInfix   : ";

			    et.infix();

			break;

			case 4:

	   			 cout<<"\n\nPostfix : ";

	   			 et.postfix();
	
			break;

			case 5:


	   			 cout<<"\n\nEvaluated Result : "<<et.evaluate();
	
			break;
	
			default:
		
				cout<<"Invalid Input."<<endl;

				break;	

			}
	
	}
	    return 0;
	
}