Searching Techniques in Data Structure in hindi

Srajan
⏰ 6 min read

सिलेबस के अनुसार DATA STRUCTURES के सभी टॉपिक यहाँ देखें — बिल्कुल फ्री

Table of Contents

Searching Techniques in Hindi – सर्चिंग टेक्निक्स क्या है?

Endless Horse – Find End? Play Game
  • Searching (सर्चिंग) एक ऐसी process है जिसमें array, list या table जैसे data के collection में से किसी दिए गए key element को ढूंढा जाता है।
  • सरल शब्दों में Searching को समझें तो यह बिल्कुल वैसा है जैसे किताबों के ढेर में से अपनी जरूरत की एक किताब निकालना।
  • इसका मकसद है कि element मिल जाए तो उसका index या position बताया जाए, और न मिले तो "Not Found" का result मिले।
  • Searching Techniques असल में वो Algorithms (एल्गोरिदम) हैं जो तय करते हैं कि elements को किस क्रम में और कैसे check करना है।
  • कौन सी technique सही रहेगी, यह data की size, उसका sorted होना और values के distribution पर निर्भर करता है।
  • इनका इस्तेमाल Database, Operating System, Compiler, Search Engine और रोजमर्रा के Mobile Apps तक में किया जाता है।
  • Searching का algorithm Programmer या Developer चुनता है और code में implement करता है।
  • अच्छी Searching technique का लक्ष्य कम से कम comparisons में सही result तक पहुंचना होता है।
  • सबसे बड़ी चुनौती बहुत बड़े data में speed की है, क्योंकि कुछ techniques data बढ़ने पर काफी slow हो जाती हैं।

Example of Searching Techniques (उदाहरण)

मान लीजिए आपके Mobile में 500 contacts save हैं और आपको "Rahul" का number चाहिए। अगर आप list को पहले नाम से आखिरी नाम तक एक-एक करके देखते हैं, तो यह Linear Search है। वहीं अगर contacts alphabetical order में हैं और आप सीधे बीच से खोलकर देखते हैं कि "R" आगे है या पीछे, तो यह Binary Search का तरीका है।

Types of Searching Techniques in Hindi – सर्चिंग टेक्निक्स के प्रकार

Searching Techniques को मुख्य रूप से दो categories में बांटा जाता है: Sequential Search और Interval Search।

Types of Searching Techniques in Hindi

Searching Techniques Sequential Search Interval Search Linear Search Binary, Jump, आदि
  1. Sequential Search: इसमें elements को शुरू से आखिर तक एक के बाद एक check किया जाता है। यह sorted या unsorted, दोनों तरह के data पर चलता है।
  2. Interval Search: इसमें data पहले से sorted होना जरूरी है, और हर step में search range को छोटा करते हुए target तक पहुंचा जाता है।

Types of Sequential Search in Hindi

Sequential Search Linear Search

Linear Search in Hindi – लीनियर सर्च क्या है?

Linear Search (लीनियर सर्च) सबसे आसान Searching technique है, जिसे Sequential Search भी कहा जाता है। इसमें array के पहले element से शुरू करके हर element की तुलना key से की जाती है, और यह तब तक चलता है जब तक match न मिले या array खत्म न हो जाए। इस technique को Sorted data की जरूरत नहीं होती।

  1. Start: Array के पहले element (index 0) से शुरुआत करें।
  2. Compare: Current element की तुलना key से करें।
  3. Match: अगर दोनों बराबर हैं, तो उस element का index return करें और process रोक दें।
  4. Move: अगर बराबर नहीं हैं, तो अगले element पर जाएं और step 2 दोहराएं।
  5. End: Array खत्म हो जाए और match न मिले, तो "Not Found" return करें।

Array है [12, 45, 7, 23, 89] और key है 23। सबसे पहले 12 से compare होगा, फिर 45 से, फिर 7 से, और चौथे number पर यानी index 3 पर 23 मिल जाएगा। कुल 4 comparisons हुए। अगर key 50 होती, तो पांचों elements check करने के बाद "Not Found" मिलता।

  1. Best Case: O(1), जब key पहले ही element पर मिल जाए।
  2. Average Case: O(n), क्योंकि औसतन आधे elements तक जाना पड़ता है।
  3. Worst Case: O(n), जब key आखिरी element हो या मौजूद ही न हो।
  4. Space Complexity: O(1), क्योंकि extra memory की जरूरत नहीं पड़ती।
  1. Simple Logic: Implement करना बहुत आसान है और code बहुत छोटा रहता है।
  2. No Sorting Required: Unsorted data पर भी सीधे काम करता है।
  3. Any Data Structure: Array के साथ-साथ Linked List पर भी चल जाता है।
  4. Small Data: छोटे data में extra setup के बिना जल्दी result दे देता है।
  1. Slow on Large Data: Data लाखों elements का हो तो comparisons बहुत बढ़ जाते हैं।
  2. No Shortcut: Data sorted भी हो तब भी यह उसका फायदा नहीं उठा पाता।
  3. Inefficient Repeated Search: बार-बार search करने पर हर बार शुरू से चलना पड़ता है।

Types of Interval Search in Hindi

Interval Search Binary Search Jump Search Interpolation Search Exponential Search
  1. Binary Search: Sorted array को बीच से दो हिस्सों में बांटकर हर बार आधा हिस्सा छोड़ दिया जाता है।
  2. Jump Search: Fixed size के blocks में आगे कूदते हुए सही block पकड़ा जाता है, फिर उसी block में Linear Search होता है।
  3. Interpolation Search: Key की value के आधार पर अनुमान लगाया जाता है कि वह array में कहां हो सकती है।
  4. Exponential Search: Index को दोगुना करते हुए range ढूंढी जाती है, फिर उस range में Binary Search चलता है।

Binary Search in Hindi – बाइनरी सर्च क्या है?

Binary Search (बाइनरी सर्च) एक Divide and Conquer पर आधारित technique है, जिसका इस्तेमाल Sorted array में element ढूंढने के लिए किया जाता है। हर step में बीच वाले element से key की तुलना होती है, और उसके आधार पर array का आधा हिस्सा पूरी तरह छोड़ दिया जाता है। इसी वजह से यह Linear Search से कहीं ज्यादा तेज है।

  1. Initialize: low = 0 और high = n-1 रखें।
  2. Find Middle: mid = low + (high - low) / 2 निकालें।
  3. Match: अगर arr[mid] == key है, तो mid return करें।
  4. Go Right: अगर arr[mid] < key है, तो low = mid + 1 करें।
  5. Go Left: अगर arr[mid] > key है, तो high = mid - 1 करें।
  6. Repeat: जब तक low <= high है, step 2 से दोहराते रहें; वरना "Not Found" return करें।

Array है [5, 12, 18, 25, 33, 47, 60] और key है 33। शुरुआत में low = 0, high = 6, तो mid = 3 और arr[3] = 25 है। 25 < 33 है, इसलिए low = 4 हो जाएगा। अब mid = 5 और arr[5] = 47 है, जो 33 से बड़ा है, इसलिए high = 4 हो जाएगा। इस बार mid = 4 है और arr[4] = 33 मिल जाता है। सिर्फ 3 comparisons में result आ गया।

  1. Best Case: O(1), जब key पहली ही बार में बीच पर मिल जाए।
  2. Average Case: O(log n)।
  3. Worst Case: O(log n), क्योंकि हर step में range आधी हो जाती है।
  4. Space Complexity: Iterative version में O(1), और Recursive version में O(log n)।
  1. Fast Performance: 10 लाख elements में भी ज्यादा से ज्यादा लगभग 20 comparisons लगते हैं।
  2. Low Memory: Iterative तरीके में extra space नहीं लगती।
  3. Predictable: Worst case भी O(log n) ही रहता है।
  1. Sorted Data Needed: Array का sorted होना जरूरी है, वरना result गलत आएगा।
  2. Random Access Required: Array पर आसानी से चलता है, लेकिन Linked List पर इसे चलाना कठिन है।
  3. Sorting Cost: Data बार-बार बदलता हो तो उसे हर बार sort करने का खर्च बढ़ जाता है।

Jump Search in Hindi – जंप सर्च क्या है?

Jump Search (जंप सर्च) में Sorted array को बराबर size के blocks में बांटकर पूरे block के आगे कूदा जाता है। जब वह block मिल जाता है जिसमें key हो सकती है, तब सिर्फ उसी block में Linear Search चलाई जाती है। Block size आमतौर पर √n रखी जाती है, जहां n array में elements की कुल संख्या है।

  1. Set Block Size: m = √n निकालें और prev = 0 रखें।
  2. Jump: जब तक arr[min(m, n) - 1] < key है, prev = m करें और m में √n जोड़ते जाएं।
  3. Boundary Check: अगर prev, n से बड़ा या बराबर हो जाए, तो "Not Found" return करें।
  4. Linear Scan: prev से शुरू करके उसी block में एक-एक element check करें।
  5. Result: Key मिल जाए तो index return करें, वरना "Not Found"।

Array है [3, 8, 14, 21, 29, 36, 45, 52, 60, 71, 85, 93, 100, 110, 125, 140], यानी n = 16 और block size m = 4। Key है 52। पहले arr[3] = 21 देखा, जो 52 से छोटा है, इसलिए आगे कूदे। फिर arr[7] = 52 पर रुक गए, क्योंकि यह key से छोटा नहीं है। अब index 4 से 7 के बीच Linear Search करने पर 29, 36, 45 के बाद 52 index 7 पर मिल जाता है।

  1. Best Case: O(1)।
  2. Average Case: O(√n)।
  3. Worst Case: O(√n)।
  4. Space Complexity: O(1)।

Interpolation Search in Hindi – इंटरपोलेशन सर्च क्या है?

Interpolation Search (इंटरपोलेशन सर्च) Binary Search का ही एक improved version है, जो उन arrays पर सबसे अच्छा चलता है जिनकी values लगभग बराबर अंतर पर फैली हों। Binary Search हमेशा बीच पर जाता है, लेकिन यह key की value देखकर अनुमान लगाता है कि वह array में कहां हो सकती है। Phone directory में "Z" से शुरू होने वाला नाम ढूंढते समय हम सीधे आखिर के पन्नों की तरफ जाते हैं, यह बिल्कुल वही सोच है।

Probe position इस formula से निकाली जाती है:

pos = low + ((key - arr[low]) * (high - low)) / (arr[high] - arr[low])

  1. Initialize: low = 0 और high = n-1 रखें।
  2. Calculate Position: ऊपर वाले formula से pos निकालें।
  3. Match: अगर arr[pos] == key है, तो pos return करें।
  4. Narrow Range: arr[pos] < key हो तो low = pos + 1, और arr[pos] > key हो तो high = pos - 1 करें।
  5. Repeat: जब तक key, arr[low] और arr[high] के बीच है, step 2 दोहराएं।

Array है [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] और key है 70। यहां low = 0 और high = 9 है। Formula में values डालने पर pos = 0 + ((70 - 10) × 9) / (100 - 10) = 540 / 90 = 6 आता है। arr[6] = 70 है, यानी पहले ही probe में element मिल गया।

  1. Best Case: O(1)।
  2. Average Case: O(log log n), जब values uniformly distributed हों।
  3. Worst Case: O(n), जब values बहुत असमान तरीके से बढ़ रही हों।
  4. Space Complexity: O(1)।

Exponential Search in Hindi – एक्सपोनेंशियल सर्च क्या है?

Exponential Search (एक्सपोनेंशियल सर्च) दो चरणों में काम करता है। पहले चरण में index 1, 2, 4, 8, 16 की तरह दोगुना होता जाता है, जब तक arr[i] key से बड़ा न हो जाए। इससे वह range मिल जाती है जिसमें key हो सकती है। दूसरे चरण में उसी range पर Binary Search चलाया जाता है। इसका इस्तेमाल खासतौर पर तब होता है जब array बहुत बड़ा हो या उसकी size पहले से पता न हो।

  1. First Check: अगर arr[0] == key है, तो 0 return करें।
  2. Find Range: i = 1 से शुरू करें और जब तक i < n और arr[i] <= key है, i = i × 2 करते रहें।
  3. Binary Search: i/2 से min(i, n-1) की range में Binary Search चलाएं।
  4. Result: Key मिले तो index return करें, वरना "Not Found"।

Array है [2, 5, 9, 14, 20, 27, 35, 44, 56, 70, 85, 99] और key है 44। i = 1 पर arr[1] = 5 है, फिर i = 2 पर 9, i = 4 पर 20, और i = 8 पर 56 मिलता है, जो 44 से बड़ा है, इसलिए यहां रुक जाते हैं। अब index 4 से 8 के बीच Binary Search चलता है। mid = 6 पर arr[6] = 35 है, जो छोटा है, इसलिए low = 7 हो जाता है। mid = 7 पर arr[7] = 44 मिल जाता है।

  1. Best Case: O(1)।
  2. Average Case: O(log n)।
  3. Worst Case: O(log n)।
  4. Space Complexity: O(1), Iterative implementation में।

Comparison of Searching Techniques in Hindi – सर्चिंग टेक्निक्स की तुलना

Basis Linear Search Binary Search Jump Search Interpolation Search Exponential Search
Sorted Data जरूरी नहीं जरूरी जरूरी जरूरी जरूरी
Approach एक-एक element check बीच से range आधी करना Blocks में जंप करना Value से position का अनुमान Range दोगुनी करके Binary Search
Best Case O(1) O(1) O(1) O(1) O(1)
Average Case O(n) O(log n) O(√n) O(log log n) O(log n)
Worst Case O(n) O(log n) O(√n) O(n) O(log n)
Space Complexity O(1) O(1) Iterative O(1) O(1) O(1) Iterative
Best Suited For छोटा या unsorted data बड़ा sorted array Backward traversal महंगा हो Uniformly distributed values Unbounded या बहुत बड़ा array

Applications of Searching Techniques in Hindi – सर्चिंग टेक्निक्स के उपयोग

  1. Database Queries: Table में किसी record को ढूंढने के लिए Index पर इन्हीं techniques का इस्तेमाल किया जाता है।
  2. Search Engines: Indexed data में से keyword से जुड़े pages तेजी से निकाले जाते हैं।
  3. Compilers: Symbol Table में variable या function का नाम ढूंढने में Searching काम आती है।
  4. Operating Systems: File System में file या directory की location पता करने के लिए इसका इस्तेमाल होता है।
  5. E-commerce Websites: Product list में price, brand या category के आधार पर filtering की जाती है।
  6. Contact and Dictionary Apps: Sorted list में नाम या word को सीधे ढूंढने में Binary Search जैसी techniques लगती हैं।
  7. Gaming and Networking: Routing Table में path ढूंढना और game में object की position खोजना भी Searching का ही काम है।

FAQs

Searching Techniques वो Algorithms हैं जिनसे data के collection में से किसी specific element को ढूंढा जाता है। इनका नतीजा या तो उस element का index होता है या "Not Found"। Linear, Binary, Jump, Interpolation और Exponential Search इनके मुख्य उदाहरण हैं।
Searching Techniques मुख्य रूप से दो प्रकार की होती हैं: Sequential Search और Interval Search। Sequential Search में Linear Search आती है, जबकि Interval Search में Binary, Jump, Interpolation और Exponential Search शामिल हैं।
Linear Search में array के elements को पहले से आखिरी तक एक-एक करके key से compare किया जाता है। यह sorted और unsorted, दोनों तरह के data पर चलता है। इसकी Worst Case Time Complexity O(n) होती है।
Binary Search एक ऐसी technique है जो sorted array में बीच के element से compare करके हर बार search range आधी कर देती है। इसकी Time Complexity O(log n) होती है, इसलिए यह बड़े data के लिए Linear Search से काफी तेज है।
Jump Search में sorted array को √n size के blocks में बांटकर block-by-block आगे बढ़ा जाता है। सही block मिलने के बाद उसी block में Linear Search चलाई जाती है। इसकी Time Complexity O(√n) है।
Interpolation Search एक formula की मदद से key की value के आधार पर उसकी संभावित position का अनुमान लगाती है। Uniformly distributed sorted data पर इसकी Average Time Complexity O(log log n) होती है, लेकिन Worst Case में यह O(n) तक जा सकती है।
Exponential Search में पहले index को 1, 2, 4, 8 की तरह दोगुना करते हुए वह range ढूंढी जाती है जिसमें key हो सकती है। उसके बाद उसी range में Binary Search चलाया जाता है। यह बहुत बड़े या unbounded sorted array के लिए उपयोगी है।
Linear Search unsorted data पर चलती है लेकिन O(n) समय लेती है। Binary और Exponential Search sorted data में O(log n) में result देती हैं, Jump Search O(√n) लेती है, और Interpolation Search uniform data पर औसतन O(log log n) में काम करती है।
Searching Techniques का इस्तेमाल Database Queries, Search Engines, Compilers, Operating Systems, E-commerce filtering और Contact या Dictionary Apps में किया जाता है। जहां भी बड़े data में से कोई item ढूंढना हो, वहां किसी न किसी Searching technique का उपयोग होता है।
Srajan

✍️ Srajan

SEO Executive | Content Research & Optimization | 1.5+ Years of Experience

•