Pseudo Code Generator

Infix to Postfix Converter Pseudo Code

This pseudo code outlines the process of converting infix expressions to postfix expressions using stack data structures. It includes detailed functions for stack operations and precedence handling necessary for the conversion.

Prompt

#include 
#include 

typedef struct 
{
    int top;
    char items[100];
} Stack;

void initializeStack(Stack *s) 
{
    s->top = -1;
}

int isStackFull(Stack *s) 
{
    return s->top == 99;
}

int isStackEmpty(Stack *s) 
{
    return s->top == -1;
}

void pushToStack(Stack *s, char value) 
{
    if (!isStackFull(s)) 
    {
        s->items[++(s->top)] = value;
    }
}

char popFromStack(Stack *s) 
{
    if (!isStackEmpty(s)) 
    {
        return s->items[(s->top)--];
    }
    return '\0';
}

char peekStack(Stack *s) 
{
    if (!isStackEmpty(s)) 
    {
        return s->items[s->top];
    }
    return '\0';
}

int isOperator(char ch) 
{
    return ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '^';
}

int precedenceOf(char op) 
{
    if (op == '+' || op == '-') 
    {
        return 1;
    } 
    else if (op == '*' || op == '/') 
    {
        return 2;
    } 
    else if (op == '^') 
    {
        return 3;
    }
    return 0;
}

int isHigherPrecedence(char op1, char op2) 
{
    int p1 = precedenceOf(op1);
    int p2 = precedenceOf(op2);
    return p1 > p2 || (p1 == p2 && op1 != '^');
}

void infixToPostfix(char *infix, char *postfix) 
{
    Stack s;
    initializeStack(&s);
    int i = 0, j = 0;

    while (infix[i] != '\0') 
    {
        if ((infix[i] >= 'a' && infix[i] <= 'z') || (infix[i] >= 'A' && infix[i] <= 'Z') || (infix[i] >= '0' && infix[i] <= '9')) 
        {
            postfix[j++] = infix[i];
        } 
        else if (infix[i] == '(') 
        {
            pushToStack(&s, infix[i]);
        } 
        else if (infix[i] == ')') 
        {
            while (!isStackEmpty(&s) && peekStack(&s) != '(') 
            {
                postfix[j++] = popFromStack(&s);
            }
            popFromStack(&s); 
        } 
        else if (isOperator(infix[i])) 
        {
            while (!isStackEmpty(&s) && isHigherPrecedence(peekStack(&s), infix[i])) 
            {
                postfix[j++] = popFromStack(&s);
            }
            pushToStack(&s, infix[i]);
        }
        i++;
    }

    while (!isStackEmpty(&s)) 
    {
        postfix[j++] = popFromStack(&s);
    }

    postfix[j] = '\0';
}

int main() 
{
    char infixExpression[100];
    char postfixExpression[100];

    printf("Enter an infix expression: ");
    scanf("%s", infixExpression);

    infixToPostfix(infixExpression, postfixExpression);

    printf("Postfix expression: %s\n", postfixExpression);

    return 0;
}

Answer

Pseudo Code for Infix to Postfix Conversion

This pseudo code describes the logic and functionality of the given C code that converts an infix expression to a postfix expression using a stack.

Data Structures

Stack

Attributes:
- top: an integer to track the top index of the stack
- items: an array to store stack items (max size 100)

Functions

Initialize Stack

Function: initializeStack(Stack s)
- Set s.top to -1

Check if Stack is Full

Function: isStackFull(Stack s)
- Return true if s.top is equal to 99, else return false

Check if Stack is Empty

Function: isStackEmpty(Stack s)
- Return true if s.top is equal to -1, else return false

Push to Stack

Function: pushToStack(Stack s, char value)
- If stack is not full:
  - Increment s.top
  - Assign value to s.items[s.top]

Pop from Stack

Function: popFromStack(Stack s)
- If stack is not empty:
  - Return s.items[s.top]
  - Decrement s.top
- Else return null (or a suitable error value)

Peek Top of Stack

Function: peekStack(Stack s)
- If stack is not empty:
  - Return s.items[s.top]
- Else return null (or a suitable error value)

Check if Character is an Operator

Function: isOperator(char ch)
- Return true if ch is one of +, -, *, /, ^
- Else return false

Get Precedence of an Operator

Function: precedenceOf(char op)
- If op is + or -: return 1
- Else if op is * or /: return 2
- Else if op is ^: return 3
- Else return 0

Compare Precedence of Two Operators

Function: isHigherPrecedence(char op1, char op2)
- Assign precedence of op1 to p1
- Assign precedence of op2 to p2
- Return true if p1 is greater than p2
- Return true if p1 is equal to p2 and op1 is not equal to ^
- Else return false

Infix to Postfix Conversion

Function: infixToPostfix(char infix, char postfix)
- Create stack s and initialize s
- Set i (infix index) to 0, j (postfix index) to 0
- While infix[i] is not null:
  - If infix[i] is an operand (alphanumeric):
    - Assign infix[i] to postfix[j]
    - Increment j
  - Else if infix[i] is (:
    - Push infix[i] onto stack s
  - Else if infix[i] is ):
    - While stack s is not empty and peekStack(s) is not (:
      - Pop from stack s and assign to postfix[j]
      - Increment j
    - Pop ( from stack s
  - Else if infix[i] is an operator:
    - While stack s is not empty and isHigherPrecedence(peekStack(s), infix[i]) is true:
      - Pop from stack s and assign to postfix[j]
      - Increment j
    - Push infix[i] onto stack s
  - Increment i
- While stack s is not empty:
  - Pop from stack s and assign to postfix[j]
  - Increment j
- Set postfix[j] to null (to terminate the string)

Main Function

Function: main()
- Declare infixExpression and postfixExpression as string arrays of size 100
- Print prompt: "Enter an infix expression: "
- Read user input into infixExpression
- Call infixToPostfix(infixExpression, postfixExpression)
- Print result: "Postfix expression: " followed by postfixExpression

This pseudo code provides a structured approach to converting infix expressions into their postfix equivalents using a stack, detailing each function and its purpose in a clear and understandable manner.