1. Data Structures — ڈھانچے

Difficulty: Advanced — اعلیٰ
Time: ~35 minutes

Importing — درآمد

درآمد {
    مربوط_فہرست, ڈھیر, قطار, دوطرفہ_قطار,
    ترجیحی_قطار, بائنری_تلاش_درخت, گراف
} سے "اردو/ڈھانچے";

مربوط_فہرست — Linked List

A chain of nodes where each points to the next. Unlike arrays, insertion/deletion at the front is O(1).

متغیر مف = نیا مربوط_فہرست();

مف.شامل_کریں(10);        // append to end
مف.شامل_کریں(20);
مف.شامل_کریں(30);
مف.شروع_میں_شامل(5);    // prepend to front

لکھو(مف.فہرست());        // [5, 10, 20, 30]
لکھو(مف.موجود_ہے(20));   // True

مف.نکالیں(20);           // remove by value
لکھو(مف.فہرست());        // [5, 10, 30]

مف.الٹا_کریں();          // reverse in-place
لکھو(مف.فہرست());        // [30, 10, 5]

لکھو(لمبائی(مف));         // 3

Iteration — دہرانا:

کے_لیے (متغیر قدر میں مف) {
    لکھو(قدر);
}

Method	Description
`.شامل_کریں(ق)`	Append to end
`.شروع_میں_شامل(ق)`	Prepend to front
`.نکالیں(ق)`	Remove first occurrence; returns `سچ`/`جھوٹ`
`.موجود_ہے(ق)`	Check if value exists
`.فہرست()`	Return as regular list
`.الٹا_کریں()`	Reverse in-place

اردو: مربوط_فہرست میں .شامل_کریں() آخر میں اور .شروع_میں_شامل() شروع میں شامل کرتا ہے۔ .نکالیں() قدر سے نکالتا ہے۔

ڈھیر — Stack (LIFO)

Last-in, first-out. Perfect for undo/redo, expression parsing, depth-first traversal.

متغیر ڈ = نیا ڈھیر();

ڈ.دھکیلیں(1);
ڈ.دھکیلیں(2);
ڈ.دھکیلیں(3);

لکھو(ڈ.جھانکیں());    // 3   (peek — don't remove)
لکھو(ڈ.نکالیں());     // 3   (pop — remove top)
لکھو(ڈ.نکالیں());     // 2
لکھو(ڈ.خالی_ہے());    // False
لکھو(لمبائی(ڈ));      // 1

Example: matching brackets — قوسین جانچ:

فنکشن قوسین_درست(متن_م) {
    متغیر ڈھیر_م = نیا ڈھیر();
    کے_لیے (متغیر حرف میں متن_م) {
        اگر (حرف == "(") {
            ڈھیر_م.دھکیلیں(حرف);
        } ورنہ_اگر (حرف == ")") {
            اگر (ڈھیر_م.خالی_ہے()) { واپس جھوٹ; }
            ڈھیر_م.نکالیں();
        }
    }
    واپس ڈھیر_م.خالی_ہے();
}

لکھو(قوسین_درست("(الف + ب) * (ج - د)"));   // True
لکھو(قوسین_درست("((غلط)"));                  // False

قطار — Queue (FIFO)

First-in, first-out. For task queues, BFS, print spoolers.

متغیر ق = نیا قطار();

ق.شامل_کریں("پہلا");
ق.شامل_کریں("دوسرا");
ق.شامل_کریں("تیسرا");

لکھو(ق.اگلا());       // پہلا   (peek)
لکھو(ق.نکالیں());     // پہلا   (dequeue)
لکھو(ق.نکالیں());     // دوسرا
لکھو(ق.خالی_ہے());    // False

دوطرفہ_قطار — Deque (Double-Ended Queue)

Add or remove from either end in O(1).

متغیر دق = نیا دوطرفہ_قطار();

دق.دائیں_شامل(1);
دق.دائیں_شامل(2);
دق.بائیں_شامل(0);     // [0, 1, 2]

لکھو(دق.بائیں_نکالیں());    // 0
لکھو(دق.دائیں_نکالیں());    // 2
لکھو(دق.بائیں_جھانکیں());   // 1

Method	Description
`.بائیں_شامل(ق)`	Add to left (front)
`.دائیں_شامل(ق)`	Add to right (back)
`.بائیں_نکالیں()`	Remove from left
`.دائیں_نکالیں()`	Remove from right
`.بائیں_جھانکیں()`	Peek at left
`.دائیں_جھانکیں()`	Peek at right

ترجیحی_قطار — Priority Queue (Min-Heap)

Always dequeues the item with the lowest priority number first. Pass زیادہ_سے_زیادہ=سچ for a max-heap.

متغیر تق = نیا ترجیحی_قطار();

تق.شامل_کریں("کام ج", 3);
تق.شامل_کریں("کام الف", 1);    // highest priority
تق.شامل_کریں("کام ب", 2);

لکھو(تق.نکالیں());    // کام الف  (priority 1)
لکھو(تق.نکالیں());    // کام ب    (priority 2)
لکھو(تق.نکالیں());    // کام ج    (priority 3)

Max-heap — زیادہ سے زیادہ:

متغیر مق = نیا ترجیحی_قطار(زیادہ_سے_زیادہ=سچ);
مق.شامل_کریں("چھوٹا", 1);
مق.شامل_کریں("بڑا", 10);
لکھو(مق.نکالیں());    // بڑا  (highest number first)

اردو: ترجیحی_قطار میں چھوٹا عدد پہلے نکلتا ہے (کم ترجیح نمبر = زیادہ اہمیت)۔ زیادہ_سے_زیادہ=سچ سے بڑا عدد پہلے نکلے گا۔

بائنری_تلاش_درخت — Binary Search Tree

Keeps values sorted. Search, insert, and delete in O(log n) average.

متغیر بت = نیا بائنری_تلاش_درخت();

بت.داخل_کریں(5);
بت.داخل_کریں(3);
بت.داخل_کریں(7);
بت.داخل_کریں(1);
بت.داخل_کریں(4);

لکھو(بت.ترتیب_سے());       // [1, 3, 4, 5, 7]   (sorted!)
لکھو(بت.موجود_ہے(3));      // True
لکھو(بت.موجود_ہے(6));      // False
لکھو(بت.سب_سے_چھوٹا());    // 1
لکھو(بت.سب_سے_بڑا());      // 7
لکھو(بت.اونچائی());         // 3
لکھو(لمبائی(بت));           // 5

بت.نکالیں(3);
لکھو(بت.ترتیب_سے());       // [1, 4, 5, 7]

گراف — Graph

Adjacency-list graph supporting BFS, DFS, and shortest path.

Undirected — غیر ہدایت یافتہ

متغیر گ = نیا گراف();

گ.کنارہ_شامل_کریں("الف", "ب");
گ.کنارہ_شامل_کریں("الف", "ج");
گ.کنارہ_شامل_کریں("ب", "د");

لکھو(گ.کونے());                   // ['الف', 'ب', 'ج', 'د']
لکھو(گ.ہم_سایہ("الف"));           // ['ب', 'ج']
لکھو(گ.چوڑائی_تلاش("الف"));       // BFS: ['الف', 'ب', 'ج', 'د']
لکھو(گ.گہرائی_تلاش("الف"));       // DFS: ['الف', 'ب', 'د', 'ج']
لکھو(گ.راستہ_ہے("الف", "د"));     // True

Directed with weights — ہدایت یافتہ + وزن

متغیر وزنی_گ = نیا گراف(ہدایت_یافتہ=سچ);

وزنی_گ.کنارہ_شامل_کریں("الف", "ب", 4);
وزنی_گ.کنارہ_شامل_کریں("الف", "ج", 2);
وزنی_گ.کنارہ_شامل_کریں("ج", "ب", 1);
وزنی_گ.کنارہ_شامل_کریں("ب", "د", 3);

لکھو(وزنی_گ.مختصر_راستہ("الف", "د"));   // ['الف', 'ج', 'ب', 'د']

Graph methods — گراف کے طریقے:

Method	Description
`.کونا_شامل_کریں(v)`	Add vertex
`.کنارہ_شامل_کریں(u, v, وزن=1)`	Add edge
`.ہم_سایہ(v)`	Neighbours of v
`.کونے()`	All vertices
`.کنارے()`	All edges as `(u, v, وزن)`
`.چوڑائی_تلاش(آغاز)`	BFS traversal order
`.گہرائی_تلاش(آغاز)`	DFS traversal order
`.راستہ_ہے(الف, ب)`	Connectivity check
`.مختصر_راستہ(الف, ب)`	Dijkstra shortest path
`.طوپو_ترتیب()`	Topological sort (DAG)

When to Use Which — کب کیا استعمال کریں

Structure	Best For
`مربوط_فہرست`	Fast front insert/delete; unknown size
`ڈھیر`	Undo/redo, recursion simulation, DFS
`قطار`	Task scheduling, BFS, message passing
`دوطرفہ_قطار`	Sliding window, deque algorithms
`ترجیحی_قطار`	Scheduling by priority, Dijkstra
`بائنری_تلاش_درخت`	Sorted data, fast min/max/search
`گراف`	Networks, paths, dependencies

← Intermediate | Next: Algorithms →