Postfix to Infix Conversion

Postfix to Infix/conversion/code.c

@@ -0,0 +1,95 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+// Define the maximum size for the stack and expression
+#define MAX 100
+
+// Stack structure to store strings (expressions)
+struct Stack {
+    int top;
+    char* items[MAX];
+};
+
+// Function to initialize the stack
+void initStack(struct Stack* stack) {
+    stack->top = -1;
+}
+
+// Function to push an item onto the stack
+void push(struct Stack* stack, char* str) {
+    if (stack->top >= MAX - 1) {
+        printf("Stack overflow\n");
+        return;
+    }
+    stack->items[++(stack->top)] = strdup(str); // strdup duplicates the string
+}
+
+// Function to pop an item from the stack
+char* pop(struct Stack* stack) {
+    if (stack->top == -1) {
+        printf("Stack underflow\n");
+        return NULL;
+    }
+    return stack->items[(stack->top)--];
+}
+
+// Function to check if a character is an operator
+int isOperator(char ch) {
+    return (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == '^');
+}
+
+// Function to convert a Postfix expression to Infix
+void postfixToInfix(char* postfix) {
+    struct Stack stack;
+    initStack(&stack);
+
+    int length = strlen(postfix);
+
+    // Traverse the Postfix expression from left to right
+    for (int i = 0; i < length; i++) {
+        // If the character is an operand, push it onto the stack
+        if (isalnum(postfix[i])) {
+            char operand[2] = {postfix[i], '\0'};  // Create a string for the operand
+            push(&stack, operand);
+        }
+        // If the character is an operator
+        else if (isOperator(postfix[i])) {
+            // Pop the top two operands from the stack
+            char* operand1 = pop(&stack);
+            char* operand2 = pop(&stack);
+
+            // Create a new string: (operand2 operator operand1)
+            char* expression = (char*)malloc(strlen(operand1) + strlen(operand2) + 4);
+            sprintf(expression, "(%s%c%s)", operand2, postfix[i], operand1);
+
+            // Push the resulting expression back onto the stack
+            push(&stack, expression);
+
+            // Free dynamically allocated memory
+            free(operand1);
+            free(operand2);
+        }
+    }
+
+    // The final result is the remaining element in the stack
+    char* result = pop(&stack);
+    printf("Infix Expression: %s\n", result);
+
+    // Free the final result memory
+    free(result);
+}
+
+int main() {
+    char postfix[MAX];
+
+    // Input the Postfix expression
+    printf("Enter a Postfix expression: ");
+    scanf("%s", postfix);
+
+    // Convert and display the Infix expression
+    postfixToInfix(postfix);
+
+    return 0;
+}

Postfix to Infix/conversion/readme.md

@@ -0,0 +1,41 @@
+# Postfix to Infix Conversion
+
+## Description:
+This project provides a tool for converting arithmetic expressions from Postfix notation (Reverse Polish Notation) to Infix notation. Postfix notation places operators after their operands, while Infix notation places operators between operands with parentheses to ensure the correct precedence. This conversion is useful for readability and in situations where expressions need to be evaluated based on operator precedence.
+
+## Problem Definition:
+Given an arithmetic expression in Postfix form (e.g., `A B + C *`), the objective is to convert it to Infix form (e.g., `(A + B) * C`) using an algorithm that handles operator precedence and parenthesis placement correctly.
+
+## Key Elements:
+- **Operands:** Variables or numbers.
+- **Operators:** (`+`, `-`, `*`, `/`, `^`).
+
+The output of converting a postfix expression to an infix expression should:
+1. Correctly place operators between operands.
+2. Include parentheses to maintain the correct precedence of operations, avoiding ambiguity.
+
+## Algorithm
+1. **Initialize a Stack:** Create an empty stack to store operands and intermediate expressions.
+2. **Read the Postfix Expression:** Start reading the postfix expression from left to right.
+3. **Process Each Symbol:**
+    - **If the Symbol is an Operand:**
+        - Push it onto the stack as a string.
+    - **If the Symbol is an Operator:**
+        - Pop the top two elements from the stack. Let’s call them `operand1` and `operand2`.
+        - Form a new infix expression in the format `(operand2 operator operand1)` (since postfix order is reversed).
+        - Push this new expression (with parentheses) back onto the stack.
+4. **Repeat:** Continue processing each symbol in the postfix expression until the entire expression is parsed.
+5. **Final Result:** The stack will contain one element at the end, which is the required infix expression.
+
+## Example
+For the Postfix expression: `A B + C *`
+- **Step 1:** `A` is an operand, push it → Stack: `[A]`
+- **Step 2:** `B` is an operand, push it → Stack: `[A, B]`
+- **Step 3:** `+` is an operator, pop `B` and `A`, form `(A + B)`, push it → Stack: `[(A + B)]`
+- **Step 4:** `C` is an operand, push it → Stack: `[(A + B), C]`
+- **Step 5:** `*` is an operator, pop `C` and `(A + B)`, form `((A + B) * C)`, push it → Stack: `[((A + B) * C)]`
+
+**Final Infix output:** `((A + B) * C)`
+
+## Time Complexity
+The algorithm performs a single scan of the postfix expression, making it **O(n)** in time complexity, where `n` is the number of characters in the input expression. Each operand and operator is pushed and popped from the stack at most once, ensuring linear complexity.