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

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

सरणियों के बारे में एक और रोचक तथ्य। सारणियाँ केवल एक आयामी (रैखिक) नहीं होती हैं। वे द्वि-आयामी भी हो सकते हैं।

इसका क्या मतलब है, आप पूछें?

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

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} };

ऐसे कई स्थान हैं जहाँ आपको एक प्रोग्रामर के रूप में द्वि-आयामी सरणी की आवश्यकता हो सकती है। द्वि-आयामी सरणियाँ लगभग हर बोर्ड गेम की नींव हैं, जैसे शतरंज, चेकर्स, टिक-टैक-टो और समुद्री युद्ध:

शतरंज या समुद्री युद्ध के लिए द्वि-आयामी सरणियाँ एकदम सही हैं। हमें केवल सेल निर्देशांक से संख्याएँ चाहिए। 'प्यादा e2-e4' नहीं, बल्कि 'प्यादा (5,2) -> (5,4)'। एक प्रोग्रामर के तौर पर आपके लिए यह और भी आसान हो जाएगा।

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

वैसे, यहाँ एक दिलचस्प दुविधा है:

जब हम का उपयोग करके एक सरणी बनाते हैं , तो क्या हमारे पास 'दो पंक्तियों और 5 कॉलमnew int[2][5]; ' की तालिका है या यह 'दो कॉलम और 5 पंक्तियाँ ' है?" दूसरे शब्दों में, क्या हम पहले चौड़ाई और फिर ऊंचाई निर्दिष्ट कर रहे हैं... या इसके विपरीत, पहले ऊँचाई और फिर चौड़ाई ठीक है, जैसा कि हम अक्सर कहते हैं, यहाँ सब कुछ इतना सरल नहीं है।

आइए इस सवाल से शुरू करें कि एरे को मेमोरी में कैसे स्टोर किया जाता है ।

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

"चौड़ाई x ऊँचाई" के पक्ष में तर्क।

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

"ऊँचाई x चौड़ाई" के पक्ष में तर्क।

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

// 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 कॉलम के साथ एक मैट्रिक्स मिलता है।

जमीनी स्तर

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

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

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

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

और अब आप सीखेंगे कि वास्तव में द्वि-आयामी सरणियों को कैसे व्यवस्थित किया जाता है। तैयार?

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

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

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

इस प्रकार द्वि-आयामी सरणियाँ वास्तव में काम करती हैं। और यह दृष्टिकोण जावा प्रोग्रामर को कई फायदे देता है:

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

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}
};

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