द्वि-आयामी सरणियाँ

Codegym यूनिवर्सिटी कोर्स के भाग के रूप में एक परामर्शदाता के साथ एक व्याख्यान स्निपेट। पूर्ण पाठ्यक्रम के लिए साइन अप करें।

"नमस्कार, अमीगो!"

"नमस्कार, ऋषि!"

"आप पहले से ही सरणियों के बारे में एक या दो चीजें जानते हैं, और आप कुछ कार्यों को हल करने में भी कामयाब रहे हैं, मुझे उम्मीद है। लेकिन आप सब कुछ नहीं जानते हैं। उदाहरण के लिए, यहां सरणियों के बारे में एक और दिलचस्प तथ्य है। सरणियाँ केवल एक-आयामी (रैखिक) नहीं हैं ). वे द्वि-आयामी भी हो सकते हैं।"

"उम ... इसका क्या मतलब है?"

"इसका मतलब है कि सरणी की कोशिकाएं न केवल एक स्तंभ (या पंक्ति) का प्रतिनिधित्व कर सकती हैं, बल्कि एक आयताकार तालिका भी हो सकती हैं।

int[][]name = new int[width][height];

"जहाँ नाम सरणी चर का नाम है, चौड़ाई तालिका की चौड़ाई (कोशिकाओं में) है, और ऊँचाई तालिका की ऊँचाई है। एक उदाहरण देखें:

int[][] data = new int[2][5];
data[1][1] = 5;

"यह स्मृति में कैसा दिखेगा:

"वैसे, द्वि-आयामी सरणी के लिए, आप तेज़ प्रारंभिकरण का भी उपयोग कर सकते हैं:

// Lengths of months of the year in each quarter
int[][] months = { {31, 28, 31}, {30, 31, 30}, {31, 31, 30}, {31, 30, 31} };

"हम्म... अब यह दिलचस्प है। अगर हम कल्पना करें कि पहले आंतरिक कोष्ठक एक तत्व का प्रतिनिधित्व करते हैं, तो अगला एक दूसरा है... तो एक द्वि-आयामी सरणी सरणियों की एक सरणी की तरह है?"

"आप कितने चतुर छात्र हैं! बिल्कुल सही। पहला तत्व एक-आयामी सरणी है {31, 28, 31}, दूसरा है {30, 31, 30}, और इसी तरह। लेकिन हम इस पाठ में थोड़ी देर बाद वापस आएंगे। तब तक, इस बारे में सोचने का प्रयास करें पंक्तियों और स्तंभों के साथ एक तालिका के रूप में एक द्वि-आयामी सरणी, प्रत्येक चौराहे पर सेल बनाती है।

"मेरे पास इसकी एक मानसिक तस्वीर है। वैसे, इन द्वि-आयामी सरणियों के लिए उनका क्या उपयोग किया जाता है?"

"प्रोग्रामर को अक्सर द्वि-आयामी सरणी की आवश्यकता होती है। यदि आप बारीकी से देखते हैं, लगभग किसी भी बोर्ड गेम को ऑफ-द-शेल्फ द्वि-आयामी सरणी का उपयोग करके कार्यान्वित किया जाता है: शतरंज, चेकर्स, टिक-टैक-टो, समुद्री युद्ध, आदि।"

"मैं समझ गया! शतरंज या समुद्री युद्ध का खेल मैदान पूरी तरह से द्वि-आयामी सरणियों पर फिट बैठता है!"

"हां, लेकिन आपको सेल निर्देशांक के रूप में संख्याओं का उपयोग करने की आवश्यकता है। 'पॉन e2-e4' नहीं, बल्कि 'पॉन (5,2) -> (5,4)'। प्रोग्रामर के रूप में यह आपके लिए और भी आसान होगा। "

सरणियों में तत्वों को व्यवस्थित करना: (x, y) या (y, x)

"द्वि-आयामी सरणी बनाना एक दिलचस्प दुविधा पैदा करता है। जब हम का उपयोग करके एक सरणी बनाते हैं , तो क्या हमारे पास 'दो पंक्तियों और 5 कॉलमnew int [2][5]; ' की तालिका होती है या यह 'दो कॉलम और 5 पंक्तियां' होती है?"

"दूसरे शब्दों में, यह पूरी तरह स्पष्ट नहीं है कि क्या हम पहले चौड़ाई निर्दिष्ट कर रहे हैं और फिर 'ऊंचाई... या इसके विपरीत, पहले ऊंचाई और फिर चौड़ाई?"

"हाँ, यही दुविधा है। और इसका कोई निश्चित उत्तर नहीं है।"

"क्या करें?"

"सबसे पहले, यह समझना महत्वपूर्ण है कि हमारी द्वि-आयामी सरणी वास्तव में स्मृति में कैसे संग्रहीत होती है । स्वाभाविक रूप से, कंप्यूटर मेमोरी में वास्तव में इसमें कोई तालिका नहीं होती है: स्मृति में प्रत्येक स्थान में अनुक्रमिक संख्यात्मक पता होता है: 0, 1, 2, ... हमारे लिए, यह एक 2 × 5 टेबल है, लेकिन मेमोरी में यह सिर्फ 10 सेल हैं, इससे ज्यादा कुछ नहीं। पंक्तियों और स्तंभों में कोई विभाजन नहीं।"

"मैं यह समझ गया। फिर हम कैसे निर्धारित करते हैं कि कौन सा आयाम पहले आता है - चौड़ाई या ऊँचाई?"

"आइए पहले विकल्प पर विचार करें। चौड़ाई पहले, फिर ऊंचाई। "इस दृष्टिकोण के पक्ष में तर्क यह है: हर कोई स्कूल में गणित सीखता है, और वे सीखते हैं कि समन्वय जोड़े को 'x' (यानी, क्षैतिज अक्ष) के रूप में लिखा जाता है। और फिर 'y' (ऊर्ध्वाधर आयाम)। और यह सिर्फ एक स्कूल मानक नहीं है - यह गणित में आम तौर पर स्वीकृत मानक है। जैसा कि वे कहते हैं, आप गणित के साथ बहस नहीं कर सकते।"

"क्या ऐसा है? ठीक है, अगर हम इसे नहीं लड़ सकते हैं, तो पहले चौड़ाई और फिर ऊँचाई?"

" 'ऊंचाई पहले, फिर चौड़ाई' के पक्ष में एक दिलचस्प तर्क है । यह तर्क द्वि-आयामी सरणियों के तेजी से आरंभीकरण से आता है। आखिरकार, अगर हम अपनी सरणी को इनिशियलाइज़ करना चाहते हैं, तो हम इस तरह कोड लिखते हैं:"

// Matrix of important data
int[][] matrix = { {1, 2, 3, 4, 5}, {1, 2, 3, 4, 5} };

"तो यह हमारे लिए क्या करता है?"

"क्या आपने कुछ नोटिस किया? अगर हमारे पास यह है तो क्या होगा?

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {1, 2, 3, 4, 5}
};

"यदि हम अपने डेटा को कोड लाइन में लाइन से लिखते हैं, तो हमें 2 पंक्तियों और 5 कॉलम वाली तालिका मिलती है।"

"अब मैं देख रहा हूँ। 2 ऊंचाई है, और 5 चौड़ाई है... तो फिर हमें किस विकल्प का उपयोग करना चाहिए?"

"यह आपको तय करना है कि कौन सा अधिक सुविधाजनक है। सबसे महत्वपूर्ण बात यह है कि एक ही परियोजना पर काम करने वाले सभी प्रोग्रामर एक ही दृष्टिकोण पर टिके रहते हैं।"

"यदि आप किसी ऐसे प्रोजेक्ट पर काम करते हैं जिसके कोड में बहुत से प्रारंभिक द्वि-आयामी सरणी हैं, तो संभवतः वहां सब कुछ तेज़ डेटा प्रारंभिकता पर आधारित होगा, यानी आपके पास मानक 'ऊंचाई x चौड़ाई' होगी।

"यदि आप अपने आप को एक ऐसी परियोजना में पाते हैं जिसमें बहुत सारे गणित शामिल हैं और निर्देशांक (उदाहरण के लिए, गेम इंजन) के साथ काम कर रहे हैं, तो कोड 'चौड़ाई x ऊंचाई' दृष्टिकोण को अपनाएगा।

द्वि-आयामी सरणियों को कैसे व्यवस्थित किया जाता है

"अब, क्या आपको द्वि-आयामी सरणियों की विशेष विशेषता याद है जिसे आपने पाठ की शुरुआत में देखा था?"

"हाँ! यह था कि द्वि-आयामी सरणियाँ वास्तव में सरणियाँ हैं!"

"काफी सही।" दूसरे शब्दों में, यदि एक साधारण सरणी के मामले में एक सरणी चर एक कंटेनर के संदर्भ को संग्रहीत करता है जो सरणी तत्वों को संग्रहीत करता है, तो द्वि-आयामी सरणियों के मामले में स्थिति थोड़ा विस्फोट करती है: एक द्वि-आयामी -अरे वेरिएबल एक कंटेनर के संदर्भ को संग्रहीत करता है जो एक-आयामी सरणियों के संदर्भों को संग्रहीत करता है। इसे सौ बार समझाने की कोशिश करने के बजाय इसे एक बार कार्रवाई में देखना बेहतर है:"

"बाईं ओर , हमारे पास एक द्वि-आयामी-सरणी चर है, जो एक द्वि-आयामी-सरणी वस्तु के संदर्भ को संग्रहीत करता है। बीच में एक द्वि-आयामी सरणी वस्तु होती है, जिसकी कोशिकाएँ एक-आयामी सरणियों को संग्रहीत करती हैं, जो हैं एक द्वि-आयामी सरणी की पंक्तियाँ। और दाईं ओर , आप चार एक-आयामी सरणियाँ देख सकते हैं - हमारे द्वि-आयामी सरणी की पंक्तियाँ। इस तरह द्वि-आयामी सरणियाँ वास्तव में काम करती हैं।

"शानदार! लेकिन यह हमें क्या देता है?"

"चूंकि 'कंटेनर का कंटेनर' 'पंक्तियों की सरणियों' के संदर्भों को संग्रहीत करता है, इसलिए हम पंक्तियों को बहुत जल्दी और आसानी से स्वैप कर सकते हैं। 'कंटेनर का कंटेनर' प्राप्त करने के लिए, आपको केवल दो के बजाय एक इंडेक्स निर्दिष्ट करने की आवश्यकता है। उदाहरण:

int[][] data = new int[2][5];
int[] row1 = data[0];
int[] row2 = data[1];

"नीचे दिए गए कोड को देखें। हम इसका उपयोग पंक्तियों को स्वैप करने के लिए कर सकते हैं:"

// Matrix of important data
int[][] matrix = {
  {1, 2, 3, 4, 5},
  {5, 4, 3, 2, 1}
};

int[] tmp = matrix[0];
matrix[0] = matrix[1];
matrix[1] = tmp;

{
  {5, 4, 3, 2, 1},
  {1, 2, 3, 4, 5}
};

"समझ गया। यह किसी भी दो सामान्य वस्तुओं की अदला-बदली करने जैसा काम करता है।"

"तो यह करता है। ठीक है, यदि आप एक द्वि-आयामी सरणी के एक सेल का संदर्भ देते हैं, लेकिन आप सरणी के नाम के बाद केवल एक इंडेक्स निर्दिष्ट करते हैं, तो आप कंटेनरों के एक कंटेनर का जिक्र कर रहे हैं, जिनकी कोशिकाएं सामान्य एक- के संदर्भों को संग्रहीत करती हैं- आयामी सरणी।"

"सब कुछ तार्किक और स्पष्ट लगता है। व्याख्यान के लिए धन्यवाद, ऋषि!"

"आपका स्वागत है। इसे बुद्धिमानी से व्यवहार में लाएं।"