Solution for Problem 1 (Infix, postfix and prefix)
a.
Postfix:
	ab+c+d+
	ab+cde-/*
b.
Prefix:
	*2+34
	*+ab/c-de
c.
Infix:
	a*b-(c+d)
	(a+b)*(c-(d-e))

================================================================================

Solution for Problem 2 (Language recognition with stacks)

#include <stdlib.h>
#include <iostream.h>
#include <string.h>

class mystack {
  struct link {
	 char data;
	 link* next;
	 link(char Data, link* Next) {
		   data=Data;
			next=Next;
				}
				} * head;
  public:
	mystack(){head=NULL;}
	~mystack();
	void Push(char Data){
	     head=new link(Data,head);
	     }
	     char Pop();
	     bool StackIsEmpty();
};

char mystack::Pop(){
     if(head==0)
	return 0;
	char result=head->data;
	link* oldhead=head;
	head=head->next;
	delete oldhead;
	return result;
}

bool mystack::StackIsEmpty(){
     if (head==0)
	return 1;
	else 
	     return 0;
}

mystack::~mystack(){
	link* cursor=head;
	while(head){
		cursor=cursor->next;
			delete head;
			       head=cursor;
			       }
}


main(){
	mystack S;
	char str[100], stackpop;
	int i=0,flag=1;
	
	cout<<"Input a string: ";
	cin>>str;
	cout<<endl;
	
	while((str[i]!='$')&&(str[i]!=0)){
		S.Push(str[i]);
			i++;
			}
			
			i++;
			
			while(flag && (i<strlen(str))){
				   stackpop=S.Pop();
					if ((stackpop!=0) && (stackpop=str[i]))
							  i++;
								else 
									flag=0;
									}
									
									if(flag && S.StackIsEmpty())
										cout<<"String is in language."<<endl;
										else
											cout<<"String is not in language."<<endl;
												      
												      
}
	
================================================================================

Solution for Problem 3 (Infix expression evaluatuion)
// The first class of this code is the same as the above solution. You may
like
// to make the same class as a header file to be included in this program.


#include <stdlib.h>
#include <iostream.h>

int precedence(char ch){
    if (ch=='+'||ch=='-') return 1;
    if (ch=='*'||ch=='/') return 2;
    return -1;
}

class mystack {
  struct link {
	 int data;
	 link* next;
	 link(int Data, link* Next) {
		  data=Data;
			next=Next;
				}
				} * head;
  public:
	mystack(){head=NULL;}
	~mystack();
	void Push(int Data){
	     head=new link(Data,head);
	     }
	     int Pop();
	     bool StackIsEmpty();
	     int GetStackTop();
};

int mystack::Pop(){
    if(head==0)
	return 0;
	int result=head->data;
	link* oldhead=head;
	head=head->next;
	delete oldhead;
	return result;
}

bool mystack::StackIsEmpty(){
     if (head==0)
	return 1;
	else 
	     return 0;
}

int mystack::GetStackTop(){
    if(head==0)
	return 0;
	return head->data;
}

mystack::~mystack(){
	link* cursor=head;
	while(head){
		cursor=cursor->next;
			delete head;
			       head=cursor;
			       }
}



class InfixCalc {
      mystack S;
      char PE[100];
      char str[100];
  public:
  InfixCalc(char exp[]);
  ~InfixCalc();
	void in2post();
	int calc();
};


InfixCalc::InfixCalc(char exp[]){
			  int i=0;
			  while(exp[i]!=0){
				str[i]=exp[i];
					i++;
						}
						str[i]=0;
}

void InfixCalc::in2post(){
     int i=0;
     int j=0;
     char ch;
     while(str[i]!=0){
	ch=str[i];
		switch(ch){
				case '0':
					case '1':
						case '2':
							case '3':
								case '4':
									case '5':
										case '6':
											case '7':
												case '8':
													case '9':
															PE[j]=ch;
															   j++;
															      break;
															        case '(':
																       S.Push(ch);
																          break;
																	    case ')':
																		   while(S.GetStackTop()!='('){
																		       PE[j]=S.Pop();
																		           j++;
																			       }
																			          S.Pop();
																				     break;
																				       case '+':
																					     case '-':
																						   case '*':
																							 case '/':
																							        while(!S.StackIsEmpty() &&
(S.GetStackTop()!='(')
			&&(precedence(ch)<=precedence(S.GetStackTop()))){
							PE[j]=S.Pop();
											j++;
														}
															  S.Push(ch);
															     break;
															      }
															      i++;
															      }
															      
															      while(!S.StackIsEmpty()){
															       PE[j]=S.Pop();
															        j++;
																 }
																 PE[j]=0;
																 cout<<"The Postfix is :"<<PE<<endl;
}

int InfixCalc::calc(){
    char ch;
    int j=0;
    int value,Operand1,Operand2,result;
    while(PE[j]!=0){
	ch=PE[j];
		j++;
			if ((ch>='0')&&(ch<='9')){
				value=ch-'0';
						S.Push(value);
								}
									else {
										Operand2=S.Pop();	
														Operand1=S.Pop();
															 switch(ch){
															    case '+': result=Operand1+Operand2;
																        break;
																	   case '-': result=Operand1-Operand2;
																		       break;
																		          case '*': result=Operand1*Operand2;
																				      break;
																				         case '/': 
																						     if (Operand2==0){
																							    cout<<"Cannot divided by
0."<<endl;
						exit(0);
											}
															else
															     result=Operand1/Operand2;
															         break;
																   }
																     S.Push(result);
																      }
																      }
																      cout<<"The result is: "<<S.Pop()<<endl;
}

InfixCalc::~InfixCalc(){
}
	
main(){
	
	char str[100];
	cout<<"Input the expression: ";
	cin>>str;
	cout<<endl;
	
	InfixCalc A(str);
	A.in2post();
	A.calc();
}