"use strict"; const {Fragment: _Fragment, jsx: _jsx, jsxs: _jsxs} = arguments[0]; const {useMDXComponents: _provideComponents} = arguments[0]; function _createMdxContent(props) { const _components = { code: "code", h3: "h3", h4: "h4", li: "li", ol: "ol", p: "p", span: "span", strong: "strong", table: "table", tbody: "tbody", td: "td", th: "th", thead: "thead", tr: "tr", ul: "ul", ..._provideComponents(), ...props.components }, {Analogy, Answer, Assessment, BlockDiagram, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, Hinglish, ImportantQA, MCQ, Practical, Prompt, QAQuestion, Remember, SubTopicHeader, Theory, TopicOverview} = _components; if (!Analogy) _missingMdxReference("Analogy", true); if (!Answer) _missingMdxReference("Answer", true); if (!Assessment) _missingMdxReference("Assessment", true); if (!BlockDiagram) _missingMdxReference("BlockDiagram", 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 (!ImportantQA) _missingMdxReference("ImportantQA", 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 (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "5.1", title: "Introduction to Queue: ADT, Array and Linked List Representation" }), _jsx(English, { children: _jsx(TopicOverview, { title: "Introduction to Queue", topicId: "5.1", readingTime: "8 min read", difficulty: "Medium", children: _jsx(_components.p, { children: "A Queue is a fundamental linear data structure that operates under the First-In-First-Out (FIFO) principle, where the first element added is the first one to be removed. Similar to a queue of customers at a ticket counter, elements are inserted at one end called the Rear and deleted from the other end called the Front. This subtopic explores the concept of queues, compares them with stacks, describes the Queue Abstract Data Type (ADT), and details how a queue is represented internally using static arrays and dynamic linked lists." }) }) }), _jsx(Hinglish, { children: _jsx(TopicOverview, { title: "Queue Ka Parichay", topicId: "5.1", readingTime: "8 min read", difficulty: "Medium", children: _jsx(_components.p, { children: "Queue ek basic linear data structure hai jo First-In-First-Out (FIFO) principle par kaam karta hai, yaani jo element pehle add hoga wahi pehle remove hoga. Jaise ticket counter par logo ki line hoti hai, thik waise hi queue mein elements ek end se add hote hain jise Rear kehte hain, aur doosre end se delete hote hain jise Front kehte hain. Is subtopic mein hum queue ke concept ko samjhenge, ise stack se compare karenge, iske Abstract Data Type (ADT) ko explore karenge, aur array aur linked list representations ko detail mein cover karenge." }) }) }), _jsxs(DefinitionGroup, { children: [_jsx(DefinitionEntry, { term: "Queue", children: _jsx(_components.p, { children: "A Queue is a linear data structure that follows the First-In-First-Out (FIFO) principle, where elements are inserted at the Rear and removed from the Front. Hinglish: Queue ek linear data structure hai jo FIFO principle follow karta hai, jisme elements ko Rear end par insert kiya jata hai aur Front end se remove kiya jata hai." }) }), _jsx(DefinitionEntry, { term: "FIFO", children: _jsx(_components.p, { children: "FIFO stands for First-In-First-Out, a scheduling or processing principle where the element that is added first to the structure is the very first one to be deleted. Hinglish: FIFO ka matlab hai First-In-First-Out. Yeh wo principle hai jiske according jo element structure mein sabse pehle add hoga, wahi sabse pehle delete bhi hoga." }) }), _jsx(DefinitionEntry, { term: "Front", children: _jsx(_components.p, { children: "Front is a pointer or index variable that tracks the beginning of the queue, representing the position from which elements are removed (dequeued). Hinglish: Front ek pointer ya index variable hai jo queue ke starting point ko track karta hai, yaani jahan se elements ko delete (dequeue) kiya jata hai." }) }), _jsx(DefinitionEntry, { term: "Rear", children: _jsx(_components.p, { children: "Rear is a pointer or index variable that tracks the end of the queue, representing the position at which new elements are inserted (enqueued). Hinglish: Rear ek pointer ya index variable hai jo queue ke end point ko track karta hai, yaani jahan naye elements ko insert (enqueue) kiya jata hai." }) }), _jsx(DefinitionEntry, { term: "Enqueue", children: _jsx(_components.p, { children: "Enqueue is the operation of adding or inserting a new element at the rear end of the queue. Hinglish: Enqueue operation ka matlab hai queue ke rear end par ek naya element insert ya add karna." }) }), _jsx(DefinitionEntry, { term: "Dequeue", children: _jsx(_components.p, { children: "Dequeue is the operation of removing or deleting an element from the front end of the queue. Hinglish: Dequeue operation ka matlab hai queue ke front end se kisi element ko remove ya delete karna." }) }), _jsx(DefinitionEntry, { term: "ADT", children: _jsx(_components.p, { children: "Abstract Data Type (ADT) is a mathematical model for a data type that defines its data values and operations, while keeping the internal implementation details completely hidden. Hinglish: ADT ek mathematical model hai jo data structures ke values aur unke operations ko specify karta hai, lekin unke internal implementation details ko chhupa ke rakhta hai." }) })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "📌 Concept of Queue and FIFO Principle" }), _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "Queue" }), " is a linear data structure that stores elements in a sequential manner. It follows the ", _jsx(_components.strong, { children: "FIFO (First-In-First-Out)" }), " principle, which states that the element that goes in first will be the first one to come out."] }), _jsx(_components.p, { children: "Unlike a Stack where elements are added and removed from the same end, a Queue uses two separate ends:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Rear" }), ": The end where new elements are inserted."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Front" }), ": The end from which existing elements are removed."] }), "\n"] }), _jsx(_components.h4, { children: "🔄 Differences: Queue vs Stack" }), _jsx(_components.p, { children: "To understand the distinction clearly, let's compare their structures:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Access Principle" }), ": Queue is FIFO (First-In-First-Out), while Stack is LIFO (Last-In-First-Out)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Number of Pointers" }), ": Queue uses two pointers (`Front` and `Rear`) to manage the structure. Stack only needs a single pointer (`Top`)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operation Ends" }), ": In a Queue, insertion and deletion are done at opposite ends. In a Stack, both operations happen at the same top end."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📌 Queue Ka Concept aur FIFO Principle" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Queue" }), " ek linear data structure hai jo elements ko sequential order mein store karta hai. Yeh ", _jsx(_components.strong, { children: "FIFO (First-In-First-Out)" }), " principle par kaam karta hai, jiska simple matlab hai ki jo element sabse pehle insert hoga, wahi sabse pehle delete hoga."] }), _jsx(_components.p, { children: "Stack ke opposite, jahan insertion aur deletion ek hi end se hota hai, Queue mein do alag-alag ends use hote hain:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Rear" }), ": Yeh wo end hai jahan se naye elements ko insert kiya jata hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Front" }), ": Yeh wo end hai jahan se elements ko remove kiya jata hai."] }), "\n"] }), _jsx(_components.h4, { children: "🔄 Differences: Queue vs Stack" }), _jsx(_components.p, { children: "Dono ke beech ke main differences ko samajhte hain:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Access Principle" }), ": Queue FIFO principle follow karta hai, jabki Stack LIFO (Last-In-First-Out) principle follow karta hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Number of Pointers" }), ": Queue ko manage karne ke liye do pointers (`Front` aur `Rear`) chahiye hote hain. Stack ko handle karne ke liye sirf ek pointer (`Top`) ki zaroorat hoti hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Operation Ends" }), ": Queue mein insert aur delete do opposite ends par hote hain. Stack mein insert aur delete ek hi end (Top) se hote hain."] }), "\n"] })] }), _jsx(Analogy, { children: _jsxs(_components.p, { children: [_jsx("b", { children: "Ticket Counter Line Analogy" }), _jsx("br", {}), "\n", _jsx(_components.strong, { children: "English:" }), " Imagine a line of people waiting to buy a ticket. The person who comes first gets the ticket first and leaves from the Front. A new person joins at the end (Rear) of the line. This is exactly how a Queue works (FIFO).", _jsx("br", {}), _jsx("br", {}), "\n", _jsx(_components.strong, { children: "Hinglish:" }), " Sochiye ek cinema ticket counter par logo ki line khadi hai. Jo sabse pehle aaya use sabse pehle ticket milegi aur wo Front se chala jayega. Naya person line ke end (Rear) par join karega. Yeh bilkul Queue (FIFO) ki tarah hai."] }) }), _jsxs(English, { children: [_jsx(_components.h3, { children: "⚡ Front & Rear Pointer Positions during Operations" }), _jsx(_components.p, { children: "To manage a queue, we track two primary indices or pointers, `Front` and `Rear`. The movement of these pointers depends on the operations performed:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Initial State (Empty Queue)" }), ":\nInitially, when the queue contains no elements, both `Front` and `Rear` are set to ", _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.7278em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "−" }), _jsx(_components.span, { className: "mord", children: "1" })] }) }) }), "."] }), "\n", _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.8778em", verticalAlign: "-0.1944em" } }), _jsx(_components.span, { className: "mord", children: "−" }), _jsx(_components.span, { className: "mord", children: "1" }), _jsx(_components.span, { className: "mpunct", children: "," }), _jsx(_components.span, { className: "mspace", style: { marginRight: "1em" } }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.1667em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7278em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "−" }), _jsx(_components.span, { className: "mord", children: "1" })] })] }) }) }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "First Insertion (Enqueue)" }), ":\nWhen the first element is added to an empty queue, both `Front` and `Rear` are incremented and set to index ", _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.6444em" } }), _jsx(_components.span, { className: "mord", children: "0" })] }) }) }), "."] }), "\n", _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.8778em", verticalAlign: "-0.1944em" } }), _jsx(_components.span, { className: "mord", children: "0" }), _jsx(_components.span, { className: "mpunct", children: "," }), _jsx(_components.span, { className: "mspace", style: { marginRight: "1em" } }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.1667em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "0" })] })] }) }) }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Subsequent Insertions (Enqueue)" }), ":\nEvery new element is inserted at the `Rear` end. The `Rear` pointer is incremented by 1, while the `Front` pointer remains unchanged."] }), "\n", _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "+" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "1" })] })] }) }) }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Deletions (Dequeue)" }), ":\nWhen an element is removed, the element at index `Front` is fetched, and the `Front` pointer is incremented by 1 to point to the next element."] }), "\n", _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "+" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "1" })] })] }) }) }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Resetting the Queue" }), ":\nIf we delete all elements, `Front` will cross `Rear` (", _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7224em", verticalAlign: "-0.0391em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: ">" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" })] })] }) }), "). When this happens, we reset both pointers back to ", _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.7278em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "−" }), _jsx(_components.span, { className: "mord", children: "1" })] }) }) }), " to represent an empty queue."] }), "\n"] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "⚡ Operations Ke Dauran Front aur Rear Pointer Ki Positions" }), _jsx(_components.p, { children: "Queue ko control karne ke liye hum do main pointers use karte hain: `Front` aur `Rear`. In pointers ki positions kuch is tarah change hoti hain:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Initial State (Empty Queue)" }), ":\nJab queue empty hoti hai, toh `Front` aur `Rear` dono ki value ", _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.7278em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "−" }), _jsx(_components.span, { className: "mord", children: "1" })] }) }) }), " set hoti hai."] }), "\n", _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.8778em", verticalAlign: "-0.1944em" } }), _jsx(_components.span, { className: "mord", children: "−" }), _jsx(_components.span, { className: "mord", children: "1" }), _jsx(_components.span, { className: "mpunct", children: "," }), _jsx(_components.span, { className: "mspace", style: { marginRight: "1em" } }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.1667em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7278em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "−" }), _jsx(_components.span, { className: "mord", children: "1" })] })] }) }) }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "First Insertion (Enqueue)" }), ":\nJab queue mein sabse pehla element insert hota hai, toh `Front` aur `Rear` dono increment hokar ", _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.6444em" } }), _jsx(_components.span, { className: "mord", children: "0" })] }) }) }), " par aa jate hain."] }), "\n", _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.8778em", verticalAlign: "-0.1944em" } }), _jsx(_components.span, { className: "mord", children: "0" }), _jsx(_components.span, { className: "mpunct", children: "," }), _jsx(_components.span, { className: "mspace", style: { marginRight: "1em" } }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.1667em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "0" })] })] }) }) }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Subsequent Insertions (Enqueue)" }), ":\nIske baad naye elements humesha `Rear` end par insert hote hain. Isliye sirf `Rear` pointer increment hota hai aur `Front` apni jagah par fixed rehta hai."] }), "\n", _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "+" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "1" })] })] }) }) }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Deletions (Dequeue)" }), ":\nJab queue se element remove hota hai, toh element ko check karke `Front` pointer ko 1 se aage badha diya jata hai."] }), "\n", _jsx(_components.span, { className: "katex-display", children: _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "=" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "+" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "1" })] })] }) }) }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Resetting the Queue" }), ":\nAgar delete karte-karte saare elements khatam ho jayein, toh `Front` pointer `Rear` ko cross kar jayega (", _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7224em", verticalAlign: "-0.0391em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "F" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" }), _jsx(_components.span, { className: "mord mathnormal", children: "o" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mord mathnormal", children: "t" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: ">" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6833em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0077em" }, children: "R" }), _jsx(_components.span, { className: "mord mathnormal", children: "e" }), _jsx(_components.span, { className: "mord mathnormal", children: "a" }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "r" })] })] }) }), "). Aisi situation mein hum dono pointers ko wapas ", _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.7278em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "−" }), _jsx(_components.span, { className: "mord", children: "1" })] }) }) }), " par set kar dete hain."] }), "\n"] }), "\n"] })] }), _jsxs(BlockDiagram, { title: "Enqueue and Dequeue Pointer Positions", children: [_jsx(_components.p, { children: "Initial Empty Queue:\n[ ] [ ] [ ] [ ] [ ]\nFront = -1, Rear = -1" }), _jsx(_components.p, { children: "Enqueue(10):\n[10] [ ] [ ] [ ] [ ]\n^\nFront = 0, Rear = 0" }), _jsx(_components.p, { children: "Enqueue(20):\n[10] [20] [ ] [ ] [ ]\n^ ^\nFront = 0, Rear = 1" }), _jsx(_components.p, { children: "Enqueue(30):\n[10] [20] [30] [ ] [ ]\n^ ^\nFront = 0, Rear = 2" }), _jsx(_components.p, { children: "Dequeue() -> Returns 10:\n[ ] [20] [30] [ ] [ ]\n^ ^\nFront = 1, Rear = 2" })] }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🧱 Queue as an Abstract Data Type (ADT)" }), _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "Queue ADT" }), " defines the logical properties and supported operations on a queue structure without detailing the code implementation. It consists of a set of data items and operations."] }), _jsx(_components.p, { children: "The core operations of a Queue ADT include:" }), _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "`enqueue(data)`: Inserts a new element at the `Rear` of the queue." }), "\n", _jsx(_components.li, { children: "`dequeue()`: Removes and returns the element present at the `Front` of the queue." }), "\n", _jsx(_components.li, { children: "`peek()` / `front()`: Returns the element at the `Front` of the queue without deleting it." }), "\n", _jsx(_components.li, { children: "`isEmpty()`: Returns `true` if the queue contains no elements, else returns `false`." }), "\n", _jsx(_components.li, { children: "`isFull()`: Returns `true` if the queue is completely filled up to its capacity, else returns `false`." }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🧱 Queue Abstract Data Type (ADT) Ke Roop Mein" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Queue ADT" }), " queue ke components aur unpar allowed operations ko specify karta hai, bina ye soche ki hum code array se likh rahe hain ya linked list se."] }), _jsx(_components.p, { children: "Queue ADT ke standard operations ye hain:" }), _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "`enqueue(data)`: Queue ke `Rear` end par naya element add karta hai." }), "\n", _jsx(_components.li, { children: "`dequeue()`: Queue ke `Front` end se element delete karta hai aur use return karta hai." }), "\n", _jsx(_components.li, { children: "`peek()` / `front()`: Queue ke front element ko check karta hai bina use delete kiye." }), "\n", _jsx(_components.li, { children: "`isEmpty()`: Check karta hai ki queue empty hai ya nahi. Agar empty ho toh `true` return karta hai." }), "\n", _jsx(_components.li, { children: "`isFull()`: Check karta hai ki queue full ho chuki hai ya nahi." }), "\n"] })] }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📦 Array Representation of Queue (Static Queue)" }), _jsx(_components.p, { children: "An array representation of a queue uses a one-dimensional static array to hold the elements, along with two integer variables `front` and `rear` to store indices." }), _jsx(_components.h4, { children: "⚠️ Limitations of Linear Queue using Array" }), _jsx(_components.p, { children: "While simple to implement, the static array representation has significant drawbacks:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Fixed Capacity" }), ": The maximum capacity of the queue is fixed at compile-time and cannot grow dynamically."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Memory Wastage (No Space Reutilization)" }), ": In a linear queue, when elements are dequeued, the `front` pointer moves forward. The memory slots before `front` become empty but unusable. This is because new elements can only be inserted at the `rear` index."] }), "\n", _jsxs(_components.p, { children: ["If `rear` reaches the maximum index of the array, the queue reports a ", _jsx(_components.strong, { children: "Queue Overflow (Full)" }), " condition, even if multiple spaces are free at the beginning of the array."] }), "\n"] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📦 Queue Ka Array Representation (Static Queue)" }), _jsx(_components.p, { children: "Array representation mein hum ek single-dimensional fixed-size array aur do integer variables (`front` aur `rear`) ka use karte hain elements aur unke indices track karne ke liye." }), _jsx(_components.h4, { children: "⚠️ Linear Queue Using Array Ke Limitations" }), _jsx(_components.p, { children: "Yeh simple toh hai, par iske bade drawbacks hain:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Fixed Capacity" }), ": Queue ka maximum size starting mein hi fix ho jata hai aur hum use dynamic run-time par change nahi kar sakte."] }), "\n"] }), "\n", _jsxs(_components.li, { children: ["\n", _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Memory Wastage" }), ": Linear queue mein jab hum dequeue karte hain, toh `front` aage badh jata hai. `front` se pehle wali spaces memory mein khali hone ke baavjud useless ho jati hain kyunki naye elements sirf `rear` end par hi add ho sakte hain."] }), "\n", _jsxs(_components.p, { children: ["Agar `rear` array ke aakhiri index (`MAX - 1`) par pahunch jaye, toh queue ", _jsx(_components.strong, { children: "Overflow" }), " show karega, bhale hi shuruat ke slots empty pade hon."] }), "\n"] }), "\n"] })] }), _jsx(CodeBlock, { language: "c", children: `#include #define MAX 5 int queue[MAX]; int front = -1; int rear = -1; int isFull() { return rear == MAX - 1; } int isEmpty() { return front == -1 || front > rear; } void enqueue(int value) { if (isFull()) { printf("Queue Overflow! Cannot enqueue %d\\\\n", value); return; } if (front == -1) { front = 0; } rear++; queue[rear] = value; printf("Enqueued: %d\\\\n", value); } int dequeue() { if (isEmpty()) { printf("Queue Underflow! Cannot dequeue\\\\n"); return -1; } int val = queue[front]; front++; if (front > rear) { // Reset queue when it becomes empty front = -1; rear = -1; } return val; } void display() { if (isEmpty()) { printf("Queue is empty!\\\\n"); return; } printf("Queue elements: "); for (int i = front; i <= rear; i++) { printf("%d ", queue[i]); } printf("\\\\n"); } int main() { enqueue(10); enqueue(20); enqueue(30); display(); printf("Dequeued: %d\\\\n", dequeue()); display(); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "🔗 Linked List Representation of Queue (Dynamic Queue)" }), _jsx(_components.p, { children: "To overcome the limitations of fixed size and memory wastage, a queue can be implemented dynamically using a Linked List." }), _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Each node in the queue contains two parts: the `data` field and a `next` pointer pointing to the next node." }), "\n", _jsxs(_components.li, { children: ["Instead of indices, `front` and `rear` are actual node pointers:", "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "`front` points to the first node (head of the list)." }), "\n", _jsx(_components.li, { children: "`rear` points to the last node (tail of the list)." }), "\n"] }), "\n"] }), "\n"] }), _jsx(_components.h4, { children: "⚡ Key Advantages:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Dynamic Size" }), ": The queue grows and shrinks dynamically. Memory is allocated on the heap only when an element is enqueued."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "No Overflow" }), ": Since memory is allocated dynamically, the queue is never full unless the system completely runs out of memory."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Efficient Space Utilization" }), ": Space is occupied only when needed, solving the array representation's wastage issue."] }), "\n"] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🔗 Queue Ka Linked List Representation (Dynamic Queue)" }), _jsx(_components.p, { children: "Array ke size limitations aur memory wastage problems ko door karne ke liye hum Queue ko Linked List se implement karte hain." }), _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Har node ke do parts hote hain: `data` aur `next` node ka pointer (address)." }), "\n", _jsxs(_components.li, { children: ["Pointers `front` aur `rear` indexes ki jagah memory addresses store karte hain:", "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "`front` pointer pehle node (list head) ko point karta hai." }), "\n", _jsx(_components.li, { children: "`rear` pointer aakhiri node (list tail) ko point karta hai." }), "\n"] }), "\n"] }), "\n"] }), _jsx(_components.h4, { children: "⚡ Key Advantages:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Dynamic Size" }), ": Queue size dynamically grow ya shrink ho sakta hai. Jab element add hota hai tabhi memory allocate hoti hai."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "No Overflow" }), ": Queue memory khatam hone tak kabhi overflow nahi hoti."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Efficient Space" }), ": Shuruat ke empty spaces block hone ki problem yahan nahi hoti kyunki dynamic nodes pointer update karke discard ho jate hain."] }), "\n"] })] }), _jsx(CodeBlock, { language: "c", children: `#include #include struct Node { int data; struct Node* next; }; struct Node* front = NULL; struct Node* rear = NULL; int isEmpty() { return front == NULL; } void enqueue(int value) { struct Node* newNode = (struct Node*)malloc(sizeof(struct Node)); if (newNode == NULL) { printf("Queue Overflow! Heap memory is full.\\\\n"); return; } newNode->data = value; newNode->next = NULL; if (front == NULL) { // First insertion front = rear = newNode; } else { rear->next = newNode; rear = newNode; } printf("Enqueued: %d\\\\n", value); } int dequeue() { if (isEmpty()) { printf("Queue Underflow!\\\\n"); return -1; } struct Node* temp = front; int val = temp->data; front = front->next; if (front == NULL) { // Queue becomes empty rear = NULL; } free(temp); return val; } void display() { if (isEmpty()) { printf("Queue is empty!\\\\n"); return; } struct Node* temp = front; printf("Queue elements: "); while (temp != NULL) { printf("%d -> ", temp->data); temp = temp->next; } printf("NULL\\\\n"); } int main() { enqueue(10); enqueue(20); enqueue(30); display(); printf("Dequeued: %d\\\\n", dequeue()); display(); return 0; }` }), _jsx(Remember, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Queue Empty Condition" }), ":", "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Array: `front == -1` or `front > rear`" }), "\n", _jsx(_components.li, { children: "Linked List: `front == NULL`" }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Queue Full Condition" }), ":", "\n", _jsxs(_components.ul, { children: ["\n", _jsx(_components.li, { children: "Array: `rear == MAX - 1`" }), "\n", _jsx(_components.li, { children: "Linked List: No static limit (only system out of memory)" }), "\n"] }), "\n"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Time Complexities" }), ":", "\n", _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Enqueue (Insertion): ", _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", children: "1" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) })] }), "\n", _jsxs(_components.li, { children: ["Dequeue (Deletion): ", _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", children: "1" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) })] }), "\n", _jsxs(_components.li, { children: ["Peek (Front element): ", _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", children: "1" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) })] }), "\n", _jsxs(_components.li, { children: ["isEmpty / isFull: ", _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", children: "1" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) })] }), "\n"] }), "\n"] }), "\n"] }) }), _jsx(ComparisonTable, { title: "Array Representation vs Linked List Representation of Queue", 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: "Array Representation" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Linked List Representation" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Memory Allocation" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Static (allocated at compile-time)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Dynamic (allocated on heap at run-time)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Size Limit" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Fixed size (defined by array capacity)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Dynamic size (can grow as long as memory is available)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Wastage of Space" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Yes (spaces before Front pointer cannot be reused in linear queue)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "No (memory is allocated only when a node is added)" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Memory Overhead" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "No extra overhead" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Yes, extra memory is needed for pointer fields in nodes" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Overflow Condition" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Happens when Rear index reaches capacity limit" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Happens only when system memory is fully exhausted" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Execution Speed" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Faster operations as no dynamic memory overhead" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Slightly slower due to dynamic allocation and pointer traversal" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Time Complexity" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Enqueue and Dequeue operations are ", _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", children: "1" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) })] }), _jsxs(_components.td, { style: { textAlign: "left" }, children: ["Enqueue and Dequeue operations are ", _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", children: "1" }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) })] })] })] })] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "Define Queue and explain the FIFO principle with a real-life example (2 Marks)." }), _jsxs(Answer, { children: [_jsx(_components.h3, { children: "Definition of Queue" }), _jsxs(_components.p, { children: ["A ", _jsx(_components.strong, { children: "Queue" }), " is a linear data structure that stores elements sequentially. It follows the ", _jsx(_components.strong, { children: "FIFO (First-In, First-Out)" }), " principle, where the insertion of elements takes place at one end called the ", _jsx(_components.strong, { children: "Rear" }), " (or Back) and the deletion of elements takes place at the other end called the ", _jsx(_components.strong, { children: "Front" }), " (or Head)."] }), _jsx(_components.h3, { children: "The FIFO Principle" }), _jsxs(_components.p, { children: ["The ", _jsx(_components.strong, { children: "FIFO" }), " principle states that the element that is inserted first into the queue will be the first one to be removed."] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Enqueue:" }), " The operation to insert an element into the queue at the ", _jsx(_components.strong, { children: "Rear" }), " end."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Dequeue:" }), " The operation to remove an element from the queue from the ", _jsx(_components.strong, { children: "Front" }), " end."] }), "\n"] }), _jsx(_components.h3, { children: "Real-Life Example" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "A Ticket Counter Line:" }), " People standing in line to buy a cinema ticket. The person who arrives first is at the front of the line, gets served first, and leaves first. Any new person joins at the end of the line (Rear) and waits for their turn."] }), "\n"] })] })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsx(Prompt, { children: "Write C functions for enqueue and dequeue operations using array representation, including full and empty conditions (4 Marks)." }), _jsxs(Answer, { children: [_jsx(_components.h3, { children: "Array Representation of Queue" }), _jsxs(_components.p, { children: ["A queue is represented using a one-dimensional array of a fixed size ", _jsx(_components.code, { children: "MAX" }), ", with two integer pointers:"] }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "front" }), ": Points to the index of the first element in the queue."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "rear" }), ": Points to the index of the last element in the queue."] }), "\n"] }), _jsx(_components.h3, { children: "Queue Conditions" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Queue Full (Overflow):" }), " Occurs when the queue has reached its maximum capacity. The condition is:\n", _jsx(_components.span, { className: "katex", children: _jsxs(_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 text", children: _jsx(_components.span, { className: "mord", children: "rear" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "==" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7667em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "MAX" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } }), _jsx(_components.span, { className: "mbin", children: "−" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2222em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6444em" } }), _jsx(_components.span, { className: "mord", children: "1" })] })] }) })] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Queue Empty (Underflow):" }), " Occurs when there are no elements in the queue. The condition is:\n", _jsx(_components.span, { className: "katex", children: _jsxs(_components.span, { className: "katex-html", "aria-hidden": "true", children: [_jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.6944em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "front" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: "==" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.7778em", verticalAlign: "-0.0833em" } }), _jsx(_components.span, { className: "mord", children: "−" }), _jsx(_components.span, { className: "mord", children: "1" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "1em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "or" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "1em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "front" }) }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mrel", children: ">" }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } })] }), _jsxs(_components.span, { className: "base", children: [_jsx(_components.span, { className: "strut", style: { height: "0.4306em" } }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: "rear" }) })] })] }) })] }), "\n"] }), _jsx(_components.h3, { children: "C Implementation Functions" }), _jsx(_components.p, { children: "The functions for enqueue and dequeue operations are implemented as follows:" }), _jsx(CodeBlock, { language: "c", children: `#include #define MAX 5 int queue[MAX]; int front = -1; int rear = -1; // Function to check if the queue is full int isFull() { return (rear == MAX - 1); } // Function to check if the queue is empty int isEmpty() { return (front == -1 || front > rear); } // Enqueue function to insert an element void enqueue(int value) { if (isFull()) { printf("Queue Overflow! Cannot enqueue %d\\n", value); return; } if (front == -1) { front = 0; // Initialize front on first insertion } rear++; queue[rear] = value; printf("Enqueued %d successfully\\n", value); } // Dequeue function to delete an element int dequeue() { if (isEmpty()) { printf("Queue Underflow! Cannot dequeue\\n"); return -1; } int value = queue[front]; front++; // Reset pointers if queue becomes empty if (front > rear) { front = -1; rear = -1; } return value; }` })] })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Explain the representation of Queue using a Linked List. Write C code for enqueue and dequeue in a linked queue (6 Marks)." }), _jsxs(Answer, { children: [_jsx(_components.h3, { children: "Linked List Representation of Queue" }), _jsx(_components.p, { children: "In a linked list representation, each element in the queue is a dynamic node. Each node contains:" }), _jsxs(_components.ol, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "data" }), ": The value stored in the node."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "next" }), ": A pointer pointing to the next node in the queue."] }), "\n"] }), _jsx(_components.p, { children: "To track the queue, we maintain two pointers:" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "front" }), ": Points to the first node of the linked list (where deletion/dequeue occurs)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.code, { children: "rear" }), ": Points to the last node of the linked list (where insertion/enqueue occurs)."] }), "\n", _jsx(_components.li, { children: "Unlike array representation, the size is dynamic and can grow or shrink during runtime (no fixed size overflow condition)." }), "\n"] }), _jsx(_components.h3, { children: "Queue Operations" }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Enqueue:" }), " Allocate memory for a new node. If the queue is empty (", _jsx(_components.code, { children: "front == NULL" }), "), both ", _jsx(_components.code, { children: "front" }), " and ", _jsx(_components.code, { children: "rear" }), " point to the new node. Otherwise, link the current ", _jsx(_components.code, { children: "rear" }), " node to the new node using ", _jsx(_components.code, { children: "rear → next" }), " and then update ", _jsx(_components.code, { children: "rear" }), " to point to the new node."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Dequeue:" }), " Check if the queue is empty (", _jsx(_components.code, { children: "front == NULL" }), "). If not, store the ", _jsx(_components.code, { children: "front" }), " node in a temporary pointer, retrieve the data, advance ", _jsx(_components.code, { children: "front" }), " to the next node (", _jsx(_components.code, { children: "front → next" }), "), and free the memory of the temporary node. If ", _jsx(_components.code, { children: "front" }), " becomes ", _jsx(_components.code, { children: "NULL" }), ", reset ", _jsx(_components.code, { children: "rear" }), " to ", _jsx(_components.code, { children: "NULL" }), "."] }), "\n"] }), _jsx(_components.h3, { children: "C Implementation Functions" }), _jsx(_components.p, { children: "The functions for linked queue operations are implemented as follows:" }), _jsx(CodeBlock, { language: "c", children: `#include #include // Structure of Node struct Node { int data; struct Node* next; }; // Global pointers for front and rear struct Node* front = NULL; struct Node* rear = NULL; // Enqueue operation in linked queue void enqueue(int value) { struct Node* temp = (struct Node*)malloc(sizeof(struct Node)); if (temp == NULL) { printf("Queue Overflow! Heap memory is full.\\n"); return; } temp->data = value; temp->next = NULL; // If queue is empty if (front NULL && rear NULL) { front = rear = temp; return; } // Insert at rear end and update rear rear->next = temp; rear = temp; printf("Enqueued %d to linked queue\\n", value); } // Dequeue operation in linked queue int dequeue() { if (front == NULL) { printf("Queue Underflow! Linked queue is empty.\\n"); return -1; } struct Node* temp = front; int data = temp->data; // Move front to next node front = front->next; // If queue becomes empty, set rear to NULL if (front == NULL) { rear = NULL; } free(temp); return data; }` })] })] })] }) }), "\n", _jsxs(Assessment, { topicId: "5.1", children: [_jsx(MCQ, { questions: [{ "id": "d083cb3c-c916-4458-b2b9-7d6e2ee0b711", "q": "What is the fundamental principle on which a standard Queue data structure operates?", "options": ["First In First Out (FIFO)", "Last In First Out (LIFO)", "LIFO and FIFO combined", "Random Access"], "answer": 0, "hint": "Elements are removed in the same order they were added.", "explanation": "Queue is a linear data structure that follows the First In First Out (FIFO) principle, where insertion happens at the rear and deletion happens at the front." }, { "id": "6e30518a-4068-4561-a83c-efc2c3495353", "q": "Which of the following operations is used to insert an element into a Queue?", "options": ["Pop", "Push", "Dequeue", "Enqueue"], "answer": 3, "hint": "Think of adding an item to the end of the line.", "explanation": "The enqueue operation adds an item to the rear end of the queue." }, { "id": "eceb59f5-67ce-4884-9df7-31ba57d68a0c", "q": "In a standard Queue ADT, which operation removes and returns the element at the front?", "options": ["Enqueue", "Dequeue", "Peek", "Display"], "answer": 1, "hint": "This operation deletes the element that has been in the queue the longest.", "explanation": "Dequeue is the operation that removes the front element of the queue and returns it." }, { "id": "f5accd11-c1ff-4188-b5c0-023db916f3ea", "q": "What is the time complexity of the enqueue and dequeue operations in an efficient array or linked list implementation of a Queue?", "options": ["O(1)", "O(n)", "O(log n)", "O(n log n)"], "answer": 0, "hint": "These operations access the front and rear pointers directly, requiring constant time.", "explanation": "Both enqueue and dequeue can be done in O(1) time if proper front and rear pointers are maintained." }, { "id": "8666ef01-dbbb-4ba9-96c0-f2e3feafd338", "q": "In an array representation of a linear Queue, what condition indicates that the Queue is full?", "options": ["front -1", "rear MAX - 1", "front rear", "rear front - 1"], "answer": 1, "hint": "In a basic linear queue, the rear pointer moves forward as elements are inserted and stops at the last array index.", "explanation": "For a linear queue implemented using an array of size MAX, the queue is full when the rear index reaches MAX minus 1." }, { "id": "de3c588f-dbf7-40a2-8533-27da1f1d0609", "q": "What is a major disadvantage of representing a Queue using a simple linear array?", "options": ["Elements cannot be deleted", "Inability to reuse memory space of deleted elements", "Random access is too slow", "High memory overhead compared to linked lists"], "answer": 1, "hint": "Once rear reaches the end, we cannot insert more elements even if front elements are dequeued.", "explanation": "In a simple linear array queue, once the rear pointer reaches the maximum index, no more insertions are possible even if space is vacant at the beginning. This is called memory wastage." }, { "id": "df71b0c3-a8c6-4389-9d37-be6622055113", "q": "How is the Queue Empty condition check represented in a standard array implementation?", "options": ["{\"front -1 or front > rear\"}", "rear -1", "front rear + 1", "front MAX - 1"], "answer": 0, "hint": "The queue is empty when no elements have been inserted or when all inserted elements are dequeued.", "explanation": "A queue is empty when front is equal to negative 1 or if the front index has crossed the rear index due to successive dequeue operations." }, { "id": "34d9643c-bcca-41b3-9349-af8c2dcd99a4", "q": "In a linked list representation of a Queue, where do insertions and deletions occur?", "options": ["Insertions at front, deletions at rear", "Insertions at rear, deletions at front", "Both insertions and deletions at front", "Both insertions and deletions at rear"], "answer": 1, "hint": "To follow the FIFO principle, new nodes are appended at one end and removed from the other.", "explanation": "In a linked list queue, new elements are inserted at the rear or tail of the list, and elements are deleted from the front or head." }, { "id": "d080b2a1-847a-4196-8b11-36b8e5ab7e51", "q": "Which pointer(s) must be maintained in a linked list implementation of a Queue to ensure O(1) operations?", "options": ["Only front pointer", "Only rear pointer", "Both front and rear pointers", "No pointers are needed"], "answer": 2, "hint": "We need quick access to both the beginning and the end of the list.", "explanation": "Maintaining both front and rear pointers allows us to enqueue at the rear and dequeue from the front in O(1) time without traversing the list." }, { "id": "cefa77cc-3233-4c00-ac77-60d69522b64c", "q": "In the linked list representation of a Queue, what is the value of front and rear pointers when the Queue is empty?", "options": ["front NULL and rear NULL", "front 0 and rear -1", "front == NULL and rear != NULL", "front != NULL and rear == NULL"], "answer": 0, "hint": "Since there are no nodes in the list, both pointers point to nothing.", "explanation": "When the queue is empty, there are no nodes in the linked list, so both front and rear pointers are set to NULL." }], topicId: "5.1" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Introduction to Queue", seoDesc: "Master Introduction to Queue with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "introduction to queue, introduction to queue notes, introduction to queue 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."); }