Data Structures and Algorithms Interview Questions Hindi mein

Data Structures और Algorithms: Interviews के लिए Patterns कोर्स के 22 सवाल, हर सवाल के सही जवाब और explanation के साथ। जवाब देखने से पहले ख़ुद सोचें।

मॉड्यूल 1: आधार

1. इनपुट 1,000 से 1,000,000 हो जाता है। O(log n) चरण गणना लगभग...

  1. तीन गुना
  2. 1000 गुना बढ़ती है
  3. ~10 चरण बढ़ती है
  4. दोगुना होता है
जवाब देखें

जवाब: ~10 चरण बढ़ती है

log2(1e6) - log2(1e3) लगभग 20 - 10 = 10 अतिरिक्त चरण।

पाठ: Big-O और जटिलता

मॉड्यूल 2: डेटा स्ट्रक्चर

2. दो strings anagram हैं या नहीं, जाँचने का सबसे तेज़ तरीका?

  1. हर क्रमचय आज़माएँ
  2. एक को उल्टा कर तुलना करें
  3. हर string sort करें और केवल lengths की तुलना करें
  4. वर्ण गणनाओं की तुलना करें
जवाब देखें

जवाब: वर्ण गणनाओं की तुलना करें

हर वर्ण गिनना O(n) है; क्रमचय O(n!) हैं।

पाठ: Strings

3. आपको key से तेज़ lookup चाहिए और क्रम की परवाह नहीं। चुनें...

  1. Hash map
  2. Sorted array + binary search
  3. Linked list
  4. Stack
जवाब देखें

जवाब: Hash map

Hash map प्रति lookup औसत O(1); binary search O(log n) और sorting चाहिए।

पाठ: Hash Map

4. खाली असंतुलित BST में 1,2,3,4,5 क्रम में डालें। Search लागत हो जाती है...

  1. O(log n)
  2. O(n)
  3. O(1)
  4. O(n log n)
जवाब देखें

जवाब: O(n)

क्रमबद्ध insert दाईं ओर झुकी श्रृंखला बनाते हैं — असल में linked list। संतुलित trees (AVL, red-black) इसे ठीक करते हैं।

पाठ: Binary Search Tree

5. Fenwick tree के update और prefix-sum operations चलते हैं:

  1. O(1)
  2. O(log n)
  3. O(n)
  4. O(n log n)
जवाब देखें

जवाब: O(log n)

दोनों index को सबसे कम set bit बदलते हुए ऊपर/नीचे जाते हैं, O(log n) चरणों में।

पाठ: Fenwick Tree (BIT)

मॉड्यूल 3: Graph Algorithms

6. Dijkstra's algorithm सही परिणाम केवल तब देता है जब:

  1. Graph undirected हो
  2. सभी edge weights गैर-ऋणात्मक हों
  3. Graph में कोई cycle न हो
  4. Graph एक tree हो
जवाब देखें

जवाब: सभी edge weights गैर-ऋणात्मक हों

Negative weights greedy 'सबसे नज़दीकी node final है' मान्यता को गलत कर सकते हैं — इसकी जगह Bellman-Ford इस्तेमाल करें।

पाठ: Dijkstra's Algorithm

7. Path compression और union by rank के साथ, find/union लगभग चलते हैं:

  1. O(n)
  2. O(log n)
  3. O(n log n)
  4. लगभग O(1) (inverse-Ackermann)
जवाब देखें

जवाब: लगभग O(1) (inverse-Ackermann)

Amortized complexity O(α(n)) है, inverse Ackermann function, जो किसी भी वास्तविक n के लिए प्रभावी रूप से स्थिर है।

पाठ: Union-Find / Disjoint Set

मॉड्यूल 4: Sorting और Searching

8. Binary search के लिए डेटा होना चाहिए...

  1. Hash map में संग्रहीत
  2. अभाज्य लंबाई का
  3. Sorted (या predicate पर monotonic)
  4. केवल धनात्मक संख्याएँ
जवाब देखें

जवाब: Sorted (या predicate पर monotonic)

आधा हटाना तभी काम करता है जब एक ओर लक्ष्य न होने की गारंटी हो — इसके लिए क्रम चाहिए।

पाठ: Binary Search

9. Merge sort का worst-case समय है...

  1. O(n^2)
  2. O(n)
  3. O(log n)
  4. O(n log n)
जवाब देखें

जवाब: O(n log n)

विभाजन हमेशा संतुलित होता है, इसलिए हर मामले में O(n log n) — quicksort के विपरीत।

पाठ: Merge Sort

मॉड्यूल 5: एल्गोरिदम पैटर्न

10. विपरीत-सिरे two-pointer तरकीब को array चाहिए...

  1. Sorted
  2. सभी धनात्मक
  3. सम लंबाई
  4. Palindromic
जवाब देखें

जवाब: Sorted

Sorted क्रम ही तय करने देता है कि वर्तमान योग से कौन-सा पॉइंटर हिलाना है।

पाठ: Two Pointers

11. आपको अभारित graph में सबसे छोटा पथ चाहिए। उपयोग करें...

  1. DFS
  2. BFS
  3. दोनों समान काम करते हैं
  4. Bubble sort
जवाब देखें

जवाब: BFS

BFS दूरी के क्रम में खोजता है, तो लक्ष्य तक पहली बार पहुँचना सबसे छोटा पथ है। DFS ऐसी गारंटी नहीं देता।

पाठ: Depth-First Search

12. सिक्के [1, 3, 4], 6 बनाएँ कम से कम सिक्कों में। Greedy (पहले 4) 3 सिक्के देता है (4+1+1)। इष्टतम है...

  1. 3 सिक्के — greedy सही है
  2. असंभव
  3. 2 सिक्के (3 + 3)
  4. 1 coin
जवाब देखें

जवाब: 2 सिक्के (3 + 3)

3+3 = 6 दो सिक्के उपयोग करता है। यहाँ greedy विफल — coin change को सामान्यतः DP चाहिए।

पाठ: Greedy

मॉड्यूल 6: Advanced Patterns

13. लंबाई m के pattern को लंबाई n के text में खोजने पर KMP की कुल time complexity है:

  1. O(n*m)
  2. O(n + m)
  3. O(n log m)
  4. O(m^2)
जवाब देखें

जवाब: O(n + m)

LPS array O(m) में बनती है, और खोज खुद O(n) है क्योंकि text pointer कभी पीछे नहीं जाता।

पाठ: String Matching

14. LRU cache को singly linked list के बजाय doubly linked list की ज़रूरत क्यों है?

  1. यह कम memory इस्तेमाल करती है
  2. यह किसी node को केवल उसका pointer देकर O(1) में हटाने देती है
  3. यह keys को वर्णानुक्रम में क्रमबद्ध करती है
  4. Hash maps को doubly linked lists चाहिए ही होती हैं
जवाब देखें

जवाब: यह किसी node को केवल उसका pointer देकर O(1) में हटाने देती है

prev pointer के साथ, एक node खुद को O(1) में unlink कर सकता है; singly linked list में पिछला node खोजने में O(n) लगेगा।

पाठ: LRU Cache Design

15. Binary search की time complexity क्या है?

  1. O(n)
  2. O(1)
  3. O(log n)
  4. O(n log n)
जवाब देखें

जवाब: O(log n)

हर कदम search range आधी करता है।

पाठ: K-way Merge

16. कौन-सी structure key से औसत O(1) lookup देती है?

  1. Linked list
  2. Stack
  3. Sorted array scan
  4. Hash map
जवाब देखें

जवाब: Hash map

Hash function keys को buckets से map करता है।

पाठ: K-way Merge

17. Balanced-bracket जाँच के लिए कौन-सी structure उपयुक्त है?

  1. Stack
  2. Queue
  3. Trie
  4. Heap
जवाब देखें

जवाब: Stack

Opening push करें, closing पर pop करें।

पाठ: K-way Merge

18. Unweighted graph में shortest paths कौन-सा traversal खोजता है?

  1. DFS
  2. BFS
  3. In-order
  4. Post-order
जवाब देखें

जवाब: BFS

BFS level-by-level खोजता है।

पाठ: K-way Merge

19. Dijkstra का algorithm कब सही परिणाम देता है?

  1. The graph is a tree
  2. The graph is undirected
  3. All edge weights are non-negative
  4. The graph is small
जवाब देखें

जवाब: All edge weights are non-negative

Negative edges के लिए Bellman-Ford चाहिए।

पाठ: K-way Merge

20. Merge sort का worst-case time क्या है?

  1. O(n^2)
  2. O(n)
  3. O(log n)
  4. O(n log n)
जवाब देखें

जवाब: O(n log n)

यह हमेशा बराबर बाँटता और merge करता है।

पाठ: K-way Merge

21. Longest-substring समस्याओं को एक pass में कौन-सा pattern संभालता है?

  1. Sliding window
  2. Union-find
  3. Bit manipulation
  4. K-way merge
जवाब देखें

जवाब: Sliding window

दाएँ बढ़ाएँ, ज़रूरत पर बाएँ घटाएँ।

पाठ: K-way Merge

22. कौन-सी बात किसी समस्या को dynamic programming के उपयुक्त बनाती है?

  1. Random inputs
  2. Overlapping subproblems and optimal substructure
  3. Large strings
  4. Sorted data
जवाब देखें

जवाब: Overlapping subproblems and optimal substructure

पुनर्गणना से बचने के लिए subproblem उत्तर रखें।

पाठ: K-way Merge

← कोर्स पर वापस जाएँ