C# Çok Boyutlu Diziler – En Ayrıntılı Anlatım

C# Çok Boyutlu Diziler – En Ayrıntılı Anlatım ile c sharp eğitimlerimize devam ediyoruz. Önceki derslerimde ArrayList ile Dizi karşılaştırmasını yapmıştık. Ancak dizilerin kullanımı sadece list olarak (tek boyutlu) değil birden fazla boyutlu olabilir. Tablo mantığı gibi düşünebilirsiniz.  Bir dizi birden fazla boyut aldığında tablo mantığına dönüşür satırlar ve stunlar içerir. Bu dersimizde de bu mantığı anlatmaya çalışacağım. Dilerseniz C sharp çok boyutlu diziler ‘e geçelim.

Diziler normal değişken tanımlar gibi tanımlarız. Ancak ufak bir fark ile. Bu fark köşeli parantezlerdir. Bir değişken türünün yanında köşeli parantez varsa o kesinlikle bir dizidir.

C Sharp çok boyutlu diziler

Düzenli Diziler

Düzenli diziler her satırda aynı sayıda kolon barındıran dizilerdir. Bir sql tablosu gibi düşünün. Her kolon ile hücre bir yerde çakışır. Tam anlatamadım belki ama aşağıdaki görsele baktığınızda anlayacaksınız. :)

Öncelikle tek boyutlu diziye bakalım.

int[] Dizi = new int[3];

İki boyutlu bir dizi nasıl tanımlanır görelim. Aşağıda tanımlanmış olan dizi, iki boyutlu bir dizidir. Dört satır ve iki stun alır.

int[,] dizi = new int[4, 2];

Üç boyutlu bir dizini nasıl tanımlanır onu da görelim.

int[, ,] dizi_ = new int[4, 2, 3];

Örneklere göz attığımızda her boyut için bir virgül kullandığımızı görmüşsünüzdür.  Düzenli dizi tanımlanırken aralara virgül konulara boyutlar artırılabilir.

int[,] array2D = new int[,] { 
    { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } 
    
};

int[,] array2Da = new int[4, 2] { 
    { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } 
    
};


string[,] array2Db = new string[3, 2] { 
    { "one", "two" }, { "three", "four" }, { "five", "six" } 
    
};


int[, ,] array3D = new int[,,] { 
    { { 1, 2, 3 }, { 4, 5, 6 } }, 
    { { 7, 8, 9 }, { 10, 11, 12 } } 
    
};

int[, ,] array3Da = new int[2, 2, 3] {
    { { 1, 2, 3 }, { 4, 5, 6 } }, 
    { { 7, 8, 9 }, { 10, 11, 12 } } 
    
};

Yukarıdaki örneklere baktığımızda çok boyutlu dizilere değer atama işlemlerini görebiliriz. Ancak 3 boyutlu dizileri anlamak biraz zordur. Çok fazla da işimize yaramazlar daha doğrusu çok fazla kullanmayız. En azından ben hiç üç boyutlu dizi kullanmadım. Ancak mantığını bildiğimden sizlere de anlatıyorum.

Şimdi yukarıdaki üç boyutlu dizi örneklerinden birisi üzerinden olayın mantığını açıklamaya çalışayım.

            int[,,] Dizi_3D = new int[2, 3, 4]           
           // 2 Satır
           // 3 Kolon
           // Her kolonda 4 değer
            {
                { // satır 1
                    { // Kolon 1
                      1, // Değer 1
                      2, // Değer 2
                      3, // Değer 3
                      4  // Değer 4
                    }, 

                    { 4, 6, 7 ,8} , // Kolon 2
                    { 9, 10, 11 ,12} // Kolon 3
                },

                { // satır 2
                    { 12, 11, 10, 9 }, // Kolon 1
                    { 8, 7, 6, 5 }, // Kolon 2
                    { 4, 3, 2, 1 } // Kolon 3
                },

            };

Yukarıdaki örneği inceleyerek 3 boyutlu dizinin mantığını anlayabilirsiniz. Dört boyutlu dizilerde de değerlerin içerisinde değerler olacaktır.

Her hücresinde bir tablo olan bir tablo düşünün. Sanırım bu en kısa ve en anlaşılır anlatım şeklidir.

Yani şöyle;

            int[,,,] Dizi_4D = new int[1, 2, 3, 4]   
            // 1 Satır
            // 2 Kolon
            // Her kolonda 3 değer
            // Her değerin içerisinde 4 değer        
            {
                { // satır 1
                   { // Kolon 1
                      { // Değer 1
                        1, // Değerin Değeri 1
                        2, // Değerin Değeri 2
                        3, // Değerin Değeri 3
                        4  // Değerin Değeri 4
                       }, 
                      { 1 ,2, 3, 4}, // Değer 2
                      { 1 ,2, 3, 4}, // Değer 3                      
                    },

                    { // Kolon 2  
                      { 1 ,2, 3, 4},  // Değer 1
                      { 1 ,2, 3, 4},  // Değer 2
                      { 1 ,2, 3, 4},  // Değer 3                        
                    }                   
                }
            };

Çok boyutlu dizilerin mantığı bu şekildedir. Şimdi de bu değerleri nasıl alabiliriz ona bakalım.

            int _int = Dizi_4D[1,2,3,4];
            // 1. satırın
            // 2. kolonunun
            // 3. değerinin
            // 4. değerini almış oluyoruz.

            int _int2 = Dizi_4D[1, 2, 2, 3];
            // 1. satırın
            // 2. kolonunun
            // 2. değerinin
            // 3. değerini almış oluyoruz.

Dizilerden veri okuma da bu şekildedir.

C sharp çok boyutlu diziler örnek

Olayı daha da iyi anlamanız için dört boyutlu bir dizi üzerinden şöyle örnek hazırladım. Ekran görüntüsü ile birlikte paylaşıyorum.

        private void Form1_Load(object sender, EventArgs e)
        {
            int[,,,] Dizi_4D = new int[1, 2, 3, 4]
            {{{{ 1, 2, 3, 4},
               { 5 ,6, 7, 8},
               { 9 ,10, 11, 12}},

              {{ 13 ,14, 15, 16},
               { 17 ,18, 19, 20},
               { 21 ,22, 23, 24}}}};


            //Dizi elemanlarini for döngüsü ile bulmak.
            for (int row = 0; row < Dizi_4D.GetLength(0); row++)
            {
                listBox1.Items.Add(Dizi_4D[row, 0, 0, 0].ToString());


                for (int col = 0; col < Dizi_4D.GetLength(1); col++)
                {
                    listBox2.Items.Add(Dizi_4D[row, col, 0, 0].ToString());


                    for (int colrow = 0; colrow < Dizi_4D.GetLength(2); colrow++)
                    {
                        listBox3.Items.Add(Dizi_4D[row, col, colrow, 0].ToString());


                        for (int colRowcol = 0; colRowcol < Dizi_4D.GetLength(3); colRowcol++)
                        {
                            listBox4.Items.Add(Dizi_4D[row, col, colrow, colRowcol].ToString());
                        }
                    }
                }
            }
        }

Düzensiz Diziler

Düzenli dizilerin tersidir. Yine tam olarak anlatamıyorum. :)

Düzensiz dizilerin tanımla şekilleri de düzenli dizilere göre biraz farklıdır. Şöyle ki;

int[][] DuzensizDizi = new int[3][];

Yukarıdaki tanımlama şekli iki boyutlu düzensiz bir dizidir. Üç satır olacağını belirttik ama kolon sayısı vermedik. Bu şekilde yukarıdaki görsel görünen şekilde bir dizi oluşturabiliriz.

Düzensiz dizilere değer atama şekilleri de şöyledir;

            int[][] DuzensizDizi = new int[3][];


            DuzensizDizi[0] = new int[5];
            DuzensizDizi[1] = new int[4];
            DuzensizDizi[2] = new int[2];


            DuzensizDizi[0] = new int[] { 1, 3, 5, 7, 9 };
            DuzensizDizi[1] = new int[] { 0, 2, 4, 6 };
            DuzensizDizi[2] = new int[] { 11, 22 };


            int[][] DuzensizDizi2 = new int[][]
                    {
                        new int[] {1,3,5,7,9},
                        new int[] {0,2,4,6},
                        new int[] {11,22}
                    };

            int[][] DuzensizDizi3 =
                    {
                        new int[] {1,3,5,7,9},
                        new int[] {0,2,4,6},
                        new int[] {11,22}
                    };


            DuzensizDizi3[0][1] = 77;

Örneklerde gördüğünüz gibi, DuzensizDizi3’de 0. indexe yani ilk satıra beş değer, ikinci satıra dört değer, üçüncü satırada iki değer atadık. Düzenli dizilerde bu şekilde bir tanımlama yada değer ataması yapamayız.

Aynı zamanda bir dizi tanımlarken, hem düzenli hemde düzensiz diziyi aynı anda kullanabiliriz.

int[][,] DuzensizDizi4 = new int[3][,] 
{
    new int[,] { {1,3}, {5,7} },
    new int[,] { {0,2}, {4,6}, {8,10} },
    new int[,] { {11,22}, {99,88}, {0,9} , {100,200} } 
};

Yukarıdaki örnekte gördüğünüz gibi hem düzenli hemde düzensiz diziyi aynı anda kullandık. İki boyutlu düzensiz dizinin ikinci boyutuna iki boyutlu düzenli dizi ataması yapmış olduk.

Düzensiz dizilerdeki gibi satırlardaki kolonlara denk gelecek hücrelerde bir sınırlama yok. Yani bir satırda iki hücre, bir satırda on hücre olabilir. Ama her değer ikili olmak zorundadır.

Düzenli dizilerde for döngüsü kullandık ancak düzensiz dizilerde, yukarıda bahsetmeye çalıştığım satır / kolon uyuşmazlığı nedeni ile for döngüsü kullanamayız. Düzensiz dizilerde foreach döngüsü kullanabiliriz.

            int[][] DuzensizDizi2 = new int[][]
                     {
                        new int[] {1,3,5,7,9},
                        new int[] {0,2,4,6},
                        new int[] {11,22}
                     };

            foreach (int[] row in DuzensizDizi2)
            {
                listBox1.Items.Add(row.ToString());
                // Buna gerek yoktur
                // Ancak eklenirse alacağımız sonucu göstermek için ekledim.
                foreach (int col in row)
                {
                    listBox2.Items.Add(col.ToString());
                }
                 // Satırları birbirinden ayrı görmek istediğimiz için...
                listBox2.Items.Add("-----------------");
            }

        }

İlk foreach içerisinde eklemeye çalıştığımız elemanlar dizi içerdiğinden dolayı, en soldaki listbox’a değerler değil türünün ne olduğu geldi. Örnek kodlarda da belirttiğim gibi ikinci foeach içerisinden gelecek olanlar bizim istediğimiz değerler olacaktır.

C Sharp Çok Boyutlu Diziler – En Ayrıntılı Anlatım dersimizde bu kadar dostlar. Umarım çok boyutlu dizilerin mantığını güzelce anlatabilmişimdir. Elimden geldiğince anlayacağınız şekilde anlatmaya çalıştım.

C Sharp Eğitim Seti ve ERP Programlama ders listesi için tıklayınız. 

Bu dersi hazırlarken aşağıdaki siteden destek aldım.

1 – www.docs.microsoft.com

Takipte ve sağlıcakla kalınız. ;)