Linear Search in Data Structure in Hindi

Srajan
⏰ 4 min read

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

Table of Contents

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

Endless Horse – Find End? Play Game
  • Linear Search (लीनियर सर्च) एक Searching Algorithm है, जिसमें array या list के elements को पहले से आखिरी तक एक-एक करके key से compare किया जाता है।
  • इसे Sequential Search (सीक्वेंशियल सर्च) भी कहते हैं, क्योंकि elements को उसी क्रम में check किया जाता है जिस क्रम में वे store हैं।
  • सरल शब्दों में Linear Search को समझें तो यह बिल्कुल वैसा है जैसे बिना क्रम में रखे कागजों के ढेर में से अपना एक कागज ढूंढना, जहां हर कागज को उठाकर देखना पड़ता है।
  • इसका इस्तेमाल तब किया जाता है जब data sorted न हो या data बहुत छोटा हो।
  • Key मिलने पर उस element का index return किया जाता है, और पूरा array check करने के बाद भी न मिले तो "Not Found" या -1 मिलता है।
  • यह Array के साथ-साथ Linked List पर भी चलता है, क्योंकि इसे सिर्फ आगे बढ़ते जाना होता है।
  • Linear Search को Programmer या Developer code में implement करता है, और इसका logic इतना सीधा है कि Beginners सबसे पहले इसी से Searching सीखते हैं।
  • इसकी सबसे बड़ी कमजोरी बड़े data में है, जहां elements बढ़ने के साथ comparisons भी उतने ही बढ़ते जाते हैं।

मान लीजिए एक class में 40 बच्चों की attendance register बिना roll number के क्रम में भरी है, और आपको "Amit" का नाम ढूंढना है। आप register का पहला नाम पढ़ते हैं, फिर दूसरा, फिर तीसरा, और यह तब तक चलता है जब तक "Amit" न मिल जाए। यही Linear Search है।

Algorithm of Linear Search in Hindi – लीनियर सर्च का एल्गोरिदम

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

Working of Linear Search in Hindi – लीनियर सर्च कैसे काम करता है

Array है [14, 8, 31, 5, 27, 19] और key है 27। Search इस क्रम में आगे बढ़ता है:

  1. Step 1: index 0 पर arr[0] = 14 है, जो 27 के बराबर नहीं है, इसलिए आगे बढ़ें।
  2. Step 2: index 1 पर arr[1] = 8 है, जो 27 के बराबर नहीं है।
  3. Step 3: index 2 पर arr[2] = 31 है, यहां भी match नहीं मिला।
  4. Step 4: index 3 पर arr[3] = 5 है, फिर भी match नहीं मिला।
  5. Step 5: index 4 पर arr[4] = 27 है, जो key के बराबर है, इसलिए index 4 return होता है।

इस search में कुल 5 comparisons हुए। अगर key 40 होती, तो सभी 6 elements check करने के बाद "Not Found" मिलता।

Program of Linear Search in Hindi – लीनियर सर्च का प्रोग्राम

C language में Linear Search का program इस तरह लिखा जाता है:

#include 

int linearSearch(int arr[], int n, int key) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == key) {
            return i;
        }
    }
    return -1;
}

int main() {
    int arr[] = {14, 8, 31, 5, 27, 19};
    int n = sizeof(arr) / sizeof(arr[0]);
    int key = 27;

    int result = linearSearch(arr, n, key);

    if (result == -1)
        printf("Element not found");
    else
        printf("Element found at index %d", result);

    return 0;
}

Output: Element found at index 4

Complexity of Linear Search in Hindi – लीनियर सर्च की कॉम्प्लेक्सिटी

  1. Best Case: O(1), जब key पहले ही element पर मिल जाए।
  2. Average Case: O(n), क्योंकि औसतन लगभग आधे elements तक जाना पड़ता है।
  3. Worst Case: O(n), जब key आखिरी element हो या array में हो ही नहीं।
  4. Space Complexity: O(1), क्योंकि सिर्फ एक loop variable के अलावा extra memory नहीं लगती।

Advantages of Linear Search in Hindi – लीनियर सर्च के फायदे

  1. Simple Logic: इसे समझना और code करना बहुत आसान है।
  2. No Sorting Required: Unsorted data पर भी सीधे चल जाता है।
  3. Works on Any Structure: Array के साथ Linked List पर भी बिना बदलाव के चलता है।
  4. No Extra Memory: O(1) space में काम पूरा हो जाता है।
  5. Good for Small Data: कुछ elements वाले data में setup के बिना जल्दी result मिल जाता है।
  6. Finds All Matches: थोड़ा बदलाव करके एक ही key के सभी occurrences निकाले जा सकते हैं।

Disadvantages of Linear Search in Hindi – लीनियर सर्च के नुकसान

  1. Slow on Large Data: Elements लाखों में हों तो comparisons भी लाखों तक पहुंच जाते हैं।
  2. Sorted Data Ignored: Data sorted हो तब भी यह उसका कोई फायदा नहीं उठा पाता।
  3. Repeated Searches: बार-बार search करने पर हर बार शुरू से चलना पड़ता है।
  4. Higher Time Cost: Binary Search जैसी techniques की तुलना में O(n) का समय काफी ज्यादा है।

Linear Search vs Binary Search in Hindi – लीनियर सर्च और बाइनरी सर्च में अंतर

Basis Linear Search Binary Search
Category Sequential Search Interval Search
Sorted Data जरूरी नहीं जरूरी
Approach एक-एक element check करना बीच से range आधी करना
Best Case O(1) O(1)
Average Case O(n) O(log n)
Worst Case O(n) O(log n)
Data Structure Array और Linked List मुख्य रूप से Array
Implementation बहुत आसान थोड़ा जटिल
Best Suited For छोटा या unsorted data बड़ा sorted data

Applications of Linear Search in Hindi – लीनियर सर्च के उपयोग

  1. Small Lists: जिस list में कुछ ही items हों, वहां sorting का खर्च उठाने से बेहतर सीधे Linear Search चलाना है।
  2. Unsorted Data: Log files, raw input और temporary data में किसी value को ढूंढने के लिए इसका इस्तेमाल किया जाता है।
  3. Linked List Traversal: Linked List में किसी node की value ढूंढने के लिए यही तरीका अपनाया जाता है।
  4. Validation Checks: किसी value के पहले से list में मौजूद होने की जांच, जैसे duplicate entry check, इसी से की जाती है।
  5. Finding Min and Max: Unsorted array में सबसे छोटा या सबसे बड़ा element निकालने के लिए पूरे array पर इसी तरह चलना पड़ता है।
  6. Embedded Systems: कम memory वाले devices में छोटे lookup tables पर यही सबसे हल्का विकल्प होता है।

FAQs

Linear Search एक Searching Algorithm है जिसमें array के elements को पहले से आखिरी तक एक-एक करके key से compare किया जाता है। Match मिलने पर उसका index return होता है, वरना "Not Found" मिलता है। इसे Sequential Search भी कहते हैं।
Searching Techniques दो प्रकार की होती हैं: Sequential Search और Interval Search। Linear Search, Sequential Search का ही type है, और यह sorted व unsorted दोनों तरह के data पर चलता है।
इसमें index 0 से शुरू करके हर element की तुलना key से की जाती है। Match मिलते ही index return होता है, और array खत्म होने तक न मिले तो -1 या "Not Found" return किया जाता है।
Linear Search हर index पर जाकर arr[i] की तुलना key से करता है। पहला match मिलते ही search रुक जाता है। अगर 6 elements के array में key पांचवें index पर हो, तो 5 comparisons के बाद result मिल जाता है।
Program में एक for loop होता है जो 0 से n-1 तक चलता है। Loop के अंदर अगर arr[i] == key हो जाए तो i return किया जाता है, और loop खत्म होने तक match न मिले तो function -1 return करता है।
Linear Search की Best Case Time Complexity O(1) और Average व Worst Case O(n) होती है। इसकी Space Complexity O(1) है, क्योंकि इसमें extra memory की जरूरत नहीं पड़ती।
Linear Search आसान है, unsorted data पर चलता है, Array और Linked List दोनों पर काम करता है और extra memory नहीं लेता। छोटे data में यह बिना किसी तैयारी के तुरंत result देता है।
बड़े data में Linear Search बहुत slow हो जाता है, क्योंकि comparisons की संख्या elements के साथ बढ़ती जाती है। Data sorted होने पर भी यह उसका फायदा नहीं ले पाता और बार-बार search में हर बार शुरू से चलता है।
Linear Search को sorted data की जरूरत नहीं होती और इसकी Worst Case Complexity O(n) है। Binary Search को sorted data चाहिए, लेकिन इसकी Worst Case Complexity O(log n) है, इसलिए बड़े data में यह कहीं ज्यादा तेज है।
Linear Search का इस्तेमाल छोटी lists, unsorted data, Linked List traversal, duplicate entry की जांच और embedded systems के छोटे lookup tables में किया जाता है।
Srajan

✍️ Srajan

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

•