Arrays.binarySearch
क्रमबद्ध Arrays में खोजें
Arrays.binarySearch, CoddyKit पर Java Academy का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह Java Academy सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
क्रमबद्ध ऐरे में खोज
Arrays.binarySearch किसी क्रमबद्ध ऐरे में तत्व को O(log n) समय में खोजता है। यह खोज-सीमा को बार-बार आधा करता है, इसलिए हर तत्व को जाँचने की तुलना में बहुत तेज़ है।
क्रमबद्ध होने की पूर्वशर्त
ऐरे पहले से आरोही क्रम में क्रमबद्ध होना चाहिए। यदि ऐसा नहीं है, तो परिणाम अनिश्चित होता है। संदेह होने पर हमेशा पहले Arrays.sort करें।
एक मूलभूत खोज
जब मान मिल जाता है, तो binarySearch उसका इंडेक्स लौटाता है।
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] nums = {2, 4, 6, 8, 10};
int index = Arrays.binarySearch(nums, 8);
System.out.println("Found at index " + index);
}
}मान न मिलने पर
यदि मान मौजूद नहीं है, तो रिटर्न मान ऋणात्मक होता है: यह -(insertionPoint) - 1 के बराबर होता है। insertion point वह स्थान है जहाँ ऐरे को क्रमबद्ध रखने के लिए मान रखा जाता।
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] nums = {2, 4, 6, 8, 10};
int result = Arrays.binarySearch(nums, 5);
System.out.println("Raw result: " + result);
}
}Insertion point प्राप्त करना
ऋणात्मक परिणाम को इंसर्शन इंडेक्स में बदलने के लिए -(result) - 1 की गणना करें। इससे पता चलता है कि न मिले मान को कहाँ रखना है।
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] nums = {2, 4, 6, 8, 10};
int result = Arrays.binarySearch(nums, 5);
if (result < 0) {
int insertionPoint = -(result) - 1;
System.out.println("Would insert at index " + insertionPoint);
}
}
}ऑब्जेक्ट ऐरे में खोज
binarySearch प्राकृतिक क्रम का उपयोग करके ऑब्जेक्ट ऐरे पर भी काम करता है। ऐरे उसी क्रम में क्रमबद्ध होना चाहिए जिस क्रम में खोज तुलना करती है।
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
String[] names = {"Alice", "Bob", "Charlie", "Dave"};
int index = Arrays.binarySearch(names, "Charlie");
System.out.println("Charlie at index " + index);
}
}Comparator से खोज
यदि ऐरे को कस्टम Comparator से क्रमबद्ध किया गया था, तो आपको binarySearch में वही Comparator पास करना होगा; अन्यथा परिणाम अर्थहीन होंगे।
import java.util.Arrays;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
String[] names = {"Dave", "Charlie", "Bob", "Alice"};
Comparator<String> desc = Comparator.reverseOrder();
Arrays.sort(names, desc);
int index = Arrays.binarySearch(names, "Charlie", desc);
System.out.println("Index: " + index);
}
}एक सीमा में खोज
आप binarySearch(array, fromIndex, toIndex, key) से खोज को ऐरे के एक हिस्से तक सीमित कर सकते हैं। सीमा की सीमाएँ sort के समान समावेशी-बहिष्कारी नियम का पालन करती हैं।
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] nums = {2, 4, 6, 8, 10, 12};
int index = Arrays.binarySearch(nums, 1, 5, 8);
System.out.println("Index: " + index);
}
}डुप्लिकेट का परिणाम निश्चित नहीं
यदि ऐरे में समान मान कई बार हैं, तो यह गारंटी नहीं है कि कौन-सा मेल खाता इंडेक्स लौटाया जाएगा। बाइनरी खोज का उपयोग अद्वितीय कुंजियों वाले ऐरे पर करना सबसे अच्छा है।
केवल लूप क्यों न चलाएँ
रैखिक खोज O(n) होती है और क्रमबद्ध न किए गए डेटा पर भी काम करती है। बाइनरी खोज O(log n) होती है, लेकिन इसके लिए क्रमबद्ध डेटा आवश्यक है। बड़े डेटा-संग्रह में बार-बार खोज के लिए एक बार क्रमबद्ध करके कई बार बाइनरी खोज करना बहुत लाभदायक होता है।
सब कुछ साथ में
क्रमबद्ध करें, फिर खोजें और परिणाम की सुरक्षित रूप से व्याख्या करें।
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] ids = {40, 10, 30, 20};
Arrays.sort(ids);
int r = Arrays.binarySearch(ids, 30);
if (r >= 0) {
System.out.println("Found 30 at index " + r);
} else {
System.out.println("Not found; insert at " + (-(r) - 1));
}
}
}त्वरित जाँच
binarySearch की अपनी समझ की जाँच करें।
पुनरावलोकन
आपने Arrays.binarySearch से तेज़ खोज करना सीखा।
- ऐरे को पहले क्रमबद्ध करना आवश्यक है।
- गैर-ऋणात्मक परिणाम मिला हुआ इंडेक्स होता है।
- ऋणात्मक परिणाम insertion point को
-(result) - 1के रूप में रखता है। - क्रमबद्ध करने और खोजने के लिए एक ही Comparator का उपयोग करें।
एआई शिक्षक के साथ Java सीखें — निःशुल्क
अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।
- पाठ्यक्रम
- 104
- पाठ
- 374
अक्सर पूछे जाने वाले प्रश्न
क्या “Arrays.binarySearch” पाठ निःशुल्क है?
हाँ—“Arrays.binarySearch” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और Java Academy पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। Java Academy पाठ्यक्रम में कुल 4 पाठ शामिल हैं।
“Arrays.binarySearch” में मैं क्या सीखूँगा?
क्रमबद्ध Arrays में खोजें आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ Java Academy का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।
क्या Java Academy शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?
पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर Java Academy शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।
“Arrays.binarySearch” पाठ पूरा करने में कितना समय लगता है?
CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।
क्या मैं इस Java Academy पाठ में कोड लिख और चला सकता हूँ?
हाँ। हर Java Academy पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।
इस पाठ्यक्रम के सभी पाठ
- Arrays.sort और क्रमबद्ध करना
- Arrays.binarySearch
- Arrays.fill और copyOf
- Arrays.equals और toString