Tatasusunan

---

Konsep

• Tatasusunan adalah suatu koleksi objek-objek sama jenis yang mempunyai bilangan yang tetap.
• Objek-objek di dalam tatasusunan dipanggil unsur bagi tatasusunan tersebut.
• Unsur-unsur di dalam tatasusunan disimpan berjujukan dalam ingatan komputer.
• Setiap unsur tatasusunan dirujuk dengan menyatakan nama tatasusunan, diikuti dengan satu atau lebih subskrip, yang setiap satunya berada dalam kurungan bersegi.
• Setiap subskrip diwakili dengan integer positif.
• Dalam tatasusunan n unsur. Bilangan subkskrip ialah n-1.Unsur-unsurnya terdiri daripada :

x[0], x[1],x[2],..., x[n-1]

Keterangan :
Unsur dalam tatasusunan di atas yang disusun dalam ingatan komputer seperti di bawah :

x[0]	x[1]	x[2]	x[3]	...	...	x[n-1]
Unsur 1	Unsur 2	Unsur 3	Unsur 4	...	...	Unsur n-1

Pengisytiharan Tatasusunan

• Pada umumnya, definasi tatasusunan satu matra ditulis sebagai
• jenis_data nama_tatasusunan[ ungkapan ] dimana jenis_data mewakili jenis data samada int, char atau float bagi tatasusunan.
• nama_tatasusunan mewakili sebarang nama pembolehubah yang mewakili tatasusunan.
• ungkapan mewakili bilangan integer positif yang menunjukkan bilangan unsur dalam tatasusunan.
char negeri[10];
int umur[5];
Keterangan :
Tatasusunan negeri mempunyai 10 unsur dari data jenis aksara.
Tatasusunan umur mempunyai 5 unsur dari data jenis integer.

Penemulaan unsur tatasusunan

• Setelah tatasusunan telah diisytiharkan, unsur-unsurnya perlu dimulakan. Jika tidak ia akan mengandungi rawak 'sampah'(garbage).
• Tatasusunan boleh dimulakan pada masa jalanan(run time) dan pada masa kompil(compile time).
• Penemulaan nilai tatasusunan pada masa Jalanan Unsur tatasusunan mengandungi nilai rawak selagi belum diumpukkan nilai tertentu oleh aturcara:
int bil[5];
Keterangan :
Dalam ingatan nilai penemulaan boleh mengambil sebarang integer seperti :
bil[0] = 0
bil[1] = 20870
bil[2] = 680
bil[2] =4020
bil[4] = 9104
• Nilai unsur tatasusunan boleh dimulakan pada masa jalanan aturcara. Sebagai contoh, arahan 'for' berikut digunakan:
for(i = 0; i < 20; i++) gaji[i] = 0.0;
Keterangan :
Unsur penemulaan bagi 50 unsur tatasusunan gaji ialah 0.0.
• Permulaan nilai tatasusunan masa kompil. Unsur tatasusunan boleh dimulakan pada masa kompil di bahagian pengisytiharan tatasusunan.
int kadar[5] = {1, 2, 6, 10, 8}
Keterangan : Dalam ingatan: kadar 1 2 6 10 8
int baki[6] = {20, 15, 20, 11}
Keterangan : Dalam ingatan baki 20 15 20 11 0 0
• Jika senarai unsur yang diberi kurang dari bilangan unsur yang ditakrifkan dalam tatasusunan, pengkompil akan mengisi baki unsur dengan 0.
• Pertimbangkan dua definasi tatsusunan jenis char berikut:
char warna[4] = "BIRU";
char warna[] = "BIRU";

Hasil umpukan di atas adalah berbeza disebabkan oleh aksara NOL, '\0' yang ditambahkan secara otomatik di hujung string warna yang kedua.Oleh itu :
• unsur tatasusunan pertama adalah
• warna[0] = 'B'
• warna[1] = 'I'
• warna[2] = 'R'
• warna[2] = 'U'
• unsur tatasusunan kedua adalah
• warna[0] = 'B'
• warna[1] = 'I'
• warna[2] = 'R'
• warna[2] = 'U'
• warna[4] ='\0'
Kesimpulan: Tatasusunan pertama adalah kurang, kerana aksara NOL \0 tidak dimasukkan ke dalam tatasusunan.
Definasi tatasusunan sepatutnya ditulis sebagai char warna[5] = "BIRU";

Mencapai unsur dalam tatasususunan melalui subskrip

• Kelebihan untuk menggunakan tatasusunan untuk menyimpan data ialah keupayaannya untuk merujuk unsur-unsur tatasusunan melalui nombor. Ini membenarkan kita menggunakan pembolehubah yang dipanggil subskrip, untuk merujuk unsur dalam tatasusunan.

/* Aturcara mencapai unsur tatasusunan
*/ #include <stdio.h>
main()
{
int I, n[8] = {22, 25, 20, 15, 40, 68, 70, 50}; printf("%s%12s\n", "UNSUR", "NILAI"};
for(i = 0 ; I<=7 ; I++)
printf("%7d%12d\n", I, n[i]);
return 0;
}

• Sekiranya saiz tatasusunan diabaikan dalam pengisytiharan nilai awal, bilangan unsur tatasusunan akan mewakili saiz tatasusunan tersebut.
int n[]={1,2,2,4,5};
Keterangan :
Pengisytiharan di atas akan menghasilkan tatasusunan yang mempunyai 5 unsur.
• Pernyataan Define menakrifkan pemalar simbolik kepada suatu nilai. Pertimbangkan aturcara dan ouput berikut:
/* Penggunaan arahan Define */
#include <stdio.h>
#define SAIZ 10
main()
{
int n[saiz], j;
printf("%s %12s \n", "UNSUR", "NILAI");
for (j = 0 ; j <= saiz-1, j++){
s[j] = 2 + 2*j; printf("%7d%12d\n", j=0, s[j]);
}
return 0;
}
Outputnya:
UNSUR NILAI 0 2 1 4 2 6 2 8 4 10 5 12 6 14 7 16 8 18 9 20.
Pernyataa define menakrifkan pemalar simbolik saiz yang bernilai 10. Bila aturcara diproses, kesemua kehadiran pemalar simbolik SAIZ akan diganti dengan teks pengganti 10. Kelebihan menggunakan pemalar simbolik untuk menentukan saiz tatasusunan alah kera ia menjadikan aturcara lebih fleksibel dan mudahubah skala. Pengaturcara boleh menukar saiz tatasusunan dengan mudah, misalnya dari 10 kepada 100 dengan sekadar menukarkan nilai saiz dalam arahan #define dari 10 kepada 100. Walau bagaimanapun, keburukan penggunaan pernyataan define ialah ialah merugikan ruang ingatan, kerana pernyataan tersebut sentiasa memegangg nilainya pada lokasi ingatan.

Menghantar tatasusunan kepada fungsi.

• Untuk menghantar tatasusunan kepada fungsi, nama tatasusunan mesti muncul tanpa kurungan atau subskrip di dalam panggilan fungsi. Semasa mengisytiharkan tatasusunan sebagai argument fungsi, nama tatasusunan ditulis sebagai sepasang kurungan siku yang kosong.
• Bila tatasusunan dihantar kepada suatu fungsi, nilai unsurnya tidak dihantar kepada fungsi, tetapi nama tatasusunan diinterpretasikan sebagai alamat unsur pertama tatasusunan. Oleh yang demikian sebarang unsur tatasusunan boleh dicapai dari fungsi. Malahan, jika unsur tatasusunan diubahsuai di sekitar fungsi, perubahan tersebut akan dikenalpasti oleh bahagian aturcara yang memanggil fungsi tersebut.
#include <stdio.h>
void ubahsuai(int a[]);
main()
{
int bil, a[2];
printf("\nDari main, sebelum panggil fungsi :\n"); for(bil=0; bil<=2 ; ++bil) {
a[bil] = bil+1;
printf("a[%d] = %d \n", bil, a[bil]);
}
ubahsuai(a);
printf("\nDari main, selepas panggil fungsi :\n"); for(bil= 0; bil<=2 ; ++bil)
printf("a[%d] = %d \n", bil, a[bil]);
return 0;
}
void ubahsuai(int a[ ])
{
int bil;
printf("\nDari fungsi, selepas diubahsuai nilai unsur :\n");
for(bil=0; bil<=2; ++bil) {
a[bil]=999;
printf("a[%d] = %d \n", bil, a[bil]);
}
return;
}

Mengisih tatasusunan

• a = {7, 4, 6, 8, 2}
• Pusingan pertama: 7 4 4, 7, 6, 8, 2 7 6 4, 6, 7, 8, 2 7 8 4, 6, 7, 8, 2 biarkan 8 2 4, 6, 7, 2, 8
• Kesimpulan: pusingan pertama memindahkan nilai maksima ke kedudukan paling kanan.
• Kemudian kita masuk pusingan kedua, cuma perlu menggerakkan nilai kedua besar ke kedudukan kedua kanan.
• Pusingan kedua : 4 6 4, 6, 7, 2, 8 biarkan 6 7 4, 6, 7, 2, 8 biarkan 7 2 4, 6, 2, 7, 8 7 8 4, 6, 2, 7, 8 biarkan
• Pusingan ketiga: 4 6 4, 6, 2, 7, 8 biarkan 6 2 4, 2, 6, 7, 8 6 7 4, 2, 6, 7, 8 biarkan 7 8 4, 2, 6, 7, 8 biarkan
• Pusingan keempat: 4 2 2, 4, 6, 7, 8 4 6 2, 4, 6, 7, 8 biarkan 6 7 2, 4, 6, 7, 8 biarkan 7 8 2, 4, 6, 7, 8 biarkan
• Unsur terisih, a = {2, 4, 6, 7, 8} Bahagian utama isihan gelembong ialah saling tukar(swaping) dua unsur. Untuk saling tukar dua pembolehubah, penggunaan pembolehubah ketiga diperlukan.
• Contoh: Saling tukarkan nilai i dan j berikut:
/* Mengisih tatasusunan jenis integer satu matra, mengikut tertib menurun*/
#include <stdio.h>
#define saiz 100 void isih(int n, int x[ ]);
main()
{
int i, n, x[saiz]; /* baca nilai untuk n */
printf("\nBerapa banyak nombor yang akan dimasukkan? "); scanf("%d", &n);
printf("\n"); /* baca senarai nombor-nombor */
for( i=0; i<n ; ++i) {
printf(" \n i= %d x = ", i+1);
scanf("%d", &x[i]);
}/* isih unsur tatasusunan */ isih(n, x);
/* senaraikan nombor-nombor yang telah diisih */
printf("\n\n Senarai nombor yang telah diisih: \n\n");
for(i = 0; i <n; ++i)
printf("\n i= %d x = %d \n ", i+1 , x[i]);
return 0;
} /* tamat aturcara utama */
void isih( int n, int x[ ] ) /* fungsi mengisih senarai nombor*/
{
int i, item, temp;
for(item = 0; item < n-1; ++item) /* cari unsur terkecil dari baki senarai unsur*/
for(i= item+1; i<n; ++i)
if(x[i] < x[item] {
temp = x[item]; x[item] = x[i]; x[i] = temp;
}
return;
}

Tatasusunan berbilang matra

• Tatasusunan satu matra boleh juga disebut sebagai senarai. Selain dari tatasusunan satu matra, terdapat juga tatasusunan lebih daripada satu matra.
• Tatasusunan berbilang matra yang mudah ialah tatasusunan dua matra, juga disebut sebagai matriks.
• Dalam matematik, sesuatu unsur matriks dirujuk dengan tatatanda Mxy dengan x ialah bilangan baris dan y ialah bilangan lajur.
• Dalam bahasa C, Mxy dirujuk dengan menggunakan tatatanda M[x][y].

• Tatasusunan berbilang matra boleh ditakrif dan dimulakan dengan menggunakan tanda {} bersarang.
Contoh:
int M[2][2] = { {2, 4}, menakrifkan matriks M = {6, 2} };
Dalam ingatan komputer, nombor-nombor ini disusun sebagai:
M[0][0]
M[0][1]
M[1][0]
M[1][1]

HAKCIPTA TERPELIHARA