infix_to_postfix2.c File Reference

Infix to Postfix converter implementation More...

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <stdlib.h>
#include <stdint.h>
#include <assert.h>

Include dependency graph for infix_to_postfix2.c:

Data Structures
struct	Stack
	for printf() and scanf() More...

Functions
void	push (char opd)
	Function to push on the stack. More...
char	pop ()
	Function to pop from the stack. More...
uint16_t	isEmpty ()
	Function to check whether the stack is empty or not. More...
char	Top ()
	Function to get top of the stack. More...
int16_t	priority (char opr)
	Function to check priority of operators. More...
char *	convert (char inf[])
	Function to convert infix expression to postfix expression. More...
static void	test ()
	Self-test implementations. More...
int	main ()
	Main function. More...

Variables
struct Stack	st
	global declaration of stack st

Detailed Description

Infix to Postfix converter implementation

The input infix expression is of type string upto 24 characters. Supported operations- '+', '-', '/', '*', ''

Author

Kumar Yash

See also

infix_to_postfix.c

Function Documentation

convert()

char * convert

(

char

inf[]

)

Function to convert infix expression to postfix expression.

Parameters

inf	the input infix expression

Returns

output postfix expression

< to store the postfix expression

< loop iterator

< keeps track of end of postfix string

                          {
    static char post[25];               ///< to store the postfix expression
    int i;                              ///< loop iterator
    int j = 0;                          ///< keeps track of end of postfix string
    for(i = 0; i < strlen(inf); i++) {
        if(isalnum(inf[i])) {           // if scanned element is an alphabet or number
            post[j] = inf[i];           // append in postfix expression
            j++;
        }
        else if(inf[i] == '(') {        // if scanned element is opening parentheses
            push(inf[i]);               // push on stack.
        }
        else if(inf[i] == ')') {        // if scanned element is closing parentheses,
            while(Top() != '(') {       // pop elements from stack and append in postfix expression
                post[j] = pop();        // until opening parentheses becomes top.
                j++;
            }
            pop();                      // pop opening parentheses
        }
        else {                          // if scanned element is an operator
            while( (!isEmpty()) && (priority(inf[i]) <= priority(Top())) ) {    // pop and append until stack becomes
                post[j] = pop();                                                // empty or priority of top operator
                j++;                                                            // becomes smaller than scanned operator
            }                                                                   // '(' has priority -1
            push(inf[i]);               // push the scanned operator
        }
    }
    while(!isEmpty()) {                 // pop and append residual operators from stack
        post[j] = pop();
        j++;
    }
    post[j] = '\0';                     // end postfix string with null character
    return post;
}

Here is the call graph for this function:

isEmpty()

int isEmpty

(

)

Function to check whether the stack is empty or not.

Returns 1 if stack is empty, returns 0 if not empty.

Returns

1 if the stack IS empty

0 if the stack is NOT empty

                   {
    if(st.top == -1) {
        return 1;
    }
    return 0;
}

main()

int main

(

void

)

Main function.

Returns

0 on exit

initialize

run self-test implementations

< to store input infix expression

           {
    st.top = -1;            /// initialize
    test();             /// run self-test implementations
    char inf[25];           ///< to store input infix expression
    printf("Enter infix: ");
    scanf("%s", inf);
    printf("Postfix: %s", convert(inf));
    return 0;
}

Here is the call graph for this function:

pop()

void pop

(

void

)

Function to pop from the stack.

Pop data from the stack.

Returns

popped character

< to store the popped value to be returned

           {
    char item;              ///< to store the popped value to be returned
    if(st.top == -1) {      // underflow condition
        printf("Stack underflow...");
        exit(1);
    }
    item = st.stack[st.top];
    st.top--;
    return item;
}

priority()

int16_t priority

(

char

opr

)

Function to check priority of operators.

Parameters

opr	operator whose priority is to be checked

Returns

0 if operator is '+' or '-'

1 if operator is '/' or '*' or ''

-1 otherwise

                           {
    if(opr == '+' || opr == '-') {
        return 0;
    }
    else if(opr == '/' || opr == '*' || opr == '%') {
        return 1;
    }
    else {
        return -1;
    }
}

push()

void push

(

char

opd

)

Function to push on the stack.

Parameters

opd	character to be pushed in the stack

Returns

void

                    {
    if(st.top == 9) {       // overflow condition
        printf("Stack overflow...");
        exit(1);
    }
    st.top++;
    st.stack[st.top] = opd;
}

test()

static void test ( void  )

static

Self-test implementations.

Returns

void

this ensures that the algorithm works as expected

this ensures that the algorithm works as expected

                   {
    /* check sample test case
       input- "(A/(B-C)*D+E)"
       expected output- "ABC-/D*E+"
     */
    assert(strcmp(convert("(A/(B-C)*D+E)"), "ABC-/D*E+") == 0);             /// this ensures that the algorithm works as expected
    /* input- "7-(2*3+5)*(8-4/2)"
       expected output- "723*5+842/-*-"
     */
    assert(strcmp(convert("7-(2*3+5)*(8-4/2)"), "723*5+842/-*-") == 0);             /// this ensures that the algorithm works as expected
    printf("All tests have successfully passed!\n");
}

Here is the call graph for this function:

Top()

char Top

(

)

Function to get top of the stack.

Returns

top of stack

           {
    return st.stack[st.top];
}