"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", 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 }, {Analogy, Answer, Assessment, CodeBlock, ComparisonTable, ContentAttribution, DefinitionEntry, DefinitionGroup, English, Explanation, FormulaBox, Hinglish, HowItWorks, ImportantQA, KeyPoints, MCQ, Practical, Prompt, QAQuestion, SubTopicHeader, Theory, TopicOverview} = _components; if (!Analogy) _missingMdxReference("Analogy", true); 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 (!FormulaBox) _missingMdxReference("FormulaBox", 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 (!SubTopicHeader) _missingMdxReference("SubTopicHeader", true); if (!Theory) _missingMdxReference("Theory", true); if (!TopicOverview) _missingMdxReference("TopicOverview", true); return _jsxs(_Fragment, { children: [_jsxs(Theory, { children: [_jsx(SubTopicHeader, { id: "3.3", title: "Operations on Arrays" }), _jsxs(TopicOverview, { title: "Operations on Arrays", topicId: "3.3", readingTime: "14 min read", difficulty: "Medium", children: [_jsx(English, { children: _jsx(_components.p, { children: "Arrays are not just collections of data sitting idle in memory — they are dynamic structures that support a rich set of operations. In this subtopic, we explore the fundamental operations that can be performed on arrays: traversal, insertion, deletion, searching, sorting, and updating. Understanding these operations is essential because they form the backbone of data manipulation in C programming. From simply visiting each element to sorting thousands of records, these operations are used everywhere — in databases, scientific computing, game development, and everyday applications." }) }), _jsx(Hinglish, { children: _jsx(_components.p, { children: "Arrays sirf data ke collections nahi hain jo memory mein baithe rehte hain — yeh kaafi dynamic structures hain jinpe bahut saare operations perform kiye ja sakte hain. Is subtopic mein hum arrays pe perform hone wale fundamental operations explore karenge: traversal, insertion, deletion, searching, sorting, aur updating. In operations ko samajhna bahut zaroori hai kyunki yeh C programming mein data manipulation ka foundation hain. Chahe sirf har element ko visit karna ho ya hazaaron records ko sort karna ho — yeh operations har jagah use hote hain: databases mein, scientific computing mein, game development mein, aur aam applications mein." }) })] }), _jsxs(DefinitionGroup, { children: [_jsxs(DefinitionEntry, { term: "Array Traversal", children: [_jsx(English, { children: _jsx(_components.p, { children: "Array traversal is the process of visiting each element of an array one by one, typically from the first element to the last. It is the most basic operation and is a building block for almost every other array operation. For example, printing all marks of students in a class requires traversing the marks array completely." }) }), _jsx(Hinglish, { children: _jsx(_components.p, { children: "Array traversal ka matlab hai array ke har element ko ek ek karke visit karna, usually first element se last tak. Yeh sabse basic operation hai aur lagbhag har doosre array operation ki foundation hai. Jaise, ek class ke saare students ke marks print karna — iske liye poore marks array ko traverse karna padta hai." }) })] }), _jsxs(DefinitionEntry, { term: "Linear Search", children: [_jsx(English, { children: _jsx(_components.p, { children: "Linear search (also called sequential search) is a searching technique where you check each element of the array one by one from the beginning until the target value is found or the array ends. It works on both sorted and unsorted arrays but has a time complexity of O(n), making it slow for large datasets." }) }), _jsx(Hinglish, { children: _jsx(_components.p, { children: "Linear search (ise sequential search bhi kehte hain) ek aisi searching technique hai jisme tum array ke first element se last tak ek ek karke check karte ho ki target value mila ya nahi. Yeh sorted aur unsorted arrays dono pe kaam karta hai, lekin iski time complexity O(n) hoti hai, jo bade datasets ke liye slow ban jaata hai." }) })] }), _jsxs(DefinitionEntry, { term: "Binary Search", children: [_jsx(English, { children: _jsxs(_components.p, { children: ["Binary search is an efficient searching algorithm that works only on ", _jsx(_components.strong, { children: "sorted arrays" }), ". It repeatedly divides the search interval in half — comparing the target with the middle element and eliminating half of the remaining elements at each step. Its time complexity is O(log n), making it significantly faster than linear search for large arrays."] }) }), _jsx(Hinglish, { children: _jsxs(_components.p, { children: ["Binary search ek efficient searching algorithm hai jo sirf ", _jsx(_components.strong, { children: "sorted arrays" }), " pe kaam karta hai. Yeh baar baar search interval ko half divide karta hai — target ko middle element se compare karta hai aur har step mein baaki elements ka aadha eliminate kar deta hai. Iski time complexity O(log n) hai, jo ise linear search se kafi fast banata hai bade arrays ke liye."] }) })] }), _jsxs(DefinitionEntry, { term: "Bubble Sort", children: [_jsx(English, { children: _jsx(_components.p, { children: "Bubble sort is a simple sorting algorithm that repeatedly steps through the array, compares adjacent elements, and swaps them if they are in the wrong order. The largest unsorted element \"bubbles up\" to its correct position after each pass. It has a time complexity of O(n²), making it suitable for small datasets but inefficient for large ones." }) }), _jsx(Hinglish, { children: _jsx(_components.p, { children: "Bubble sort ek simple sorting algorithm hai jo baar baar array ke through step karta hai, adjacent elements ko compare karta hai, aur agar woh galat order mein hain toh unhe swap kar deta hai. Har pass ke baad sabse bada unsorted element apni sahi position pe \"bubble\" ho jaata hai. Iski time complexity O(n²) hai, jo ise chhote datasets ke liye sahi hai lekin bade datasets ke liye inefficient hai." }) })] }), _jsxs(DefinitionEntry, { term: "Selection Sort", children: [_jsx(English, { children: _jsx(_components.p, { children: "Selection sort works by repeatedly finding the minimum (or maximum) element from the unsorted portion of the array and placing it at the beginning. It selects the smallest element and swaps it with the first unsorted element, then moves the boundary of the sorted portion one step forward. Its time complexity is also O(n²)." }) }), _jsx(Hinglish, { children: _jsx(_components.p, { children: "Selection sort kaam karta hai array ke unsorted portion mein se baar baar minimum (ya maximum) element dhundhkar aur use beginning pe rakh kar. Yeh sabse chhota element select karta hai aur use first unsorted element ke saath swap kar deta hai, phir sorted portion ki boundary ek step aage badha deta hai. Iski time complexity bhi O(n²) hai." }) })] }), _jsxs(DefinitionEntry, { term: "Insertion Sort", children: [_jsx(English, { children: _jsx(_components.p, { children: "Insertion sort builds the sorted array one element at a time by picking each element and inserting it into its correct position among the previously sorted elements. It works similarly to how we sort playing cards in our hands — picking one card at a time and placing it in the right spot. Its worst-case time complexity is O(n²), but it performs well (O(n)) on nearly sorted data." }) }), _jsx(Hinglish, { children: _jsx(_components.p, { children: "Insertion sort sorted array ko ek ek element karke banata hai — har element ko pick karta hai aur pehle se sorted elements ke beech mein uski sahi position pe insert karta hai. Yeh bilkul waise kaam karta hai jaise hum apne haath mein playing cards ko sort karte hain — ek ek card uthate aur sahi jagah pe rakhte hain. Iski worst-case time complexity O(n²) hai, lekin nearly sorted data pe yeh O(n) tak perform karta hai." }) })] })] }), _jsxs(Explanation, { children: [_jsxs(English, { children: [_jsx(_components.h3, { children: "🖥️ Array Traversal" }), _jsxs(_components.p, { children: ["Traversal is the foundation of all array operations. The idea is simple: use a loop to access every element of the array from index ", _jsx(_components.code, { children: "0" }), " to ", _jsx(_components.code, { children: "n-1" }), ". This can be done using a ", _jsx(_components.code, { children: "for" }), " loop, ", _jsx(_components.code, { children: "while" }), " loop, or ", _jsx(_components.code, { children: "do-while" }), " loop. In practice, the ", _jsx(_components.code, { children: "for" }), " loop is most commonly used because the number of iterations is known in advance."] }), _jsx(_components.h3, { children: "🔍 Searching in Arrays" }), _jsxs(_components.p, { children: ["Searching means finding whether a particular value exists in the array and at which position. There are two primary techniques: ", _jsx(_components.strong, { children: "Linear Search" }), " and ", _jsx(_components.strong, { children: "Binary Search" }), "."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Linear Search" }), " is straightforward — you start from the first element and check each element one by one until you find the target or reach the end. It works on both sorted and unsorted arrays but takes O(n) time."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Binary Search" }), " is much faster at O(log n) but requires the array to be ", _jsx(_components.strong, { children: "sorted first" }), ". It works by comparing the target with the middle element — if the target is smaller, search the left half; if larger, search the right half. This halves the search space at every step."] }), _jsx(_components.h3, { children: "🔃 Array Insertion" }), _jsxs(_components.p, { children: ["Insertion means adding a new element at a specific position in the array. Since arrays have fixed size in C, inserting an element requires ", _jsx(_components.strong, { children: "shifting" }), " all subsequent elements one position to the right to make space. The steps are:"] }), _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Check if the array has space (i.e., current size is less than declared capacity)." }), "\n", _jsx(_components.li, { children: "Start from the last element and shift each element one position to the right." }), "\n", _jsx(_components.li, { children: "Place the new element at the desired position." }), "\n", _jsx(_components.li, { children: "Increment the current size." }), "\n"] }), _jsx(_components.h3, { children: "❌ Array Deletion" }), _jsxs(_components.p, { children: ["Deletion means removing an element from a specific position. Similar to insertion, this requires ", _jsx(_components.strong, { children: "shifting" }), " elements — but this time to the left. The steps are:"] }), _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Find the element to be deleted (using search)." }), "\n", _jsx(_components.li, { children: "Shift all elements after the target one position to the left." }), "\n", _jsx(_components.li, { children: "Decrement the current size." }), "\n"] }), _jsx(_components.h3, { children: "📊 Sorting Algorithms" }), _jsx(_components.p, { children: "Sorting arranges array elements in ascending or descending order. We cover three fundamental sorting algorithms:" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Bubble Sort" }), " — Compare adjacent elements and swap if they are in wrong order. After each pass, the largest element reaches its correct position. It requires up to ", _jsx(_components.code, { children: "n-1" }), " passes."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Selection Sort" }), " — Find the minimum element from the unsorted portion and swap it with the first unsorted element. Repeat until the entire array is sorted."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Insertion Sort" }), " — Pick each element and insert it into its correct position in the sorted portion. Like sorting cards in hand."] }), _jsx(_components.h3, { children: "🔄 Updating Elements" }), _jsxs(_components.p, { children: ["Updating is the simplest operation — just access the element by its index and assign a new value. For example, ", _jsx(_components.code, { children: "arr[3] = 50;" }), " changes the value at index 3 to 50."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "🖥️ Array Traversal" }), _jsxs(_components.p, { children: ["Traversal sabse pehla aur basic operation hai. Idea simple hai: ek loop use karo jo array ke har element ko index ", _jsx(_components.code, { children: "0" }), " se ", _jsx(_components.code, { children: "n-1" }), " tak access kare. Yeh ", _jsx(_components.code, { children: "for" }), " loop, ", _jsx(_components.code, { children: "while" }), " loop, ya ", _jsx(_components.code, { children: "do-while" }), " loop se ho sakta hai. Practically mein ", _jsx(_components.code, { children: "for" }), " loop sabse zyada use hota hai kyunki iterations ki sankhya pehle se pata hoti hai."] }), _jsx(_components.h3, { children: "🔍 Searching in Arrays" }), _jsxs(_components.p, { children: ["Searching ka matlab hai pata lagana ki koi particular value array mein hai bhi ya nahi, aur agar hai toh kahan hai. Do primary techniques hain: ", _jsx(_components.strong, { children: "Linear Search" }), " aur ", _jsx(_components.strong, { children: "Binary Search" }), "."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Linear Search" }), " simple hai — tum first element se start karte ho aur ek ek karke har element check karte ho jab tak target na mil jaye ya array khatam na ho jaye. Yeh sorted aur unsorted dono arrays pe kaam karta hai lekin O(n) time leta hai."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Binary Search" }), " kaafi fast hai O(log n) pe lekin iske liye array ", _jsx(_components.strong, { children: "pehle se sorted hona zaroori hai" }), ". Yeh target ko middle element se compare karke kaam karta hai — agar target chhota hai toh left half mein dhundho, agar bada hai toh right half mein. Har step mein search space half ho jaata hai."] }), _jsx(_components.h3, { children: "🔃 Array Insertion" }), _jsxs(_components.p, { children: ["Insertion ka matlab hai array mein kisi specific position pe naya element daalna. C mein arrays ki fixed size hoti hai, isliye insertion ke liye target position ke baad ke saare elements ko ", _jsx(_components.strong, { children: "shift" }), " karna padta hai — ek position right taraf — taaki jagah ban sake. Steps yeh hain:"] }), _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Check karo ki array mein jagah hai ya nahi (current size, capacity se chhota hai)." }), "\n", _jsx(_components.li, { children: "Last element se start karke har element ko ek position right shift karo." }), "\n", _jsx(_components.li, { children: "Naya element desired position pe rakho." }), "\n", _jsx(_components.li, { children: "Current size increment karo." }), "\n"] }), _jsx(_components.h3, { children: "❌ Array Deletion" }), _jsx(_components.p, { children: "Deletion ka matlab hai array se kisi specific position se element hataana. Insertion ki tarah, isme bhi elements ko shift karna padta hai — lekin is baar left taraf. Steps yeh hain:" }), _jsxs(_components.ol, { children: ["\n", _jsx(_components.li, { children: "Jis element ko delete karna hai use dhundho (search karke)." }), "\n", _jsx(_components.li, { children: "Target element ke baad ke saare elements ko ek position left shift karo." }), "\n", _jsx(_components.li, { children: "Current size decrement karo." }), "\n"] }), _jsx(_components.h3, { children: "📊 Sorting Algorithms" }), _jsx(_components.p, { children: "Sorting array elements ko ascending ya descending order mein arrange karta hai. Hum teen fundamental sorting algorithms cover karenge:" }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Bubble Sort" }), " — Adjacent elements ko compare karo aur agar galat order mein ho toh swap karo. Har pass ke baad sabse bada element apni sahi position pe pahunch jaata hai. Maximum ", _jsx(_components.code, { children: "n-1" }), " passes lagte hain."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Selection Sort" }), " — Unsorted portion mein se minimum element dhundho aur first unsorted element ke saath swap karo. Poora array sorted na ho jaane tak repeat karo."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Insertion Sort" }), " — Har element ko pick karo aur sorted portion mein uski sahi position pe insert karo. Bilkul jaise haath mein cards sort karte hain."] }), _jsx(_components.h3, { children: "🔄 Updating Elements" }), _jsxs(_components.p, { children: ["Updating sabse simple operation hai — bas element ko uske index pe access karo aur nayi value assign karo. Jaise, ", _jsx(_components.code, { children: "arr[3] = 50;" }), " se index 3 pe value 50 ho jaati hai."] })] }), _jsx(_components.pre, { children: _jsx(_components.code, { className: "language-mermaid", children: "flowchart TD\r\n A[\"⚡ Array Operations\"] --> B[\"🔄 Traversal\"]\r\n A --> C[\"➕ Insertion\"]\r\n A --> D[\"➖ Deletion\"]\r\n A --> E[\"🔍 Searching\"]\r\n A --> F[\"📊 Sorting\"]\r\n A --> G[\"✏️ Updating\"]\r\n E --> E1[\"Linear Search — O(n)\"]\r\n E --> E2[\"Binary Search — O(log n)\"]\r\n F --> F1[\"Bubble Sort\"]\r\n F --> F2[\"Selection Sort\"]\r\n F --> F3[\"Insertion Sort\"]\r\n style A fill:#2563eb,color:#fff,stroke:#1e40af\r\n style E fill:#059669,color:#fff,stroke:#047857\r\n style F fill:#dc2626,color:#fff,stroke:#b91c1c\n" }) }), _jsxs(HowItWorks, { title: "Insertion in an Array — Step by Step", children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Scenario:" }), " Insert value ", _jsx(_components.code, { children: "25" }), " at position ", _jsx(_components.code, { children: "3" }), " in array ", _jsx(_components.code, { children: "[10, 20, 30, 40, 50]" }), " (size = 5)"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 1:" }), " Start from the last element (index 4)."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 2:" }), " Shift ", _jsx(_components.code, { children: "arr[4]" }), " (50) to index 5 → ", _jsx(_components.code, { children: "[10, 20, 30, 40, _, 50]" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 3:" }), " Shift ", _jsx(_components.code, { children: "arr[3]" }), " (40) to index 4 → ", _jsx(_components.code, { children: "[10, 20, 30, _, 40, 50]" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 4:" }), " Shift ", _jsx(_components.code, { children: "arr[2]" }), " (30) to index 3 → ", _jsx(_components.code, { children: "[10, 20, _, 30, 40, 50]" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 5:" }), " Place ", _jsx(_components.code, { children: "25" }), " at index 2 → ", _jsx(_components.code, { children: "[10, 20, 25, 30, 40, 50]" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 6:" }), " New size = 6. ✅"] })] }), _jsxs(HowItWorks, { title: "Deletion from an Array — Step by Step", children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Scenario:" }), " Delete element at position ", _jsx(_components.code, { children: "2" }), " (value 25) from array ", _jsx(_components.code, { children: "[10, 20, 25, 30, 40, 50]" }), " (size = 6)"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 1:" }), " Identify element at index 2 → value is ", _jsx(_components.code, { children: "25" }), "."] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 2:" }), " Shift ", _jsx(_components.code, { children: "arr[3]" }), " (30) to index 2 → ", _jsx(_components.code, { children: "[10, 20, 30, _, 40, 50]" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 3:" }), " Shift ", _jsx(_components.code, { children: "arr[4]" }), " (40) to index 3 → ", _jsx(_components.code, { children: "[10, 20, 30, 40, _, 50]" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 4:" }), " Shift ", _jsx(_components.code, { children: "arr[5]" }), " (50) to index 4 → ", _jsx(_components.code, { children: "[10, 20, 30, 40, 50, _]" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Step 5:" }), " New size = 5. ✅"] })] }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Code — Array Traversal" }), _jsx(_components.p, { children: "Below is a program that declares an integer array, initializes it, and prints all elements using traversal." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Code — Array Traversal" }), _jsx(_components.p, { children: "Niche ek program hai jo ek integer array declare karta hai, initialize karta hai, aur traversal use karke saare elements print karta hai." })] }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int arr[] = {10, 20, 30, 40, 50}; int n = 5; printf("Array elements: "); for (int i = 0; i < n; i++) { printf("%d ", arr[i]); } printf("\\n"); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Code — Linear Search" }), _jsx(_components.p, { children: "The program below searches for a target value in the array. If found, it prints the index; otherwise, it prints \"not found\"." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Code — Linear Search" }), _jsx(_components.p, { children: "Niche ka program array mein ek target value dhundhta hai. Agar mil jaata hai toh index print karta hai, nahi mila toh \"not found\" print karta hai." })] }), _jsx(CodeBlock, { language: "c", children: `#include int linearSearch(int arr[], int n, int target) { for (int i = 0; i < n; i++) { if (arr[i] == target) { return i; // Found at index i } } return -1; // Not found } int main() { int arr[] = {12, 45, 67, 23, 89, 34}; int n = 6; int target = 23; int result = linearSearch(arr, n, target); if (result != -1) printf("Element %d found at index %d\\n", target, result); else printf("Element %d not found\\n", target); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Code — Binary Search" }), _jsxs(_components.p, { children: ["This program performs binary search on a ", _jsx(_components.strong, { children: "sorted" }), " array. It compares the target with the middle element and narrows the search to half of the array in each iteration."] })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Code — Binary Search" }), _jsxs(_components.p, { children: ["Yeh program ek ", _jsx(_components.strong, { children: "sorted" }), " array pe binary search perform karta hai. Yeh target ko middle element se compare karta hai aur har iteration mein search ko array ke aadhe hisse tak narrow kar deta hai."] })] }), _jsx(CodeBlock, { language: "c", children: `#include int binarySearch(int arr[], int n, int target) { int low = 0, high = n - 1; while (low <= high) { int mid = (low + high) / 2; if (arr[mid] == target) return mid; // Found else if (arr[mid] < target) low = mid + 1; // Search right half else high = mid - 1; // Search left half } return -1; // Not found } int main() { int arr[] = {10, 25, 30, 45, 50, 67, 80}; int n = 7; int target = 45; int result = binarySearch(arr, n, target); if (result != -1) printf("Element %d found at index %d\\n", target, result); else printf("Element %d not found\\n", target); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Code — Insertion in an Array" }), _jsx(_components.p, { children: "The program below inserts a new element at a given position by shifting subsequent elements to the right." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Code — Insertion in an Array" }), _jsx(_components.p, { children: "Niche ka program ek naya element diye gaye position pe insert karta hai — baaki elements ko right shift karke jagah banata hai." })] }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int arr[10] = {10, 20, 30, 40, 50}; int n = 5; // current number of elements int pos = 2; // insert at index 2 int val = 25; // value to insert // Shift elements to the right for (int i = n - 1; i >= pos; i--) { arr[i + 1] = arr[i]; } // Insert the new element arr[pos] = val; n++; printf("After insertion: "); for (int i = 0; i < n; i++) { printf("%d ", arr[i]); } printf("\\n"); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Code — Deletion from an Array" }), _jsx(_components.p, { children: "The program below deletes an element at a given position by shifting subsequent elements to the left." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Code — Deletion from an Array" }), _jsx(_components.p, { children: "Niche ka program ek element ko diye gaye position se delete karta hai — baaki elements ko left shift karke." })] }), _jsx(CodeBlock, { language: "c", children: `#include int main() { int arr[10] = {10, 20, 25, 30, 40, 50}; int n = 6; // current number of elements int pos = 2; // delete element at index 2 printf("Deleted element: %d\\n", arr[pos]); // Shift elements to the left for (int i = pos; i < n - 1; i++) { arr[i] = arr[i + 1]; } n--; printf("After deletion: "); for (int i = 0; i < n; i++) { printf("%d ", arr[i]); } printf("\\n"); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Code — Bubble Sort" }), _jsx(_components.p, { children: "This is the classic Bubble Sort implementation. In each pass, adjacent elements are compared and swapped if they are in the wrong order. After each pass, the largest unsorted element moves to its correct position." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Code — Bubble Sort" }), _jsx(_components.p, { children: "Yeh classic Bubble Sort implementation hai. Har pass mein adjacent elements compare kiye jaate hain aur agar galat order mein hain toh swap kiye jaate hain. Har pass ke baad sabse bada unsorted element apni sahi position pe chala jaata hai." })] }), _jsx(CodeBlock, { language: "c", children: `#include void bubbleSort(int arr[], int n) { for (int i = 0; i < n - 1; i++) { int swapped = 0; // Optimization flag for (int j = 0; j < n - 1 - i; j++) { if (arr[j] > arr[j + 1]) { // Swap arr[j] and arr[j+1] int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; swapped = 1; } } if (swapped == 0) break; // Array already sorted } } int main() { int arr[] = {64, 34, 25, 12, 22, 11, 90}; int n = 7; bubbleSort(arr, n); printf("Sorted array: "); for (int i = 0; i < n; i++) printf("%d ", arr[i]); printf("\\n"); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Code — Selection Sort" }), _jsx(_components.p, { children: "In Selection Sort, the algorithm finds the minimum element from the unsorted portion and swaps it with the first unsorted element. This process repeats until the array is fully sorted." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Code — Selection Sort" }), _jsx(_components.p, { children: "Selection Sort mein algorithm unsorted portion mein se minimum element dhundhta hai aur use first unsorted element ke saath swap kar deta hai. Yeh process tab tak repeat hota hai jab tak poora array sorted na ho jaaye." })] }), _jsx(CodeBlock, { language: "c", children: `#include void selectionSort(int arr[], int n) { for (int i = 0; i < n - 1; i++) { int minIdx = i; for (int j = i + 1; j < n; j++) { if (arr[j] < arr[minIdx]) { minIdx = j; } } // Swap the found minimum with arr[i] if (minIdx != i) { int temp = arr[i]; arr[i] = arr[minIdx]; arr[minIdx] = temp; } } } int main() { int arr[] = {64, 25, 12, 22, 11}; int n = 5; selectionSort(arr, n); printf("Sorted array: "); for (int i = 0; i < n; i++) printf("%d ", arr[i]); printf("\\n"); return 0; }` }), _jsxs(English, { children: [_jsx(_components.h3, { children: "📝 Code — Insertion Sort" }), _jsx(_components.p, { children: "In Insertion Sort, each element is picked and placed into its correct position among the already sorted elements. This is similar to how you sort cards in your hand — you pick one card and slide it into the right place." })] }), _jsxs(Hinglish, { children: [_jsx(_components.h3, { children: "📝 Code — Insertion Sort" }), _jsx(_components.p, { children: "Insertion Sort mein har element ko pick karke pehle se sorted elements ke beech mein uski sahi position pe insert kiya jaata hai. Yeh bilkul waise hai jaise tum apne haath mein cards ko sort karte ho — ek card uthate ho aur sahi jagah pe slide karte ho." })] }), _jsx(CodeBlock, { language: "c", children: `#include void insertionSort(int arr[], int n) { for (int i = 1; i < n; i++) { int key = arr[i]; int j = i - 1; // Shift elements that are greater than key while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; j--; } arr[j + 1] = key; } } int main() { int arr[] = {12, 11, 13, 5, 6}; int n = 5; insertionSort(arr, n); printf("Sorted array: "); for (int i = 0; i < n; i++) printf("%d ", arr[i]); printf("\\n"); return 0; }` }), _jsx(ComparisonTable, { title: "Sorting Algorithms — Comparison", 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: "Bubble Sort" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Selection Sort" }), _jsx(_components.th, { style: { textAlign: "left" }, children: "Insertion Sort" })] }) }), _jsxs(_components.tbody, { children: [_jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Best Case Time" }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_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: ")" })] }) }) }), " (already sorted)"] }), _jsx(_components.td, { style: { textAlign: "left" }, children: _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: "1.0641em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "msupsub", children: _jsx(_components.span, { className: "vlist-t", children: _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.8141em" }, children: _jsxs(_components.span, { style: { top: "-3.063em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: "2" }) })] }) }) }) }) })] }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) }) }), _jsxs(_components.td, { style: { textAlign: "left" }, children: [_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: ")" })] }) }) }), " (already sorted)"] })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Worst Case Time" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _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: "1.0641em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "msupsub", children: _jsx(_components.span, { className: "vlist-t", children: _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.8141em" }, children: _jsxs(_components.span, { style: { top: "-3.063em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: "2" }) })] }) }) }) }) })] }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _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: "1.0641em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "msupsub", children: _jsx(_components.span, { className: "vlist-t", children: _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.8141em" }, children: _jsxs(_components.span, { style: { top: "-3.063em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: "2" }) })] }) }) }) }) })] }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _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: "1.0641em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "msupsub", children: _jsx(_components.span, { className: "vlist-t", children: _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.8141em" }, children: _jsxs(_components.span, { style: { top: "-3.063em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: "2" }) })] }) }) }) }) })] }), _jsx(_components.span, { className: "mclose", children: ")" })] }) }) }) })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Space Complexity" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _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: ")" })] }) }) }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _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: ")" })] }) }) }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: _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.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Stable?" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "✅ Yes" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "❌ No" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "✅ Yes" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Adaptive?" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "✅ Yes (with optimization)" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "❌ No" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "✅ Yes" })] }), _jsxs(_components.tr, { children: [_jsx(_components.td, { style: { textAlign: "left" }, children: _jsx(_components.strong, { children: "Best For" }) }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Nearly sorted data" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Small datasets" }), _jsx(_components.td, { style: { textAlign: "left" }, children: "Nearly sorted data" })] })] })] }) }), _jsxs(HowItWorks, { title: "Bubble Sort — Dry Run", children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Array:" }), " ", _jsx(_components.code, { children: "[64, 34, 25, 12]" })] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Pass 1:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Compare 64 & 34 → Swap → ", _jsx(_components.code, { children: "[34, 64, 25, 12]" })] }), "\n", _jsxs(_components.li, { children: ["Compare 64 & 25 → Swap → ", _jsx(_components.code, { children: "[34, 25, 64, 12]" })] }), "\n", _jsxs(_components.li, { children: ["Compare 64 & 12 → Swap → ", _jsx(_components.code, { children: "[34, 25, 12, 64]" }), " ✅ 64 in correct place"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Pass 2:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Compare 34 & 25 → Swap → ", _jsx(_components.code, { children: "[25, 34, 12, 64]" })] }), "\n", _jsxs(_components.li, { children: ["Compare 34 & 12 → Swap → ", _jsx(_components.code, { children: "[25, 12, 34, 64]" }), " ✅ 34 in correct place"] }), "\n"] }), _jsx(_components.p, { children: _jsx(_components.strong, { children: "Pass 3:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: ["Compare 25 & 12 → Swap → ", _jsx(_components.code, { children: "[12, 25, 34, 64]" }), " ✅ 25 in correct place"] }), "\n"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Result:" }), " ", _jsx(_components.code, { children: "[12, 25, 34, 64]" }), " — Sorted! 🎉"] })] }), _jsxs(HowItWorks, { title: "Binary Search — Dry Run", children: [_jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Sorted Array:" }), " ", _jsx(_components.code, { children: "[10, 25, 30, 45, 50, 67, 80]" }), ", ", _jsx(_components.strong, { children: "Target:" }), " ", _jsx(_components.code, { children: "45" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Iteration 1:" }), " low=\"0,\" high=\"6,\" mid=\"3\" → ", _jsx(_components.code, { children: "arr[3]=45" }), " == target → ", _jsx(_components.strong, { children: "Found at index 3!" }), " ✅"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Another example — Target:" }), " ", _jsx(_components.code, { children: "67" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Iteration 1:" }), " low=\"0,\" high=\"6,\" mid=\"3\" → ", _jsx(_components.code, { children: "arr[3]=45" }), " ", "<", " 67 → low=\"4\"\r\n", _jsx(_components.strong, { children: "Iteration 2:" }), " low=\"4,\" high=\"6,\" mid=\"5\" → ", _jsx(_components.code, { children: "arr[5]=67" }), " == target → ", _jsx(_components.strong, { children: "Found at index 5!" }), " ✅"] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Another example — Target:" }), " ", _jsx(_components.code, { children: "15" })] }), _jsxs(_components.p, { children: [_jsx(_components.strong, { children: "Iteration 1:" }), " low=\"0,\" high=\"6,\" mid=\"3\" → ", _jsx(_components.code, { children: "arr[3]=45" }), " > 15 → high=\"2\"\r\n", _jsx(_components.strong, { children: "Iteration 2:" }), " low=\"0,\" high=\"2,\" mid=\"1\" → ", _jsx(_components.code, { children: "arr[1]=25" }), " > 15 → high=\"0\"\r\n", _jsx(_components.strong, { children: "Iteration 3:" }), " low=\"0,\" high=\"0,\" mid=\"0\" → ", _jsx(_components.code, { children: "arr[0]=10" }), " ", "<", " 15 → low=\"1\"\r\n", _jsx(_components.strong, { children: "Iteration 4:" }), " low=\"1,\" high=\"0\" → low > high → ", _jsx(_components.strong, { children: "Not Found" }), " ❌"] })] }), _jsxs(FormulaBox, { title: "Time Complexity Summary", children: [_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: "1em", verticalAlign: "-0.25em" } }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "T" }), _jsx(_components.span, { className: "msupsub", children: _jsxs(_components.span, { className: "vlist-t vlist-t2", children: [_jsxs(_components.span, { className: "vlist-r", children: [_jsx(_components.span, { className: "vlist", style: { height: "0.3361em" }, children: _jsxs(_components.span, { style: { top: "-2.55em", marginLeft: "-0.1389em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: _jsx(_components.span, { className: "mord text mtight", children: _jsx(_components.span, { className: "mord mtight", children: "Linear Search" }) }) }) })] }) }), _jsx(_components.span, { className: "vlist-s", children: "" })] }), _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.15em" }, children: _jsx(_components.span, {}) }) })] }) })] }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" }), _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: "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: ")" })] })] }) }) }), _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: "1.0361em", verticalAlign: "-0.2861em" } }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "T" }), _jsx(_components.span, { className: "msupsub", children: _jsxs(_components.span, { className: "vlist-t vlist-t2", children: [_jsxs(_components.span, { className: "vlist-r", children: [_jsx(_components.span, { className: "vlist", style: { height: "0.3361em" }, children: _jsxs(_components.span, { style: { top: "-2.55em", marginLeft: "-0.1389em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: _jsx(_components.span, { className: "mord text mtight", children: _jsx(_components.span, { className: "mord mtight", children: "Binary Search" }) }) }) })] }) }), _jsx(_components.span, { className: "vlist-s", children: "" })] }), _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.2861em" }, children: _jsx(_components.span, {}) }) })] }) })] }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" }), _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: "1em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsxs(_components.span, { className: "mop", children: ["lo", _jsx(_components.span, { style: { marginRight: "0.0139em" }, children: "g" })] }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.1667em" } }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" })] })] }) }) }), _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: "1em", verticalAlign: "-0.25em" } }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "T" }), _jsx(_components.span, { className: "msupsub", children: _jsxs(_components.span, { className: "vlist-t vlist-t2", children: [_jsxs(_components.span, { className: "vlist-r", children: [_jsx(_components.span, { className: "vlist", style: { height: "0.3361em" }, children: _jsxs(_components.span, { style: { top: "-2.55em", marginLeft: "-0.1389em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: _jsx(_components.span, { className: "mord text mtight", children: _jsx(_components.span, { className: "mord mtight", children: "Bubble Sort" }) }) }) })] }) }), _jsx(_components.span, { className: "vlist-s", children: "" })] }), _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.15em" }, children: _jsx(_components.span, {}) }) })] }) })] }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" }), _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: "1.1141em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "msupsub", children: _jsx(_components.span, { className: "vlist-t", children: _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.8641em" }, children: _jsxs(_components.span, { style: { top: "-3.113em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: "2" }) })] }) }) }) }) })] }), _jsx(_components.span, { className: "mclose", children: ")" })] })] }) }) }), _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: "1em", verticalAlign: "-0.25em" } }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "T" }), _jsx(_components.span, { className: "msupsub", children: _jsxs(_components.span, { className: "vlist-t vlist-t2", children: [_jsxs(_components.span, { className: "vlist-r", children: [_jsx(_components.span, { className: "vlist", style: { height: "0.3361em" }, children: _jsxs(_components.span, { style: { top: "-2.55em", marginLeft: "-0.1389em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: _jsx(_components.span, { className: "mord text mtight", children: _jsx(_components.span, { className: "mord mtight", children: "Selection Sort" }) }) }) })] }) }), _jsx(_components.span, { className: "vlist-s", children: "" })] }), _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.15em" }, children: _jsx(_components.span, {}) }) })] }) })] }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" }), _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: "1.1141em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "msupsub", children: _jsx(_components.span, { className: "vlist-t", children: _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.8641em" }, children: _jsxs(_components.span, { style: { top: "-3.113em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: "2" }) })] }) }) }) }) })] }), _jsx(_components.span, { className: "mclose", children: ")" })] })] }) }) }), _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: "1em", verticalAlign: "-0.25em" } }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.1389em" }, children: "T" }), _jsx(_components.span, { className: "msupsub", children: _jsxs(_components.span, { className: "vlist-t vlist-t2", children: [_jsxs(_components.span, { className: "vlist-r", children: [_jsx(_components.span, { className: "vlist", style: { height: "0.3283em" }, children: _jsxs(_components.span, { style: { top: "-2.55em", marginLeft: "-0.1389em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: _jsx(_components.span, { className: "mord text mtight", children: _jsx(_components.span, { className: "mord mtight", children: "Insertion Sort" }) }) }) })] }) }), _jsx(_components.span, { className: "vlist-s", children: "" })] }), _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.15em" }, children: _jsx(_components.span, {}) }) })] }) })] }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "mclose", children: ")" }), _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: "1.1141em", verticalAlign: "-0.25em" } }), _jsx(_components.span, { className: "mord mathnormal", style: { marginRight: "0.0278em" }, children: "O" }), _jsx(_components.span, { className: "mopen", children: "(" }), _jsxs(_components.span, { className: "mord", children: [_jsx(_components.span, { className: "mord mathnormal", children: "n" }), _jsx(_components.span, { className: "msupsub", children: _jsx(_components.span, { className: "vlist-t", children: _jsx(_components.span, { className: "vlist-r", children: _jsx(_components.span, { className: "vlist", style: { height: "0.8641em" }, children: _jsxs(_components.span, { style: { top: "-3.113em", marginRight: "0.05em" }, children: [_jsx(_components.span, { className: "pstrut", style: { height: "2.7em" } }), _jsx(_components.span, { className: "sizing reset-size6 size3 mtight", children: _jsx(_components.span, { className: "mord mtight", children: "2" }) })] }) }) }) }) })] }), _jsx(_components.span, { className: "mclose", children: ")" }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: " worst case" }) }), _jsx(_components.span, { className: "mpunct", children: "," }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.2778em" } }), _jsx(_components.span, { className: "mspace", style: { marginRight: "0.1667em" } }), _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: ")" }), _jsx(_components.span, { className: "mord text", children: _jsx(_components.span, { className: "mord", children: " best case" }) })] })] }) }) })] }), _jsxs(Analogy, { children: [_jsx(_components.p, { children: _jsx(_components.strong, { children: "Array Operations are like a Library System:" }) }), _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Traversal" }), " = Checking every shelf in the library one by one to find all books by a particular author. You visit each shelf sequentially."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Linear Search" }), " = Looking for a specific book by checking every shelf from the entrance until you find it. Slow, but works regardless of how books are organized."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Binary Search" }), " = If books are arranged alphabetically, you go to the middle shelf first. If the book comes after that letter, you skip the first half entirely. Much faster!"] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Insertion" }), " = Adding a new book to an already full shelf — you need to shift existing books to make space."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Deletion" }), " = Removing a book and then sliding the remaining books together so there's no gap."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Sorting" }), " = Arranging all books on a shelf in alphabetical order — picking and placing each book in the right spot."] }), "\n"] })] }), _jsx(KeyPoints, { children: _jsxs(_components.ul, { children: ["\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Traversal" }), " visits every element in the array using a loop — it is the foundation of all other operations."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Linear Search" }), " checks elements one by one — works on unsorted arrays but is O(n)."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Binary Search" }), " is O(log n) but ", _jsx(_components.strong, { children: "requires a sorted array" }), " — uses divide-and-conquer to eliminate half the search space each step."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Insertion" }), " and ", _jsx(_components.strong, { children: "Deletion" }), " both require ", _jsx(_components.strong, { children: "shifting elements" }), " — insertion shifts right, deletion shifts left."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Bubble Sort" }), " repeatedly swaps adjacent elements — largest element bubbles to the end each pass."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Selection Sort" }), " finds the minimum element from the unsorted portion and swaps it to the front."] }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Insertion Sort" }), " picks each element and slides it into its correct position — efficient for nearly sorted data."] }), "\n", _jsx(_components.li, { children: "All three sorting algorithms have O(n²) worst-case time, but Insertion Sort is O(n) for best (already sorted) input." }), "\n", _jsx(_components.li, { children: "All three sorting algorithms use O(1) extra space (in-place sorting)." }), "\n", _jsxs(_components.li, { children: [_jsx(_components.strong, { children: "Updating" }), " an element is the simplest operation — direct index access and assignment: ", _jsx(_components.code, { children: "arr[i] = newValue;" }), "."] }), "\n"] }) })] })] }), "\n", _jsx(Practical, { children: _jsxs(ImportantQA, { children: [_jsxs(QAQuestion, { marks: 2, children: [_jsx(Prompt, { children: "What is meant by traversal of an array? Explain with a simple example." }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 Definition ", _jsx(_components.strong, { children: "Traversal" }), " means visiting every element of an array exactly once, from the first element to the last (or vice versa), usually in a sequential manner. It is the most fundamental operation on an array. We use a ", _jsx(_components.strong, { children: "loop" }), " (typically a ", _jsx(_components.code, { children: "for" }), " loop) to access each element one by one using its index. ### 📝 Example Consider an array: ", _jsx(_components.code, { children: "arr[5] = {10, 20, 30, 40, 50}" }), " To traverse and print all elements: ", _jsx(_components.code, { children: "c for (int i = 0; i < 5; i++) { printf("%d ", arr[i]); } " }), " ", _jsx(_components.strong, { children: "Output:" }), " ", _jsx(_components.code, { children: "10 20 30 40 50" }), " Here, the loop variable ", _jsx(_components.code, { children: "i" }), " acts as the index and moves from ", _jsx(_components.code, { children: "0" }), " to ", _jsx(_components.code, { children: "4" }), ", visiting each element sequentially."] }) })] }), _jsxs(QAQuestion, { marks: 4, children: [_jsxs(Prompt, { children: ["Explain the Bubble Sort algorithm with a step-by-step trace. Sort the array ", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", "64, 25, 12, 22, 11", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", "\"", "{", "\"", "}", "\"", "}", " in ascending order."] }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 Bubble Sort Algorithm Bubble Sort is a simple sorting algorithm that repeatedly ", _jsx(_components.strong, { children: "compares adjacent elements" }), " and ", _jsx(_components.strong, { children: "swaps" }), " them if they are in the wrong order. After each full pass, the largest unsorted element \"bubbles up\" to its correct position. ", _jsx(_components.strong, { children: "Steps:" }), " 1. Compare adjacent elements. If the first is greater than the second, swap them. 2. Move to the next pair and repeat. 3. After one full pass, the largest element reaches the last position. 4. Repeat for the remaining unsorted portion until the entire array is sorted. ", _jsx(_components.strong, { children: "Time Complexity:" }), " Best Case: ", _jsx(_components.code, { children: "$O(n)$" }), ", Worst Case: ", _jsx(_components.code, { children: "$O(n^2)$" }), " ### 📝 Trace for ", _jsx(_components.code, { children: "{64, 25, 12, 22, 11}" }), " | Pass | Comparisons & Swaps | Array After Pass | |---|---|---| | ", _jsx(_components.strong, { children: "Pass 1" }), " | (64,25) swap, (64,12) swap, (64,22) swap, (64,11) swap | ", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", "25, 12, 22, 11, ", _jsx(_components.strong, { children: "64" }), "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", "\"", "{", "\"", "}", "\"", "}", " | | ", _jsx(_components.strong, { children: "Pass 2" }), " | (25,12) swap, (25,22) no swap, (25,11) swap | ", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", "12, 22, 11, ", _jsx(_components.strong, { children: "25" }), ", 64", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", "\"", "{", "\"", "}", "\"", "}", " | | ", _jsx(_components.strong, { children: "Pass 3" }), " | (12,22) no swap, (22,11) swap | ", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", "12, 11, ", _jsx(_components.strong, { children: "22" }), ", 25, 64", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", "\"", "{", "\"", "}", "\"", "}", " | | ", _jsx(_components.strong, { children: "Pass 4" }), " | (12,11) swap | ", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", _jsx(_components.strong, { children: "11" }), ", ", _jsx(_components.strong, { children: "12" }), ", 22, 25, 64", "{", "\"", "{", "\"", "}", "\"", "{", "\"", "}", "\"", "}", "\"", "{", "\"", "}", "\"", "}", " | ", _jsx(_components.strong, { children: "Sorted Array:" }), " ", _jsx(_components.code, { children: "{11, 12, 22, 25, 64}" }), " ### 💻 C Code for Bubble Sort ", _jsx(_components.code, { children: "c #include int main() { int arr[] = {64, 25, 12, 22, 11}; int n = 5, i, j, temp; for (i = 0; i < n - 1; i++) { for (j = 0; j < n - 1 - i; j++) { if (arr[j] > arr[j + 1]) { temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } printf("Sorted array: "); for (i = 0; i < n; i++) printf("%d ", arr[i]); return 0; } " }), " In Bubble Sort, the inner loop runs ", _jsx(_components.code, { children: "n-1-i" }), " times because after each pass, the last ", _jsx(_components.code, { children: "i" }), " elements are already in their correct sorted position."] }) })] }), _jsxs(QAQuestion, { marks: 6, children: [_jsx(Prompt, { children: "Write a complete C program that performs linear search on an array of integers. The program should accept n elements from the user, accept a key to search, and display the position if found or a 'not found' message otherwise." }), _jsx(Answer, { children: _jsxs(_components.h3, { children: ["🎯 What is Linear Search? ", _jsx(_components.strong, { children: "Linear Search" }), " (also called sequential search) checks each element of the array one by one from the beginning until the desired element (key) is found or the end of the array is reached. ", _jsx(_components.strong, { children: "Time Complexity:" }), " ", _jsx(_components.code, { children: "$O(n)$" }), " in the worst case. ### 📝 Algorithm (Step-by-Step) 1. Start from the first element (index ", _jsx(_components.code, { children: "0" }), "). 2. Compare the current element with the key. 3. If a match is found, return the index position. 4. If not found, move to the next element. 5. If the end of the array is reached without finding the key, report \"not found\". ### 💻 Complete C Program ", _jsx(_components.code, { children: "c #include int main() { int arr[100], n, key, i, found = 0; printf("Enter the number of elements: "); scanf("%d", &n); printf("Enter %d elements:\\n", n); for (i = 0; i < n; i++) { scanf("%d", &arr[i]); } printf("Enter the element to search: "); scanf("%d", &key); /* Linear Search */ for (i = 0; i < n; i++) { if (arr[i] == key) { printf("Element %d found at position %d.\\n", key, i + 1); found = 1; break; } } if (found == 0) { printf("Element %d not found in the array.\\n", key); } return 0; } " }), " ### 📋 Sample Output ", _jsx(_components.code, { children: " Enter the number of elements: 5 Enter 5 elements: 10 25 30 45 50 Enter the element to search: 30 Element 30 found at position 3. " }), " ### 🔑 Key Points to Remember - Linear search works on ", _jsx(_components.strong, { children: "both sorted and unsorted" }), " arrays. - It is simple to implement but ", _jsx(_components.strong, { children: "inefficient for large arrays" }), " compared to binary search. - The ", _jsx(_components.code, { children: "break" }), " statement is used to stop the loop as soon as the element is found, avoiding unnecessary comparisons. - We use a ", _jsx(_components.strong, { children: "flag variable" }), " (", _jsx(_components.code, { children: "found" }), ") to track whether the element was located or not. If the array has duplicate elements, linear search will always return the position of the ", _jsx(_components.strong, { children: "first occurrence" }), " because of the ", _jsx(_components.code, { children: "break" }), " statement. To find all occurrences, remove the ", _jsx(_components.code, { children: "break" }), " and collect all matching positions."] }) })] })] }) }), "\n", _jsxs(Assessment, { topicId: "3.3", children: [_jsx(MCQ, { questions: [{ "id": "98b5255a-79f6-430e-87c9-c75a33aa8f59", "q": "What is the default value of an uninitialized integer array element in C?", "options": ["Always 0", "Indeterminate (garbage value)", "-1", "NULL"], "answer": 1, "hint": "Consider the default value assigned to uninitialized array elements.", "explanation": "When an array is declared without explicit initialization, its elements contain indeterminate (garbage) values. This means the initial value is not necessarily zero." }, { "id": "74fbf575-ec29-4057-b8ae-1c2446e44c9d", "q": "Which loop structure is most commonly used to reverse the elements of a one-dimensional array?", "options": ["A single while loop with one index variable", "A single for loop with one index variable", "Two nested for loops where the inner loop depends on the outer loop's index", "A single for loop that swaps the element at index i with the element at index n-i-1"], "answer": 3, "hint": "The operation requires two nested loops, where the inner loop reverses the order for each pair of elements.", "explanation": "Swapping the first with the last, second with the second last, and so on, for half the array length, reverses the array." }, { "id": "f3690fb7-8e34-4d8e-8340-79e5b606dfb2", "q": "What is the time complexity of searching for an element in an unsorted array using the linear search method?", "options": ["O(n)", "O(log n)", "O(1)", "O(n^2)"], "answer": 0, "hint": "The time complexity is O(n) because each element must be checked.", "explanation": "Linear search sequentially examines each element until the target is found or the end is reached. In the worst case, it checks all n elements." }, { "id": "4935a60c-f9f4-4839-9be6-ea4bbd945a82", "q": "Which prerequisite must be met before applying binary search on an array?", "options": ["The array must contain unique elements.", "The array must be of floating-point type.", "The array must be sorted.", "The array must be two-dimensional."], "answer": 2, "hint": "Think about the condition needed for binary search to work.", "explanation": "Binary search works by repeatedly dividing the search interval in half. It requires the array to be sorted beforehand to function correctly." }, { "id": "740165e8-3875-44b3-ad23-d9c2a233d87c", "q": "When inserting a new element at position 'pos' in an array of size 'n', which statement best describes the operation?", "options": ["The new element overwrites the element at index 'pos'.", "Elements from index 'pos' to 'n-1' are shifted to the right, and the new element is placed at index 'pos'.", "The array size automatically increases by 1.", "Elements from index 'pos+1' to 'n-1' are shifted to the left, and the new element is placed at index 'pos+1'."], "answer": 1, "hint": "Consider the logical steps: assign new value, then shift subsequent elements.", "explanation": "Insertion involves shifting elements to the right to make space for the new element at the desired position. The number of shifts depends on the insertion position." }, { "id": "d887eb95-543d-4f25-addf-9ce7a6dc43c6", "q": "To delete an element at index 'pos' from an array, which operation is typically performed?", "options": ["Set the element at index 'pos' to 0.", "Decrement the array size and ignore the element at 'pos'.", "Shift elements from index 0 to 'pos-1' one position to the right.", "Shift elements from index 'pos+1' to the end one position to the left."], "answer": 3, "hint": "Deletion is the opposite of insertion; think about how the gap is filled.", "explanation": "To delete an element, the subsequent elements are shifted one position to the left to fill the gap, effectively reducing the logical size of the array." }, { "id": "80e6beab-f1bf-4608-86bb-2fdff9324f82", "q": "What is the correct sequence of statements to swap the values of two array elements arr[i] and arr[j]?", "options": ["arr[i] = arr[j]; arr[j] = arr[i];", "temp = arr[i]; arr[i] = arr[j];", "temp = arr[i]; arr[i] = arr[j]; arr[j] = temp;", "arr[i] = arr[j]; arr[j] = arr[i]; temp = arr[i];"], "answer": 2, "hint": "Think about using a temporary variable and two indices.", "explanation": "Swapping two elements 'a' and 'b' using a temporary variable t follows: t is a; a is b; b is t. This requires an intermediate storage location." }, { "id": "1a64993a-09c5-42ec-88db-a77412bf29e5", "q": "Which algorithm is used to find the maximum value in an array of size n?", "options": ["Initialize max to arr[0], then iterate through the array comparing each element with max and updating if larger.", "Sort the array in ascending order and take the first element.", "Sort the array in descending order and take the first element.", "Use a binary search tree to store and then retrieve the maximum."], "answer": 0, "hint": "The operation requires iterating through the entire array once, tracking the highest value seen.", "explanation": "Finding the maximum involves initializing a variable to the first element, then comparing it with each subsequent element, updating the maximum when a larger element is found." }, { "id": "b1ea5fb5-0bc9-4f2c-b8d5-5faf4af9da6b", "q": "To count the number of times a specific value 'target' appears in an array of size n, which approach is standard?", "options": ["Use the array's sizeof operator to calculate the total bytes and divide by the size of the target.", "Use a loop to iterate through the array, incrementing a counter whenever the current element equals 'target'.", "Use the array's index as a hash key to directly look up the count.", "Use the array's memory address to calculate the count based on pointer arithmetic."], "answer": 1, "hint": "The operation uses nested loops and a counter for each element.", "explanation": "Counting occurrences requires iterating through the array for each unique element and maintaining a tally. This can be done with nested loops or by using a frequency array if the range is known." }, { "id": "ffaabeb0-5275-4a0c-9029-0d8439544e82", "q": "What is the average-case time complexity of the insertion sort algorithm when applied to an array of n elements?", "options": ["O(n log n)", "O(n)", "O(n^2)", "O(log n)"], "answer": 2, "hint": "Consider the number of comparisons needed relative to the array size.", "explanation": "The minimum number of comparisons for insertion sort in the worst case is O(n^2). In the best case (already sorted), it is O(n). On average, it remains O(n^2)." }], topicId: "3.3" }), _jsx(ContentAttribution, { sourceTitle: "Curriculum Reference", sourceUrl: "https://learningway.in", professor: "Faculty Review Team", model: "Curriculum AI", seoTitle: "Operations on Arrays", seoDesc: "Master Operations on Arrays with comprehensive notes, real-world examples, and practice quiz on LearningWay.", seoKeywords: "operations on arrays, operations on arrays notes, operations on arrays 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."); }