S11L13 - मैप्स में खोज - संग्रह फ्रेमवर्क

html

जावा मैप्स में खोज: कलेक्शन्स फ्रेमवर्क के साथ प्रभावी तकनीकें
सामग्री तालिका

परिचय - पृष्ठ 1
जावा कलेक्शन्स फ्रेमवर्क को समझना - पृष्ठ 2
कलेक्शन्स में बाइनरी सर्च - पृष्ठ 4
मैप्स पर बाइनरी सर्च की सीमाएँ - पृष्ठ 6
मैप्स में खोज - पृष्ठ 8

map.get(key) का उपयोग करना
वैल्यू द्वारा कीज़ ढूंढना


मैप्स में खोज लागू करना: चरण-दर-चरण - पृष्ठ 12
कोड वॉकथ्रू - पृष्ठ 15
खोज विधियों की तुलना - पृष्ठ 18
निष्कर्ष - पृष्ठ 20
अतिरिक्त संसाधन - पृष्ठ 21


परिचय
स्वागत है "जावा मैप्स में खोज: कलेक्शन्स फ्रेमवर्क के साथ प्रभावी तकनीकें।" इस ईबुक में, हम जावा के कलेक्शन्स फ्रेमवर्क में उपलब्ध विभिन्न खोज तंत्रों में गहराई से गोता लगाते हैं, विशेष रूप से Map कलेक्शन्स में खोज पर ध्यान केंद्रित करते हैं। डेटा संरचनाओं में कुशलतापूर्वक खोज करना अनुकूलित और उच्च-प्रदर्शन वाले अनुप्रयोगों के निर्माण के लिए महत्वपूर्ण है।
यह गाइड कवर करेगा:

कलेक्शन्स फ्रेमवर्क के मूलभूत सिद्धांत।
बाइनरी सर्च तकनीकें और उनकी उपयुक्तता।
Map कलेक्शन्स पर बाइनरी सर्च के उपयोग की सीमाएँ।
Map ऑब्जेक्ट्स के भीतर खोजने के प्रभावी तरीके।
खोज कार्यक्षमताओं के चरण-दर-चरण कार्यान्वयन।
व्यापक कोड वॉकथ्रू।
विभिन्न खोज विधियों का तुलनात्मक विश्लेषण।

इस ईबुक के अंत तक, आप Java अनुप्रयोगों में मजबूत खोज तंत्रों को लागू करने का ज्ञान प्राप्त कर लेंगे, जो शुरुआती लोगों और बुनियादी ज्ञान वाले डेवलपर्स दोनों के लिए समर्पित हैं।

जावा कलेक्शन्स फ्रेमवर्क को समझना
जावा कलेक्शन्स फ्रेमवर्क डेटा के समूहों को एकल इकाई के रूप में संग्रहित और प्रबंधित करने के लिए कक्षाओं और इंटरफेसों का एक सेट प्रदान करता है। कलेक्शन्स कुशल डेटा संग्रह, पुनर्प्राप्ति, और प्रबंधन की अनुमति देती हैं, जिससे वे जावा प्रोग्रामिंग में अपरिहार्य बन जाती हैं।
मुख्य इंटरफेस और क्लासेस

List Interface: एक क्रमबद्ध संग्रह (जिसे अनुक्रम भी कहा जाता है) का प्रतिनिधित्व करता है। उदाहरणों में ArrayList, LinkedList, और Vector शामिल हैं।
Set Interface: एक संग्रह का प्रतिनिधित्व करता है जो डुप्लिकेट तत्वों की अनुमति नहीं देता। उदाहरणों में HashSet, LinkedHashSet, और TreeSet शामिल हैं।
Map Interface: एक संग्रह का प्रतिनिधित्व करता है जो कीज़ को वैल्यूज़ से मैप करता है, बिना डुप्लिकेट कीज़ की अनुमति के। उदाहरणों में HashMap, TreeMap, और LinkedHashMap शामिल हैं।
Queue Interface: एक संग्रह का प्रतिनिधित्व करता है जिसे संसाधन से पहले तत्वों को रखने के लिए डिज़ाइन किया गया है। उदाहरणों में LinkedList, PriorityQueue, और ArrayDeque शामिल हैं।

कलेक्शन्स फ्रेमवर्क का महत्व

कुशलता: विभिन्न डेटा संरचनाओं के लिए अनुकूलित कार्यान्वयन प्रदान करता है।
लचीलापन: विभिन्न आवश्यकताओं को पूरा करने के लिए इंटरफेसेस और क्लासेस की विस्तृत श्रृंखला प्रदान करता है।
इंटरऑपरबिलिटी: विभिन्न कलेक्शन्स के बीच आसान एकीकरण को सुविधाजनक बनाता है।
रखरखाव योग्य: मानकीकृत इंटरफेसेस के माध्यम से साफ-सुथरा और अधिक रखरखाव योग्य कोड को बढ़ावा देता है।


कलेक्शन्स में बाइनरी सर्च
बाइनरी सर्च एक अत्यधिक कुशल एल्गोरिदम है जो क्रमबद्ध आइटमों की सूची से एक आइटम खोजने के लिए उपयोग किया जाता है। यह खोज अंतराल को बार-बार आधे में विभाजित करके काम करता है, जिससे समय जटिलता O(log n) तक कम हो जाती है, जहाँ n कलेक्शन में तत्वों की संख्या है।
बाइनरी सर्च कैसे काम करता है

Initialization: तत्वों की पूरी सीमा के साथ शुरू करें।
Midpoint Calculation: वर्तमान सीमा के मध्य तत्व को निर्धारित करें।
Comparison: लक्षित वैल्यू की तुलना मध्य तत्व से करें।

यदि समान है, तो खोज सफल है।
यदि लक्ष्य कम है, तो खोज को निचली आधे पर दोहराएं।
यदि लक्ष्य अधिक है, तो खोज को ऊपरी आधे पर दोहराएं।


Termination: यदि सीमा खाली हो गई है, तो लक्ष्य मौजूद नहीं है।

Java में बाइनरी सर्च लागू करना
Java Collections क्लास में एक बिल्ट-इन बाइनरी सर्च मेथड प्रदान करता है:




		
		
			
			
Java
			
			
int index = Collections.binarySearch(list, key);

			
				
					
				
					1
2
3
				
						 
int index = Collections.binarySearch(list, key);
 
					
				
			
		


- Prerequisite: बाइनरी सर्च करने से पहले सूची को सॉर्ट किया जाना चाहिए।
- Return Value: यदि खोज की सूची में है, तो खोज कुंजी का इंडेक्स लौटाता है; अन्यथा, (-insertion point - 1) लौटाता है।
बाइनरी सर्च के लाभ

गति: लॉगरिदमिक समय में खोजें करता है।
सरलता: Java के बिल्ट-इन मेथड्स का उपयोग करके लागू करना आसान है।
कुशलता: किसी तत्व को खोजने के लिए आवश्यक तुलना की संख्या को कम करता है।


मैप्स पर बाइनरी सर्च की सीमाएँ
जबकि बाइनरी सर्च क्रमबद्ध सूचियों के लिए शक्तिशाली है, यह Java में Map कलेक्शन्स के मामले में सीमित है।
मुख्य सीमाएँ

मैप्स की अनसॉर्टेड प्रकृति:

अधिकांश Map इम्प्लीमेंटेशन्स, जैसे कि HashMap, कीज़ के क्रम को बनाए नहीं रखते हैं, जिससे बाइनरी सर्च अनुपयोगी हो जाती है।
सॉर्टेड मैप्स जैसे कि TreeMap भी एलिमेंट्स तक रैंडम एक्सेस का समर्थन नहीं करते हैं, जो बाइनरी सर्च के लिए आवश्यक है।


इंडेक्स-आधारित एक्सेस की कमी:

बाइनरी सर्च इंडेक्स द्वारा तत्वों तक पहुंचने पर निर्भर करता है, जो Map इंटरफेस के साथ संभव नहीं है।
Maps की डिजाइन की-वैल्यू पेयरिंग के लिए की गई है, न कि क्रमबद्ध इंडेक्सिंग के लिए।


इटरेशन की जटिलता:

Map पर बाइनरी सर्च करने का प्रयास करने से इसे कीज़ या वैल्यूज़ की एक क्रमबद्ध सूची में परिवर्तित करने की आवश्यकता होगी, जिससे ओवरहेड बढ़ता है।



वैकल्पिक दृष्टिकोण
इन सीमाओं को देखते हुए, Map कलेक्शन्स के भीतर कुशलतापूर्वक खोज करने के लिए वैकल्पिक विधियों की आवश्यकता होती है। इनमें शामिल हैं:

Direct Key Lookup: जब की ज्ञात हो, तो map.get(key) जैसे मेथड्स का उपयोग करना।
Iterative Search: कुछ मापदंडों के आधार पर कीज़ या वैल्यूज़ को ढूंढने के लिए Map के माध्यम से इटरेट करना।


मैप्स में खोज
Map कलेक्शन्स के भीतर खोज दो मुख्य तरीकों से की जा सकती है:

Direct Key Lookup (map.get(key)): जब की ज्ञात हो, तो संबंधित वैल्यू प्राप्त करना सीधा और कुशल है।
Finding Keys by Value: जब वैल्यू ज्ञात हो, लेकिन की नहीं, तो संबंधित की को खोजने के लिए इटरेटिव सर्च आवश्यक है।

map.get(key) का उपयोग करना
map.get(key) मेथड एक विशिष्ट की के साथ जुड़ी वैल्यू को प्राप्त करने का सीधे तरीका प्रदान करता है।
लाभ

कुशलता: HashMap इम्प्लीमेंटेशन्स के लिए स्थिर-समय प्रदर्शन (O(1))।
सरलता: सीधे और लागू करने में आसान।

उदाहरण




		
		
			
			
Java
			
			
Map<String, String> map = new HashMap<>();
map.put("001", "Chand");
map.put("002", "Alex");

String value = map.get("001"); // Returns "Chand"

			
				
					
				
					1
2
3
4
5
6
7
				
						 
Map<String, String> map = new HashMap<>();
map.put("001", "Chand");
map.put("002", "Alex");
 
String value = map.get("001"); // Returns "Chand"
 
					
				
			
		


वैल्यू द्वारा कीज़ ढूंढना
जब वैल्यू ज्ञात हो, और संबंधित की को पहचानने की आवश्यकता हो, तो Map के माध्यम से इटरेशन करना आवश्यक होता है।
Value द्वारा Key खोजने के चरण

keySet के माध्यम से इटरेट करें: Map में सभी कीज़ तक पहुंचें।
वैल्यू्स की तुलना करें: प्रत्येक की के लिए, संबंधित वैल्यू प्राप्त करें और इसे लक्षित वैल्यू के साथ तुलना करें।
Key प्राप्त करें: यदि मैच मिलता है, तो संबंधित की प्राप्त करें।

उदाहरण




		
		
			
			
Java
			
			
Map<String, String> map = new HashMap<>();
map.put("001", "Chand");
map.put("002", "Alex");

String targetValue = "Alex";
String foundKey = null;

for (String key : map.keySet()) {
    if (map.get(key).equals(targetValue)) {
        foundKey = key;
        break; // Exit loop once the key is found
    }
}

System.out.println("Key for value 'Alex': " + foundKey);

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						 
Map<String, String> map = new HashMap<>();
map.put("001", "Chand");
map.put("002", "Alex");
 
String targetValue = "Alex";
String foundKey = null;
 
for (String key : map.keySet()) {
    if (map.get(key).equals(targetValue)) {
        foundKey = key;
        break; // Exit loop once the key is found
    }
}
 
System.out.println("Key for value 'Alex': " + foundKey);
 
					
				
			
		



मैप्स में खोज लागू करना: चरण-दर-चरण
Map कलेक्शन्स के भीतर प्रभावी खोज तंत्रों को लागू करने के लिए, इन विस्तृत चरणों का पालन करें:
चरण 1: मैप को इनिशियलाइज़ करें
शुरू करने के लिए, Map को की-वैल्यू जोड़ों के साथ बनाएं और पॉप्युलेट करें।




		
		
			
			
Java
			
			
Map<String, String> map = new HashMap<>();
map.put("001", "Chand");
map.put("002", "Alex");
map.put("003", "Jordan");

			
				
					
				
					1
2
3
4
5
6
				
						 
Map<String, String> map = new HashMap<>();
map.put("001", "Chand");
map.put("002", "Alex");
map.put("003", "Jordan");
 
					
				
			
		


चरण 2: Direct Key Lookup
जब की ज्ञात हो, तो वैल्यू प्राप्त करने के लिए map.get(key) का उपयोग करें।




		
		
			
			
Java
			
			
String value = map.get("002"); // Returns "Alex"

			
				
					
				
					1
2
3
				
						 
String value = map.get("002"); // Returns "Alex"
 
					
				
			
		


चरण 3: वैल्यू द्वारा Key के लिए इटरेटिव सर्च
जब वैल्यू ज्ञात हो, तो संबंधित की को खोजने के लिए Map के माध्यम से इटरेट करें।




		
		
			
			
Java
			
			
String targetValue = "Jordan";
String foundKey = null;

for (String key : map.keySet()) {
    if (map.get(key).equals(targetValue)) {
        foundKey = key;
        break; // Exit loop once the key is found
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						 
String targetValue = "Jordan";
String foundKey = null;
 
for (String key : map.keySet()) {
    if (map.get(key).equals(targetValue)) {
        foundKey = key;
        break; // Exit loop once the key is found
    }
}
 
					
				
			
		


चरण 4: इटरेशन को बेहतर बनाना
विशेष रूप से बड़े Maps के साथ प्रदर्शन बढ़ाने के लिए, keySet() की तुलना में entrySet() का उपयोग करने पर विचार करें ताकि get ऑपरेशन्स की संख्या कम हो सके।




		
		
			
			
Java
			
			
for (Map.Entry<String, String> entry : map.entrySet()) {
    if (entry.getValue().equals(targetValue)) {
        foundKey = entry.getKey();
        break;
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
				
						 
for (Map.Entry<String, String> entry : map.entrySet()) {
    if (entry.getValue().equals(targetValue)) {
        foundKey = entry.getKey();
        break;
    }
}
 
					
				
			
		


चरण 5: कई मैचों को संभालना
यदि कई कीज़ समान वैल्यू साझा करती हैं, तो break स्टेटमेंट को हटा दें और सभी मिलते-जुलते कीज़ को इकट्ठा करें।




		
		
			
			
Java
			
			
List<String> matchingKeys = new ArrayList<>();

for (Map.Entry<String, String> entry : map.entrySet()) {
    if (entry.getValue().equals(targetValue)) {
        matchingKeys.add(entry.getKey());
    }
}

System.out.println("Keys for value 'Alex': " + matchingKeys);

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						 
List<String> matchingKeys = new ArrayList<>();
 
for (Map.Entry<String, String> entry : map.entrySet()) {
    if (entry.getValue().equals(targetValue)) {
        matchingKeys.add(entry.getKey());
    }
}
 
System.out.println("Keys for value 'Alex': " + matchingKeys);
 
					
				
			
		



कोड वॉकथ्रू
चलो एक पूर्ण Java प्रोग्राम का अन्वेषण करें जो सीधे लुकअप और इटरेटिव सर्च दोनों का उपयोग करके Map के भीतर खोज को प्रदर्शित करता है।
पूर्ण कोड उदाहरण




		
		
			
			
Java
			
			
import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        // Initialize the Map
        Map<String, String> employeeMap = new HashMap<>();
        employeeMap.put("001", "Chand");
        employeeMap.put("002", "Alex");
        employeeMap.put("003", "Jordan");
        employeeMap.put("004", "Alex"); // Duplicate value

        // Direct Key Lookup
        String employeeName = employeeMap.get("002");
        System.out.println("Employee with ID '002': " + employeeName);

        // Find Key by Value (Single Match)
        String targetValue = "Jordan";
        String foundKey = null;

        for (Map.Entry<String, String> entry : employeeMap.entrySet()) {
            if (entry.getValue().equals(targetValue)) {
                foundKey = entry.getKey();
                break; // Exit loop after finding the first match
            }
        }

        if (foundKey != null) {
            System.out.println("Employee ID for 'Jordan': " + foundKey);
        } else {
            System.out.println("Employee 'Jordan' not found.");
        }

        // Find Keys by Value (Multiple Matches)
        String duplicateValue = "Alex";
        List<String> matchingKeys = new ArrayList<>();

        for (Map.Entry<String, String> entry : employeeMap.entrySet()) {
            if (entry.getValue().equals(duplicateValue)) {
                matchingKeys.add(entry.getKey());
            }
        }

        if (!matchingKeys.isEmpty()) {
            System.out.println("Employee IDs for 'Alex': " + matchingKeys);
        } else {
            System.out.println("Employee 'Alex' not found.");
        }
    }
}

			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
				
						 
import java.util.HashMap;
import java.util.Map;
 
public class Main {
    public static void main(String[] args) {
        // Initialize the Map
        Map<String, String> employeeMap = new HashMap<>();
        employeeMap.put("001", "Chand");
        employeeMap.put("002", "Alex");
        employeeMap.put("003", "Jordan");
        employeeMap.put("004", "Alex"); // Duplicate value
 
        // Direct Key Lookup
        String employeeName = employeeMap.get("002");
        System.out.println("Employee with ID '002': " + employeeName);
 
        // Find Key by Value (Single Match)
        String targetValue = "Jordan";
        String foundKey = null;
 
        for (Map.Entry<String, String> entry : employeeMap.entrySet()) {
            if (entry.getValue().equals(targetValue)) {
                foundKey = entry.getKey();
                break; // Exit loop after finding the first match
            }
        }
 
        if (foundKey != null) {
            System.out.println("Employee ID for 'Jordan': " + foundKey);
        } else {
            System.out.println("Employee 'Jordan' not found.");
        }
 
        // Find Keys by Value (Multiple Matches)
        String duplicateValue = "Alex";
        List<String> matchingKeys = new ArrayList<>();
 
        for (Map.Entry<String, String> entry : employeeMap.entrySet()) {
            if (entry.getValue().equals(duplicateValue)) {
                matchingKeys.add(entry.getKey());
            }
        }
 
        if (!matchingKeys.isEmpty()) {
            System.out.println("Employee IDs for 'Alex': " + matchingKeys);
        } else {
            System.out.println("Employee 'Alex' not found.");
        }
    }
}
 
					
				
			
		


कोड का स्पष्टीकरण

Import Statements:

HashMap और Map को आयात किया जाता है ताकि Map इंटरफेस और इसकी HashMap इम्प्लीमेंटेशन का उपयोग किया जा सके।


Main Class:

public class Main: प्रोग्राम का प्रवेश बिंदु।


Initializing the Map:

Map<String, String> employeeMap = new HashMap<>();: कर्मचारी आईडी और नाम संग्रहीत करने के लिए HashMap बनाता है।
employeeMap.put("001", "Chand");: मैप में की-वैल्यू जोड़े जोड़ता है।


Direct Key Lookup:

String employeeName = employeeMap.get("002");: की "002" से संबंधित वैल्यू प्राप्त करता है।
System.out.println(...): परिणाम आउटपुट करता है।


Finding a Single Key by Value:

entrySet() के माध्यम से इटरेट करता है ताकि वैल्यू "Jordan" से संबंधित की को ढूंढा जा सके।
पहली मैच मिलने पर लूप तोड़ देता है।
पाई गई की या नहीं मिलने का संदेश आउटपुट करता है।


Finding Multiple Keys by Value:

वैल्यू "Alex" से संबंधित सभी कीज़ के लिए खोज करता है।
मिलती-जुलती कीज़ को List में इकट्ठा करता है।
सभी पाई गई कीज़ या नहीं मिलने का संदेश आउटपुट करता है।



प्रोग्राम का आउटपुट




		
		
			
			
Java
			
			Employee with ID '002': Alex
Employee ID for 'Jordan': 003
Employee IDs for 'Alex': [002, 004]
			
				
					
				
					1
2
3
				
						Employee with ID '002': Alex
Employee ID for 'Jordan': 003
Employee IDs for 'Alex': [002, 004]
					
				
			
		



खोज विधियों की तुलना
जावा में Map कलेक्शन्स में विभिन्न खोज विधियों की दक्षता और प्रयोज्यता को बेहतर समझने के लिए, चलिए सीधे की लुकअप और इटरेटिव सर्च की तुलना करें।


मानदंड
Direct Key Lookup (map.get(key))
Iterative Search (Map traversal)


प्रदर्शन
O(1) - स्थिर समय
O(n) - रैखिक समय


उपयोग मामला
जब की ज्ञात हो
जब वैल्यू ज्ञात हो और की की आवश्यकता हो


जटिलता
सरल और सीधा
अधिक जटिल, इटरेशन शामिल है


बड़े मैप्स के लिए उपयुक्तता
स्थिर समय के कारण अत्यधिक उपयुक्त
समय रैखिक रूप से बढ़ने के कारण कम उपयुक्त


कोड की सरलता
उच्च
मध्यम


कई मैचों को संभालना
लागू नहीं
अतिरिक्त लॉजिक के साथ लागू किया जा सकता है


किस विधि का उपयोग कब करें

Direct Key Lookup: उन परिदृश्यों के लिए आदर्श जहाँ की आसानी से उपलब्ध हो और संबंधित वैल्यू को जल्दी से प्राप्त करने की आवश्यकता हो।
Iterative Search: आवश्यक है जब वैल्यू ज्ञात हो और संबंधित कीज़ की पहचान की जानी हो। यह विधि उन स्थितियों में अनिवार्य है जहाँ रिवर्स लुकअप की आवश्यकता होती है।


निष्कर्ष
कुशल डेटा पुनर्प्राप्ति मजबूत Java अनुप्रयोगों के विकास में महत्वपूर्ण है। कलेक्शन्स फ्रेमवर्क में विभिन्न खोज तंत्रों की क्षमताओं और सीमाओं को समझने से डेवलपर्स को उनके विशिष्ट उपयोग मामलों के अनुसार सूचित निर्णय लेने में सशक्त किया जाता है।
मुख्य निष्कर्ष

Collections Framework: विभिन्न ऑपरेशन्स के लिए प्रत्येक को अनुकूलित विभिन्न डेटा संरचनाएं प्रदान करता है।
Binary Search: क्रमबद्ध सूचियों के लिए अत्यधिक कुशल है लेकिन Map कलेक्शन्स पर सीधे लागू नहीं हो सकता है उनकी अंतर्निहित संरचना के कारण।
Maps and Searching:

Direct Key Lookup (map.get(key)): कुंजी ज्ञात होने पर वैल्यू प्राप्त करने के लिए स्थिर-समय प्रदर्शन प्रदान करता है।
Iterative Search: ज्ञात वैल्यू के आधार पर कीज़ को खोजने के लिए आवश्यक, हालांकि रैखिक समय जटिलता के साथ।


Optimization Tips:

अधिक कुशल इटरेशन के लिए keySet() की बजाय entrySet() का उपयोग करें।
प्रदर्शन बढ़ाने के लिए खोज आवश्यकताओं के आधार पर उपयुक्त डेटा संरचनाओं को लागू करें।



इन खोज तकनीकों का प्रभावी ढंग से उपयोग करके, डेवलपर्स सुनिश्चित कर सकते हैं कि उनके Java अनुप्रयोगों में अनुकूलित प्रदर्शन और स्केलेबिलिटी बनी रहे।
SEO Keywords: Java Collections Framework, binary search in Java, searching in Java Maps, map.get method, iterative search in maps, Java HashMap search, finding keys by value, Java programming tips, efficient data retrieval, Java developer guide

अतिरिक्त संसाधन

आधिकारिक Java डाक्यूमेंटेशन
Java HashMap ट्यूटोरियल
Java Maps को समझना
Effective Java प्रोग्रामिंग
Java प्रोग्रामिंग सर्वोत्तम प्रथाएँ


नोट: यह लेख AI द्वारा निर्मित है।
मानदंड	Direct Key Lookup (map.get(key))	Iterative Search (Map traversal)
प्रदर्शन	O(1) - स्थिर समय	O(n) - रैखिक समय
उपयोग मामला	जब की ज्ञात हो	जब वैल्यू ज्ञात हो और की की आवश्यकता हो
जटिलता	सरल और सीधा	अधिक जटिल, इटरेशन शामिल है
बड़े मैप्स के लिए उपयुक्तता	स्थिर समय के कारण अत्यधिक उपयुक्त	समय रैखिक रूप से बढ़ने के कारण कम उपयुक्त
कोड की सरलता	उच्च	मध्यम
कई मैचों को संभालना	लागू नहीं	अतिरिक्त लॉजिक के साथ लागू किया जा सकता है