ऐरे क्या है?
ऐरे एक ही प्रकार के कई मानों को एक नाम से रखता है। नंबर लिखे लॉकरों की पंक्ति सोचिए।
- हर लॉकर एक एलिमेंट है।
- उसका नंबर इंडेक्स है, जो 0 से शुरू होता है।
- एलिमेंट की संख्या लंबाई (length) है। आख़िरी इंडेक्स = length − 1।
Python: scores = [72, 85, 90, 64, 78]
Java: int[] scores = {72, 85, 90, 64, 78};
C++: int scores[5] = {72, 85, 90, 64, 78};एक मान पढ़ना: scores[1] = 85। बदलना: scores[3] = 70। scores[5] माँगना त्रुटि है (index out of bounds), क्योंकि छठा डिब्बा है ही नहीं।
लूप से ऐरे का ट्रैवर्सल
ट्रैवर्सल यानी हर एलिमेंट पर क्रम से एक बार जाना। लूप यह करता है, इसलिए वही कोड 5 मानों पर भी चलता है और 5,000 पर भी। इसी से लिस्ट हल को सामान्य बनाती है।
Python: for i in range(len(a)): print(a[i])
Java: for (int i = 0; i < a.length; i++) { ... }
for (int x : a) { ... }
C++: for (int i = 0; i < n; i++) { ... }i < length लिखें, i <= length नहीं, वरना लूप अंत से एक डिब्बा आगे चला जाएगा।
ऐरे के मुख्य एल्गोरिद्म
- योग और औसत: total = 0, हर मान जोड़ो, औसत = total / length।
- सबसे बड़ा / छोटा: पहले मान से शुरू करो, बड़ा (छोटा) मिले तो बदल दो।
- गिनती: शर्त पूरी हो (जैसे अंक ≥ 50) तो 1 जोड़ो।
- लीनियर सर्च: हर डिब्बा जाँचो; लक्ष्य मिले तो उसका इंडेक्स लौटाओ, न मिले तो −1।
- उलटना और अदला-बदली: पहले आधे भाग में a[i] को a[n−1−i] से बदलो।
big = a[0]
for x in a:
if x > big: big = x
2D ऐरे: पंक्ति और स्तंभ
2D ऐरे पंक्तियों का ऐरे है। grid[r][c] पंक्ति r और स्तंभ c का खाना है (दोनों 0 से)।
Java: int[][] g = new int[3][4]; // 3 पंक्ति, 4 स्तंभ Python: g = [[1, 2, 3], [4, 5, 6]]
पंक्ति-क्रम (row-major): बाहर पंक्तियों का लूप, अंदर स्तंभों का। स्तंभ-क्रम (column-major): बाहर स्तंभों का लूप। आम काम: पंक्ति का योग, स्तंभ का योग, ग्रिड में सबसे बड़ा, खाने खोजना।
ऐरे, लिस्ट और दूसरी डेटा संरचनाएँ
| ऐरे | लिस्ट (ArrayList, Python list) | |
|---|---|---|
| आकार | बनाते समय तय | बढ़-घट सकता है |
| जोड़ना/हटाना | नहीं, नया ऐरे बनाना पड़ता है | add, insert, remove |
| लंबाई | a.length | size() / len() |
Java की ArrayList केवल ऑब्जेक्ट रखती है, इसलिए संख्याएँ रैपर क्लास में जाती हैं: int के लिए Integer, double के लिए Double। Java यह बदलाव अपने-आप करता है (ऑटोबॉक्सिंग और अनबॉक्सिंग)।
दूसरी संरचनाएँ: डिक्शनरी कुंजी से मान ढूँढती है, सेट केवल अलग-अलग मान रखता है, स्टैक/क्यू निकालने का क्रम तय करते हैं।
करके देखें: आपके हफ़्ते के कदम
7 दिन तक रोज़ के कदम (या व्यायाम के मिनट) लिखें। उन्हें 7 लंबाई के ऐरे में रखें। हाथ से लूप चलाएँ: कुल, औसत, सबसे अच्छा दिन (सबसे बड़े मान का इंडेक्स), और कितने दिन 5,000 से ऊपर रहे। फिर किसी भी भाषा में टाइप करके उत्तर जाँचें।
मुख्य सूत्र और परिभाषाएँ
- इंडेक्स 0 से length − 1 तक
- a[i] पढ़ता है, a[i] = v बदलता है
- औसत = योग / लंबाई
- 2D: g[row][col]; पंक्तियाँ = g.length, स्तंभ = g[0].length
- लीनियर सर्च: n एलिमेंट में अधिकतम n जाँच
हल किए गए उदाहरण
1. a = [4, 9, 2, 7]। a[0], a[3], लंबाई और आख़िरी इंडेक्स बताइए।
a[0] = 4, a[3] = 7, लंबाई = 4, आख़िरी इंडेक्स = 3।
2. [5, 3, 8] पर योग वाला लूप चलाइए।
total = 0 → 5 → 8 → 16। औसत = 16 / 3 ≈ 5.33।
3. [6, 11, 4, 11, 9] में सबसे बड़ा मान और उसका पहला इंडेक्स?
big = 6, फिर 11 (इंडेक्स 1)। दूसरा 11 बड़ा नहीं, इसलिए नहीं बदला। उत्तर 11, इंडेक्स 1।
4. [3, 7, 1] में 7 की लीनियर सर्च। कितनी तुलनाएँ?
3 ≠ 7, 7 = 7 → इंडेक्स 1 पर, 2 तुलनाओं में मिला।
5. g = [[1, 2, 3], [4, 5, 6]]। g[1][0], पंक्ति-योग और स्तंभ-योग?
g[1][0] = 4। पंक्ति-योग 6 और 15। स्तंभ-योग 5, 7, 9।
6. [1, 2, 3, 4, 5] को उसी ऐरे में उलटिए।
a[0]↔a[4], a[1]↔a[3] बदलें; बीच वाला वहीं → [5, 4, 3, 2, 1]। सिर्फ़ 2 अदला-बदली।
आम गलतियाँ
- इंडेक्स 1 से शुरू मानना: पहला एलिमेंट a[0] है।
- i <= length वाला लूप: यह अंत से आगे जाकर त्रुटि देता है।
- सबसे बड़ा मान 0 से शुरू करना: सभी मान ऋणात्मक हों तो ग़लत उत्तर। a[0] से शुरू करें।
- 2D में g[row][col] का क्रम उलटना, या स्तंभ गिनने के लिए g.length लेना।