CHAPTER 6 ARRAY

6.1 PENGANTAR
Bab ini berfungsi sebagai pengantar topik penting dari struktur data’. Dalam Bab 10, kita
membahas gagasan struktur (struktur) C - struktur data yang terdiri dari item data terkait dari
berbagai jenis yang berbeda. Array dan struktur adalah entitas "statis" karena ukurannya tetap
sama selama eksekusi program (mereka mungkin, tentu saja, menjadi kelas penyimpanan
otomatis dan karenanya dibuat dan dihancurkan setiap kali blok di mana mereka didefinisikan
dimasukkan dan dikeluarkan). Di Bab 12, kami memperkenalkan struktur data dinamis seperti
daftar, antrian, tumpukan dan pohon yang dapat tumbuh dan menyusut saat program dijalankan.

6.2 Array
Array adalah sekelompok lokasi memori yang terkait dengan fakta bahwa mereka semua
memiliki nama yang sama dan jenis yang sama. Untuk merujuk ke lokasi atau elemen tertentu
dalam larik, kami menentukan nama larik dan nomor posisi elemen tertentu dalam larik.
Gambar 6.1 menunjukkan larik bilangan bulat yang disebut c. Array ini mengandung 12
elemen. Salah satu elemen ini dapat dirujuk dengan memberi nama array diikuti oleh nomor
posisi elemen tertentu dalam tanda kurung siku ([]). Elemen pertama di setiap array adalah
elemen zeroth. Dengan demikian, elemen pertama dari array c disebut sebagai c [0], elemen
kedua dari array c disebut sebagai c [1], elemen ketujuh dari array c disebut sebagai c [6], dan,
dalam umum, elemen engan dari array c disebut sebagai c [i - 1]. Nama larik, seperti nama
variabel lainnya, hanya boleh berisi huruf, angka, dan garis bawah. Nama-nama array tidak dapat
dimulai dengan digit.
Nomor posisi yang terdapat dalam tanda kurung siku secara lebih formal disebut sebagai
sub-skrip (atau indeks). Subscript harus berupa integer atau ekspresi integer. Jika sebuah
program menggunakan ekspresi sebagai subskrip, maka ekspresi dievaluasi untuk menentukan
subskrip. Misalnya, jika a = 5 dan b = 6, maka pernyataannya.

c [a + b] + = 2;
menambahkan 2 ke elemen array c [11]. Nama larik langganan adalah lvalue — itu dapat
digunakan di sisi kiri tugas.
Mari kita periksa array c (Gambar 6.1) lebih dekat. Nama array adalah c. Ke-12
elemennya disebut sebagai c [0], c [1], c [2], ..., c [11]. Nilai yang disimpan dalam c [0] adalah –
45, nilai c [1] adalah 6, nilai c [2] adalah 0, nilai c [7] adalah 62 dan nilai c [11] adalah 78. Untuk
mencetak jumlah nilai yang terkandung dalam tiga elemen pertama dari array c, kita akan
menulis.
printf( "%d", c[ 0 ] + c[ 1 ] + c[ 2 ] );
 Name of array (note
that all elements of this
array have the same
name, c)

c[ 0 ] -45
c[ 1 ] 6
0
c[ 2 ]
72
c[ 3 ]
1543
c[ 4 ]
-89
c[ 5 ] 0
c[ 6 ] 62

c[ 7 ] -3
1
c[ 8 ]
6453
c[ 9 ]
78
c[ 10 ]
c[ 11 ]

Position number of the element within array c

Untuk membagi nilai elemen ketujuh dari array c oleh 2 dan menetapkan hasilnya ke
variabel x, kami akan menulis
x = c[ 6 ] / 2;

Kesalahan Pemrograman Umum 6.1

Penting untuk dicatat perbedaan antara "elemen ketujuh dari array" dan "elemen array
tujuh." Karena array subscript dimulai pada 0, "elemen ketujuh dari array" memiliki
subskrip 6, sementara "elemen array tujuh" memiliki subscript 7 dan sebenarnya elemen
kedelapan dari array. Ini adalah sumber kesalahan "off-by-one".

Tanda kurung yang digunakan untuk melampirkan subscript dari array sebenarnya
dianggap sebagai operator di C. Mereka memiliki tingkat yang sama diutamakan sebagai
operator panggilan fungsi (yaitu, tanda kurung yang ditempatkan mengikuti nama fungsi
untuk memanggil fungsi itu). Gambar 6.2 menunjukkan preseden dan asosiativitas
operator yang diperkenalkan pada titik ini dalam teks.

Operators Associativity Type

[] () left to right highest

++ -- ! (type) right to left unary
/ % left to right multiplicativ
e

Operators Associativity Type

+ - left to right additive
< <= > >= left to right relational
== != left to right equality
&& left to right logical AND
|| left to right logical OR
?: right to left conditional
= += -= = /= % right to left assignment
=
, left to right Comma

6.3 Menentukan Array

Array menempati ruang di memori. Anda menetapkan jenis setiap elemen dan jumlah elemen
yang dibutuhkan oleh setiap larik sehingga komputer dapat mencadangkan jumlah memori yang
sesuai. Untuk memberi tahu komputer agar menyimpan 12 elemen untuk integer array c,
definisinya
int c[ 12 ];
digunakan. Definisi berikut
int b[ 100 ], x[ 27 ];
menyimpan 100 elemen untuk bilangan integer b dan 27 elemen untuk bilangan bulat x.Array
dapat berisi tipe data lain. Sebagai contoh, sebuah array tipe char dapat digunakan untuk
menyimpan string karakter. Karakter string dan kesamaannya dengan array dibahas dalam Bab 8.
Hubungan antara pointer dan array dibahas dalam Bab 7.
6.4 Contoh Array
Bagian ini menyajikan beberapa contoh yang mendemonstrasikan bagaimana mendefinisikan
array, bagaimana cara inisialisasi array dan bagaimana melakukan banyak manipulasi array
umum.Menentukan Array dan Menggunakan Loop untuk Menginisialisasi Elemen Array
Gambar 6.3 menggunakan untuk pernyataan untuk menginisialisasi elemen dari 10-elemen
integer array n ke nol dan mencetak array dalam format tabel. Pernyataan printf pertama (baris
16) menampilkan kepala kolom untuk dua kolom yang dicetak dalam pernyataan berikutnya.
1/ Fig. 6.3: fig06_03.c

2 initializing an array /
3 #include <stdio.h>
4
5 / function main begins program execution /
6 int main( void )
7 {
8 int n[ 10 ]; / n is an array of 10 integers /
9 int i; / counter /
10 / initialize elements of array n to 0 /
11 for ( i = 0; i < 10; i++ ) {
12 n[ i ] = 0; / set element at location i to 0 /
13 } / end for /
14 printf( "%s%13s\n", "Element", "Value" );
15 / output contents of array n in tabular format /
16 for ( i = 0; i < 10; i++ ) { printf( "%7d%13d\n", i, n[ i ] );
17 } / end for /
18 return 0;
19 }

Element Value
0 0
1 0
2 0
3 0
4 0
5 0
6 0
7 0
8 0
9 0
Menginisialisasi Array dalam Definisi dengan Daftar Initializer
Elemen-elemen array juga dapat diinisialisasi ketika array didefinisikan dengan mengikuti
definisi dengan tanda dan tanda kurung yang sama, {}, yang berisi daftar initial-izer yang
dipisahkan koma. Gambar 6.4 menginisialisasi array integer dengan 10 nilai (baris 9) dan
mencetak array dalam format tabel.

1. / Fig. 6.4: fig06_04.c

2. Initializing an array with an initializer list /
3. #include <stdio.h>
4
5 / function main begins program execution /
6 int main( void )
7 {
8 / use initializer list to initialize array n /
9 int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
10 int i; / counter /
11 printf( "%s%13s\n", "Element", "Value" );
12 / output contents of array in tabular format /
13 for ( i = 0; i < 10; i++ ) {
14 printf( "%7d%13d\n", i, n[ i ] );
15 } / end for /
16
17 return 0;}
18

Element Value
0 32
1 27
2 64
3 18
4 95
5 14
6 90
7 70
8 60
9 37

Jika ada lebih sedikit initializers daripada elemen dalam array, elemen yang tersisa diinisialisasi
ke nol. Misalnya, elemen dari array n pada Gambar 6.3 bisa saja diinisialisasi ke nol sebagai
berikut:
 int n[ 10 ] = { 0 };

ini secara eksplisit menginisialisasi elemen pertama ke nol dan menginisialisasi sembilan elemen
tersisa ke nol karena ada lebih sedikit initializers daripada ada elemen dalam array. Penting
untuk diingat bahwa array tidak secara otomatis diinisialisasi ke nol. Anda setidaknya harus
menginisialisasi elemen pertama ke nol agar elemen yang tersisa secara otomatis di-role. Metode
menginisialisasi elemen array ke 0 dilakukan pada waktu kompilasi untuk array statis dan saat
runtime untuk array otomatis.

Kesalahan Pemrograman Umum 6.2

Lupa untuk menginisialisasi elemen array yang elemennya harus diinisialisasi.

Definisi larik
int n[ 5 ] = { 32, 27, 64, 18, 95, 14 };
menyebabkan kesalahan sintaks karena ada enam initializers dan hanya lima elemen array.

Common Programming Error 6.3

Menyediakan lebih banyak initializers dalam daftar penginisialisasi array daripada ada elemen
dalam array adalah kesalahan sintaks.

Jika ukuran array dihilangkan dari definisi dengan daftar initializer, jumlah elemen dalam array
akan menjadi jumlah elemen dalam daftar penginisialisasi. Sebagai contoh,
int n[] = { 1, 2, 3, 4, 5 };

Akan Membuat Array Lima Elemen.

Menentukan Ukuran Array dengan Elemen Konstan dan Memulai Array Simbolik dengan
Perhitungan
Gambar 6.5 menginisialisasi elemen dari 10-elemen array ke nilai 2, 4, 6,…, 20 dan mencetak
array dalam format tabel. Nilai-nilai ini dihasilkan dengan mengalikan lingkaran dengan 2 dan
menambahkan

1 / Fig. 6.5: fig06_05.c

2 Initialize the elements of array s to the even integers from 2 to 20 /
3 #include <stdio.h>
4 #define SIZE 10 / maximum size of array /
5
6 / function main begins program execution /
7 int main( void )
8 {
9 / symbolic constant SIZE can be used to specify array size /
10 int s[ SIZE ]; / array s has SIZE elements /
 11 int j; / counter
12 for ( j = 0; j < SIZE; j++ ) { / set the values /s[ j ] = 2 + 2 j;
13 } / end for /
14 printf( "%s%13s\n", "Element", "Value" );
15 / output contents of array s in tabular format /
16 for ( j = 0; j < SIZE; j++ ) {
17 printf( "%7d%13d\n", j, s[ j ] );
18 } / end for /
19 return 0;}

Element Value
0 2
1 4
2 6
3 8
4 10
5 12
6 14
7 16
8 18
9 20
Inisialisasi elemen larik s ke bilangan bulat genap dari 2 hingga 20.
Instruksi #define preprocessor diperkenalkan dalam program ini. Jalur 4

mendefinisikan SIZE konstan simbolis yang nilainya 10. Konstanta simbolik adalah identifier
yang diganti dengan teks pengganti oleh preprocessor C sebelum program dikompilasi. Ketika
program ini preprocessed, semua kejadian dari SIZE konstan simbolis

diganti dengan teks pengganti 10. Menggunakan konstanta simbolis untuk menentukan ukuran
larik membuat program lebih skalabel. Pada Gambar 6.5, kita bisa memiliki yang pertama untuk
loop (baris 13) mengisi array 1000-elemen hanya dengan mengubah nilai SIZE dalam direktif
#define dari 10 hingga 1000. Jika SIZE konstan simbolis belum digunakan, kita harus mengubah
program di tiga tempat terpisah untuk skala program untuk menangani 1000 elemen array.
Ketika program menjadi lebih besar, teknik ini menjadi lebih berguna untuk menulis program
yang jelas.

Kesalahan Pemrograman Umum 6.4

Mengakhiri arahan #define atau #include preprocessor dengan titik koma. Ingat bahwa arahan
preprocessor bukan pernyataan C. Jika arahan #define preprocessor pada baris 4 diakhiri dengan
titik koma, semua kemunculan SIZE konstan simbolis dalam program diganti dengan teks 10;
oleh preprocessor. Ini dapat menyebabkan kesalahan sintaks pada waktu kompilasi, atau
kesalahan logika pada waktu eksekusi. Ingat bahwa preprocessor bukan C — itu hanya
manipulator teks.
Kesalahan Pemrograman Umum 6.5
Menetapkan nilai ke konstanta simbolis dalam pernyataan yang dapat dieksekusi adalah
kesalahan sintaks. Konstanta simbolis bukanlah variabel. Tidak ada ruang yang disediakan
untuknya oleh compiler seperti variabel yang menahan nilai pada waktu eksekusi.

Pengamatan Rekayasa Perangkat Lunak 6.1

Menentukan ukuran setiap larik sebagai konstanta simbolis membuat program menjadi lebih
skalabel.
Latihan Pemrograman yang Baik 6.1
Gunakan hanya huruf besar untuk nama simbolik konstan. Ini membuat konstanta ini menonjol
dalam program dan mengingatkan Anda bahwa konstanta simbolis bukanlah variabel.
Latihan Pemrograman yang Baik 6.2
Dalam nama konstanta simbolik multi kata, gunakan garis bawah untuk memisahkan kata untuk
membaca, Menjumlahkan Elemen dari Array
Gambar 6.6 menjumlahkan nilai-nilai yang terkandung dalam array integer 12-elemen a. Untuk
badan pemerintah (baris 16) melakukan total.

2 Compute the sum of the elements of the array /

3 #include <stdio.h>
4 #define SIZE 12
5
6 / function main begins program execution /
7 int main( void )
8 {
9 / use initializer list to initialize array /
10 int a[ SIZE ] = { 1, 3, 5, 4, 7, 2, 99, 16, 45, 67, 89, 45 };

11 int i; / counter /
12 int total = 0; / sum of array /
13 / sum contents of array a /
14 for ( i = 0; i < SIZE; i++ ) { total += a[ i ];
15 } / end for /
16 printf( "Total of array element values is %d\n", total );
17 return 0;}

Total of array element values is 383

Menggunakan Array untuk Meringkas Hasil Survei
Contoh berikut kami menggunakan array untuk merangkum hasil data yang dikumpulkan dalam
survei. Perhatikan pernyataan masalah.
Empat puluh siswa diminta untuk menilai kualitas makanan di kantin siswa pada skala 1 sampai
10 (1 berarti mengerikan dan 10 berarti sangat baik). Tempatkan 40 tanggapan dalam larik
bilangan bulat dan rangkum hasil jajak pendapat.
Ini adalah aplikasi array yang khas (lihat Gambar 6.7). Kami ingin meringkas jumlah tanggapan
dari setiap jenis (yaitu, 1 hingga 10). Respons larik (baris 17) adalah susunan 40-ele- ment
tanggapan siswa. Kami menggunakan frekuensi array 11-elemen (baris 14) untuk menghitung
jumlah kemunculan setiap respons. Kami mengabaikan frekuensi [0] karena logis untuk memiliki
respons 1 frekuensi penambahan [1] daripada frekuensi [0]. Ini memungkinkan kita untuk
menggunakan setiap respons secara langsung sebagai subskrip dalam larik frekuensi.
1 / Fig. 6.7: fig06_07.c
2 Student poll program /
3 #include <stdio.h>
4 #define RESPONSE_SIZE 40 / define array sizes /
5 #define FREQUENCY_SIZE 11
6
7 / function main begins program execution /
8 int main( void )
9 {

10 int answer; / counter to loop through 40 responses /

11 int rating; / counter to loop through frequencies 1-10 /
12
13 / initialize frequency counters to 0 /
14 int frequency[ FREQUENCY_SIZE ] = { 0 };
15
16 / place the survey responses in the responses array /
17 int responses[ RESPONSE_SIZE ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10,

18 1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6,
19 5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };
20 / for each answer, select value of an element of array responses
21 and use that value as subscript in array frequency to
22 determine element to increment /
23 for ( answer = 0; answer < RESPONSE_SIZE; answer++ ) {
25 ++frequency[ responses [ answer ] ];
 26 }/ end for /

27
28 / display results /
29 printf( "%s%17s\n", "Rating", "Frequency" );
30
31 / output the frequencies in a tabular format /
32 for ( rating = 1; rating < FREQUENCY_SIZE; rating++ ) {
33 printf( "%6d%17d\n", rating, frequency[ rating ] );
34 } / end for /
35 return 0;}

Rating Frequency
1 2
2 2
3 2
4 2
5 5
6 11
7 5
8 7
9 1
10 3

Latihan Pemrograman yang Baik 6.3

Upayakan kejelasan program. Kadang-kadang mungkin bermanfaat untuk memperdagangkan
penggunaan memori atau waktu prosesor yang paling efisien dalam mendukung penulisan
program yang lebih jelas.

Tip Kinerja 6.1

Kadang-kadang pertimbangan kinerja jauh lebih besar daripada pertimbangan kejelasan.
The for loop (baris 24) mengambil tanggapan satu per satu dari respon larik dan menambahkan
salah satu dari 10 penghitung (frekuensi [1] ke frekuensi [10]) dalam larik frekuensi. Pernyataan
kunci dalam lingkaran adalah baris 25

++ frekuensi [tanggapan [jawaban]];

yang menambah frekuensi yang sesuai tergantung pada nilai respons [jawaban]. Ketika jawaban
variabel konter adalah 0, respons [jawaban] adalah 1, jadi
++ frequeoncy [jawaban [jawaban]]; ditafsirkan sebagai
++ frekuensi [1];

yang menambahkan elemen array satu. Ketika jawabannya 1, respons [jawaban] adalah 2, jadi
++ frekuensi [tanggapan [jawaban]]; ditafsirkan sebagai
++ frekuensi [2];
yang menambahkan elemen array dua. Ketika jawabannya adalah 2, jawaban [jawaban] adalah 6,
jadi
++ frekuensi [tanggapan [jawaban]]; sebenarnya ditafsirkan sebagai
++ frekuensi [6];

diolah dalam survei, hanya diperlukan 11 elemen array (mengabaikan elemen nol) untuk
menjumlahkan hasilnya. Jika data berisi nilai yang tidak valid seperti 13, program akan mencoba
menambahkan 1 ke frekuensi [13]. Ini akan berada di luar batas-batas array. C tidak memiliki
batas array yang memeriksa untuk mencegah program merujuk ke elemen yang tidak ada.
Dengan demikian, program eksekusi dapat "berjalan" dari ujung array tanpa peringatan. Anda
harus memastikan bahwa semua referensi array tetap dalam batas-batas array.

Common Programming Error 6.6

Mengacu pada elemen di luar batas array.
Tip Error-Prevention 6.1
Ketika mengulang melalui array, subscript array tidak boleh pergi di bawah 0 dan harus selalu
kurang dari jumlah total elemen dalam array (size - 1). Pastikan kondisi pengakhiran loop
mencegah mengakses elemen di luar rentang ini.
Tip Kesalahan-Pencegahan 6.2
Program harus memvalidasi kebenaran dari semua nilai input untuk mencegah informasi yang
salah mempengaruhi perhitungan program.
Graphing Array Element Values dengan Histogram
Contoh berikut (Gambar 6.8) membaca angka dari larik dan membuat grafik informasi dalam
bentuk diagram batang atau histogram — setiap angka dicetak, kemudian bilah yang terdiri dari
banyak tanda bintang dicetak di samping nomor tersebut. Pernyataan bersarang untuk (garis 20)
menggambar bar. Perhatikan penggunaan printf ("\ n") untuk mengakhiri bar histogram (baris
24).
1 / Fig. 6.8: fig06_08.c

2 Histogram printing program /

3 #include <stdio.h>
4 #define SIZE 10
5
6 / function main begins program execution /
7 int main( void )
8 {
 9 / use initializer list to initialize array n /
10 int n[ SIZE ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };

11 int i; / outer for counter for array elements /

12 int j; / inner for counter counts s in each histogram bar /
14 printf( "%s%13s%17s\n", "Element", "Value", "Histogram" );

15
13 / for each element of array n, output a bar of the histogram /
14 for ( i = 0; i < SIZE; i++ ) {
15 printf( "%7d%13d ", i, n[ i ]) ;
16 for ( j = 1; j <= n[ i ]; j++ ) { / print one bar / printf( "%c", ' ' );
17 } / end inner for /
18 printf( "\n" ); / end a histogram bar /
19 } / end outer for /
26. return 0;}

Element Histogram

Mengalir Waktu Die 6000 dan Meringkas Hasil dalam Array

Di Bab 5, kami menyatakan bahwa kami akan menunjukkan metode yang lebih elegan dalam
menulis program dadu-bergulir pada Gambar 5.8. Masalahnya adalah menggulung satu dadu
enam sisi 6000 kali untuk menguji apakah generator bilangan acak benar-benar menghasilkan
bilangan acak. Versi array dari program ini ditunjukkan pada Gambar 6.9.
1 / Fig. 6.9: fig06_09.c

2 Roll a six-sided die 6000 times /

3 #include <stdio.h>
4 #include <stdlib.h>
5 #include <time.h>
6 #define SIZE 7
7
 8 / function main begins program execution /
9 int main( void )
10 {

11 int face; / random die value 1 - 6 /

12 int roll; / roll counter 1-6000 /
13 int frequency[ SIZE ] = { 0 }; / clear counts /
15 srand( time( NULL ) ); / seed random-number generator /

16
17 / roll die 6000 times /
18 for ( roll = 1; roll <= 6000; roll++ ) {
19 face = 1 + rand() % 6;
20 ++frequency[ face ]; / replaces 26-line switch of Fig. 5.8 /
21 }/ end for /

22
23 printf( "%s%17s\n", "Face", "Frequency" );

24
25 / output frequency elements 1-6 in tabular format /
26 for ( face = 1; face < SIZE; face++ ) {
27 printf( "%4d%17d\n", face, frequency[ face ] );
28 } / end for /
29

14 return 0 ;}

Face Frequency
1 1029
2 951
3 987
4 1033
5 1010
6 990

Menggunakan Array Karakter untuk Menyimpan dan Memanipulasi String

Kami telah membahas hanya bilangan bulat. Namun, array mampu menyimpan data jenis apa
pun. Kami sekarang membahas menyimpan string dalam array karakter. Sejauh ini, satu-satunya
kemampuan pemrosesan string yang kita miliki adalah menghasilkan string dengan printf. String
seperti "hello" benar-benar merupakan array statis karakter individu dalam C.
Karakter array memiliki beberapa fitur unik. Sebuah array karakter dapat diinisialisasi
menggunakan string literal. Sebagai contoh,
char string1 [] = "pertama";
menginisialisasi elemen dari array string1 ke karakter individu dalam string literal "pertama".
Dalam hal ini, ukuran string array1 ditentukan oleh compiler berdasarkan panjang string. String
"pertama" berisi lima karakter plus karakter string-termi- nasional khusus yang disebut karakter
null. Jadi, array string1 sebenarnya mengandung enam elemen. Konstanta karakter yang
mewakili karakter null adalah '\ 0'. Semua string dalam C diakhiri dengan karakter ini. Sebuah
array karakter yang mewakili sebuah string harus selalu didefinisikan cukup besar untuk
menampung jumlah karakter dalam string dan karakter null terminating. Character array juga
dapat diinisialisasi dengan konstanta karakter individu di dalamnya-
daftar tializer. Definisi sebelumnya setara dengan
char string1 [] = {'f', 'i', 'r', 's', 't', '\ 0'};
Karena string benar-benar merupakan array karakter, kita dapat mengakses karakter individu
dalam string secara langsung menggunakan notasi subscript array. Misalnya, string1 [0] adalah
karakter
'f' dan string1 [3] adalah karakter 's'.

Kita juga dapat memasukkan string langsung ke array karakter dari keyboard menggunakan
scanf dan pengubah konversi% s. Sebagai contoh,

char string2 [20];

membuat array karakter yang mampu menyimpan string paling banyak 19 karakter dan karakter
null beremudian. Pernyataan
scanf ("% s", string2);
membaca string dari keyboard ke string2. Nama array dilewatkan ke scanf tanpa yang
disebutkan sebelumnya & digunakan dengan variabel nonstring. The & biasanya digunakan
untuk menyediakan scanf dengan lokasi variabel dalam memori sehingga nilai dapat disimpan di
sana. Di Bagian 6.5, ketika kita membahas lewat array ke fungsi, kita akan melihat bahwa nilai
dari sebuah nama array adalah alamat awal dari array; oleh karena itu, & tidak perlu. Fungsi
scanf akan membaca karakter sampai spasi, tab, newline atau end-of-file indicator di-enkontrak.
String harus tidak lebih dari 19 karakter untuk meninggalkan ruang untuk karakter null
terminating. Jika pengguna mengetik 20 karakter atau lebih, program Anda mungkin macet!
Untuk alasan ini, gunakan specifier konversi% 19s sehingga scanf tidak menulis karakter ke
dalam memori di luar akhir array.Merupakan tanggung jawab Anda untuk memastikan bahwa
larik di mana string dibaca mampu menahan string apa pun yang diketik pengguna di keyboard.
Fungsi scanf membaca karakter dari keyboard sampai karakter spasi-putih pertama ditemui —
tidak memeriksa seberapa besar lariknya. Dengan demikian, scanf dapat menulis di luar ujung
array.
Common Programming Error 6.7
Tidak menyediakan scanf dengan array karakter yang cukup besar untuk menyimpan string yang
diketik di papan tombol dapat mengakibatkan penghancuran data dalam program dan kesalahan
runtime lainnya. Ini juga dapat membuat sistem rentan terhadap serangan cacing dan virus.
Sebuah array karakter yang merepresentasikan string dapat di-output dengan printf dan% s con-
version specifier. String string2 dicetak dengan pernyataan
printf ("% s \ n", string2);
Fungsi printf, seperti scanf, tidak memeriksa seberapa besar array karakter. Karakter string
dicetak hingga karakter null yang diakhiri ditemukan.
Gambar 6.10 menunjukkan inisialisasi array karakter dengan string literal, membaca string ke
dalam array karakter, mencetak array karakter sebagai string dan mengakses karakter individual
string.
1 / Fig. 6.10: fig06_10.c
2 Treating character arrays as strings /
3 #include <stdio.h>
4
5 / function main begins program execution /
6 int main( void )
7 {

8 char string1[ 20 ]; / reserves 20 characters /

9 char string2[] = "string literal"; / reserves 15 characters /
10 int i; / counter /
11
12 / read string from user into array string1 /
13 printf("Enter a string: ");
14 scanf( "%s", string1 ); / input ended by whitespace character /
15 printf( "string1 is: %s\nstring2 is: %s\n"
16 "string1 with spaces between characters is:\n", string1, string2 );
17 for ( i = 0; string1[ i ] != '\0'; i++ ) {
18 printf( "%c ", string1[ i ] );
19 } / end for /
20 printf( "\n" );
 Enter a string: Hello there

string1 is: Hello

string2 is: string literal

string1 with spaces between characters is: H e l l o

21 return 0;}

Gambar 6.10 | Memperlakukan susunan karakter sebagai string. (Bagian 2 dari 2.)

Gambar 6.10 menggunakan pernyataan untuk (baris 22) untuk loop melalui string1 array dan
mencetak karakter individual yang dipisahkan oleh spasi, menggunakan% c konversi specifier.
Kondisi dalam pernyataan, string1 [i]! = '\ 0', adalah benar ketika karakter null terminating belum
ditemukan dalam string.

Array Lokal Statis dan Array Lokal Otomatis

Bab 5 membahas statis penspesifikasi kelas penyimpanan. Variabel lokal statis ada selama durasi
program, tetapi hanya terlihat di badan fungsi. Kita dapat menerapkan statis ke definisi array
lokal sehingga array tidak dibuat dan diinisialisasi setiap kali fungsi dipanggil dan array tidak
dihancurkan setiap kali fungsi tersebut dikeluarkan dalam program. Ini mengurangi waktu
eksekusi program, terutama untuk program dengan fungsi yang sering disebut yang berisi array
besar.

Tip Kinerja 6.2

Dalam fungsi yang berisi larik otomatis di mana fungsi sering masuk dan keluar dari cakupan,
buat larik statis sehingga tidak dibuat setiap kali fungsi dipanggil.
Array yang statis diinisialisasi sekali pada saat kompilasi. Jika Anda tidak secara eksplisit
menginisialisasi array statis, elemen-elemen array diinisialisasi ke nol oleh kompilator.
Gambar 6.11 menunjukkan fungsi staticArrayInit (baris 22) dengan statis lokal
larik (baris 25) dan fungsi automaticArrayInit (baris 44) dengan larik otomatis local (baris 47).
Fungsi staticArrayInit dipanggil dua kali (baris 12 dan 16). Array statis lokal dalam fungsi
diinisialisasi ke nol oleh compiler (baris 25). Fungsi mencetak larik, menambahkan 5 ke setiap
elemen dan mencetak larik lagi. Saat kedua fungsi dipanggil, array statis berisi nilai yang
disimpan selama panggilan fungsi pertama. Fungsi automaticArrayInit juga disebut dua kali
(baris 13 dan 17). Elemen-elemen dari array lokal otomatis dalam fungsi diinisialisasi dengan
nilai 1, 2 dan 3 (baris 47). Fungsi mencetak larik, menambahkan 5 ke setiap elemen dan
mencetak larik lagi. Saat kedua fungsi dipanggil, elemen array diinisialisasi ke 1, 2, dan 3 lagi
karena larik memiliki durasi penyimpanan otomatis.
Kesalahan Pemrograman Umum 6.8
Dengan asumsi bahwa elemen dari array statis lokal diinisialisasi ke nol setiap kali fungsi di
mana array didefinisikan disebut.

1 / Fig. 6.11: fig06_11.c

2 Static arrays are initialized to zero /
3 #include <stdio.h>
4
5 void staticArrayInit( void ); / function prototype /
6 void automaticArrayInit( void ); / function prototype /
7
8 / function main begins program execution /
9 int main( void )
10 {
11 printf( "First call to each function:\n" );
12 staticArrayInit();
13 automaticArrayInit();
14
15 printf( "\n\nSecond call to each function:\n" );
16 staticArrayInit();
17 automaticArrayInit();
18 return 0; / indicates successful termination /
19 } / end main /
20
21 / function to demonstrate a static local array /
22 void staticArrayInit( void )
23 {
24 / initializes elements to 0 first time function is called
25 static int array1[ 3 ];
26 int i; / counter /
27
28 printf( "\nValues on entering staticArrayInit:\n" );
29
30 / output contents of array1 /
31 for ( i = 0; i <= 2; i++ ) {
32 printf( "array1[ %d ] = %d ", i, array1[ i ] );
33 } / end for /
34
35 printf( "\nValues on exiting staticArrayInit:\n" );
37 / modify and output contents of array1 /
38 for ( i = 0; i <= 2; i++ ) {

39 printf( "array1[ %d ] = %d ", i, array1[ i ] += 5 );

40 } / end for /
41 } / end function staticArrayInit /
42
43 / function to demonstrate an automatic local array /
44 void automaticArrayInit( void )
45 {
46 / initializes elements each time function is called /
47 int array2[ 3 ] = { 1, 2, 3 };
48 int i; / counter /

49
50 printf( "\n\nValues on entering
automaticArrayInit:\n" );

51
52 / output contents of array2 /
53 for ( i = 0; i <= 2; i++ ) {

54 printf("array2[ %d ] = %d ", i, array2[ i ] );

55 } / end for /
56
57 printf( "\nValues on exiting automaticArrayInit:\n"
);

58
59 / modify and output contents of array2 /
60 for ( i = 0; i <= 2; i++ ) {

61 printf( "array2[ %d ] = %d ", i, array2[ i ] += 5 );

62 } / end for /
63 }
Untuk meneruskan argumen larik ke fungsi, tentukan nama larik tanpa tanda kurung. Sebagai
contoh, jika array hourlyTemperatures telah didefinisikan sebagai

int hourlyTemperatures [24];

panggilan fungsi

modifyArray (hourlyTemperatures, 24)

melewati array hourlyTemperatures dan ukurannya berfungsi memodifikasiArray. Tidak seperti
array char yang mengandung string, jenis array lain tidak memiliki terminator khusus. Untuk
alasan ini, ukuran array dilewatkan ke fungsi, sehingga fungsi dapat memproses jumlah elemen
yang tepat.
C secara otomatis meneruskan array ke fungsi dengan referensi — fungsi yang dipanggil dapat
memodifikasi nilai elemen dalam array asli pemanggil. Nama array mengevaluasi ke alamat
elemen pertama dari array. Karena alamat awal dari array dilewatkan, fungsi yang dipanggil tahu
dengan tepat di mana array disimpan. Oleh karena itu, ketika fungsi yang dipanggil mengubah
elemen larik dalam badan fungsinya, itu memodifikasi elemen sebenarnya dari larik di lokasi
ingatan aslinya.
Gambar 6.12 menunjukkan bahwa nama array adalah benar-benar alamat elemen pertama dari
array dengan mencetak larik, & larik [0] dan & larik menggunakan penentu konversi% p —
penentu konversi khusus untuk mencetak alamat. Penentu konversi% p biasanya mengeluarkan
alamat sebagai angka heksadesimal. Bilangan heksadesimal (bilangan 16) terdiri dari angka 0
hingga 9 dan huruf A hingga F (huruf-huruf ini adalah ekuivalen heksadesimal dari angka 10–
15). Mereka sering digunakan sebagai notasi singkat untuk nilai integer yang besar. Lampiran C,
Sistem Bilangan, menyediakan diskusi mendalam tentang hubungan antara biner (basis 2), oktal
(basis 8), desimal (basis 10; bilangan bulat standar) dan bilangan bulat heksadesimal. Output
menunjukkan bahwa baik array dan & array [0] memiliki nilai yang sama, yaitu 0012FF78.
Output dari program ini tergantung pada sistem, tetapi alamat selalu identik untuk eksekusi
tertentu dari program ini pada komputer tertentu.
Tip Kinerja 6.3
Lewat array dengan referensi masuk akal untuk alasan kinerja. Jika array dilewatkan oleh nilai,
salinan setiap elemen akan dilewatkan. Untuk array yang besar dan sering lewat, ini akan
memakan waktu dan akan mengkonsumsi penyimpanan untuk salinan dari array.
Pengamatan Rekayasa Perangkat Lunak 6.2
Ini memungkinkan untuk meneruskan array berdasarkan nilai (dengan menggunakan trik
sederhana yang kami jelaskan di Bab 10).
Meskipun seluruh array dilewatkan oleh referensi, elemen array individual dilewatkan oleh nilai
persis seperti variabel sederhana. Sekumpulan data sederhana yang sederhana (seperti int, float
dan chars) disebut skalar. Untuk meneruskan elemen array ke fungsi, gunakan nama subscripted
dari elemen array sebagai argumen dalam panggilan fungsi. Di Bab 7, kami menunjukkan cara
meneruskan skalar (yaitu, variabel individual dan elemen array) ke fungsi berdasarkan referensi.
 1 / Fig. 6.12: fig06_12.c

2 The name of an array is the same as &array[ 0 ] /

3 #include <stdio.h>
4
5 / function main begins program execution /
6 int main( void )
7 {
8 char array[ 5 ]; / define an array of size 5 /
9. printf( " array = %p\n&array[0] = %p\n &array = %p\n",

array, &array[ 0 ], &array );

10.
11. return 0; }

array = 0012FF78 &array[0] = 0012FF78

&array = 0012FF78

Gambar 6.12 | Nama array sama dengan alamat elemen pertama array.
Untuk fungsi untuk menerima larik melalui pemanggilan fungsi, daftar parameter fungsi harus
menentukan bahwa larik akan diterima. Sebagai contoh, header fungsi untuk fungsi modifyArray
(yang kami panggil sebelumnya di bagian ini) mungkin ditulis sebagai
void modifyArray (int b [], int size)
menunjukkan bahwa memodifikasiArray mengharapkan untuk menerima array integer dalam
parameter b dan jumlah elemen array dalam ukuran parameter. Ukuran array tidak diperlukan
antara kurung array. Jika sudah dimasukkan, kompilator memeriksa bahwa itu lebih besar dari
nol, lalu mengabaikannya. Menentukan ukuran negatif adalah kesalahan kompilasi. Karena array
secara otomatis dilewatkan oleh referensi, ketika fungsi yang dipanggil menggunakan nama
array b, itu akan merujuk ke array di pemanggil (array hourlyTemperatures pada panggilan
sebelumnya). Di Bab 7, kami memperkenalkan notasi lain untuk menunjukkan bahwa suatu array
sedang diterima oleh suatu fungsi. Seperti yang akan kita lihat, notasi ini didasarkan pada
hubungan intim antara array dan pointer dalam C.
Gambar 6.13 menunjukkan perbedaan antara melewatkan seluruh larik dan meneruskan elemen
larik. Program ini pertama kali mencetak lima elemen dari integer array a (baris 20-22).
Selanjutnya, a dan ukurannya diteruskan ke fungsi modifyArray (baris 27), di mana setiap
elemen a dikalikan dengan 2 (garis 54-55). Kemudian dicetak ulang di utama (baris 32-34).
Seperti yang ditunjukkan output, elemen-elemen a memang dimodifikasi dengan
memodifikasiArray. Sekarang program mencetak nilai [3] (baris 38) dan meneruskannya ke
fungsi modifyElement (baris 40). Function modifyElement mengalikan argumennya dengan 2
(baris 64) dan mencetak nilai baru. Ketika [3] dicetak ulang di utama (baris 43), itu belum
dimodifikasi, karena elemen array individual dilewatkan oleh nilai.

2 Passing arrays and individual array elements to functions /

3 #include <stdio.h>
4 #define SIZE 5
5 void modifyArray( int b[], int size );
6 void modifyElement( int e );
7 / function main begins program execution /
8 int main( void )
9 {
10 int a[ SIZE ] = { 0, 1, 2, 3, 4 }; / initialize a /
11 int i; / counter /
12 printf( "Effects of passing entire array by reference:\n\nThe "
13 "values of the original array are:\n" );
14 / output original array /
15 for ( i = 0; i < SIZE; i++ ) {
16 printf( "%3d", a[ i ] );
17 } / end for /
18 printf( "\n" );
19 / pass array a to modifyArray by reference /modifyArray( a, SIZE );
20 printf( "The values of the modified array are:\n" );
21 / output modified array /
22 for ( i = 0; i < SIZE; i++ ) {
23 printf( "%3d", a[ i ] );
24 } / end for /
25 / output value of a[ 3 ] /
26 printf( "\n\n\nEffects of passing array element "
27 "by value:\n\nThe value of a[3] is %d\n", a[ 3 ] );
28 modifyElement( a[ 3 ] ); / pass array element a[ 3 ] by value
29 / output value of a[ 3 ] /
30 printf( "The value of a[ 3 ] is %d\n", a[ 3 ] );
31 return 0;}
32 / in function modifyArray, "b" points to the original array "a"in memory /
33 void modifyArray( int b[], int size ){
34 int j; / counter /
35 / multiply each array element by 2 /
36 for ( j = 0; j < size; j++ ) { b[ j ] = 2;} / end for /
37 } / end function modifyArray /
38 / in function modifyElement, "e" is a local copy of array element a[ 3 ] passed
 from main /
39 void modifyElement( int e ){
40 / multiply parameter by 2 /
41 printf( "Value in modifyElement is %d\n", e = 2 ); }

Efek melewatkan seluruh larik dengan referensi: Nilai-nilai larik asli adalah:
01234
Nilai dari array yang dimodifikasi adalah: 0 2 4 6 8

Efek dari elemen array yang lewat berdasarkan nilai: Nilai [3] adalah 6
Nilai dalam modifikasi adalah 12 Nilai dari [3] adalah 6

Gambar 6.13 | Lewat array dan elemen array individu ke fungsi. (Bagian 3 dari 3.)
Mungkin ada situasi di program Anda di mana suatu fungsi tidak boleh diizinkan untuk
memodifikasi elemen array. Karena array selalu dilewatkan oleh referensi, modifikasi nilai
dalam array sulit untuk dikendalikan. C menyediakan tipe kualifikasi const untuk mencegah
modifikasi dari nilai-nilai larik dalam suatu fungsi. Ketika parameter array didahului oleh const
qualifier, elemen array menjadi konstan dalam tubuh fungsi, dan setiap upaya untuk
memodifikasi elemen dari array dalam hasil fungsi tubuh dalam kesalahan waktu kompilasi. Ini
memungkinkan Anda untuk memperbaiki program sehingga tidak mencoba mengubah elemen
array.
Gambar 6.14 menunjukkan kualifikasi const. Fungsi tryToModifyArray (baris 20) didefinisikan
dengan parameter const int b [], yang menentukan bahwa array b adalah konstan dan tidak dapat
dimodifikasi. Output menunjukkan pesan kesalahan yang dihasilkan oleh kompiler-kesalahan
mungkin berbeda pada sistem Anda. Masing-masing dari tiga upaya oleh fungsi untuk
memodifikasi elemen array menghasilkan kesalahan kompilator "l-nilai menentukan objek
const." Kualifier const dibahas lagi di Bab 7.
1 / Fig. 6.14: fig06_14.c

2 Demonstrating the const type qualifier with arrays /

3 #include <stdio.h>
4
5 void tryToModifyArray( const int b[] ); / function prototype /

6
7 / function main begins program execution /
8 int main( void )
9 {
10 int a[] = { 10, 20, 30 }; / initialize a /
 11. tryToModifyArray( a );
12. printf("%d %d %d\n", a[ 0 ], a[ 1 ], a[ 2 ] );
13. return 0;}
14. void tryToModifyArray( const int b[] ){
15. b[ 0 ] /= 2; / error / b[ 1 ] /= 2; / error / b[ 2 ] /= 2;} / error /

Compiling...

FIG06_14.C

fig06_14.c(22) : error C2166: l-value specifies const object fig06_14.c(23) : error C2166: l-
value specifies const object fig06_14.c(24) : error C2166: l-value specifies const object

Gambar 6.14 | penyortir tipe const. (Bagian 2 dari 2.)

Pengamatan Rekayasa Perangkat Lunak 6.3

Kualifier tipe const dapat diterapkan ke parameter array dalam definisi fungsi untuk mencegah
array asli dari yang dimodifikasi dalam tubuh fungsi. Ini adalah contoh lain dari prinsip paling
tidak istimewa. Fungsi tidak boleh diberikan kemampuan untuk memodifikasi larik kecuali itu
benar-benar diperlukan.
6.6 Sorting Array
Menyortir data (yaitu, menempatkan data ke dalam urutan tertentu seperti naik atau turun) adalah
salah satu aplikasi komputasi yang paling penting. Bank menyortir semua cek berdasarkan
nomor rekening sehingga dapat menyiapkan laporan bank masing-masing pada setiap akhir
bulan. Perusahaan telepon menyortir daftar akun mereka dengan nama belakang dan, di
dalamnya, dengan nama depan untuk memudahkan menemukan nomor telepon. Hampir setiap
organisasi harus mengurutkan beberapa data dan dalam banyak kasus sejumlah besar data.
Menyortir data adalah masalah yang menarik yang telah menarik beberapa upaya penelitian
paling intens di bidang ilmu komputer. Dalam bab ini kita membahas apa yang mungkin
merupakan skema penyortiran yang paling sederhana. Dalam Bab 12 dan Lampiran F, kami
menyelidiki skema yang lebih kompleks yang menghasilkan kinerja yang unggul.

Gambar 6.14 | penyortir tipe const. (Bagian 2 dari 2.)

Pengamatan Rekayasa Perangkat Lunak 6.3

Kualifier tipe const dapat diterapkan ke parameter array dalam definisi fungsi untuk mencegah
array asli dari yang dimodifikasi dalam tubuh fungsi. Ini adalah contoh lain dari prinsip paling
tidak istimewa. Fungsi tidak boleh diberikan kemampuan untuk memodifikasi larik kecuali itu
benar-benar diperlukan.
6.6 Sorting Array
Menyortir data (yaitu, menempatkan data ke dalam urutan tertentu seperti naik atau turun) adalah
salah satu aplikasi komputasi yang paling penting. Bank menyortir semua cek berdasarkan
nomor rekening sehingga dapat menyiapkan laporan bank masing-masing pada setiap akhir
bulan. Perusahaan telepon menyortir daftar akun mereka dengan nama belakang dan, di
dalamnya, dengan nama depan untuk memudahkan menemukan nomor telepon. Hampir setiap
organisasi harus mengurutkan beberapa data dan dalam banyak kasus sejumlah besar data.
Menyortir data adalah masalah yang menarik yang telah menarik beberapa upaya penelitian
paling intens di bidang ilmu komputer. Dalam bab ini kita membahas apa yang mungkin
merupakan skema penyortiran yang paling sederhana. Dalam Bab 12 dan Lampiran F, kami
menyelidiki skema yang lebih kompleks yang menghasilkan kinerja yang unggul.

Tip Kinerja 6.4

Seringkali, algoritma yang paling sederhana berkinerja buruk. Kebajikan mereka adalah bahwa
mereka mudah untuk menulis, menguji dan men-debug. Algoritma yang lebih kompleks sering
diperlukan untuk mewujudkan kinerja maksimum.
Gambar 6.15 mengurutkan nilai-nilai dalam elemen-elemen larik 10-elemen a (baris 10) ke
dalam urutan menaik. Teknik yang kami gunakan disebut bubble sort atau sinking sort karena
nilai-nilai yang lebih kecil secara bertahap "gelembung" cara mereka ke atas ke bagian atas array
seperti bubles udara naik dalam air, sedangkan nilai-nilai yang lebih besar tenggelam ke bagian
bawah array . Tekniknya adalah untuk membuat beberapa melewati array. Pada setiap pass,
pasangan elemen yang berurutan dibandingkan. Jika pasangan dalam urutan yang meningkat
(atau jika nilainya sama), kita meninggalkan nilai sebagaimana adanya. Jika pasangan dalam
urutan menurun, nilainya bertukar dalam larik

2 #include <stdio.h>
3 #define SIZE 10
5
6 / function main begins program execution /
7 int main( void )
8{
9 / initialize a /
10 int a[ SIZE ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };

11 int pass; / passes counter /

12 int i; / comparisons counter /
13 int hold; / temporary location used to swap array elements /
14
15 printf( "Data items in original order\n" );
 16
17 / output original array /
18 for ( i = 0; i < SIZE; i++ ) {
19 printf( "%4d", a[ i ] );
20 }
21 for ( pass = 1; pass < SIZE; pass++ ) {
22 for ( i = 0; i < SIZE - 1; i++ ) {
23 if ( a[ i ] > a[ i + 1 ] ) { hold = a[ i ];
24 a[ i ] = a[ i + 1 ]; a[ i + 1 ] = hold;
25 } / end if /
26 }
27 }
28 printf( "\nData items in ascending order\n" );
29 for ( i = 0; i < SIZE; i++ ) {
30 printf( "%4d", a[ i ] );
31 }
32 printf( "\n" );
33 return 0; / indicates successful termination /
34 }

Data items in original order

2 6 4 8 10 12 89 68 45 37
Data items in ascending order 2
8 10 12 37 45 68 89

Gambar 6.15 | Menyortir sebuah array dengan bubble sort. (Bagian 2 dari 2.)
Pertama program membandingkan [0] ke [1], kemudian [1] ke [2], kemudian [2] ke [3], dan
seterusnya sampai selesai lulus dengan membandingkan [8] ke [9]. Meskipun ada 10 elemen,
hanya sembilan perbandingan yang dilakukan. Karena cara perbandingan berturut-turut dibuat,
nilai yang besar dapat bergerak ke bawah array dengan banyak posisi pada satu laluan, tetapi
nilai yang kecil dapat naik hanya satu posisi. Pada lintasan pertama, nilai terbesar dijamin untuk
tenggelam ke elemen bawah larik, [9]. Pada pass kedua, nilai terbesar kedua dijamin akan
tenggelam ke [8]. Pada tiket kesembilan, nilai kesembilan terbesar tenggelam ke [1]. Ini
meninggalkan nilai terkecil dalam [0], sehingga hanya sembilan lintasan dari array diperlukan
untuk mengurutkan larik, meskipun ada sepuluh elemen.
Penyortiran dilakukan oleh loop untuk loop (baris 24-37). Jika swap diperlukan, itu dilakukan
oleh tiga tugas

tahan = a [i];
a [i] = a [i + 1]; a [i + 1] = tahan;
di mana variabel ekstra terus menyimpan sementara salah satu dari dua nilai yang bertukar. Swap
tidak dapat dilakukan hanya dengan dua tugas

a [i] = a [i + 1];
a [i + 1] = a [i];
Jika, misalnya, [i] adalah 7 dan [i + 1] adalah 5, setelah penugasan pertama, kedua nilai akan
menjadi 5
dan nilai 7 akan hilang. Oleh karena itu kebutuhan untuk mempertahankan variabel ekstra.
Keutamaan utama dari jenis gelembung adalah mudah untuk memprogram. Namun, gelembung
semacam itu berjalan lambat karena setiap pertukaran memindahkan satu elemen hanya satu
posisi lebih dekat ke tujuan akhirnya. Ini menjadi jelas ketika menyortir array besar. Dalam
latihan, kami akan mengembangkan versi yang lebih efisien dari jenis gelembung. Jauh lebih
efisien dari jenis gelembung yang telah dikembangkan. Kami akan menyelidiki beberapa di
antaranya dalam latihan. Kursus yang lebih maju menyelidiki penyortiran dan pencarian secara
lebih mendalam.
6.7 Studi Kasus: Komputasi Mean, Median dan Mode Menggunakan Array
Kami sekarang mempertimbangkan contoh yang lebih besar. Komputer biasanya digunakan
untuk analisis data survei untuk mengumpulkan dan menganalisis hasil survei dan jajak
pendapat. Gambar 6.16 menggunakan tanggapan array diinisialisasi dengan 99 tanggapan
terhadap survei. Setiap respons adalah angka dari 1 hingga 9. Program ini menghitung mean,
median, dan mode dari 99 nilai.
Mean adalah rata-rata aritmatika dari 99 nilai. Function mean (garis 40) menggabungkan mean
dengan total 99 elemen dan membagi hasilnya dengan 99.
Median adalah "nilai tengah." Fungsi median (baris 61) menentukan median dengan memanggil
fungsi bubbleSort (didefinisikan sejalan 133) untuk mengurutkan array tanggapan ke dalam
urutan menaik, lalu memilih elemen tengah, jawab [SIZE / 2], dari susunan yang diurutkan.
Ketika ada genap jumlah elemen, median harus dihitung sebagai mean dari dua elemen tengah.
Median fungsi saat ini tidak menyediakan kemampuan ini. Fungsi printArray (baris 156)
dipanggil untuk menampilkan array tanggapan.
Modusnya adalah nilai yang paling sering terjadi di antara 99 tanggapan. Mode fungsi (baris 82)
menentukan mode dengan menghitung jumlah tanggapan dari setiap jenis, lalu memilih nilai
dengan jumlah terbesar. Versi mode fungsi ini tidak menangani dasi (lihat Latihan 6.14). Mode
fungsi juga menghasilkan histogram untuk membantu menentukan mode secara grafis. Gambar
6.17 berisi contoh menjalankan program ini. Contoh ini mencakup sebagian besar manipulasi
umum yang biasanya diperlukan dalam masalah susunan, termasuk melewatkan array ke fungsi.
1/ Fig. 6.16: fig06_16.c

2 This program introduces the topic of survey data analysis.

3 It computes the mean, median and mode of the data /
4 #include <stdio.h>
 5 #define SIZE 99
6
7 / function prototypes /
8 void mean( const int answer[] );
9 void median( int answer[] );
10 void mode( int freq[], const int answer[] ) ;
11 void bubbleSort( int a[] );
12 void printArray( const int a[] );
13
14 / function main begins program execution /
15 int main( void )
16 {
17 int frequency[ 10 ] = { 0 }; / initialize array frequency /

18
19 / initialize array response /
20 int response[ SIZE ] =
21 { 6, 7, 8, 9, 8, 7, 8, 9, 8, 9,
22 7, 8, 9, 5, 9, 8, 7, 8, 7, 8,
23 6, 7, 8, 9, 3, 9, 8, 7, 8, 7,
24 7, 8, 9, 8, 9, 8, 9, 7, 8, 9,
25 6, 7, 8, 7, 8, 7, 9, 8, 9, 2,
26 7, 8, 9, 8, 9, 8, 9, 7, 5, 3,
27 5, 6, 7, 2, 5, 3, 9, 4, 6, 4,
28 7, 8, 9, 6, 8, 7, 8, 9, 7, 8,
29 7, 4, 4, 2, 5, 3, 8, 7, 5, 6,
30 4, 5, 6, 1, 6, 5, 7, 8, 7 };

31
32 / process responses /
33 mean( response );
34 median( response );
35 mode( frequency, response );
36 return 0; / indicates successful termination /
37 }
39 / calculate average of all response values /
40 void mean( const int answer[] )
41 {
42 int j; / counter for totaling array elements /
43 int total = 0; / variable to hold sum of array elements /
44
45 printf( "%s\n%s\n%s\n", " ", " Mean", " " );

46
47 / total response values /
48 for ( j = 0; j < SIZE; j++ ) {
49 total += answer[ j ];
50 } / end for /
51
52 printf( "The mean is the average value of the data\n"
53 "items. The mean is equal to the total of\n"
54 "all the data items divided by the number\n"
55 "of data items ( %d ). The mean value for\n"
56 "this run is: %d / %d = %.4f\n\n",
57 SIZE, total, SIZE, ( double ) total / SIZE );
58 } / end function mean /
59
60 / sort array and determine median element's value /
61 void median( int answer[] )
62 {
63 printf( "\n%s\n%s\n%s\n%s",
64 " ", " Median", " ",
65 "The unsorted array of responses is" );

66
67 printArray( answer ); / output unsorted array /

68
69 bubbleSort( answer ); / sort array /

70
71 printf( "\n\nThe sorted array is" );
72 printArray( answer ); / output sorted array /
73
74 / display median element /
75 printf( "\n\nThe median is element %d of\n"
76 "the sorted %d element array.\n"
77 "For this run the median is %d\n\n",
78 SIZE / 2, SIZE, answer[ SIZE / 2 ] );
79 } / end function median /
80
81 / determine most frequent response /
82 void mode( int freq[], const int answer[] )
83 {
84 int rating; / counter for accessing elements 1-9 of array freq /
85 int j; / counter for summarizing elements 0-98 of array answer /
86 int h; / counter for diplaying histograms of elements in array freq /
87 int largest = 0; / represents largest frequency /
88 int modeValue = 0; / represents most frequent response /
89
90 printf( "\n%s\n%s\n%s\n",
91 " ", " Mode", " " );

92
93 / initialize frequencies to 0 /
94 for ( rating = 1; rating <= 9; rating++ ) {
95 freq[ rating ] = 0;
96 } / end for /
97
98 / summarize frequencies /
99 for ( j = 0; j < SIZE; j++ ) {
100 ++freq[ answer[ j ] ];
101 }/ end for /

102
103 / output headers for result columns /
104 printf( "%s%11s%19s\n\n%54s\n%54s\n\n",
105 "Response", "Frequency", "Histogram",
106 "1 1 2 2", "5 0 5 0 5" );

107
108 / output results /
109 for ( rating = 1; rating <= 9; rating++ ) {
110 printf( "%8d%11d ", rating, freq[ rating ] );
111
112 / keep track of mode value and largest frequency value /

113 if ( freq[ rating ] > largest ) {

114 largest = freq[ rating ]; modeValue
= rating;
115
116
117
118 / output histogram bar representing frequency value /
119 for ( h = 1; h <= freq[ rating ]; h++ ) {
120 printf( " " );
121 } / end inner for /
122
123 printf( "\n" ); / being new line of output /
124 } / end outer for /
125
126 / display the mode value /
127 printf( "The mode is the most frequent value.\n"
128 "For this run the mode is %d which occurred"
129 " %d times.\n", modeValue, largest );
130 } / end function mode /
131
132 / function that sorts an array with bubble sort algorithm /
133 void bubbleSort( int a[] )
134 {

135 int pass; / pass counter /

136 int j; / comparison counter /
137 int hold; / temporary location used to swap elements /
138
139 / loop to control number of passes /
140 for ( pass = 1; pass < SIZE; pass++ ) {
141
142 / loop to control number of comparisons per pass /
143 for ( j = 0; j < SIZE - 1; j++ ) {

144
145 / swap elements if out of order /
 146 if ( a[ j ] > a[ j + 1 ] ) {
147 hold = a[ j ];
148 a[ j ] = a[ j + 1 ];

149 a[ j + 1 ] = hold;
150 } / end if /
151 } / end inner for /
152 } / end outer for /
153 } / end function bubbleSort /
154
155 / output array contents (20 values per row) /
156 void printArray( const int a[] )
157 {
158 int j; / counter /

159
160 / output array contents /
161 for ( j = 0; j < SIZE; j++ ) {
162
163 if ( j % 20 == 0 ) { / begin new line every 20 values /
164 printf( "\n" );
165 } / end if /
166
167 printf( "%2d", a[ j ] );

168 } / end for /

169 }
Fig. 6.16 | Survey data analysis program. (Part 4 of 4.)

Mean

The mean is the average value of the data items.

The mean is equal to the total of all the data

Median
 Fig. 6.17 | Sample run for the survey data analysis program. (Part 1 of 2.)

8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8 8

9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9 9

Mode
Histogram

Contoh dijalankan untuk program analisis data survei. (Bagian 2 dari 2.)

6.8 Mencari Array

Anda akan sering bekerja dengan sejumlah besar data yang disimpan dalam larik. Mungkin perlu
untuk menentukan apakah suatu array berisi nilai yang cocok dengan nilai kunci tertentu. Proses
pencarian elemen tertentu dari suatu array disebut pencarian. Pada bagian ini kita membahas dua
teknik pencarian — teknik pencarian linier sederhana dan teknik pencarian biner yang lebih
efisien (tetapi lebih kompleks). Latihan 6.32 dan Latihan 6.33 di akhir bab ini meminta Anda
untuk mengimplementasikan versi rekursif dari pencarian linear dan pencarian biner.
Mencari Array dengan Pencarian Linear
Pencarian linear (Gambar 6.18) membandingkan setiap elemen dari array dengan kunci
pencarian. Karena larik tidak dalam urutan tertentu, kemungkinan besar nilainya akan ditemukan
di elemen pertama seperti yang terakhir. Oleh karena itu, rata-rata, program harus
membandingkan kunci pencarian dengan setengah elemen dari array.
1 / Fig. 6.18: fig06_18.c

2 Linear search of an array /

3 #include <stdio.h>
4 #define SIZE 100
5
6 / function prototype /
7 int linearSearch( const int array[], int key, int size );
8
9 / function main begins program execution /
10 int main( void )
11 {

12 int a[ SIZE ]; / create array a /

13 int x; / counter for initializing elements 0-99 of array a /
14 int searchKey; / value to locate in array a /
15 int element; / variable to hold location of searchKey or -1 /
16
17 / create data /
18 for ( x = 0; x < SIZE; x++ ) {
19 a[ x ] = 2 x;
20 }/ end for /

21
22 printf( "Enter integer search key:\n" );
23 scanf( "%d", &searchKey );
24
/ attempt to locate searchKey in array a / element =
25 linearSearch( a, searchKey, SIZE );

26
27
28 / display results /
29 if ( element != -1 ) {
30 printf( "Found value in element %d\n", element );
31 } / end if /
32 else {
33 printf( "Value not found\n" );
34 } / end else /
35
36 return 0; / indicates successful termination /
37 } / end main /
 38 / compare key to every element of array until the location is found or until the
end of array is reached; return subscript of element if key or -1 if key is
39 not found /

int linearSearch( const int array[], int key, int size )

40
41
int n; / counter /

42
43 / loop through array /

for ( n = 0; n < size; ++n ) {

44
45
if ( array[ n ] == key ) {
46 return n; / return location of key /

47 } / end if /

} / end for /
48

Enter integer search key:

37

Value not found

Enter integer search key:

36

Found value in element 18

Gambar 6.18 | Pencarian linier sebuah array. (Bagian 3 dari 3.)
Mencari Array dengan Pencarian Biner
Metode pencarian linier berfungsi baik untuk array kecil atau tidak disortir. Namun, untuk
pencarian linear array besar tidak efisien. Jika array diurutkan, teknik pencarian binary
berkecepatan tinggi dapat digunakan.
Algoritma pencarian biner menghilangkan dari pertimbangan satu-setengah dari elemen
dalam array diurutkan setelah setiap perbandingan. Algoritme menempatkan elemen tengah dari
array dan membandingkannya dengan kunci pencarian. Jika mereka sama, kunci pencarian
ditemukan dan subscript array dari elemen tersebut dikembalikan. Jika mereka tidak sama,
masalah berkurang menjadi mencari setengah dari array. Jika tombol pencarian lebih kecil dari
elemen tengah array, setengah bagian pertama dari pencarian dicari, jika tidak, setengah bagian
kedua dari array dicari. Jika kunci pencarian tidak ditemukan dalam sub-tugas yang ditentukan
(bagian dari array asli), algoritma ini diulangi pada seperempat dari array asli. Pencarian
berlanjut sampai tombol pencarian sama dengan elemen tengah dari sub-rangkai, atau hingga
sub-tugas terdiri dari satu elemen yang tidak sama dengan tombol pencarian (yaitu, tombol
pencarian tidak ditemukan).
Dalam skenario kasus terburuk, mencari array dari 1023 elemen hanya membutuhkan 10
perbandingan menggunakan pencarian biner. Berulang kali membagi 1024 dengan 2
menghasilkan nilai 512, 256, 128,64, 32, 16, 8, 4, 2 dan 1. Angka 1024 (210) dibagi 2 hanya 10
kali untuk mendapatkan nilai 1. Membagi dengan 2 setara dengan satu perbandingan dalam
algoritma pencarian biner. Array elemen 1048576 (220) membutuhkan maksimum 20
perbandingan untuk menemukan kunci pencarian. Array satu miliar elemen membutuhkan
maksimum 30 perbandingan untuk menemukan kunci pencarian. Ini adalah peningkatan luar
biasa dalam kinerja atas pencarian linear yang diperlukan membandingkan kunci pencarian
hingga rata-rata setengah dari elemen array. Untuk array satu miliar elemen, ini adalah
perbedaan antara rata-rata 500 juta perbandingan dan maksimum 30 perbandingan! Perbandingan
maksimum untuk setiap array dapat ditentukan dengan mencari kekuatan pertama 2 lebih besar
dari jumlah elemen array.
Gambar 6.19 menyajikan versi iteratif dari fungsi binarySearch (baris 44-74).
Fungsi ini menerima empat argumen - sebuah bilangan integer b yang akan dicari, sebuah
pencarian integerKey, subskrip array rendah dan subscript array yang tinggi (ini menentukan
porsi array yang akan dicari). Jika tombol pencarian tidak cocok dengan elemen tengah dari sub-
array, subscript rendah atau subscript tinggi dimodifikasi sehingga subrame yang lebih kecil
dapat dicari. Jika tombol pencarian lebih kecil dari elemen tengah, subscript tinggi diset ke
tengah - 1 dan pencarian dilanjutkan pada elemen dari rendah ke menengah - 1. Jika tombol
pencarian lebih besar dari elemen tengah, maka subscript rendah adalah set ke tengah + 1 dan
pencarian dilanjutkan pada elemen dari tengah + 1 ke tinggi. Program adalah 16 (24), jadi
maksimum 4 perbandingan diperlukan untuk menemukan kunci pencarian. Program ini
menggunakan printHeader fungsi (baris 77-96) untuk menampilkan larik subscript dan fungsi
printRow (baris 100-120) untuk menghasilkan setiap sub-rangkai selama proses pencarian biner.
Elemen tengah di setiap sub-ruas ditandai dengan tanda bintang () untuk menunjukkan elemen
yang dibandingkan dengan kunci penelusuran.
1/ Fig. 6.19: fig06_19.c

2 Binary search of a sorted array /

3 #include <stdio.h>
4 #define SIZE 15
5
6 / function prototypes /
7 int binarySearch( const int b[], int searchKey, int low, int high );
8 void printHeader( void );
9 void printRow( const int b[], int low, int mid, int high );
10
11 / function main begins program execution /
12 int main( void )
13 {

14 int a[ SIZE ]; / create array a /

15 int i; / counter for initializing elements 0-14 of array a /
16 int key; / value to locate in array a /
17 int result; / variable to hold location of key or -1 /
18
19 / create data /
20 for ( i = 0; i < SIZE; i++ ) {
21 a[ i ] = 2 i;
22 }/ end for /

23
24 printf( "Enter a number between 0 and 28: " );
25 scanf( "%d", &key );
26
27 printHeader();

28
29 / search for key in array a /
30 result = binarySearch( a, key, 0, SIZE - 1 );
31
32 / display results /
33 if ( result != -1 ) {
34 printf( "\n%d found in array element %d\n", key, result );
35 } / end if /
36 else {
37 printf( "\n%d not found\n", key );
38 } / end else /
39
40 return 0; / indicates successful termination /
41 } / end main /
42
43 / function to perform binary search of an array /
44 int binarySearch( const int b[], int searchKey, int low, int high )
45 {
46 int middle; / variable to hold middle element of array /

47
48 / loop until low subscript is greater than high subscript /
49 while ( low <= high ) {
50
51 / determine middle element of subarray being searched /
52 middle = ( low + high ) / 2;
53
54 / display subarray used in this loop iteration /
55 printRow( b, low, middle, high );
56 / if searchKey matched middle element, return middle /
57 if ( searchKey == b[ middle ] ) {
58 return middle;
59 } / end if /
60 else if ( searchKey < b[ middle ] ) {
61 high = middle - 1; / search low end of array /
54 }
55 / if searchKey greater than middle element, set new low /
56 else {
57 low = middle + 1; / search high end of array /
58 }
}

72
73 return -1; / searchKey not found /
74 } / end function binarySearch /
75
76 / Print a header for the output /
77 void printHeader( void )
78 {
79 int i; / counter /

80
81 printf( "\nSubscripts:\n" );

82
83 / output column head /
84 for ( i = 0; i < SIZE; i++ ) {
85 printf( "%3d ", i );
86 } / end for /
87
88 printf( "\n" ); / start new line of output /

89
90 / output line of - characters /
91 for ( i = 1; i <= 4 SIZE; i++ ) {

92 printf( "-" );
93 } / end for /
94
95 printf( "\n" ); / start new line of output /
59 }
98 /Print one row of output showing the current
99 part of the array being processed. /
100 void printRow( const int b[], int low, int mid, int high )
101 {
102 int i; / counter for iterating through array b /

103
104 / loop through entire array /
105 for ( i = 0; i < SIZE; i++ ) {
106
107 / display spaces if outside current subarray range /
108 if ( i < low || i > high ) {
109 printf( " " );
110 } / end if /
111 else if ( i == mid ) { / display middle element /
112 printf( "%3d ", b[ i ] ); / mark middle value /
113 } / end else if /
114 else { / display other elements in subarray /
115 printf( "%3d ", b[ i ] );

116 } / end else /

117 } / end for /
118
119 printf( "\n" ); / start new line of output /
 120 }

Enter a number between 0 and 28: 25

Subscripts:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

02 4 6
8 10 12 14 16 18 20 22 24 26 28

16 18 20 22 24 26 28

Enter a number between 0 and 28: 8

Subscripts:

Fig. 6.19 | Binary search of a sorted array. (Part 3 of 4.)

Enter a number between 0 and 28: 6

Subscripts:

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

02 4 6
8 10 12 14 16 18 20 22 24 26 28

Fig. 6.19 | Binary search of a sorted array. (Part 4 of 4.)

6.9 Array Beberapa Langganan

Array dalam C dapat memiliki beberapa subskrip. Penggunaan umum dari array multi-langganan
(juga disebut multidimensi array) adalah untuk mewakili tabel nilai yang terdiri dari informasi
yang diatur dalam baris dan kolom. Untuk mengidentifikasi elemen tabel tertentu, kita harus
menetapkan dua subskrip: Yang pertama (berdasarkan konvensi) mengidentifikasi baris elemen
dan bagian kedua (berdasarkan konvensi) mengidentifikasi kolom elemen. Tabel atau larik yang
memerlukan dua subskrip untuk mengidentifikasi elemen tertentu disebut larik bersusun ganda.
Rangkaian multi-langganan dapat memiliki lebih dari dua subskrip.
Gambar 6.20 mengilustrasikan larik bersusun ganda, a. Array berisi tiga baris dan empat kolom,
sehingga dikatakan sebagai array 3-oleh-4. Secara umum, sebuah array dengan baris m dan n
kolom disebut array m-oleh-n.

Column 0 Column 1 Column 2 Column 3

Row 0 a[ 0 ][ 0 ] a[ 0 ][ 1 ] a[ 0 ][ 2 ] a[ 0 ][ 3 ]

a[ 1 ][ 0 ] a[ 1 ][ 1 ] a[ 1 ][ 2 ] a[ 1 ][ 3 ]
Row 1
a[ 2 ][ 0 ] a[ 2 ][ 1 ] a[ 2 ][ 2 ] a[ 2 ][ 3 ]
Row 2

Gambar 6.20 | Array langganan ganda dengan tiga baris dan empat kolom.
Setiap elemen dalam array a diidentifikasi pada Gambar. 6.20 oleh nama elemen bentuk a [i] [j];
a adalah nama array, dan i dan j adalah subscript yang secara unik mengidentifikasi setiap
elemen dalam a. Nama-nama elemen di baris pertama semuanya memiliki subscript pertama
0; nama-nama elemen di kolom keempat semuanya memiliki subscript kedua 3.

Common Programming Error 6.9

Mereferensikan elemen susunan larik ganda sebagai [x, y] dan bukan [x] [y]. C
menginterpretasikan [x, y] sebagai [y], dan karena itu tidak menyebabkan kesalahan kompilasi.

Larik multi-langganan dapat diinisialisasi saat ditentukan, mirip dengan larik bersusun tunggal.
Sebagai contoh, array double-subscripted int b [2] [2] dapat didefinisikan dan diinisialisasi
dengan
int b [2] [2] = {{1, 2}, {3, 4}};
Nilai dikelompokkan berdasarkan baris dalam kurung kurawal. Nilai-nilai dalam set pertama
braces menginisialisasi baris 0 dan nilai-nilai di set kedua braces menginisialisasi baris 1. Jadi,
nilai-nilai 1 dan 2 menginisialisasi elemen b [0] [0] dan b [0] [1], masing-masing , dan nilai-nilai
3 dan 4 elemen inisialisasi b [1] [0] dan b [1] [1], masing-masing. Jika tidak ada cukup
penginisialisasi untuk baris yang diberikan, elemen yang tersisa dari baris tersebut diinisialisasi
ke 0. Jadi,
int b [2] [2] = {{1}, {3, 4}};
akan menginisialisasi b [0] [0] hingga 1, b [0] [1] hingga 0, b [1] [0] hingga 3 dan b [1] [1]
hingga 4. Gambar 6.21 menunjukkan pendefinisian dan inisialisasi double- array langganan.
Program ini mendefinisikan tiga array dari dua baris dan tiga kolom (masing-masing enam
elemen). Definisi array1 (baris 11) menyediakan enam initializers dalam dua sublist. Sublist
pertama menginisialisasi baris pertama (yaitu, baris 0) dari array ke nilai 1, 2 dan 3; dan sublist
kedua menginisialisasi baris kedua (yaitu, baris 1) dari array ke nilai 4, 5 dan 6.
 1 / Fig. 6.21: fig06_21.c

2 Initializing multidimensional arrays /

3 #include <stdio.h>
4
5 void printArray( const int a[][ 3 ] ); / function prototype /

6
7 / function main begins program execution /
8 int main( void )
9 {
10 int array1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } };
11 int array2[ 2 ][ 3 ] = { 1, 2, 3, 4, 5 };
12 int array3[ 2 ][ 3 ] = { { 1, 2 }, { 4 } };
15 printf( "Values in array1 by row are:\n" );
16 printArray( array1 );
17
18 printf( "Values in array2 by row are:\n" );
19 printArray( array2 );
20
21 printf( "Values in array3 by row are:\n" );
22 printArray( array3 );
23 return 0; / indicates successful termination /
24 }
25 / function to output array with two rows and three columns /
26 void printArray( const int a[][ 3 ] )
27 {
28 int i; / row counter /
29 int j; / column counter
30
31 / loop through rows /
32 for ( i = 0; i <= 1; i++ ) {
33 / output column values /
34 for ( j = 0; j <= 2; j++ ) { printf( "%d ", a[ i ][ j ] );
35 } / end inner for /
36 printf( "\n" ); / start new line of output /
37 }
 Values in array1 by row are: 1 2 3

4 5 6

Values in array2 by row are: 1 2 3

4 5 0

Values in array3 by row are: 1 2 0

4 0 0

Gambar 6.21 | Inisialisasi array multidimensi. (Bagian 2 dari 2.)

Jika tanda kurung di sekitar masing-masing sublist dihapus dari daftar penginisialisasi
array1, kompilator akan menginisialisasi elemen dari baris pertama diikuti oleh elemen dari baris
kedua. Definisi array2 (baris 12) menyediakan lima initializers. Penginisialisasi ditugaskan ke
baris pertama, lalu baris kedua. Setiap elemen yang tidak memiliki initializer eksplisit
diinisialisasi ke nol secara otomatis, jadi array2 [1] [2] diinisialisasi ke 0.
Definisi array3 (baris 13) menyediakan tiga initializers dalam dua sublist. Sub-daftar untuk baris
pertama secara eksplisit menginisialisasi dua elemen pertama dari baris pertama ke 1 dan 2.
Elemen ketiga diinisialisasi ke nol. Sublist untuk baris kedua secara eksplisit menginisialisasi
elemen pertama ke 4. Dua elemen terakhir diinisialisasi ke nol.
Program ini memanggil printArray (baris 27-43) untuk menampilkan elemen array.
Definisi fungsi menentukan parameter larik sebagai const int a [] [3]. Saat kami menerima larik
bersyarat tunggal sebagai parameter, kurung larik kosong dalam daftar parameter fungsi.
Subscript pertama dari array multi-langganan tidak diperlukan, tetapi semua subscript berikutnya
diperlukan. Compiler menggunakan subskrip ini untuk menentukan lokasi dalam memori elemen
dalam array multi-langganan. Semua elemen array disimpan secara berurutan dalam memori
terlepas dari jumlah subscript. Dalam susunan ganda-sub-skrip, baris pertama disimpan dalam
memori diikuti oleh baris kedua.
Memberikan nilai-nilai subskrip dalam deklarasi parameter memungkinkan compiler untuk
memberitahu fungsi bagaimana menemukan elemen dalam array. Dalam susunan double-
subscripted, setiap baris pada dasarnya adalah array single-subscripted. Untuk menemukan
elemen di baris tertentu, kompiler harus tahu berapa banyak elemen di setiap baris sehingga
dapat melewati jumlah lokasi memori yang tepat saat mengakses larik. Jadi, ketika mengakses
[1] [2] dalam contoh kita, kompiler tahu untuk melewatkan tiga elemen dari baris pertama untuk
sampai ke baris kedua (baris 1). Kemudian, kompiler mengakses elemen ketiga dari baris itu
(elemen 2).
Banyak manipulasi array umum digunakan untuk pernyataan pengulangan. Sebagai contoh,
pernyataan berikut ini menetapkan semua elemen di baris ketiga dari array a pada Gambar. 6.20
ke nol:

for ( column = 0; column <= 3; column++ ) { a[ 2 ][ column ] = 0;

}
Kami menentukan baris ketiga, oleh karena itu kami tahu bahwa subskrip pertama selalu 2 (lagi,
0 adalah baris pertama dan 1 adalah yang kedua). Lingkaran hanya bervariasi pada subskrip
kedua (yaitu, kolom). Pernyataan sebelumnya untuk pernyataan setara dengan pernyataan
penugasan:

a[ 2 ][ 0 ] = 0;
a[ 2 ][ 1 ] = 0;
a[ 2 ][ 2 ] = 0;
a[ 2 ][ 3 ] = 0;
Pernyataan bersarang berikut ini menentukan total semua elemen dalam larik a.

total = 0;
for ( row = 0; row <= 2; row++ ) {
for ( column = 0; column <= 3; column++ ) { total += a[ row ][
column ];
}
}

Pernyataan untuk total elemen dari array satu baris pada suatu waktu. Bagian luar untuk
pernyataan dimulai dengan mengatur baris (yaitu, baris subskrip) ke 0 sehingga unsur-unsur
baris pertama dapat dijumlahkan oleh bagian dalam untuk pernyataan. Pernyataan luar untuk
kemudian menambahkan baris ke 1, sehingga elemen dari baris kedua dapat dijumlahkan.
Kemudian, pernyataan luar untuk kenaikan baris ke 2, sehingga elemen dari baris ketiga dapat
dijumlahkan. Hasilnya dicetak saat pernyataan nested for berakhir.
Manipulasi 2-Dimensonal Array
Gambar 6.22 melakukan beberapa manipulasi array umum lainnya pada 3-oleh-4 array stu-
dentGrades menggunakan untuk pernyataan. Setiap baris array mewakili seorang siswa dan
masing-masing kolom mewakili nilai pada salah satu dari empat ujian yang siswa ambil selama
semester. Manipulasi array dilakukan oleh empat fungsi. Fungsi minimum (baris 43–
62) menentukan nilai terendah dari setiap siswa untuk semester. Fungsi maksimum (baris 65-84)
menentukan nilai tertinggi dari setiap siswa untuk semester tersebut. Rata-rata fungsi (baris 87-
98) menentukan rata-rata semester siswa tertentu. Fungsi printArray (baris 101–120)
menghasilkan larik ber-subscript ganda dalam format tabular yang rapi.
1 / Fig. 6.22: fig06_22.c

2 Double-subscripted array example /

3 #include <stdio.h>
4 #define STUDENTS 3
5 #define EXAMS 4
6
 7 / function prototypes /
8 int minimum( const int grades[][ EXAMS ], int pupils, int tests );
9 int maximum( const int grades[][ EXAMS ], int pupils, int tests );
10 double average( const int setOfGrades[], int tests );
11 void printArray( const int grades[][ EXAMS ], int pupils, int tests );
12
13 / function main begins program execution /
14 int main( void )
15 {
16 int student; / student counter /

17
18 / initialize student grades for three students (rows) /
19 const int studentGrades[ STUDENTS ][ EXAMS ] =
20 { { 77, 68, 86, 73 },
21 { 96, 87, 89, 78 },
22 { 70, 90, 86, 81 } };

23
24 / output array studentGrades /
25 printf( "The array is:\n" );
26 printArray( studentGrades, STUDENTS, EXAMS );
27
28 / determine smallest and largest grade values /
29 printf( "\n\nLowest grade: %d\nHighest grade: %d\n",
30 minimum( studentGrades, STUDENTS, EXAMS ),
31 maximum( studentGrades, STUDENTS, EXAMS ) );
32
33 / calculate average grade for each student /
34 for ( student = 0; student < STUDENTS; student++ ) {
35 printf( "The average grade for student %d is %.2f\n",
36 student, average( studentGrades[ student ], EXAMS ) );
37 } / end for /
38
39 return 0; / indicates successful termination /
40 } / end main /
41
42 / Find the minimum grade /
43 int minimum( const int grades[][ EXAMS ], int pupils, int tests )
44 {

45 int i; / student counter /

46 int j; / exam counter /
47 int lowGrade = 100; / initialize to highest possible grade /
48
49 / loop through rows of grades /
50 for ( i = 0; i < pupils; i++ ) {
51
52 / loop through columns of grades /
53 for ( j = 0; j < tests; j++ ) {
54
55 if ( grades[ i ][ j ] < lowGrade ) {
56 lowGrade = grades[ i ][ j ];
57 } / end if /
58 } / end inner for /
59 } / end outer for /
60
61 return lowGrade; / return minimum grade /
62 } / end function minimum /
64 / Find the maximum grade /
65 int maximum( const int grades[][ EXAMS ], int pupils, int tests )
66 {

67 int i; / student counter /

68 int j; / exam counter /
69 int highGrade = 0; / initialize to lowest possible grade /
70
71 / loop through rows of grades /
72 for ( i = 0; i < pupils; i++ ) {
73
74 / loop through columns of grades /
75 for ( j = 0; j < tests; j++ ) {
76
77 if ( grades[ i ][ j ] > highGrade ) {
78 highGrade = grades[ i ][ j ];
79 } / end if /
80 } / end inner for /
81 } / end outer for /
82
83 return highGrade; / return maximum grade /
84 }
85 / Determine the average grade for a particular student /
86 double average( const int setOfGrades[], int tests )
87 {
88 int i; / exam counter /
89 int total = 0; / sum of test grades /
90
91 / total all grades for one student /
92 for ( i = 0; i < tests; i++ ) { total += setOfGrades[ i ];
93 } / end for /
94
95 return ( double ) total / tests; / average /
96 } / end function average /
100 / Print the array /
101 void printArray( const int grades[][ EXAMS ], int pupils, int tests )
102 {
103 int i; / student counter /
104 int j; / exam counter /
105
106 / output column heads /
107 printf( " [0] [1] [2] [3]" );

108
109 / output grades in tabular format /
110 for ( i = 0; i < pupils; i++ ) {
111
112 / output label for row /
113 printf( "\nstudentGrades[%d] ", i );
114 / output grades for one student /
115 for ( j = 0; j < tests; j++ ) {
116 printf( "%-5d", grades[ i ][ j ] );
117 } / end inner for /
118 } / end outer for /}
 The array is:

[0] [1] [2] [3]

Lowest grade: 68

Highest grade: 96

The average grade for student 0 is 76.00 The average

grade for student 1 is 87.50 The average grade for

Gambar 6.22 | Contoh array subscripted ganda. (Bagian 4 dari 4.)

Fungsi minimum, maksimum dan printArray masing-masing menerima tiga argumen — array
StudentGrades (disebut nilai dalam setiap fungsi), jumlah siswa (baris array) dan jumlah ujian
(kolom dari array). Setiap fungsi loop melalui nilai array menggunakan nested for statements.
Pernyataan bersarang berikut ini berasal dari definisi minimum fungsi:

/ loop melalui deretan nilai /

untuk (i = 0; i <murid; i ++) {
/ loop melalui kolom nilai /
untuk (j = 0; j <tes; j ++) {
if (grades [i] [j] <lowGrade) {lowGrade = nilai [i] [j];
} / akhir jika /
} / mengakhiri batin untuk /
} / akhiri bagian luar untuk /
Luar untuk pernyataan dimulai dengan menetapkan i (yaitu, baris subskrip) ke 0 sehingga elemen
dari baris pertama (yaitu, nilai dari siswa pertama) dapat dibandingkan dengan variabel
rendahGrade dalam tubuh batin untuk pernyataan. Bagian dalam untuk pernyataan mengitari
empat tingkat baris tertentu dan membandingkan masing-masing kelas dengan kelas rendah. Jika
nilai kurang dari rendahGrade, rendahGrade diatur ke kelas itu. Luar untuk pernyataan kemudian
menambahkan baris subskrip ke 1. Elemen-elemen baris kedua dibandingkan dengan variabel
LowGrade. Bagian luar untuk pernyataan kemudian menambahkan subscript baris ke 2. Elemen-
elemen baris ketiga dibandingkan dengan variabel LowGrade. Ketika pelaksanaan struktur
bersarang lengkap, lowGrade berisi kelas terkecil dalam array double-subscripted. Fungsi max-
imum bekerja sama dengan fungsi minimum.
Rata-rata fungsi (baris 87) mengambil dua argumen — array tunggal hasil tes untuk siswa
tertentu yang disebut setOfGrades dan jumlah hasil tes dalam larik. Ketika rata-rata dipanggil,
siswa argumen pertama [Mahasiswa] dilewatkan. Ini menyebabkan alamat dari satu baris dari
susunan double-subscripted dilewatkan ke rata-rata

Argumen studentGrades [1] adalah alamat awal dari baris kedua dari array. Ingat bahwa larik
bersusun ganda pada dasarnya merupakan larik dari larik bersusun tunggal dan bahwa nama larik
bersyarat tunggal adalah alamat larik dalam memori. Fungsi rata-rata menghitung jumlah elemen
array, membagi total dengan jumlah hasil tes dan mengembalikan hasil floating-point.