जवाबों:
सरणियों (दांतेदार सरणियों) की सरणी बहु-आयामी सरणियों की तुलना में तेज होती है और इसका उपयोग अधिक प्रभावी ढंग से किया जा सकता है। बहुआयामी सरणियों में अच्छे सिंटैक्स होते हैं।
यदि आप दांतेदार और बहुआयामी सरणियों का उपयोग करते हुए कुछ सरल कोड लिखते हैं और फिर एक IL disassembler के साथ संकलित असेंबली का निरीक्षण करते हैं, तो आप देखेंगे कि दांतेदार (या एकल आयामी) सरणियों से भंडारण और पुनर्प्राप्ति सरल IL हैं, जबकि बहुआयामी सरणियों के लिए समान संचालन विधि हैं इनवोकेशन जो हमेशा धीमे होते हैं।
निम्नलिखित तरीकों पर विचार करें:
static void SetElementAt(int[][] array, int i, int j, int value)
{
array[i][j] = value;
}
static void SetElementAt(int[,] array, int i, int j, int value)
{
array[i, j] = value;
}उनके आईएल निम्नलिखित होंगे:
.method private hidebysig static void SetElementAt(int32[][] 'array',
int32 i,
int32 j,
int32 'value') cil managed
{
// Code size 7 (0x7)
.maxstack 8
IL_0000: ldarg.0
IL_0001: ldarg.1
IL_0002: ldelem.ref
IL_0003: ldarg.2
IL_0004: ldarg.3
IL_0005: stelem.i4
IL_0006: ret
} // end of method Program::SetElementAt
.method private hidebysig static void SetElementAt(int32[0...,0...] 'array',
int32 i,
int32 j,
int32 'value') cil managed
{
// Code size 10 (0xa)
.maxstack 8
IL_0000: ldarg.0
IL_0001: ldarg.1
IL_0002: ldarg.2
IL_0003: ldarg.3
IL_0004: call instance void int32[0...,0...]::Set(int32,
int32,
int32)
IL_0009: ret
} // end of method Program::SetElementAtदांतेदार सरणियों का उपयोग करते समय आप आसानी से पंक्ति स्वैप और पंक्ति आकार बदलने जैसे कार्य कर सकते हैं। शायद कुछ मामलों में बहुआयामी सरणियों का उपयोग अधिक सुरक्षित होगा, लेकिन यहां तक कि Microsoft FxCop भी बताता है कि जब आप अपनी परियोजनाओं का विश्लेषण करने के लिए इसका उपयोग करते हैं तो बहुआयामी के बजाय दांतेदार सरणियों का उपयोग किया जाना चाहिए।
एक बहुआयामी सरणी एक अच्छा रैखिक स्मृति लेआउट बनाता है जबकि दांतेदार सरणी परोक्ष के कई अतिरिक्त स्तरों का अर्थ है।
jagged[3][6]एक दांतेदार सरणी में मान को देखते हुए var jagged = new int[10][5]इस तरह काम करता है: सूचकांक 3 पर तत्व को देखें (जो एक सरणी है) और उस सरणी में सूचकांक 6 पर तत्व को देखें (जो कि एक मूल्य है)। इस मामले में प्रत्येक आयाम के लिए, एक अतिरिक्त नज़र है (यह एक महंगी मेमोरी एक्सेस पैटर्न है)।
एक बहुआयामी सरणी को रैखिक रूप से मेमोरी में रखा जाता है, वास्तविक मूल्य इंडेक्स को एक साथ गुणा करके पाया जाता है। हालांकि, सरणी को देखते हुए var mult = new int[10,30], Lengthउस बहुआयामी सरणी की संपत्ति तत्वों की कुल संख्या यानी 10 * 30 = 300 वापस करती है।
Rankदांतेदार सरणी की संपत्ति हमेशा 1 होती है, लेकिन बहुआयामी सरणी में कोई भी रैंक हो सकती है। GetLengthकिसी भी सरणी की विधि का उपयोग प्रत्येक आयाम की लंबाई प्राप्त करने के लिए किया जा सकता है। इस उदाहरण में बहुआयामी सरणी के लिए mult.GetLength(1)30 देता है।
बहुआयामी सरणी अनुक्रमण तेज है। उदाहरण के लिए इस उदाहरण में बहुआयामी सरणी दिया गया mult[1,7]= 30 * 1 + 7 = 37, उस सूचकांक 37 पर तत्व प्राप्त करें। यह एक बेहतर मेमोरी एक्सेस पैटर्न है क्योंकि केवल एक मेमोरी लोकेशन शामिल है, जो कि सरणी का आधार पता है।
एक बहुआयामी सरणी इसलिए एक निरंतर मेमोरी ब्लॉक आवंटित करता है, जबकि एक दांतेदार सरणी को वर्ग नहीं होना चाहिए, उदाहरण के jagged[1].Lengthलिए समान नहीं jagged[2].Lengthहोना चाहिए, जो कि किसी भी बहुआयामी सरणी के लिए सही होगा।
प्रदर्शन बुद्धिमान, बहुआयामी सरणियाँ तेज होनी चाहिए। बहुत तेजी से, लेकिन वास्तव में खराब सीएलआर कार्यान्वयन के कारण वे नहीं हैं।
23.084 16.634 15.215 15.489 14.407 13.691 14.695 14.398 14.551 14.252
25.782 27.484 25.711 20.844 19.607 20.349 25.861 26.214 19.677 20.171
5.050 5.085 6.412 5.225 5.100 5.751 6.650 5.222 6.770 5.305 पहली पंक्ति दांतेदार सरणियों का समय है, दूसरा बहुआयामी सरणियों को दिखाता है और तीसरा, यह है कि यह कैसा होना चाहिए। कार्यक्रम नीचे दिखाया गया है, FYI करें यह रनिंग मोनो का परीक्षण किया गया था। (विंडोज़ टाइमिंग बहुत अलग हैं, ज्यादातर सीएलआर कार्यान्वयन विविधताओं के कारण)।
खिड़कियों पर, दांतेदार सरणियों का समय बहुत बेहतर होता है, मेरी खुद की व्याख्या के बारे में कि क्या बहुआयामी सरणी की तरह दिखना चाहिए, 'सिंगल ()' देखें। अफसोस की बात है कि विंडोज़ JIT- कंपाइलर वास्तव में बेवकूफ है, और यह दुर्भाग्य से ये प्रदर्शन चर्चाओं को कठिन बना देता है, बहुत अधिक असंगतताएं हैं।
ये मुझे खिड़कियों पर मिली टाइमिंग हैं, यहाँ एक ही सौदा, पहली पंक्ति दांतेदार सरणियाँ हैं, दूसरी बहुआयामी और तीसरी मेरी अपनी बहुआयामी कार्यान्वयन, ध्यान दें कि मोनो की तुलना में खिड़कियों पर यह कितना धीमा है।
8.438 2.004 8.439 4.362 4.936 4.533 4.751 4.776 4.635 5.864
7.414 13.196 11.940 11.832 11.675 11.811 11.812 12.964 11.885 11.751
11.355 10.788 10.527 10.541 10.745 10.723 10.651 10.930 10.639 10.595सोर्स कोड:
using System;
using System.Diagnostics;
static class ArrayPref
{
const string Format = "{0,7:0.000} ";
static void Main()
{
Jagged();
Multi();
Single();
}
static void Jagged()
{
const int dim = 100;
for(var passes = 0; passes < 10; passes++)
{
var timer = new Stopwatch();
timer.Start();
var jagged = new int[dim][][];
for(var i = 0; i < dim; i++)
{
jagged[i] = new int[dim][];
for(var j = 0; j < dim; j++)
{
jagged[i][j] = new int[dim];
for(var k = 0; k < dim; k++)
{
jagged[i][j][k] = i * j * k;
}
}
}
timer.Stop();
Console.Write(Format,
(double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
}
Console.WriteLine();
}
static void Multi()
{
const int dim = 100;
for(var passes = 0; passes < 10; passes++)
{
var timer = new Stopwatch();
timer.Start();
var multi = new int[dim,dim,dim];
for(var i = 0; i < dim; i++)
{
for(var j = 0; j < dim; j++)
{
for(var k = 0; k < dim; k++)
{
multi[i,j,k] = i * j * k;
}
}
}
timer.Stop();
Console.Write(Format,
(double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
}
Console.WriteLine();
}
static void Single()
{
const int dim = 100;
for(var passes = 0; passes < 10; passes++)
{
var timer = new Stopwatch();
timer.Start();
var single = new int[dim*dim*dim];
for(var i = 0; i < dim; i++)
{
for(var j = 0; j < dim; j++)
{
for(var k = 0; k < dim; k++)
{
single[i*dim*dim+j*dim+k] = i * j * k;
}
}
}
timer.Stop();
Console.Write(Format,
(double)timer.ElapsedTicks/TimeSpan.TicksPerMillisecond);
}
Console.WriteLine();
}
}सीधे शब्दों में कहें तो बहुआयामी सरणियाँ DBMS की तालिका के समान हैं।
ऐरे का एरे (दांतेदार ऐरे) आपको प्रत्येक तत्व को एक ही प्रकार की एक अन्य प्रकार की चर लंबाई रखने देता है।
इसलिए, यदि आप सुनिश्चित हैं कि डेटा की संरचना एक तालिका (निश्चित पंक्तियों / स्तंभों) की तरह दिखती है, तो आप एक बहुआयामी सरणी का उपयोग कर सकते हैं। दांतेदार सरणी निश्चित तत्व हैं और प्रत्येक तत्व चर लंबाई की एक सरणी पकड़ सकते हैं
जैसे प्यूसेकोड:
int[,] data = new int[2,2];
data[0,0] = 1;
data[0,1] = 2;
data[1,0] = 3;
data[1,1] = 4;उपरोक्त को 2x2 तालिका के रूप में सोचें:
1 | 2 3 | 4
int[][] jagged = new int[3][];
jagged[0] = new int[4] { 1, 2, 3, 4 };
jagged[1] = new int[2] { 11, 12 };
jagged[2] = new int[3] { 21, 22, 23 }; कॉलम की परिवर्तनशील संख्या वाली प्रत्येक पंक्ति के रूप में उपरोक्त के बारे में सोचें:
1 | 2 | 3 | 4 11 | 12 21 | 22 | 23
प्रस्तावना: यह टिप्पणी ओकटाइन द्वारा दिए गए उत्तर को संबोधित करने के लिए है , लेकिन एसओ की मूर्खतापूर्ण प्रतिष्ठा प्रणाली के कारण, मैं इसे पोस्ट नहीं कर सकता जहां यह है।
आपका यह कहना कि विधि कॉल सही नहीं होने के कारण एक दूसरे की तुलना में धीमी है। अधिक जटिल सीमा-जाँच एल्गोरिदम के कारण एक दूसरे की तुलना में धीमा है। आप IL पर नहीं, बल्कि संकलित असेंबली में देखकर इसे आसानी से सत्यापित कर सकते हैं। उदाहरण के लिए, मेरे 4.5 इंस्टॉल पर, एक तत्व को एक्सेस करना (edx में पॉइंटर के माध्यम से) एक दो-आयामी सरणी में संग्रहीत है, जो ईएक्सएक्स द्वारा ईएक्सएक्स और ईएक्सएक्स में संग्रहीत इंडेक्स के साथ इंगित किया गया है, ऐसा दिखता है:
sub eax,[ecx+10]
cmp eax,[ecx+08]
jae oops //jump to throw out of bounds exception
sub edx,[ecx+14]
cmp edx,[ecx+0C]
jae oops //jump to throw out of bounds exception
imul eax,[ecx+0C]
add eax,edx
lea edx,[ecx+eax*4+18]यहां, आप देख सकते हैं कि मेथड कॉल से कोई ओवरहेड नहीं है। चेकिंग की सीमा गैर-शून्य अनुक्रमित की संभावना के लिए बस बहुत ही जटिल है, जो कि दांतेदार सरणियों के साथ प्रस्ताव पर नहीं एक कार्यक्षमता है। यदि हम गैर-शून्य मामलों के लिए उप, सीएमपी और जेएमपीएस को हटा देते हैं, तो कोड बहुत अधिक हल हो जाता है (x*y_max+y)*sizeof(ptr)+sizeof(array_header)। यह गणना जितनी तेजी से होती है (एक को एक शिफ्ट से गुणा किया जा सकता है, क्योंकि पूरे कारण हम बाइट्स को दो बिट्स की शक्तियों के आकार का चुनते हैं) एक तत्व के लिए यादृच्छिक उपयोग के लिए और कुछ के रूप में।
एक और जटिलता यह है कि ऐसे बहुत से मामले हैं जहां एक आधुनिक संकलक एकल-आयाम सरणी पर पुनरावृति करते हुए तत्व अभिगम के लिए नेस्टेड सीमा-जाँच का अनुकूलन करेगा। परिणाम कोड है कि मूल रूप से सिर्फ सरणी की सन्निहित स्मृति पर एक सूचकांक सूचक अग्रिम है। बहु-आयामी सरणियों पर Naive पुनरावृत्ति में आमतौर पर नेस्टेड तर्क की एक अतिरिक्त परत शामिल होती है, इसलिए एक संकलक ऑपरेशन का अनुकूलन करने की कम संभावना है। इसलिए, भले ही किसी एकल तत्व तक पहुँचने की सीमा-जाँच ओवरहेड सरणी आयामों और आकारों के संबंध में निरंतर क्रम से बाहर हो जाती है, अंतर को मापने के लिए एक साधारण परीक्षण-मामले को निष्पादित करने में कई बार अधिक समय लग सकता है।
मैं इस पर अपडेट करना चाहूंगा, क्योंकि .NET कोर में मल्टी-डायमेंशनल एरेज, जैग्ड एरे की तुलना में तेज होता है । मैंने जॉन लीडग्रेन से परीक्षण चलाया और ये .NET कोर 2.0 पूर्वावलोकन पर परिणाम हैं। मैंने पृष्ठभूमि एप्लिकेशन से किसी भी संभावित प्रभाव को कम दृश्यमान बनाने के लिए आयाम मान बढ़ाया।
Debug (code optimalization disabled)
Running jagged
187.232 200.585 219.927 227.765 225.334 222.745 224.036 222.396 219.912 222.737
Running multi-dimensional
130.732 151.398 131.763 129.740 129.572 159.948 145.464 131.930 133.117 129.342
Running single-dimensional
91.153 145.657 111.974 96.436 100.015 97.640 94.581 139.658 108.326 92.931
Release (code optimalization enabled)
Running jagged
108.503 95.409 128.187 121.877 119.295 118.201 102.321 116.393 125.499 116.459
Running multi-dimensional
62.292 60.627 60.611 60.883 61.167 60.923 62.083 60.932 61.444 62.974
Running single-dimensional
34.974 33.901 34.088 34.659 34.064 34.735 34.919 34.694 35.006 34.796 मैंने असंतुष्टों में देखा और यही मैंने पाया
jagged[i][j][k] = i * j * k; निष्पादित करने के लिए 34 निर्देशों की आवश्यकता है
multi[i, j, k] = i * j * k; निष्पादित करने के लिए 11 निर्देशों की आवश्यकता है
single[i * dim * dim + j * dim + k] = i * j * k; निष्पादित करने के लिए 23 निर्देशों की आवश्यकता है
मैं यह पहचानने में सक्षम नहीं था कि एकल-आयामी सरणियाँ अभी भी बहु-आयामी से अधिक तेज़ क्यों हैं, लेकिन मेरा अनुमान है कि यह सीपीयू पर किए गए कुछ अनुकूलन के साथ करना है
बहु-आयाम सरणियाँ (n-1) -dimension matrices हैं।
तो int[,] square = new int[2,2]वर्ग मैट्रिक्स 2x2 है, int[,,] cube = new int [3,3,3]एक घन - वर्ग मैट्रिक्स 3x3 है। आनुपातिकता की आवश्यकता नहीं है।
दांतेदार सरणियाँ केवल सारणियां हैं - एक सरणी जहां प्रत्येक कोशिका में एक सरणी होती है।
तो एमडीए आनुपातिक हैं, जेडी नहीं हो सकता है! प्रत्येक सेल में मनमानी लंबाई की एक सरणी हो सकती है!
अन्य उत्तरों के अलावा, ध्यान दें कि ढेर पर एक बड़ी चक्रीय वस्तु के रूप में एक बहुआयामी सरणी आवंटित किया गया है। इसके कुछ निहितार्थ हैं:
<gcAllowVeryLargeObjects>बहुआयामी सरणियों के तरीके पर गौर करना चाहेंगे ।मैं एक रूपांतरण करने के लिए उपयोग करने के लिए assemnblies, वर्गों, विधियों और संग्रहीत कार्यविधियों के डेटाबेस का निर्माण करने के लिए ildasm द्वारा उत्पन्न फ़ाइल। पार्स कर रहा हूं। मैं निम्नलिखित में आया, जिसने मेरी पार्सिंग को तोड़ दिया।
.method private hidebysig instance uint32[0...,0...]
GenerateWorkingKey(uint8[] key,
bool forEncryption) cil managedसर्ज लिडिन, एप्रेस की पुस्तक एक्सपर्ट .NET 2.0 आईएल असेंबलर, 2006, अध्याय 8, आदिम प्रकार और हस्ताक्षर प्रकाशित, पीपी। 149-150 बताते हैं।
<type>[]का वेक्टर कहा जाता है <type>,
<type>[<bounds> [<bounds>**] ] की एक सरणी कहा जाता है <type>
**साधन दोहराया जा सकता है, [ ]वैकल्पिक का मतलब है।
उदाहरण: चलो <type> = int32।
1) int32[...,...]अपरिभाषित निचले सीमा और आकार का एक दो आयामी सरणी है
2) int32[2...5]निचले बाउंड 2 और आकार 4 का एक आयामी आयाम है।
3) int32[0...,0...]कम सीमा 0 और अपरिभाषित आकार का एक दो आयामी सरणी है।
टॉम
double[,]एक आयताकार सरणी है, जबकिdouble[][]एक "दांतेदार सरणी" के रूप में जाना जाता है। प्रत्येक पंक्ति के लिए पहले में "कॉलम" की संख्या समान होगी, जबकि दूसरी विल (संभावित) में प्रत्येक पंक्ति के लिए "कॉलम" की एक अलग संख्या होगी।