DİZİLER

GirişDizi bir kümedir. Aynı tipteki verilere tek bir isimle erişmek için kullanılır. Bir dizi bildirildikten sonra, dizinin bütün elemanları bellekte peşpeşe saklanır [1]. Bu yüzden dizilere tek bir isim altında çok sayıda değişken içeren bellek bölgesi de denir. Buna göre bir diziyi dizi yapan iki temel özellik vardır [2]:

• dizi elemanların bellekte sürekli biçimde bulunması
  
• dizi elemanların aynı türden değişkenler olması
  

Dizilerin BildirimiBir dizi çok sayıda değişken barındırdığından, bunları birbirinden ayırdetmek için indis adı verilen bir bilgiye ihtiyaç vardır. C Programlama Dili'nde, bir dizi hangi tipte tanımlanmış olursa olsun başlangıç indisi her zaman 0'dır.
Bir dizinin bildirim işleminin genel biçimi söyledir: tip dizi_adı[eleman_sayısı];
Örneğin, 5 elemanlı bazı kütle verilerini tutmak için kutle dizisi şöyle tanımlanabilir: float kutle[5];
Bu dizinin elemanlarına bir değer atama işlemi şöyle olabilir: kutle[0] = 8.471
kutle[1] = 3.683
kutle[2] = 9.107
kutle[3] = 4.739
kutle[4] = 3.918






NOT

1. elemanın indisi 0, 5. elemanın indisinin 4 olduğuna dikkat edin.

Bildirim sırasında dizilerin eleman sayısı tamsayı türünden bir sabit ifadesiyle belirtilmesi zorunludur. Örneğin:
int n=100;
int a[n];
şeklindeki tanımlama, dizi uzunluğunun değişken (n) ile belirtilmesi nedeniyle geçersizdir. Bunun yerine dizilerin eleman sayısı sembolik sabitlerle belirtmek mümkündür. Örneğin:
#define n 100
...
int a[n];
Bir dizinin bellekte kapladığı alan bayt cinsinden sizeof operatörü ile öğrenilebilir[4]. Örneğin:
int a[5],b,c;
...
b = sizeof(a); /* bellekte kapladığı alan: b = 4*5 = 20 bayt */
c = sizeof(a)/sizeof(int); /* Dizinin boyutu : c = 20/4 = 5 */

Dizilere Başlangıç Değeri VermeBir diziye başlangıç değerleri aşağıdaki gibi kısa formda atanabilir:
float kutle[5]= { 8.471, 3.683, 9.107, 4.739, 3.918 };
int kilo[3] = { 25, 72, 94 };
double a[4] = { 10.0, 5.2, 7.5, 0.0};
Küme parantezlerinin sonlandırıcı ; karakteri ile bittiğine dikkat ediniz. Bir dizinin uzunluğu belirtilmeden de başlangıç değeri atamak mümkündür. Örneğin:
int a[] = { 100, 200, 300, 400 };
float v[] = { 9.8, 11.0, 7.5, 0.0, 12.5};
Derleyici bu şekilde bir atama ile karşılaştığında, küme parantezi içindeki eleman sayısını hesaplar ve dizinin o uzunlukta açıldığını varsayar. Yukarıdaki örnekte, a dizisinin 4, v dizisinin 5 elemanlı olduğu varsayılır.

Dizileri Yazdırma/Okumaprintf ve scanf fonksiyonları bir dizinin okunması ve yazdırılması için de kullanılır. Örneğin bir A dizisinin aşağıdaki gibi bildirildiğini varsayalım:
int A[10];
Bu dizinin elemanlarını klavyeden okumak için:
for(i=0;i<10;i++)
scanf("%d",&A);
daha sonra bu değerlerini ekrana yazmak için:
for(i=0;i<10;i++)
printf("%d\n",A[i]);
Program 9.1, klavyeden girilen [i]n = 10 adet sayının ortalamasını hesaplar. Ortalama formülü ile hesaplanabilir.

Program 9.1: 10 sayının ortalamasını hesaplar




[color=gray] 1: /* 09prg01.c: 10 tamsayının aritmetik ortalamasını hesaplar */
2:
3: #include <stdio>
4:
5: #define n 10
6:
7: void main(void)
8: {
9: int i,x[n],toplam=0;
10: float ort;
11:
12: for(i=0;i<n> tcc 09prg01.c
C:\TC> 09prg01

$ gcc 09prg01.c -o 09prg01
$ ./09prg01


ÇIKTI




1. sayi : 1
2. sayi : 0
3. sayi : 9
4. sayi : 7
5. sayi : 2
6. sayi : 10
7. sayi : 11
8. sayi : 4
9. sayi : 6
10. sayi : 5
Sayilarin ortalamasi = 5.500000
Program 9.1 dizi kullanmadan da yazılabilirdi. Bazı dizi kullanmak kaçınılmaz olur. Porgram 9.2, n = 10 tane sayının ortalamasını ve standart sapmasını hesaplar.
Standart sapma: formülü ile hesaplanabilir, burada dir.

Program 9.2: n=10 sayının ortalamasını ve standart sapmasını hesaplar




[color=gray] 1: /* 09prg02.c:
2: 10 tamsayının aritmetik ortlamasını ve standart sapmasını hespalar. */
3:
4: #include <stdio>
5: #include <math>
6:
7: #define n 10
8:
9: void main(void)
10: {
11: int i,x[n];
12: int toplam=0;
13: float ort,std_sap=0.0;
14:
15: /* ortalama hesabı */
16: for(i=0;i<n;i++)
17: {
18: printf("%d. sayi : ",i+1);
19: scanf("%d",&x);
20:
21: toplam += x[i];
22: }
23:
24: ort = (float) toplam/n;
25:
26: /* standart sapma hesabı */
27: for(i=0;i<n> tcc 09prg02.c
C:\TC> 09prg02

$ gcc 09prg02.c -o 09prg02
$ ./09prg02


ÇIKTI




1. sayi : 7
2. sayi : 8
3. sayi : 9
4. sayi : 6
5. sayi : 5
6. sayi : 8
7. sayi : 8
8. sayi : 10
9. sayi : 11
10. sayi : 6
Ortalama = 7.000000
Standart sapma = 2.054805

Sıralama (Sorting)Bazı uygulamalarda bir grup sayının büyükten küçüğe, veya küçükten büyüğe, doğru sıralanması gerekebilir. Bu tip sıralama problemleri için çeşitli algoritmalar geliştirilmiştir. Sıralama mantığını anlamadan önce bir dizinin en büyük (veya en küçük) elemanının nasıl bulunduğunu anlamak gerekir. Program 9.3 bir dizinin en büyük elemanını bulup ekrana yazar.

Program 9.3: [i]Bir dizinin en büyük elemanının bulunuşu




[color=gray] 1: /* 09prg03.c:
2: Bir dizinin en büyük elemanını bulup ekrana yazar */
3:
4: #include <stdio>
5:
6: void main(void)
7: {
8: int a[10] = {100, -250, 400, 125 ,550, 900, 689, 450, 347, 700};
9: int k,eb;
10:
11: eb = a[0]; /* ilk eleman en büyük kabul ediliyor */
12:
13: for(k=1;k<10>eb) eb = a[k];
15:
16: printf("En buyuk eleman = %d\n",eb);
17: }
[color:c1a9=gray:c1a9]18:
En büyük sayıyı bulan bu algoritma oldukça kolaydır. 11. satırda eb = a[0]; ataması ile dizinin ilk elemanının en büyük olduğu varsayılır. Daha sonra büyüğe rastladıkça (14. satırda) eb = a[k]; ile eb değişmektedir.

DERLEME ve ÇALIŞTIRMA



MS DOS (Turbo C)
Linux

C:\TC> tcc 09prg03.c
C:\TC> 09prg03

$ gcc 09prg03.c -o 09prg03
$ ./09prg03


ÇIKTI




En buyuk eleman = 900
Program 9.3 bir dizinin en büyük elemanını bulur. En büyük elemanın kaçıncı indis (eleman) olduğu sorgulanmak istendiğinde: programdaki koşul yapısını aşağıdaki gibi değiştirmek yeterlidir. eb değiştikçe, i değişkeni en büyük elemanın indisini tutar.
for(k=0;k<10>eb ){
eb = a[k];
i = k;
}

n elemanlı bir dizinin, elemanlarını büyükten küçüğe doğru sıralamak için çok popüler iki algoritma aşağıda verilmiştir[2].
Seçerek Sıralama (Selection Sort):
En büyük elemanı bul başa koy biçimindeki sıramadır. Algoritmanın uygulaması Program 9.4'de gösterilmiştir.
Bu algoritmada kullanılan kombinasyon sayısı (algoritmanın karmaşıklığı): n*(n-1)/2 dir.

Program 9.4: Seçerek Sıralama (Selection Sort) Algoritması




[color=gray] 1: /* 09prg04.c:
[color=gray] 2: Seçerek Sıralama (Selection Sort) Algoritması ile bir
[color:c1a9=gray:c1a9] 3: dizinin elemanlarını büyükten küçüğe dogru sıralar */
4:
5: #include <stdio>
6:
7: #define n 10
8:
9: void main(void)
10: {
11: int a[n] = {100, -250, 400, 125 ,550, 900, 689, 450, 347, 700};
12: int i,j,k,eb;
13:
14: printf("Once : ");
15: for(k=0;k<n;k++) /* Ekrana yaz */
16: printf("%5d ",a[k]);
17:
18: for(k=0;k<n;k++) /* Sırala */
19: {
20: eb = a[k];
21: i = k;
22:
23: for(j=k+1;j<n>eb){
25: eb = a[j];
26: i = j;
27: }
28: a = a[k];
29: a[k] = eb;
30: }
31:
32: printf("\nSonra: ");
33: for(k=0;k<n> tcc 09prg04.c
C:\TC> 09prg04

$ gcc 09prg04.c -o 09prg04
$ ./09prg04


ÇIKTI




Once : 100 -250 400 125 550 900 689 450 347 700
Sonra: 900 700 689 550 450 400 347 125 100 -250
Kabarcık Sıralama (Bubble Sort):
Yanyana elemanları karşılaştırarak yer değiştir biçimde sıralamadır. Algoritmanın uygulaması Program 9.5'de gösterilmiştir.
Bu algoritmanın karmaşıklığı: (n-1)2 dir.

Program 9.5: [i]Kabarcık Sıralama (Bubble Sort) Algoritması




[color=gray] 1: /* 09prg05.c:
[color=gray] 2: Kabarcık Sıralama (Bubble Sort) Algoritması ile bir
[color:c1a9=gray:c1a9] 3: dizinin elemanlarını büyükten küçüğe dogru sıralar */
4:
5: #include <stdio>
6:
7: #define n 10
8:
9: void main(void)
10: {
11: int a[n] = {100, -250, 400, 125 ,550, 900, 689, 450, 347, 700};
12: int j,k,gecici;
13:
14: printf("Once : ");
15: for(k=0;k<n;k++) /* Ekrana yaz */
16: printf("%5d ",a[k]);
17:
18: for(k=0;k<n-1;k++) /* Sırala */
19: for(j=0;j<n-1;j++)
20: if(a[j]<a[j+1]){
21: gecici = a[j];
22: a[j] = a[j+1];
23: a[j+1] = gecici;
24: }
25:
26: printf("\nSonra: ");
27: for(k=0;k<n> tcc 09prg05.c
C:\TC> 09prg05

$ gcc 09prg05.c -o 09prg05
$ ./09prg05


ÇIKTI




Once : 100 -250 400 125 550 900 689 450 347 700
Sonra: 900 700 689 550 450 400 347 125 100 -250

Karakter Dizileri (Strings)Karakter dizileri en sık kullanılan dizilerdir. Karakterler üzerinde işlemlerin hızlı ve etkin bir biçimde yapılabilmesi için sonlandırcı karakter denilen bir tanımlamdan faydalanılmaktadır[2].


Sonlandırıcı karakter:

• dizinin bittiği yeri gösterir
  
• ASCII tablosunun sıfır numaralı ('\0') karakteridir.
  

Karakter dizilerine iki şekilde başlangıç değeri verilebilir. char s[7] = {'d','e','n','e','m','e','\0'};

yada char s[7] = "deneme";
Birinci tanımlamada sonlandırıcı karakter programcı tarafından konmalıdır. Ikinci tanımlamada ise buna gerek yoktur. Karakter dizileri gets fonksiyonu ile klavyeden okunabilir. Örneğin:
char ad[20];
...
gets(ad);
Karakter dizleri veya katarlar ders 11'de daha ayrıntılı işlenecektir. Burada sadece iki basit örnek sunulmuştur. Program 9.6'da bir karakter dizisinin uzunluğunun nasıl bulunduğu, Program 9.7'de ise bir karakter dizisinin tersyüz edilişi gösterilmiştir. İnceleyiniz.

Program 9.6: Bir karakter dizisinin uzunluğunu bulur




[color=gray] 1: /* 09prg06.c: Bir karakter dizisinin uzunluğunu bulur */
2:
3: #include <stdio>
4:
5: void main(void)
6: {
7: char s[20];
8: int k=0;
9:
10: printf("Bir seyler yazin : ");
11: gets(s); /* diziyi oku */
12:
13: while(s[k]!='\0') /* sonlandırıcı karaktere kadar */
14: k++;
15:
16: printf("Dizinin uzunlugu : %d\n",k);
17: }
[color:1308=gray:1308]18:

DERLEME ve ÇALIŞTIRMA



MS DOS (Turbo C)
Linux

C:\TC> tcc 09prg06.c
C:\TC> 09prg06

$ gcc 09prg06.c -o 09prg06
$ ./09prg06


ÇIKTI




Birseyler yazin : ahmet
Dizinin uzunlugu : 5

Program 9.7: Bir karakter dizisinin tersini bulur




[color=gray] 1: /* 09prg07.c: Bir karakter dizisini tersyüz eder */
2:
3: #include <stdio>
4:
5: void main(void)
6: {
7: char s[20];
8: int i,n,gecici;
9:
10: printf("Bir seyler yazin : ");
11: gets(s); /* diziyi oku */
12:
13: for(n=0;s[n]!='\0';n++) /* sonlandırıcı karaktere kadar */
14: ;
15:
16: for(i=0;i<n> tcc 09prg07.c
C:\TC> 09prg07

$ gcc 09prg07.c -o 09prg07
$ ./09prg07


ÇIKTI




Bir seyler yazin : Deneme
Tersi : emeneD

Çok Boyutlu DizilerBir dizi aşağıdaki gibi bildirildiğinde bir boyutlu (tek indisli) dizi olarak adlandırılır. Bu tip dizilere vektör denir.
float a[9];
Bir dizi birden çok boyuta sahip olabilir. Örneğin iki boyutlu b dizisi şöyle tanımlanabilir:
float b[9][4];
Uygulamada genellikle iki boyutlu dizilere rastlanır. İki boyutlu diziler matris olarak adlandırılır. ilk boyut satır, ikinci boyut sütün denir. Yukarıda b matrisinin eleman sayısı 9x4=36 dır. Bu durumda, genel olarak bir dizi şöyle gösterilir:

Tablo 9.1: Dizlerin Bildirimi



Dizi Çeşiti
Genel Bildirimi
Örnek

Tek boyutlu diziler (Vektörler)
tip dizi_adı[eleman_sayısı]
int veri[10];

İki boyutlu diziler (Matrisler)
tip dizi_adı[satır_sayısı][sutun_sayısı]
float mat[5][4];

Çok boyutlu diziler
tip dizi_adı[boyut_1][boyut_2]...[boyut_n];
double x[2][4][2];Çok boyutlu diziler tek boyuta indir generek bellekte tutulurlar. Tek indisli dizilerde olduğu gibi, çok indisli dizilere de başlangıç değeri vermek mümkün. Örneğin 3 satır 4 sütünlu (3x4=12 eleman) bir x matrisinin elemanları şöyle tanımlanabilir:
int x[3][4] = {11,34,42,60, 72,99,10,50, 80,66,21,38};
yada int x[3][4] = {11,34,42,60, /* 1. satır elemanları */
72,99,10,50, /* 2. satır elemanları */
80,66,21,38}; /* 3. satır elemanları */
Bu matris ekrana 'matris formunda' yazılmak istendiğinde: for(i=0;i<3;i++){
for(j=0;j<4;j++)
printf("%4d",x[j]);
printf("\\n");
}
çıktısı: 11 34 42 60
72 99 10 50
80 66 21 38
şeklinde olacaktır.
Program 9.8 iki matrisin toplamını başka bir matrise aktarır. Matris toplamı formülü ile tanımlıdır. İnceleyiniz.
Program 9.8: [i]İki matrisin toplamı




[color=gray] 1: /* 09prg08.c: iki matrisin toplamı */
2:
3: #include
4:
5: #define SAT 2
6: #define SUT 3
7:
8: void main(void)
9: {
10: int a[SAT][SUT] = {5,3,7, 0,1,2};
11: int b[SAT][SUT] = {1,2,3, 4,5,6};
12: int c[SAT][SUT];
13: int i,j;
14:
15: puts("A Matrisi:");
16: for(i=0;i

Dizilerin Fonksiyonlarda KullanılmasıDiziler de sıradan değişkenler gibi bir fonksiyona parametere olarak akratılabilir. Fakat, aktarma kuralı biraz farklıdır. Her zaman dizinin yanında boyutunun da bilinmesi gerekir.
Program 9.11 de float tipindeki bir dizinin elemanlarının yazdırılması işi bir fonksiyona yaptırılmıştır. Fonkisyona parametre olarak dizinin yanında boyutu da ilave edilmiştir. İnceleyiniz.

Program 9.11: Bir dizinin yazdırılması




[color=gray] 1: /* 09prg11.c: Bir dizinin yazdırılması */
2:
3: #include <stdio>
4:
5: void dizi_yaz(float x[],int boyut); /* yazdırma fonksiyonunun prototipi */
6:
7: void main(void)
8: {
9: float kutle[5]= { 8.471, 3.683, 9.107, 4.739, 3.918 };
10: dizi_yaz(kutle,5); /* dizi yazdırılıyor... */
11: }
12:
13: void dizi_yaz(float x[],int boyut)
14: {
15: int i;
16: for(i=0;i<boyut> tcc 09prg11.c
C:\TC> 09prg11

$ gcc 09prg11.c -o 09prg11
$ ./09prg11


ÇIKTI




8.471 3.683 9.107 4.739 3.918
Eğer dizi boyutu #define önişlemcisi ile belirtilirse boyutun ayrıca parametre olarak kullanılmasına gerek youktur. Bu durumda Program 9.11 şöyle değiştirlebilir:
...
#define BOYUT 5
void dizi_yaz(float x[]);

void main(void)
{
float kutle[BOYUT]= { 8.471, 3.683, 9.107, 4.739, 3.918 };
dizi_yaz(kutle);
}
...
Program 9.3'de bir dizinin en büyük elemanının nasıl bulunduğu gösterilmişti. En büyük elemanı bulma işlemi bir fonksiyona nasıl yaptırıldığı Program 9.12'de gösterilmiştir.

Program 9.12: Bir dizinin en büyük elemanının bulunması




[color=gray] 1: /* 09prg12.c:
2: Bir dizinin en büyük elemanını bulup ekrana yazar */
3:
4: #include <stdio>
5:
6: #define n 10 /* dizinin boyutu */
7: int en_buyuk(int a[]); /* fonksiyon prototipi */
8:
9: void main(void)
10: {
11: int a[n] = {100, -250, 400, 125 ,550, 900, 689, 450, 347, 700};
12: printf("En buyuk eleman = %d\n",en_buyuk(a));
13: }
14:
15: int en_buyuk(int a[])
16: {
17: int k,eb;
18:
19: eb = a[0]; /* ilk eleman en büyük kabul ediliyor */
20: for(k=1;k<n>eb) eb = a[k];
22:
23: return eb; /* en büyüğü gönder! */
[color:5057=gray:5057]24: }
Bu programda, dizinin boyutu sembolik bir sabit olarak 6. satırda belirtilmiştir. 11. satırda tanımlanan a dizisinin en büyük elemanı 12. satırda ekrana yazdırılmıştır. 15. satırdaki en_buyuk fonksiyonunun geri dönüş değeri eb değişkeninde saklıdır. Bu fonksiyon a dizisinin en büyük elemanını gönderir.

DERLEME ve ÇALIŞTIRMA



MS DOS (Turbo C)
Linux

C:\TC> tcc 09prg12.c
C:\TC> 09prg12

$ gcc 09prg12.c -o 09prg12
$ ./09prg12


ÇIKTI




En buyuk eleman = 900
Son olarak bir matrsin bir fonksiyona nasıl aktarılacağı anlatılacaktır. Program 9.10'da bir kare matrisin determinant hesabı gösterilmişti. Program 9.13'de tanımlanan det fonksiyonu, kendinine parametre olarak gelen bir matrisin determinantını bulup çağrıldığı yere gönderir. İnceleyiniz.

Program 9.13: Bir matrisin determinantı




[color=gray] 1:
2: /* 09prg13.c: nxn bir kare matrisin determinantını hesaplar */
3:
4: #include <stdio>
5:
6: #define n 3 /* kare matrisin boyutu */
7: float det(float matris[][]); /* fonksiyon prototipi */
8:
9: void main(void)
10: {
11: float a[n][n],determinant;
12: int i,j;
13:
14: printf("Matrisin kendi formunu girin:\n");
15: for(i=0;i<n;i++)
16: for(j=0;j<n;j++)
17: scanf("%f",&a[i][j]);
18:
19: determinant = det(a); /* det fonksiyonu çağrılıyor */
20:
21: printf("Matrisin determinanti = %f\n",determinant);
22: }
23:
24: /* det(a) fonksiyonu: a matrisinin determinantını gönderir.
[color=gray]25: 1. Matris Gauss yoketme yöntemi ile üst-üçgen forma getirilir.
26: 2. "üst-üçgen matrisin determinantı asal köşegen üzerinde bulunan
[color:5057=gray:5057]27: elemanların çarpımına eşittir" kuralına göre determinat hesaplanır. */
28:
29: float det(float matris[][n])
30: {
31: int i,j,k;
32: float d=1.0;
33:
34: for(k=0 ; k<n-1;k++) /* Gauss yoketme yöntemi */
35: for(i=k+1; i<n ;i++)
36: for(j=k+1; j<n ;j++)
37: matris[i][j] -= matris[k][j] * matris[i][k]/matris[k][k];
38:
39: for(i=0;i<n> tcc 09prg13.c
C:\TC> 09prg13

$ gcc 09prg13.c -o 09prg13
$ ./09prg13


ÇIKTI




Matrisin kendi formunu girin:
7 9 2
3 5 1
0 4 6
Matrisin determinanti = 44.000002