"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", em: "em", h3: "h3", li: "li", ol: "ol", p: "p", pre: "pre", span: "span", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {Answer, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, HowItWorks, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, Remember, Step, StepByStep, SubTopicHeader, Theory, TopicOverview} = _components; if (!Answer) _missingMdxReference("Answer", true); if (!Assessment) _missingMdxReference("Assessment", true); if (!CodeBlock) _missingMdxReference("CodeBlock", true); if (!ComparisonTable) _missingMdxReference("ComparisonTable", true); if (!ContentAttribution) _missingMdxReference("ContentAttribution", true); if (!DefinitionEntry) _missingMdxReference("DefinitionEntry", true); if (!DefinitionGroup) _missingMdxReference("DefinitionGroup", true); if (!English) _missingMdxReference("English", true); if (!Explanation) _missingMdxReference("Explanation", true); if (!Hinglish) _missingMdxReference("Hinglish", true); if (!HowItWorks) _missingMdxReference("HowItWorks", true); if (!ImportantQA) _missingMdxReference("ImportantQA", true); if (!KeyPoints) _missingMdxReference("KeyPoints", true); if (!MCQ) _missingMdxReference("MCQ", true); if (!Practical) _missingMdxReference("Practical", true); if (!Prompt) _missingMdxReference("Prompt", true); if (!QAQuestion) _missingMdxReference("QAQuestion", true); if (!Remember) _missingMdxReference("Remember", true); if (!Step) _missingMdxReference("Step", true); if (!StepByStep) _missingMdxReference("StepByStep", true); if (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "4.3", title: "Applications of Stack: Reversing, Polish Notation, Infix to Postfix, Postfix Evaluation" }), _jsxs(TopicOverview, { title: "Applications of Stack", topicId: "4.3", readingTime: "20 min read", difficulty: "Medium", children: [_jsx(English, { children: _jsx(_components.p, { children: "A stack is one of the most versatile data structures, and its LIFO (Last In, First Out) property makes it ideal for solving several real-world computational problems. In this subtopic, we explore four major applications: reversing a string or array, understanding Polish (Prefix) Notation, converting infix expressions to postfix notation, and evaluating postfix expressions. These applications form the backbone of expression evaluation in compilers, calculators, and programming language interpreters." }) }), _jsx(Hinglish, { children: _jsx(_components.p, { children: "Stack ek bahut versatile data structure hai aur iski LIFO (Last In, First Out) property isse kai real-world computational problems solve karne ke liye ideal banati hai. Is subtopic mein hum chaar major applications explore karenge: string ya array ko reverse karna, Polish (Prefix) Notation samajhna, infix expressions ko postfix notation mein convert karna, aur postfix expressions ko evaluate karna. Yeh applications compilers, calculators, aur programming language interpreters mein expression evaluation ki backbone hain." }) })] }), _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "Infix Notation", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["The standard mathematical notation where the operator is placed ", _jsx(_components.strong, { children: "between" }), " two operands. For example, A + B, A × B, or (A + B) × C. This is how humans naturally write arithmetic expressions. However, when multiple operators are involved, parentheses become necessary to define the order of evaluation — making it complex for computers to parse directly."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Yeh standard mathematical notation hai jisme operator ", _jsx(_components.strong, { children: "dono operands ke beech" }), " mein hota hai. Jaise A + B, A × B, ya (A + B) × C. Yeh woh tarika hai jisse insaan arithmetic expressions naturally likhte hain. Lekin jab multiple operators hote hain, toh evaluation order define karne ke liye parentheses zaroori ho jaate hain — jisse computers ke liye isse directly parse karna mushkil ho jaata hai."] }) })] }), _jsxs(DefinitionEntry, { term: "Polish Notation (Prefix Notation)", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["A mathematical notation system invented by Polish logician ", _jsx(_components.strong, { children: "Jan Łukasiewicz" }), " in the 1920s, where operators are placed ", _jsx(_components.strong, { children: "before" }), " their operands. For example, +AB means A + B, and ×+ABC means (A + B) × C. It eliminates the need for parentheses entirely, which makes it much easier for machines to evaluate."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Yeh ek mathematical notation system hai jo Polish logician ", _jsx(_components.strong, { children: "Jan Łukasiewicz" }), " ne 1920s mein invent kiya tha, jisme operators apne operands ke ", _jsx(_components.strong, { children: "aage" }), " place hote hain. Jaise +AB ka matlab hai A + B, aur ×+ABC ka matlab hai (A + B) × C. Isme parentheses ki zaroorat bilkul nahi hoti, jisse machines ke liye isse evaluate karna bahut easy ho jaata hai."] }) })] }), _jsxs(DefinitionEntry, { term: "Reverse Polish Notation (Postfix Notation)", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["A notation where operators are placed ", _jsx(_components.strong, { children: "after" }), " their operands. For example, AB+ means A + B, and ABC+× means (A + B) × C. Also called ", _jsx(_components.strong, { children: "postfix notation" }), ", this is the most widely used non-standard notation in computer science because it can be efficiently evaluated using a single stack, with no need for parentheses or complex precedence rules."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Yeh ek aisi notation hai jisme operators apne operands ke ", _jsx(_components.strong, { children: "baad" }), " place hote hain. Jaise AB+ ka matlab hai A + B, aur ABC+× ka matlab hai (A + B) × C. Ise ", _jsx(_components.strong, { children: "postfix notation" }), " bhi kehte hain, aur yeh computer science mein sabse zyada use hone wali non-standard notation hai kyunki isse ek single stack se efficiently evaluate kiya ja sakta hai, bina parentheses ya complex precedence rules ke."] }) })] }), _jsxs(DefinitionEntry, { term: "Operator Precedence", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["The set of rules that determine which operator gets evaluated first in an expression containing multiple operators. Operators with ", _jsx(_components.strong, { children: "higher precedence" }), " are evaluated before those with lower precedence. For instance, multiplication (*) has higher precedence than addition (+), so in the expression A + B × C, the multiplication B × C is performed first, giving A + (B × C). This concept is critical when converting infix expressions to postfix."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Yeh rules ka set hai jo decide karta hai ki multiple operators wale expression mein kaunsa operator pehle evaluate hoga. ", _jsx(_components.strong, { children: "Higher precedence" }), " wale operators pehle evaluate hote hain. Jaise multiplication (*) ki precedence addition (+) se zyada hai, toh expression A + B × C mein pehle B × C hoga, jo A + (B × C) dega. Yeh concept infix expressions ko postfix mein convert karte waqt bahut critical hota hai."] }) })] }), _jsxs(DefinitionEntry, { term: "Associativity", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["The rule that determines the direction of evaluation when two operators have the ", _jsx(_components.strong, { children: "same precedence" }), ". Most arithmetic operators (+, −, ×, ÷) are ", _jsx(_components.strong, { children: "left-associative" }), " (evaluated left to right), meaning A − B − C becomes (A − B) − C. The exponentiation operator (^) is ", _jsx(_components.strong, { children: "right-associative" }), " (evaluated right to left), meaning A ^ B ^ C becomes A ^ (B ^ C). Associativity plays a critical role in infix-to-postfix conversion, especially for the ", _jsx(_components.code, { children: "^" }), " operator."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Yeh rule hai jo decide karta hai ki jab do operators ki ", _jsx(_components.strong, { children: "same precedence" }), " ho, toh evaluation kis direction mein hoga. Zyada tar arithmetic operators (+, −, ×, ÷) ", _jsx(_components.strong, { children: "left-associative" }), " hote hain (left to right evaluate hote hain), jisse A − B − C ka matlab (A − B) − C hota hai. Exponentiation operator (^) ", _jsx(_components.strong, { children: "right-associative" }), " hota hai (right to left evaluate hota hai), jisse A ^ B ^ C ka matlab A ^ (B ^ C) hota hai. Associativity infix-to-postfix conversion mein bahut important role play karta hai, especially ", _jsx(_components.code, { children: "^" }), " operator ke liye."] }) })] })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "🔄 Reversing a String/Array using Stack" }), _jsxs(_components.p, { children: ["The simplest yet most elegant application of a stack is reversing a sequence. The LIFO property naturally reverses the order — the ", _jsx(_components.strong, { children: "last element pushed" }), " becomes the ", _jsx(_components.strong, { children: "first element popped" }), "."] }), _jsx(_components.p, { children: "Think of it like a stack of plates — you place plates one by one from the top, and when you pick them up, you get them in reverse order. Stack works exactly the same way!" }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "How it works:" }) }), _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Traverse the string/array from left to right" }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Push" }), " each character/element onto the stack one by one"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Pop" }), " each element from the stack and place it back into the string/array"] }), "\n", _jsx(_components.li, { children: "The result is the reversed sequence" }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example: Reversing \"HELLO\"" }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Step" }), _jsx(_components.th, { children: "Action" }), _jsx(_components.th, { children: "Stack (Top →)" }), _jsx(_components.th, { children: "Output" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "1" }), _jsx(_components.td, { children: "Push 'H'" }), _jsx(_components.td, { children: "H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "2" }), _jsx(_components.td, { children: "Push 'E'" }), _jsx(_components.td, { children: "E, H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "3" }), _jsx(_components.td, { children: "Push 'L'" }), _jsx(_components.td, { children: "L, E, H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "4" }), _jsx(_components.td, { children: "Push 'L'" }), _jsx(_components.td, { children: "L, L, E, H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "5" }), _jsx(_components.td, { children: "Push 'O'" }), _jsx(_components.td, { children: "O, L, L, E, H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "6" }), _jsx(_components.td, { children: "Pop all" }), _jsx(_components.td, { children: "(empty)" }), _jsx(_components.td, { children: "O, L, L, E, H" })] })] })] }), _jsxs(_components.p, { children: ["The string \"HELLO\" becomes \"OLLEH\". The time complexity is ", _jsx(_components.span, { className: "katex", children: _jsx(_components.span, { className: "katex-html", "aria-hidden": "true", children: _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "1em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) }), " and the space complexity is also ", _jsx(_components.span, { className: "katex", children: _jsx(_components.span, { className: "katex-html", "aria-hidden": "true", children: _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "1em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) }), ", where ", _jsx(_components.span, { className: "katex", children: _jsx(_components.span, { className: "katex-html", "aria-hidden": "true", children: _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.4306em" } }), _jsx(_components.span, { className: "mord mathnormal", children: "n" })] }) }) }), " is the length of the string."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Practical Uses:" }), " This technique is used in palindrome checking, undo mechanisms in text editors, and byte-reversal in networking protocols."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔄 String/Array ko Stack se Reverse Karna" }), _jsxs(_components.p, { children: ["Stack ka sabse simple lekin sabse elegant application hai kisi sequence ko reverse karna. LIFO property naturally order ko reverse kar deti hai — ", _jsx(_components.strong, { children: "last jo element push" }), " hota hai woh ", _jsx(_components.strong, { children: "pehle pop" }), " hota hai."] }), _jsx(_components.p, { children: "Socho jaise ek plate rack hai jisme plates upar se rakhi jaati hain aur upar se hi nikalti hain — jab uthaate ho toh reverse order mein milti hain. Stack bilkul isi tarah kaam karta hai!" }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Yeh kaise kaam karta hai:" }) }), _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "String/array ko left se right traverse karo" }), "\n", _jsxs(_components.li, { children: ["Har character/element ko stack mein ", _jsx(_components.strong, { children: "push" }), " karo ek ek karke"] }), "\n", _jsxs(_components.li, { children: ["Stack se har element ", _jsx(_components.strong, { children: "pop" }), " karo aur wapas string/array mein daal do"] }), "\n", _jsx(_components.li, { children: "Result reverse sequence hoga" }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example: \"HELLO\" ko reverse karna" }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { children: "Step" }), _jsx(_components.th, { children: "Action" }), _jsx(_components.th, { children: "Stack (Top →)" }), _jsx(_components.th, { children: "Output" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { children: "1" }), _jsx(_components.td, { children: "Push 'H'" }), _jsx(_components.td, { children: "H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "2" }), _jsx(_components.td, { children: "Push 'E'" }), _jsx(_components.td, { children: "E, H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "3" }), _jsx(_components.td, { children: "Push 'L'" }), _jsx(_components.td, { children: "L, E, H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "4" }), _jsx(_components.td, { children: "Push 'L'" }), _jsx(_components.td, { children: "L, L, E, H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "5" }), _jsx(_components.td, { children: "Push 'O'" }), _jsx(_components.td, { children: "O, L, L, E, H" }), _jsx(_components.td, { children: "—" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { children: "6" }), _jsx(_components.td, { children: "Pop all" }), _jsx(_components.td, { children: "(empty)" }), _jsx(_components.td, { children: "O, L, L, E, H" })] })] })] }), _jsxs(_components.p, { children: ["\"HELLO\" string \"OLLEH\" ban jaati hai. Time complexity ", _jsx(_components.span, { className: "katex", children: _jsx(_components.span, { className: "katex-html", "aria-hidden": "true", children: _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "1em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) }), " hai aur space complexity bhi ", _jsx(_components.span, { className: "katex", children: _jsx(_components.span, { className: "katex-html", "aria-hidden": "true", children: _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "1em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) }), " hai, jahan ", _jsx(_components.span, { className: "katex", children: _jsx(_components.span, { className: "katex-html", "aria-hidden": "true", children: _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.4306em" } }), _jsx(_components.span, { className: "mord mathnormal", children: "n" })] }) }) }), " string ki length hai."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Practical Uses:" }), " Yeh technique palindrome checking, text editors ke undo mechanisms, aur networking protocols mein byte-reversal ke liye use hoti hai."] })] }), _jsx(CodeBlock, { language: "c", children: `#include #include void reverseString(char str[]) { int n = strlen(str); char stack[100]; int top = -1; // Push all characters onto stack for (int i = 0; i < n; i++) { stack[++top] = str[i]; } // Pop all characters and store back for (int i = 0; i < n; i++) { str[i] = stack[top--]; } } int main() { char str[] = "HELLO"; printf("Original: %s\\n", str); reverseString(str); printf("Reversed: %s\\n", str); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📐 Understanding Polish Notation" }), _jsxs(_components.p, { children: ["Polish Notation, named after the logician ", _jsx(_components.strong, { children: "Jan Łukasiewicz" }), ", reimagines how we write mathematical expressions. Instead of placing the operator between operands (infix), we can place it ", _jsx(_components.strong, { children: "before" }), " (prefix/Polish) or ", _jsx(_components.strong, { children: "after" }), " (postfix/Reverse Polish) the operands."] }), _jsxs(_components.p, { children: ["Consider the expression: ", _jsx(_components.strong, { children: "A + B × C" }), " (which equals A + (B × C) due to precedence)"] }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Notation Type" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Format" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Meaning" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Infix" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A + B × C" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A + (B × C)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Prefix (Polish)" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "+ A × B C" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A + (B × C)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Postfix (Reverse Polish)" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A B C × +" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A + (B × C)" })] })] })] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Why does this matter for computers?" }) }), _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Infix notation requires complex parsing — the computer must check precedence rules and parentheses to understand the order of operations" }), "\n", _jsxs(_components.li, { children: ["Postfix notation eliminates ", _jsx(_components.strong, { children: "ALL parentheses" }), " — a simple left-to-right scan with a stack is enough to evaluate any expression"] }), "\n", _jsxs(_components.li, { children: ["This is why ", _jsx(_components.strong, { children: "RPN (Reverse Polish Notation)" }), " is the preferred format for expression evaluation in compilers and stack-based calculators (like the classic HP calculators)"] }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Converting between notations — a quick rule:" }), "\r\nTo convert infix to postfix (or prefix), you just need to rearrange the operators based on precedence while keeping operands in their original relative order. The stack data structure makes this reordering algorithmic and efficient."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📐 Polish Notation Ko Samajhna" }), _jsxs(_components.p, { children: ["Polish Notation, jo logician ", _jsx(_components.strong, { children: "Jan Łukasiewicz" }), " ke naam par hai, mathematical expressions likhne ka tarika badalta hai. Operator ko operands ke beech rakhne ki jagah (infix), hum ise operands ke ", _jsx(_components.strong, { children: "aage" }), " (prefix/Polish) ya ", _jsx(_components.strong, { children: "peeche" }), " (postfix/Reverse Polish) rakh sakte hain."] }), _jsxs(_components.p, { children: ["Expression consider karo: ", _jsx(_components.strong, { children: "A + B × C" }), " (jo precedence ki wajah se A + (B × C) hai)"] }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Notation Type" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Format" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Meaning" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Infix" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A + B × C" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A + (B × C)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Prefix (Polish)" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "+ A × B C" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A + (B × C)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Postfix (Reverse Polish)" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A B C × +" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A + (B × C)" })] })] })] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Yeh computers ke liye kyun important hai?" }) }), _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Infix notation mein complex parsing chahiye — computer ko precedence rules aur parentheses check karne padte hain operation order samajhne ke liye" }), "\n", _jsx(_components.li, { children: "Postfix notation saare parentheses eliminate kar deta hai — ek simple left-to-right scan aur stack kisi bhi expression ko evaluate karne ke liye kaafi hai" }), "\n", _jsxs(_components.li, { children: ["Isliye ", _jsx(_components.strong, { children: "RPN (Reverse Polish Notation)" }), " compilers aur stack-based calculators (jaise classic HP calculators) mein expression evaluation ke liye preferred format hai"] }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Notations ke beech conversion — ek quick rule:" }), "\r\nInfix se postfix (ya prefix) mein convert karne ke liye, bas operators ko precedence ke according rearrange karo jabki operands apni original relative order mein rahte hain. Stack data structure is reordering ko algorithmic aur efficient banata hai."] })] }), _jsx(ComparisonTable, { title: "Infix vs Prefix vs Postfix Notation", children: _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Feature" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Infix Notation" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Prefix (Polish)" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Postfix (RPN)" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Operator Position" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Between operands" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Before operands" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "After operands" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Example (A+B)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A + B" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "+ A B" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A B +" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Parentheses Needed" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Yes" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "No" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "No" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Evaluation Method" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Complex precedence rules" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Stack (right to left)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Stack (left to right)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Used By" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Humans, textbooks" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "LISP, Scheme" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Compilers, HP calculators" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "Associativity Handling" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Explicit parentheses needed" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Built-in via notation" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Built-in via notation" })] })] })] }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🔄 Infix to Postfix Conversion" }), _jsxs(_components.p, { children: ["Converting an infix expression to postfix is one of the most classic stack applications. The core idea is to ", _jsx(_components.strong, { children: "reorder operators" }), " based on their precedence and associativity, while keeping operands in their original order."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "The Algorithm — Step by Step:" }) }), _jsxs(_components.p, { children: ["Read the infix expression from ", _jsx(_components.strong, { children: "left to right" }), ", character by character:"] }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operand" }), " (A–Z, 0–9): Add directly to the output string"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Left parenthesis" }), " ", _jsx(_components.code, { children: "(" }), ": Push onto the stack"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Right parenthesis" }), " ", _jsx(_components.code, { children: ")" }), ": Pop and add to output until ", _jsx(_components.code, { children: "(" }), " is found. Discard both parentheses"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operator" }), " (+, −, ×, ÷, ^):", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Pop operators from the stack that have ", _jsx(_components.strong, { children: "greater or equal precedence" }), " (for left-associative operators) and add them to output"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Exception:" }), " For the ", _jsx(_components.code, { children: "^" }), " operator (right-associative), only pop operators with ", _jsx(_components.strong, { children: "strictly greater" }), " precedence"] }), "\n", _jsx(_components.li, { children: "Push the current operator onto the stack" }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["After scanning all characters, ", _jsx(_components.strong, { children: "pop all remaining operators" }), " from the stack to output"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Operator Precedence Table:" }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Operator" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Precedence Level" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Associativity" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "^" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "3 (highest)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Right to Left" })] }), _jsxs(_components.tr, { children: [_jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" })] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "2" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Left to Right" })] }), _jsxs(_components.tr, { children: [_jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" })] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "1 (lowest)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Left to Right" })] })] })] }), _jsx(_components.p, { children: _jsxs(_components.strong, { children: ["Why the exception for ", _jsx(_components.code, { children: "^" }), "?"] }) }), _jsxs(_components.p, { children: ["Since exponentiation is ", _jsx(_components.strong, { children: "right-associative" }), ", A ^ B ^ C means A ^ (B ^ C). In postfix, this becomes ", _jsx(_components.strong, { children: "A B C ^ ^" }), ". If we popped ", _jsx(_components.code, { children: "^" }), " when we encountered another ", _jsx(_components.code, { children: "^" }), " (like we do for ", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), ", ", _jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), "), we would incorrectly get A B ^ C ^, which means (A ^ B) ^ C — the ", _jsx(_components.strong, { children: "wrong associativity" }), "!"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔄 Infix se Postfix Conversion" }), _jsxs(_components.p, { children: ["Infix expression ko postfix mein convert karna ek classic stack application hai. Core idea hai ki hum operators ko unki ", _jsx(_components.strong, { children: "precedence aur associativity" }), " ke according reorder karte hain, jabki operands apni original order mein rehte hain."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Algorithm — Step by Step:" }) }), _jsxs(_components.p, { children: ["Infix expression ko ", _jsx(_components.strong, { children: "left se right" }), " padho, ek character at a time:"] }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operand" }), " (A–Z, 0–9): Seedha output string mein daal do"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Left parenthesis" }), " ", _jsx(_components.code, { children: "(" }), ": Stack mein push karo"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Right parenthesis" }), " ", _jsx(_components.code, { children: ")" }), ": Stack se pop karo aur output mein daalo jab tak ", _jsx(_components.code, { children: "(" }), " na mile. Dono parentheses ko discard karo"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operator" }), " (+, −, ×, ÷, ^):", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Stack se ", _jsx(_components.strong, { children: "greater ya equal precedence" }), " ke operators ko pop karo (left-associative operators ke liye) aur output mein add karo"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Exception:" }), " ", _jsx(_components.code, { children: "^" }), " operator ke liye (right-associative), sirf ", _jsx(_components.strong, { children: "strictly greater" }), " precedence ke operators ko pop karo"] }), "\n", _jsx(_components.li, { children: "Current operator ko stack mein push karo" }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["Saare characters scan karne ke baad, stack mein bache hue operators ko ", _jsx(_components.strong, { children: "pop" }), " karke output mein daal do"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Operator Precedence Table:" }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Operator" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Precedence Level" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Associativity" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.code, { children: "^" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "3 (sabse zyada)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Right to Left" })] }), _jsxs(_components.tr, { children: [_jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" })] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "2" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Left to Right" })] }), _jsxs(_components.tr, { children: [_jsxs(_components.td, { style: { textAlign: "left" }, children: [_jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" })] }), _jsx(_components.td, { style: { textAlign: "left" }, children: "1 (sabse kam)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Left to Right" })] })] })] }), _jsx(_components.p, { children: _jsxs(_components.strong, { children: [_jsx(_components.code, { children: "^" }), " ke liye exception kyun hai?"] }) }), _jsxs(_components.p, { children: ["Kyunki exponentiation ", _jsx(_components.strong, { children: "right-associative" }), " hota hai, A ^ B ^ C ka matlab A ^ (B ^ C) hota hai. Postfix mein yeh ", _jsx(_components.strong, { children: "A B C ^ ^" }), " banega. Agar hum ", _jsx(_components.code, { children: "^" }), " milne par stack se doosra ", _jsx(_components.code, { children: "^" }), " pop kar lete (jaise ", _jsx(_components.code, { children: "+" }), ", ", _jsx(_components.code, { children: "-" }), ", ", _jsx(_components.code, { children: "*" }), ", ", _jsx(_components.code, { children: "/" }), " ke liye karte hain), toh galat result A B ^ C ^ milta, jo (A ^ B) ^ C represent karta hai — ", _jsx(_components.strong, { children: "wrong associativity!" })] })] }), _jsx(HowItWorks, { title: "Infix to Postfix Conversion Algorithm", children: _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["Create an empty ", _jsx(_components.strong, { children: "output string" }), " and an empty ", _jsx(_components.strong, { children: "operator stack" })] }), "\n", _jsx(_components.li, { children: "Scan the infix expression from left to right" }), "\n", _jsxs(_components.li, { children: ["If the character is an ", _jsx(_components.strong, { children: "operand" }), ", append it directly to the output"] }), "\n", _jsxs(_components.li, { children: ["If the character is ", _jsx(_components.strong, { children: "'('" }), ", push it onto the stack"] }), "\n", _jsxs(_components.li, { children: ["If the character is ", _jsx(_components.strong, { children: "')'" }), ", pop from stack and append to output until '(' is encountered. Discard both parentheses"] }), "\n", _jsxs(_components.li, { children: ["If the character is an ", _jsx(_components.strong, { children: "operator" }), ":", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["While the stack is not empty AND the top of the stack is not '(' AND the top operator has precedence ≥ current operator (with the ", _jsx(_components.code, { children: "^" }), " exception): pop from stack to output"] }), "\n", _jsx(_components.li, { children: "Push the current operator onto the stack" }), "\n"] }), "\n"] }), "\n", _jsx(_components.li, { children: "After scanning is complete, pop all remaining operators from the stack and append to output" }), "\n"] }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\r\n A[\"Scan infix left to right\"] --> B{\"Is operand?\"}\r\n B -->|Yes| C[\"Add to output\"]\r\n C --> A\r\n B -->|No| D{\"Is '(' ?\"}\r\n D -->|Yes| E[\"Push to stack\"]\r\n E --> A\r\n D -->|No| F{\"Is ')' ?\"}\r\n F -->|Yes| G[\"Pop and output until '('\"]\r\n G --> A\r\n F -->|No| H{\"Is operator?\"}\r\n H -->|Yes| I[\"Pop higher/equal precedence operators to output\"]\r\n I --> J[\"Push current operator to stack\"]\r\n J --> A\r\n A -->|\"End of expression\"| K[\"Pop all remaining operators to output\"]\r\n K --> L[\"Postfix expression ready\"]\n" }) }), _jsxs(StepByStep, { title: "Example: Converting (A+B)*(C-D) to Postfix", children: [_jsx(Step, { title: "Step 1: Encounter '('", children: _jsxs(_components.p, { children: ["'(' is a left parenthesis — push it onto the stack.\r\n", _jsx(_components.strong, { children: "Output:" }), " (empty)\r\n", _jsx(_components.strong, { children: "Stack:" }), " [(]"] }) }), _jsx(Step, { title: "Step 2: Encounter 'A'", children: _jsxs(_components.p, { children: ["'A' is an operand — add directly to output.\r\n", _jsx(_components.strong, { children: "Output:" }), " A\r\n", _jsx(_components.strong, { children: "Stack:" }), " [(]"] }) }), _jsx(Step, { title: "Step 3: Encounter '+'", children: _jsxs(_components.p, { children: ["'+' is an operator. Stack top is '(', so we cannot pop anything. Push '+' onto stack.\r\n", _jsx(_components.strong, { children: "Output:" }), " A\r\n", _jsx(_components.strong, { children: "Stack:" }), " [(, +]"] }) }), _jsx(Step, { title: "Step 4: Encounter 'B'", children: _jsxs(_components.p, { children: ["'B' is an operand — add directly to output.\r\n", _jsx(_components.strong, { children: "Output:" }), " A B\r\n", _jsx(_components.strong, { children: "Stack:" }), " [(, +]"] }) }), _jsx(Step, { title: "Step 5: Encounter ')'", children: _jsxs(_components.p, { children: ["')' found — pop until '(' is encountered. Pop '+' and add to output. Discard both parentheses.\r\n", _jsx(_components.strong, { children: "Output:" }), " A B +\r\n", _jsx(_components.strong, { children: "Stack:" }), " (empty)"] }) }), _jsx(Step, { title: "Step 6: Encounter '*'", children: _jsxs(_components.p, { children: ["'", _jsxs(_components.em, { children: ["' is an operator. Stack is empty, so just push it.\r\n", _jsx(_components.strong, { children: "Output:" }), " A B +\r\n", _jsx(_components.strong, { children: "Stack:" }), " ["] }), "]"] }) }), _jsx(Step, { title: "Step 7: Encounter '('", children: _jsxs(_components.p, { children: ["'(' is a left parenthesis — push it onto the stack.\r\n", _jsx(_components.strong, { children: "Output:" }), " A B +\r\n", _jsx(_components.strong, { children: "Stack:" }), " [*, (]"] }) }), _jsx(Step, { title: "Step 8: Encounter 'C'", children: _jsxs(_components.p, { children: ["'C' is an operand — add directly to output.\r\n", _jsx(_components.strong, { children: "Output:" }), " A B + C\r\n", _jsx(_components.strong, { children: "Stack:" }), " [*, (]"] }) }), _jsx(Step, { title: "Step 9: Encounter '-'", children: _jsxs(_components.p, { children: ["'-' is an operator. Stack top is '(', so just push it.\r\n", _jsx(_components.strong, { children: "Output:" }), " A B + C\r\n", _jsx(_components.strong, { children: "Stack:" }), " [*, (, -]"] }) }), _jsx(Step, { title: "Step 10: Encounter 'D'", children: _jsxs(_components.p, { children: ["'D' is an operand — add directly to output.\r\n", _jsx(_components.strong, { children: "Output:" }), " A B + C D\r\n", _jsx(_components.strong, { children: "Stack:" }), " [*, (, -]"] }) }), _jsx(Step, { title: "Step 11: Encounter ')'", children: _jsxs(_components.p, { children: ["')' found — pop until '(' is encountered. Pop '-' and add to output. Discard both parentheses.\r\n", _jsx(_components.strong, { children: "Output:" }), " A B + C D -\r\n", _jsx(_components.strong, { children: "Stack:" }), " [*]"] }) }), _jsx(Step, { title: "Step 12: End of Expression", children: _jsxs(_components.p, { children: ["Pop all remaining operators from the stack. Pop '*' and add to output.\r\n", _jsx(_components.strong, { children: "Final Output:" }), " A B + C D - *\r\n", _jsx(_components.strong, { children: "Stack:" }), " (empty)"] }) })] }), _jsx(Remember, { children: _jsxs(_components.p, { children: [_jsxs(_components.strong, { children: ["Common Pitfall — Associativity of ", _jsx(_components.code, { children: "^" }), ":"] }), " When converting A^B^C, students often incorrectly pop the first ", _jsx(_components.code, { children: "^" }), " when they see the second ", _jsx(_components.code, { children: "^" }), ", getting A B ^ C ^. This is ", _jsx(_components.strong, { children: "WRONG!" }), " Since ", _jsx(_components.code, { children: "^" }), " is ", _jsx(_components.strong, { children: "right-associative" }), ", A^B^C = A^(B^C), and the correct postfix is ", _jsx(_components.strong, { children: "A B C ^ ^" }), ". The algorithm handles this by NOT popping ", _jsx(_components.code, { children: "^" }), " when the current operator is also ", _jsx(_components.code, { children: "^" }), "."] }) }), _jsx(Remember, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Don't Forget Remaining Operators!" }), " After scanning all characters, always pop ALL remaining operators from the stack to the output. A common mistake is stopping too early and missing the final operators, which gives an incomplete or wrong postfix expression."] }) }), _jsx(CodeBlock, { language: "c", children: `#include #include #include // Return precedence of operator int precedence(char op) { if (op == '^') return 3; if (op '*' || op '/') return 2; if (op '+' || op '-') return 1; return 0; } // Check if character is an operand int isOperand(char ch) { return isalnum(ch); } // Convert infix expression to postfix void infixToPostfix(char infix[], char postfix[]) { char stack[100]; int top = -1, j = 0; for (int i = 0; infix[i] != '\\0'; i++) { char ch = infix[i]; if (isOperand(ch)) { postfix[j++] = ch; } else if (ch == '(') { stack[++top] = ch; } else if (ch == ')') { while (top != -1 && stack[top] != '(') { postfix[j++] = stack[top--]; } top--; // Remove '(' from stack } else { // Operator while (top != -1 && precedence(stack[top]) >= precedence(ch) && ch != '^') { postfix[j++] = stack[top--]; } stack[++top] = ch; } } // Pop all remaining operators while (top != -1) { postfix[j++] = stack[top--]; } postfix[j] = '\\0'; } int main() { char infix[] = "(A+B)*(C-D)"; char postfix[100]; infixToPostfix(infix, postfix); printf("Infix: %s\\n", infix); printf("Postfix: %s\\n", postfix); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🧮 Postfix Expression Evaluation" }), _jsxs(_components.p, { children: ["Once we have a postfix expression, evaluating it is remarkably simple using a stack. Unlike infix, there are ", _jsx(_components.strong, { children: "no precedence rules to worry about" }), " and ", _jsx(_components.strong, { children: "no parentheses to handle" }), " — the postfix format has already taken care of that during conversion. This is precisely why postfix is the preferred format for machines!"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "The Algorithm — Step by Step:" }) }), _jsxs(_components.p, { children: ["Scan the postfix expression from ", _jsx(_components.strong, { children: "left to right" }), ":"] }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operand (number):" }), " Push it onto the stack"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operator:" }), " Pop the ", _jsx(_components.strong, { children: "top two" }), " operands from the stack, apply the operator, and push the result back", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Important: The ", _jsx(_components.strong, { children: "first popped" }), " value is the ", _jsx(_components.strong, { children: "second operand" }), " (right side)"] }), "\n", _jsxs(_components.li, { children: ["The ", _jsx(_components.strong, { children: "second popped" }), " value is the ", _jsx(_components.strong, { children: "first operand" }), " (left side)"] }), "\n", _jsx(_components.li, { children: "For example, for subtraction: result = secondPopped − firstPopped" }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["After scanning all characters, the ", _jsx(_components.strong, { children: "top of the stack" }), " contains the final result"] }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Key Insight:" }), " The postfix notation already encodes the correct order of operations. By simply processing operators as they appear (left to right), the stack naturally handles precedence and associativity."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Example:" }), " Evaluating ", _jsx(_components.code, { children: "5 3 + 8 2 - *" })] }), _jsx(_components.p, { children: "This postfix expression is equivalent to the infix expression (5 + 3) × (8 − 2). Let's see how the stack processes it." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🧮 Postfix Expression Evaluate Karna" }), _jsxs(_components.p, { children: ["Jab humare paas postfix expression hai, toh use stack se evaluate karna bahut simple hai. Infix ke unlike, yahan ", _jsx(_components.strong, { children: "koi precedence rules nahi hain" }), " aur ", _jsx(_components.strong, { children: "koi parentheses nahi hain" }), " — postfix format ne conversion ke time yeh sab handle kar liya hota hai. Yeh woh reason hai postfix machines ke liye preferred format hai!"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Algorithm — Step by Step:" }) }), _jsxs(_components.p, { children: ["Postfix expression ko ", _jsx(_components.strong, { children: "left se right" }), " scan karo:"] }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operand (number):" }), " Ise stack mein push karo"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operator:" }), " Stack se ", _jsx(_components.strong, { children: "top do" }), " operands pop karo, operator apply karo, aur result wapas push karo", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Important: ", _jsx(_components.strong, { children: "Pehli popped" }), " value ", _jsx(_components.strong, { children: "second operand" }), " hoti hai (right side)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Doosri popped" }), " value ", _jsx(_components.strong, { children: "first operand" }), " hoti hai (left side)"] }), "\n", _jsx(_components.li, { children: "Jaise subtraction ke liye: result = secondPopped − firstPopped" }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["Saare characters scan karne ke baad, stack ka ", _jsx(_components.strong, { children: "top" }), " final result hota hai"] }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Key Insight:" }), " Postfix notation pehle se correct order of operations encode kar chuka hota hai. Bas operators ko left se right process karte jaao, aur stack naturally precedence aur associativity handle kar leta hai."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Example:" }), " ", _jsx(_components.code, { children: "5 3 + 8 2 - *" }), " evaluate karna"] }), _jsx(_components.p, { children: "Yeh postfix expression infix expression (5 + 3) × (8 − 2) ke equivalent hai. Dekhte hain stack isse kaise process karta hai." })] }), _jsx(HowItWorks, { title: "Postfix Evaluation Algorithm", children: _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: ["Create an empty ", _jsx(_components.strong, { children: "operand stack" })] }), "\n", _jsx(_components.li, { children: "Scan the postfix expression from left to right" }), "\n", _jsxs(_components.li, { children: ["If the character is a ", _jsx(_components.strong, { children: "number/operand" }), ", push it onto the stack"] }), "\n", _jsxs(_components.li, { children: ["If the character is an ", _jsx(_components.strong, { children: "operator" }), ":", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Pop the top element and store it as ", _jsx(_components.strong, { children: "val2" }), " (second operand)"] }), "\n", _jsxs(_components.li, { children: ["Pop the next element and store it as ", _jsx(_components.strong, { children: "val1" }), " (first operand)"] }), "\n", _jsxs(_components.li, { children: ["Apply the operator: result = val1 ", _jsx(_components.strong, { children: "op" }), " val2"] }), "\n", _jsx(_components.li, { children: "Push the result back onto the stack" }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["After scanning all characters, the ", _jsx(_components.strong, { children: "top of the stack" }), " is the final result"] }), "\n"] }) }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\r\n A[\"Scan postfix left to right\"] --> B{\"Is operand/number?\"}\r\n B -->|Yes| C[\"Push onto stack\"]\r\n C --> A\r\n B -->|No| D{\"Is operator?\"}\r\n D -->|Yes| E[\"Pop val2 then val1\"]\r\n E --> F[\"Compute: val1 op val2\"]\r\n F --> G[\"Push result onto stack\"]\r\n G --> A\r\n A -->|\"End of expression\"| H[\"Top of stack = Final Result\"]\n" }) }), _jsxs(StepByStep, { title: "Example: Evaluating Postfix 5 3 + 8 2 - *", children: [_jsx(Step, { title: "Step 1: Scan '5'", children: _jsxs(_components.p, { children: ["'5' is an operand — push onto stack.\r\n", _jsx(_components.strong, { children: "Stack:" }), " [5]"] }) }), _jsx(Step, { title: "Step 2: Scan '3'", children: _jsxs(_components.p, { children: ["'3' is an operand — push onto stack.\r\n", _jsx(_components.strong, { children: "Stack:" }), " [5, 3]"] }) }), _jsx(Step, { title: "Step 3: Scan '+'", children: _jsxs(_components.p, { children: ["'+' is an operator. Pop 3 (val2), pop 5 (val1). Compute 5 + 3 = 8. Push 8.\r\n", _jsx(_components.strong, { children: "Stack:" }), " [8]"] }) }), _jsx(Step, { title: "Step 4: Scan '8'", children: _jsxs(_components.p, { children: ["'8' is an operand — push onto stack.\r\n", _jsx(_components.strong, { children: "Stack:" }), " [8, 8]"] }) }), _jsx(Step, { title: "Step 5: Scan '2'", children: _jsxs(_components.p, { children: ["'2' is an operand — push onto stack.\r\n", _jsx(_components.strong, { children: "Stack:" }), " [8, 8, 2]"] }) }), _jsx(Step, { title: "Step 6: Scan '-'", children: _jsxs(_components.p, { children: ["'-' is an operator. Pop 2 (val2), pop 8 (val1). Compute 8 − 2 = 6. Push 6.\r\n", _jsx(_components.strong, { children: "Stack:" }), " [8, 6]"] }) }), _jsx(Step, { title: "Step 7: Scan '*'", children: _jsxs(_components.p, { children: ["'*' is an operator. Pop 6 (val2), pop 8 (val1). Compute 8 × 6 = 48. Push 48.\r\n", _jsx(_components.strong, { children: "Stack:" }), " [48]"] }) }), _jsx(Step, { title: "Step 8: End — Result is 48", children: _jsxs(_components.p, { children: ["Expression fully scanned. Top of stack = 48.\r\n", _jsx(_components.strong, { children: "Infix equivalent:" }), " (5+3) × (8−2) = 8 × 6 = ", _jsx(_components.strong, { children: "48" }), " ✓"] }) })] }), _jsx(Remember, { children: _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Critical — Operand Order in Subtraction and Division!" }), " When you pop two values for ", _jsx(_components.code, { children: "-" }), " or ", _jsx(_components.code, { children: "/" }), ", remember that the ", _jsx(_components.strong, { children: "first popped value is val2" }), " (RIGHT operand) and the ", _jsx(_components.strong, { children: "second popped value is val1" }), " (LEFT operand). So for subtraction: result = val1 − val2 = secondPopped − firstPopped. A very common mistake is reversing this order, which gives wrong results like 2 − 8 = −6 instead of 8 − 2 = 6."] }) }), _jsx(CodeBlock, { language: "c", children: `#include #include #include #include // Evaluate a postfix expression int evaluatePostfix(char postfix[]) { int stack[100]; int top = -1; for (int i = 0; postfix[i] != '\\0'; i++) { char ch = postfix[i]; if (isdigit(ch)) { // Push operand (convert char to int) stack[++top] = ch - '0'; } else { // Pop two operands int val2 = stack[top--]; // second operand (right) int val1 = stack[top--]; // first operand (left) switch (ch) { case '+': stack[++top] = val1 + val2; break; case '-': stack[++top] = val1 - val2; break; case '*': stack[++top] = val1 * val2; break; case '/': stack[++top] = val1 / val2; break; case '^': stack[++top] = (int)pow(val1, val2); break; } } } return stack[top]; } int main() { char postfix[] = "53+82-*"; printf("Postfix: %s\\n", postfix); printf("Result: %d\\n", evaluatePostfix(postfix)); return 0; }` }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Stack + LIFO = Reversal:" }), " Push all elements, then pop them — the order is automatically reversed in ", _jsx(_components.span, { className: "katex", children: _jsx(_components.span, { className: "katex-html", "aria-hidden": "true", children: _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "1em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) }), " time"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Polish Notation" }), " (prefix) places operators before operands; ", _jsx(_components.strong, { children: "Reverse Polish Notation" }), " (postfix) places them after — both eliminate parentheses"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Infix to Postfix" }), " uses a stack to reorder operators by precedence and associativity while keeping operands in their original order"] }), "\n", _jsxs(_components.li, { children: [_jsxs(_components.strong, { children: ["Right-associative ", _jsx(_components.code, { children: "^" }), ":"] }), " The algorithm does NOT pop ", _jsx(_components.code, { children: "^" }), " from the stack when encountering another ", _jsx(_components.code, { children: "^" }), ", preserving right-to-left evaluation order"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Postfix Evaluation" }), " is elegant: push operands, pop-and-apply operators, and the final stack top is the answer"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operand order matters:" }), " For ", _jsx(_components.code, { children: "-" }), " and ", _jsx(_components.code, { children: "/" }), ", the first popped value is val2 (right operand) and the second popped is val1 (left operand)"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Real-world use:" }), " Compilers, HP RPN calculators, and programming language interpreters all rely on these stack-based algorithms for expression handling"] }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "Define Polish Notation and state its two main types." }), _jsxs(Answer, { children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Polish Notation" }), " is a way of writing arithmetic expressions without the need for parentheses to indicate the order of operations. In this notation, the operator is placed either before or after its operands."] }), _jsx(_components.p, { children: "Its two main types are:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Prefix Notation (Polish Notation):" }), " The operator is placed ", _jsx(_components.strong, { children: "before" }), " its operands. For example, the infix expression ", _jsx(_components.code, { children: "A + B" }), " is written as ", _jsx(_components.code, { children: "+ A B" }), " in prefix notation."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Postfix Notation (Reverse Polish Notation - RPN):" }), " The operator is placed ", _jsx(_components.strong, { children: "after" }), " its operands. For example, the infix expression ", _jsx(_components.code, { children: "A + B" }), " is written as ", _jsx(_components.code, { children: "A B +" }), " in postfix notation."] }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Key Advantage:" }), " Postfix expressions are very easy to evaluate using a stack, which eliminates the need for operator precedence and parenthesis rules during calculation."] })] })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Explain the step-by-step algorithm to convert an infix expression to a postfix expression using a stack." }), _jsxs(Answer, { children: [_jsxs(_components.p, { children: ["To convert an infix expression (e.g., ", _jsx(_components.code, { children: "A + B * C" }), ") to its postfix equivalent, we use a stack to temporarily hold operators. The core idea is to respect operator precedence and associativity."] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Algorithm Steps:" }) }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Initialize:" }), " Create an empty stack for operators and an empty output string."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Scan" }), " the infix expression from left to right, one symbol at a time."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "If the symbol is an operand" }), " (like a letter or number), directly append it to the output string."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "If the symbol is '('," }), " push it onto the stack."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "If the symbol is ')'," }), " pop operators from the stack and append them to the output string until an '(' is encountered. Pop and discard the '('."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "If the symbol is an operator" }), " (+, -, *, /, ^):", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["While the stack is not empty AND the operator at the top of the stack has ", _jsx(_components.strong, { children: "greater or equal precedence" }), " than the current operator (for left-associative operators) OR ", _jsx(_components.strong, { children: "greater precedence" }), " (for right-associative operators like ^), pop the top operator from the stack and append it to the output."] }), "\n", _jsx(_components.li, { children: "Push the current operator onto the stack." }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "After the scan is complete," }), " pop any remaining operators from the stack and append them to the output string."] }), "\n", _jsx(_components.li, { children: "The output string now contains the postfix expression." }), "\n"] }), _jsx(_components.p, { children: _jsxs(_components.strong, { children: ["Example Trace for ", _jsx(_components.code, { children: "A * B + C" }), ":"] }) }), _jsxs(_components.table, { children: [_jsx(_components.thead, { children: _jsxs(_components.tr, { children: [_jsx(_components.th, { style: { textAlign: "left" }, children: "Symbol" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Action" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Stack" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Output" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "A" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Append operand" }), _jsx(_components.td, { style: { textAlign: "left" } }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "*" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Push operator" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "*" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "B" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Append operand" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "*" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A B" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "+" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Pop * (higher precedence), then push +" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "+" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A B *" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "C" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Append operand" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "+" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A B * C" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: "(End)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Pop remaining +" }), _jsx(_components.td, { style: { textAlign: "left" } }), _jsx(_components.td, { style: { textAlign: "left" }, children: "A B * C +" })] })] })] })] })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Write a complete C program that evaluates a given valid postfix expression containing single-digit operands and arithmetic operators (+, -, *, /). Include comments to explain the key logic." }), _jsxs(Answer, { children: [_jsx(_components.p, { children: "Here is a complete C program for postfix expression evaluation using a stack:" }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-c", children: "#include \r\n#include \r\n#include // For isdigit() function\r\n\r\n#define MAX 100 // Maximum size of stack\r\n\r\n// Stack structure\r\nint stack[MAX];\r\nint top = -1;\r\n\r\n// Function to push an element onto the stack\r\nvoid push(int val) {\r\n if (top >= MAX - 1) {\r\n printf(\"Stack Overflow\\n\");\r\n exit(1);\r\n }\r\n stack[++top] = val;\r\n}\r\n\r\n// Function to pop an element from the stack\r\nint pop() {\r\n if (top == -1) {\r\n printf(\"Stack Underflow\\n\");\r\n exit(1);\r\n }\r\n return stack[top--];\r\n}\r\n\r\nint main() {\r\n char postfix[MAX];\r\n int i, op1, op2, result;\r\n\r\n printf(\"Enter a valid postfix expression (single-digit operands only): \");\r\n scanf(\"%s\", postfix);\r\n\r\n // Scan the postfix expression from left to right\r\n for (i = 0; postfix[i] != '\\0'; i++) {\r\n char symbol = postfix[i];\r\n\r\n // If the symbol is an operand (digit), push it onto the stack\r\n if (isdigit(symbol)) {\r\n // Convert char digit to its integer value (e.g., '5' -> 5)\r\n push(symbol - '0');\r\n }\r\n // If the symbol is an operator, pop two operands and perform the operation\r\n else {\r\n // Note: The first popped value is the second operand (op2)\r\n op2 = pop();\r\n op1 = pop();\r\n\r\n switch (symbol) {\r\n case '+': result = op1 + op2; break;\r\n case '-': result = op1 - op2; break;\r\n case '*': result = op1 * op2; break;\r\n case '/': \r\n if (op2 == 0) {\r\n printf(\"Error: Division by zero!\\n\");\r\n exit(1);\r\n }\r\n result = op1 / op2; \r\n break;\r\n default:\r\n printf(\"Invalid operator: %c\\n\", symbol);\r\n exit(1);\r\n }\r\n // Push the result of the operation back onto the stack\r\n push(result);\r\n }\r\n }\r\n\r\n // After scanning, the stack should contain exactly one element: the final result\r\n if (top == 0) {\r\n printf(\"Result of Postfix Evaluation: %d\\n\", pop());\r\n } else {\r\n printf(\"Invalid Postfix Expression\\n\");\r\n }\r\n\r\n return 0;\r\n}\n" }) }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "How the Program Works:" }) }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Stack Implementation:" }), " Uses an integer array ", _jsx(_components.code, { children: "stack[]" }), " and a ", _jsx(_components.code, { children: "top" }), " pointer to manage push and pop operations."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Scanning Loop:" }), " Iterates through each character of the input postfix string."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operand Handling:" }), " When a digit is found, it is converted from its ASCII character value to an integer (", _jsx(_components.code, { children: "symbol - '0'" }), ") and pushed onto the stack."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operator Handling:" }), " When an operator is found, the program pops the top two values from the stack. It's crucial to note that ", _jsxs(_components.strong, { children: ["the first popped value is the right-hand operand (", _jsx(_components.code, { children: "op2" }), ")"] }), " and the second popped value is the left-hand operand (", _jsx(_components.code, { children: "op1" }), "). The operation is performed, and the result is pushed back onto the stack."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Final Result:" }), " After processing the entire expression, the stack should contain a single element, which is the evaluated result of the postfix expression."] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Example Run:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Input Postfix:" }), " ", _jsx(_components.code, { children: "53+82-*" })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Evaluation:" }), " ", _jsx(_components.code, { children: "5 3 +" }), " → ", _jsx(_components.code, { children: "8" }), ", then ", _jsx(_components.code, { children: "8 2 -" }), " → ", _jsx(_components.code, { children: "6" }), ", then ", _jsx(_components.code, { children: "8 6 *" }), " → ", _jsx(_components.code, { children: "48" }), "."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Output:" }), " ", _jsx(_components.code, { children: "Result of Postfix Evaluation: 48" })] }), "\n"] })] })] })] }) }), "\n", _jsxs(Assessment, { topicId: "4.3", children: [_jsx(MCQ, { questions: [{ "id": "093e3eb0-00e4-4374-931d-3130732d5ccd", "q": "Which data structure is most appropriate for reversing a sequence of items?", "options": ["Queue", "Stack", "Linked List", "Array"], "answer": 1, "hint": "Think about the LIFO principle of stacks and how it reverses order.", "explanation": "A stack follows the Last-In, First-Out (LIFO) principle. Pushing all elements and then popping them retrieves them in the reverse order of insertion, making it ideal for reversal." }, { "id": "ef148dc1-035d-42eb-903c-28e54cb6e8ad", "q": "In which notation are operators placed AFTER their operands?", "options": ["Infix Notation", "Prefix Notation", "Postfix Notation", "All of these"], "answer": 2, "hint": "Recall the definitions: operators are between operands in one, after in another, and before in the third.", "explanation": "Infix notation has operators between operands (e.g., A+B). Postfix (Reverse Polish) has operators after operands (e.g., AB+). Prefix (Polish) has operators before operands (e.g., +AB)." }, { "id": "e859f7be-76b1-4807-8920-98d277b15c89", "q": "What is the primary purpose of the operator stack during infix to postfix conversion?", "options": ["To hold operators until their correct placement is determined", "To store operands before processing", "To reverse the input expression", "To check for balanced parentheses only"], "answer": 0, "hint": "Think about the precedence rules and how the stack holds operators waiting to be placed.", "explanation": "During infix to postfix conversion, a stack is used to temporarily hold operators until their correct position in the postfix expression is determined based on precedence and associativity rules." }, { "id": "c14de0fe-b883-47d4-b0e6-406f714eb2f7", "q": "Which key operation is performed when an operator is encountered during postfix expression evaluation?", "options": ["The operator is pushed onto the stack", "The stack is emptied", "Operands are converted to infix", "Operands are popped, the operation is applied, and the result is pushed"], "answer": 3, "hint": "Consider that postfix evaluation uses the stack to hold intermediate results.", "explanation": "Postfix evaluation is straightforward with a stack: operands are pushed, and when an operator is encountered, the required number of operands are popped, the operation is performed, and the result is pushed back." }, { "id": "f294fdb6-51b6-45c5-9ed7-88c9f7a6235e", "q": "What is the postfix expression for the infix expression 'A + B'?", "options": ["+AB", "AB+", "A+B", "B+A"], "answer": 1, "hint": "Look at the expression and apply the rule for postfix: operands first, then operator.", "explanation": "For the infix expression 'A + B', the operands A and B come first, followed by the operator +. Thus, the postfix equivalent is 'AB+'." }, { "id": "6c4af66a-31d9-4051-bca5-cb9b65baf6eb", "q": "Why are stacks particularly useful for evaluating mathematical expressions?", "options": ["They automatically sort the operands", "They store the final result directly", "They manage operator precedence and parentheses", "They convert expressions to binary code"], "answer": 2, "hint": "Stacks help manage the order of operations and parentheses.", "explanation": "Stacks are crucial for evaluating mathematical expressions because they handle operator precedence and parentheses correctly, ensuring operations are performed in the right order without ambiguity." }, { "id": "6a788bca-f437-4a39-a9b9-2bc61bd3afd5", "q": "Evaluate the postfix expression: 3 4 +", "options": ["12", "7", "1", "Error"], "answer": 1, "hint": "Convert step by step: process '3', '4', push them, then see '+', so pop and add.", "explanation": "For '3 4 +', push 3, push 4, then for '+', pop 4 and 3, compute 3+4 is 7, push 7. The result is 7." }, { "id": "23fc5b10-ac68-4402-abca-a461ef6a5162", "q": "Which is a key advantage of Postfix/Polish Notation over Infix Notation?", "options": ["It eliminates the need for parentheses to define precedence", "It makes expressions easier for humans to read", "It requires less memory for evaluation", "It uses fewer operators"], "answer": 0, "hint": "Remember that postfix (and prefix) notation inherently avoids ambiguity, removing the need for parentheses.", "explanation": "A major advantage of postfix (and prefix) notation is that it is unambiguous without the need for parentheses to specify the order of operations. The order is determined purely by the sequence of operators and operands." }, { "id": "7e831119-d13f-42e5-85cb-bc53e6860aac", "q": "Convert the infix expression 'A * (B + C)' to postfix notation.", "options": ["A**B+C", "ABC*+", "*(A+BC)", "ABC+*"], "answer": 3, "hint": "Apply the rules: parentheses group sub-expressions, which are converted first.", "explanation": "To convert 'A * (B + C)' to postfix, first convert the sub-expression inside parentheses: 'B + C' becomes 'BC+'. Then apply the outer operator: 'A' and 'BC+' with '*' gives 'ABC+*'." }, { "id": "7a27c637-7fc1-4b26-a66f-4cdeafd48b01", "q": "During postfix evaluation, an error condition can arise if __________.", "options": ["the expression contains too many operands", "the result is a very large number", "an operator is encountered but the stack has fewer than two operands", "the stack is empty after processing all tokens"], "answer": 2, "hint": "Consider what would happen if the stack is empty when an operator is encountered or non-empty at the end.", "explanation": "An error occurs if an operator is found but the stack has fewer than the required number of operands (underflow), or if the stack contains more than one value (or non-operand) at the end, indicating a malformed expression." }], topicId: "4.3" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Applications of Stack", seoDesc: "Master Applications of Stack with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "applications of stack, applications of stack notes, applications of stack examples, diploma engineering notes, practice quiz, learningway" })] })] }); } function MDXContent(props = {}) { const {wrapper: MDXLayout} = { ..._provideComponents(), ...props.components }; return MDXLayout ? _jsx(MDXLayout, { ...props, children: _jsx(_createMdxContent, { ...props }) }) : _createMdxContent(props); } return { default: MDXContent }; function _missingMdxReference(id, component) { throw new Error("Expected " + (component ? "component" : "object") + " `" + id + "` to be defined: you likely forgot to import, pass, or provide it."); }