Friday, December 23, 2016

Bab 5. Pemrograman C Belajar Dari Contoh



Bab. 5 Array

Tujuan Instruksional
      ·         Array.
      ·         Mendefinisikan array.
      ·         Contoh array.
      ·         Melewatkan array ke fungsi.
·         Pengurutan array.
·         Pencarian array.
·         Array subskript-jamak




5.1 Introduksi

Bab ini akan berperan sebagai pengantar topik struktur data. Array adalah struktur data yang memuat item-item berelasi bertipe sama. Pada Bab 9, akan didiskusikan notasi C tentang struktur (struct), sebuah struktur data yang memuat data berelasi dengan tipe berbeda. Array dan struktur adalah entitas statik dimana ukurannya tetap sama selama eksekusi program. Pada Bab 11, akan dikenalkan struktur data dinamis seperti list, antrian (queue), tumpukan (stack), dan pohon (tree) yang ukurannya dapat berubah selama program dieksekusi.

5.2 Array
Array adalah sekelompok lokasi memori yang berelasi oleh fakta bahwa semua memiliki nama dan tipe sama. Untuk menunjuk ke lokasi atau elemen tertentu di dalam array, nama array dan nomor posisi elemen tertentu di dalam array perlu dispesifikasi.


Gambar 5.1 | Array 12-elemen

Gambar 5.1 menampilkan sebuah array integer c. Array ini memuat 12 elemen. Sembarang elemen dapat dirujuk atau ditunjuk dengan memberikan nama array yang diikuti dengan nomor posisi elemen tertentu yang diapit dengan sepasang kurung siku ([]). Elemen pertama di dalam setiap array disebut dengan elemen ke-nol. Jadi, elemen pertama array c dirujuk dengan c[0], elemen keduanya dirujuk dengan c[1], dan secara umum, elemen ke-i dirujuk dengan c[i-1]. Nama array, seperti nama variabel yang lain, hanya dapat memuat huruf, dijit, dan garis-bawah (_). Nama array tidak bisa diawali dengan dijit.

Nomor posisi yang diapit sepasang kurung siku lebih formal disebut dengan subskript (atau indeks). Indeks harus berupa integer atau ekspresi integer. Jika suatu program menggunakan sebuah ekspresi sebagai subskript, maka ekspresi tersebut dievaluasi lebih dahulu untuk menentukan subskript. Sebagai contoh, jika a = 5 dan b = 6, maka statemen

c[ a + b ] += 2;

menambahkan 2 kepada elemen array c[11]. Nama array yang bersubskript merupakan lvalue, jadi hanya bisa digunakan di sisi kiri suatu penugasan.

Operator
Asosiatifitas
Tipe
[]   ()

++   --  !   (tipe)

*   /   %

+   -

<   <=   >   >=

==   !=

&

||

?:

=   +=   -=   *=   /=   %=

,
kiri ke kanan

kanan ke kiri

kiri ke kanan

kiri ke kanan

kiri ke kanan

kiri ke kanan

kiri ke kanan

kiri ke kanan

kanan ke kiri

kanan ke kiri

kiri ke kanan
tertinggi

unary

multiplikatif

aditif

relasional

ekualitas

AND logikal

OR logikal

kondisional

penugasan

koma

Gambar 5.2 | Keutamaan dan asosiatifitas operator

Akan diamati array c (Gambar 5.1) lebih dekat. Nama array adalah c. 12 elemennya dapat dirujuk dengan c[0], c[1], c[2], ..., c[11]. Nilai yang disimpan di dalam c[0] adalah -45, nilai yang disimpan di dalam c[1] adalah 6, nilai yang disimpan di dalam c[2] adalah 0, nilai yang disimpan di dalam c[7] adalah 62, dan nilai yang disimpan di dalam c[11] adalah 78. Untuk menampilkan penjumlahan semua nilai yang dimuat di dalam tiga elemen pertama array c, dituliskan

printf( "%d", c[ 0 ] + c[ 1 ] + c[ 2 ] );

Untuk membagi nilai dari elemen ketujuh array c dengan 2 dan menugaskan hasilnya kepada variabel x, dituliskan

x = c[ 6 ] / 2;

Kurung siku yang digunakan untuk mengapit subskript sebuah array dipandang sebagai suatu operator di dalam C. Operator tersebut memiliki level keutamaan yang sama dengan operator pemanggilan fungsi (yaitu, sepasang kurung yang ditempatkan setelah nama fungsi pada pemanggilan fungsi). Gambar 5.2 menunjukkan derajat keutamaan dan asosiatifitas yang telah dikenalkan sejauh ini.

5.3 Mendefinisikan Array
Array menempati ruang di dalam memori. Tipe setiap elemen dan jumlah elemen yang dibutuhkan setiap array dapat dispesifikasi sehingga komputer bisa mencadangkan jumlah memori yang sesuai untuk kebutuhan itu. Untuk memberitahu komputer dalam mencadangkan 12 elemen bagi array integer c, definisi

int c[ 12 ];

digunakan. Definisi berikut

int b[ 100 ], x[ 27 ];

memberikan ruang di dalam memori untuk 100 elemen dari array integer b dan 27 elemen dari array integer x.

Array dapat memuat tipe data lainnya. Misalnya, sebuah array bertipe char dapat dipakai untuk menyimpan suatu string karakter. String karakter dan kesamaannya dengan array didiskusikan pada Bab 7. Relasi antara pointer dan array didiskusikan pada Bab 6.

5.4 Contoh Array
Bagian ini akan menyajikan beberapa contoh yang mendemonstrasikan bagaimana mendefinisikan array, bagaimana menginisialisasi array, dan bagaimana memanipulasi array.

Mendefinisikan Array dan Menggunakan Loop untuk Menginisialisasi Array
Gambar 5.3 menggunakan statemen for untuk menginisialisasi dengan nol elemen-elemen dari suatu array integer n 10-elemen dan menampilkannya dalam format tabular. Statemen printf yang pertama (baris 16) menampilkan kepala kolom untuk dua kolom yang ditampilkan di dalam statemen for.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/* Gambar 5.3: gambar05_03.c
   Penginisialisasian suatu array */
#include <stdio.h>

/* fungsi main memulai eksekusi program */
int main( void )
{
  int n[ 10 ]; /* n adalah array dengan 10 integer */
  int i; /* kounter */

  /* menginisialisasi elemen array array n dengan 0 */
  for ( i = 0; i < 10; i++ ) {
    n[ i ] = 0; /* menetapkan elemen pada lokasi i menjadi 0 */
  } /* akhir for */

  printf( "%s%13s\n", "Elemen", "Nilai" );

  /* menampilkan isi array n dalam format tabular */
  for ( i = 0; i < 10; i++ ) {
    printf( "%6d%13d\n", i, n[ i ] );
  } /* akhir for */

  return 0; /* indikasi terminasi sukses */
} /* akhir main */


Elemen        Nilai
     0            0
     1            0
     2            0
     3            0
     4            0
     5            0
     6            0
     7            0
     8            0
     9            0


Gambar 5.3 | Penginisialisasian elemen-elemen suatu array dengan nol

Menginisialisasi Array
Elemen suatu array dapat pula diinisialisasi ketika array didefinisikan dengan definisi berikut menggunakan tanda sama dengan dan separang kurung kurawal, { }, yang memuat daftar penginisialisasi terpisahkan koma. Gambar 5.4 menginisialisasi suatu array integer dengan 10 nilai (baris 9) dan menampilkan array dalam format tabular.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/* Gambar 5.4: gambar05_04.c
   Penginisialisasian array menggunakan daftar penginisialisasi */
#include <stdio.h>

/* fungsi main memulai eksekusi */
int main( void )
{
  /* menggunakan daftar penginisialisasi untuk menginisialisasi array n */
  int n[ 10 ] = { 32, 27, 64, 18, 95, 14, 90, 70, 60, 37 };
  int i; /* kounter */

  printf( "%s%13s\n", "Elemen", "Nilai" );

  /* menampilkan isi array dalam format tabular */
  for ( i = 0; i < 10; i++ ) {
    printf( "%6d%13d\n", i, n[ i ] );
  } /* akhir for */

  return 0; /* indikasi terminasi sukses */
} /* akhir main */


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


Gambar 5.4 | Penginisialisasian elemen-elemen suatu array dengan suatu daftar penginisialisasi

Jika terdapat penginisialisasi lebih sedikit daripada jumlah elemen di dalam array, maka sisa elemen diinisialisasi dengan 0. Sebagai contoh, elemen-elemen array n pada Gambar 5.3 dapat diinisialisasi dengan 0 sebagai berikut:

int n[ 10 ] = { 0 };

Ini secara eksplisit menginisialisasi elemen pertama dengan 0 dan menginisialisasi sembilan elemen lainnta dengan 0 karena terdapat penginisialisasi lebih sedikit daripada jumlah elemen di dalam array. Hal penting untuk diingat adalah array tidak secara otomatis diinisialisasi dengan 0. Anda harus sedikitnya menginisialisasi elemen pertama dengan nol dan sisa elemen yang lain akan diinisialisasi secara otomatis dengan nol. Metode penginisialisasian terhadap elemen array dengan nol dilakukan pada waktu kompilasi untuk array static dan pada waktu runtime untuk array otomatis.

Definisi array

int n[ 5 ] = { 32, 27, 64, 18, 95, 14 };

akan menyebabkan error sintaks karena terdapat enam penginisialisasi dan hanya ada lima elemen array.

Jika ukuran array diabaikan dari suatu definisi dengan sebuah daftar penginisialisasi array, maka jumlah elemen di dalam array merupakan jumlah elemen di dalam daftar penginisialisasi. Sebagai contoh,

int n[] = { 1, 2, 3, 4, 5 };

akan menciptakan suatu array lima-elemen.

Menspesifikasi Ukuran Array dengan Konstanta Simbolik
Gambar 5.5 menginisialisasi elemen-elemen suatu array 10-elemen dengan nilai-nilai 2, 4, 6, ..., 20 dan menampilkan array dalam format tabular. Nilai-nilai yang dihasilkan dikalikan dengan kounter loop dan ditambahkan 2.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/* Gambar 5.5: gambar05_05.c
   Penginisialisasian elemen array s dengan integer genap dari 2 sampai 20 */
#include <stdio.h>
#define UKURAN 10 /* ukuran maksimum array */

/* fungsi main memulai eksekusi */
int main( void )
{
  /* konstanta simbolik UKURAN dapat dipakai untuk menetapkan ukuran array */
  int s[ UKURAN ]; /* array s mempunyai UKURAN elemen */
  int j; /* kounter */

  for ( j = 0; j < UKURAN; j++ ) { /* menetapkan nilai */
    s[ j ] = 2 + 2 * j;
  } /* akhir for */

  printf( "%s%13s\n", "Elemen", "Nilai" );

  /* menampilkan isi array s dalam format tabular */
  for ( j = 0; j < UKURAN; j++ ) {
    printf( "%6d%13d\n", j, s[ j ] );
  } /* akhir for */

  return 0; /* indikasi terminasi sukses */
} /* akhir main */


Elemen        Nilai
     0            2
     1            4
     2            6
     3            8
     4           10
     5           12
     6           14
     7           16
     8           18
     9           20


Gambar 5.5 | Penginisialisasian elemen-elemen array s dengan integer genap dari 2 sampai 20

Direktif preprosesor #define diintroduksi pada program ini. Baris 4

#define UKURAN 10

mendefinisikan suatu konstanta simbolik UKURAN yang memiliki nilai 10. Konstanta simbolik adalah suatu pengenal yang digantikan dengan teks pengganti oleh preprosesor C sebelum program dikompilasi. Ketika program dipra-olah, semua kemunculan konstanta simbolik UKURAN diganti dengan teks pengganti 10. Penggunaan konstanta simbolik dalam menetapkan ukuran array membuat program lebih gampang diskalakan. Pada Gambar 5.5, Anda dapat membuat loop for pertama (baris 13) untuk mengisi suatu array 1000-elemen hanya dengan mengubah nilai UKURAN di dalam direktif #define dari 10 menjadi 1000. Jika konstanta simbolik UKURAN tidak digunakan, maka Anda perlu mengubah program di tiga lokasi yang berbeda untuk menskalakan program agar dapat menangani suatu array 1000-elemen. Jika program lebih besar, teknik penggunaan konstanta simbolik ini tentu sangat berguna.

Menjumlahkan Elemen Array
Gambar 5.6 menjumlahkan nilai-nilai yang dimuat suatu array integer a 12-elemen. Tubuh statemen for (baris 16) melakukan penjumlahan ini.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/* Gambar 5.6: gambar05_06.c
   Menghitung jumlah elemen-elemen suatu array */
#include <stdio.h>
#define UKURAN 12

/* fungsi main memulai eksekusi program */
int main( void )
{
  /* menggunakan daftar penginisialisasi untuk menginisialisasi array */
  int a[ UKURAN ] = { 1, 3, 5, 4, 7, 2, 99, 16, 45, 67, 89, 45 };
  int i; /* kounter */
  int total = 0; /* jumlah array */

  /* jumlah isi suatu array a */
  for ( i = 0; i < UKURAN; i++ ) {
    total += a[ i ];
  } /* akhir for */

  printf( "Total nilai elemen array adalah %d\n", total );
  return 0; /* indikasi terminasi sukses */
} /* akhir main */




Total nilai elemen array adalah 383


Gambar 5.6 | Menghitung jumlah elemen-elemen suatu array

Menggunakan Array untuk Menyimpulkan Hasil Survey
Pada contoh berikutnya akan digunakan array dalam menyimpulkan hasil atas data yang dikoleksi dalam suatu survey. Perhatikan statemen permasalahan berikut:

Empat puluh mahasiswa diminta untuk memberikan penilaian atas kualitas makanan di kantin kampus dengan skala 1 sampai 10 (1 berarti sangat buruk dan 10 berarti sangat baik). Tempatkan 40 respon yang didapatkan di dalam suatu array integer dan simpulkan hasil survey tersebut.

Ini merupakan aplikasi array yang umum dijumpai (lihat Gambar 5.7). Anda diminta untuk menyimpulkan jumlah respon untuk tiap jenis (1 sampai 10). Array respon (baris 17) merupakan suatu array 40-elemen yang memuat respon mahasiswa. Anda menggunakan suatu array 11-elemen frekuensi (baris 14) untuk menghitung jumlah kemunculan setiap respon. Anda mengabaikan frekuensi[0] karena yang dipakai adalah mulai dari respon pada frekuensi[1].

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
/* Gambar 5.7: gambar05_07.c
   Program survey mahasiswa */
#include <stdio.h>
#define UKURAN_RESPON 40 /* mendefinisikan ukuran array */
#define UKURAN_FREKUENSI 11

/* fungsi main memulai program */
int main( void )
{
  int jawaban; /* kounter loop dengan 40 respon */
  int rating; /* kounter untuk loop dengan frekuensi 1-10 */

  /* menginisialisasi kounter frekuensi dengan 0 */
  int frekuensi[ UKURAN_FREKUENSI ] = { 0 };

  /* menempatkan respon di dalam array */
  int respon[ UKURAN_RESPON ] = { 1, 2, 6, 4, 8, 5, 9, 7, 8, 10,
     1, 6, 3, 8, 6, 10, 3, 8, 2, 7, 6, 5, 7, 6, 8, 6, 7, 5, 6, 6,
     5, 6, 7, 5, 6, 4, 8, 6, 8, 10 };

  /* untuk setiap jawaban, pilih nilai suatu elemen array respon
     dan gunakan nilai itu sebagai subskript di dalam array frekuensi
     untuk menentukan elemen yang akan diinkremens */
  for ( jawaban = 0; jawaban < UKURAN_RESPON; jawaban++ ) {
    ++frekuensi[ respon [ jawaban ] ];
  } /* end for */

  /* menampilkan hasil */
  printf( "%s%17s\n", "Rating", "Frekuensi" );

 /* menampilkan frekuensi dalam format tabular */
 for ( rating = 1; rating < UKURAN_FREKUENSI; rating++ ) {
   printf( "%6d%17d\n", rating, frekuensi[ rating ] );
 } /* akhir for */

 return 0; /* indikasi terminasi sukses */
 } /* akhir main */



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


Gambar 5.7 | Program untuk menganalisa survey mahasiswa

Loop for (baris 24) mengambil respon satu demi satu dari array respon dan menginkremen sebesar satu terhadap 10 kounter sehingga menjadi frekuensi[1] sampai frekuensi[10] di dalam array frekuensi. Statemen kunci di dalam loop adalah baris 25

++frekuensi[ respon [ jawaban ] ];

yang menginkremen kounter frekuensi tergantung nilai dari respon[jawaban]. Ketika variabel kounter jawaban bernilai 0, maka respon[jawaban] adalah 1, jadi ++frekuensi[respon[jawaban]] diinterpretasikan sebagai

++frequency[ 1 ];

yang menginkremen elemen array yang kedua. Ketika jawaban adalah 1, respon[jawaban] adalah 2, jadi ++frekuensi[respon[jawaban]] diinterpretasikan sebagai

++frequency[ 2 ];

yang menginkremen elemen array yang ketiga. Ketika jawaban adalah 2, respon[jawaban] adalah 6, jadi ++frekuensi[respon[jawaban]] diinterpretasikan sebagai

++frequency[ 6 ];

dan seterusnya.


Histogram Atas Nilai Elemen Array
Pada contoh berikutnya (Gambar 5.8), akan dibaca beberapa angka dari suatu array dan menampilkan grafik informasi dalam format grafik batang atau histogram, dimana setiap angka ditampilkan, dan kemudian sebuah batang yang memuat asterik ditampilkan. Statemen for bersarang (baris 20) dipakai untuk menggambarkan grafik batang. Perhatikan kegunaan printf(“\n”) untuk mengakhiri suatu grafik batang (baris 24).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/* Gambar 5.8: gambar05_08.c
   Program untuk menampilkan histogram */
#include <stdio.h>
#define UKURAN 10

/* function main begins program execution */
int main( void )
{
  /* menggunakan daftar penginsialisasi untuk menginisialisasi array n */
  int n[ UKURAN ] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
  int i; /* kounter untuk elemen-elemen array */
  int j; /* kounter untuk menghitung * di dalam grafik batang */

  printf( "%s%13s%17s\n", "Elemen", "Nilai", "Histogram" );

  /* untuk setiap elemen array n, ditampilkan batang histogram */
  for ( i = 0; i < UKURAN; i++ ) {
    printf( "%6d%13d        ", i, n[ i ]) ;

    for ( j = 1; j <= n[ i ]; j++ ) { /* print one bar */
      printf( "%c", '*' );
       } /* akhir for sebelah dalam*/

    printf( "\n" ); /* akhir suatu batang histogram */
  } /* end outer for */

  return 0; /* indikasi terminasi sukses */
} /* akhir main */



Elemen        Nilai        Histogram
     0           19        *******************
     1            3        ***
     2           15        ***************
     3            7        *******
     4           11        ***********
     5            9        *********
     6           13        *************
     7            5        *****
     8           17        *****************
     9            1        *


Gambar 5.8 | Program untuk menampilkan histogram
Melempar Dadu 6000 Kali dan Menyimpan Hasilnya Dalam Array
Pada Bab 4, telah disebutkan bahwa akan ditunjukkan metode yang lebih elegan dalam menulis program pelemparan-dadu pada Gambar 4.8. Permasalahannya adalah melempar dadu enam-sisi sebanyak 6000 kali untuk menguji apakah pembangkit bilangan acak sesungguhnya menghasilkan angka acak  atau tidak. Versi array dari program tersebut ditampilkan pada Gambar 5.9.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/* Gambar 5.9: gambar05_09.c
   Melempar dadu enam-sisi 6000 kali */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define UKURAN 7

/* fungsi main memulai eksekusi program */
int main( void )
{
  int muka; /* nilai dadu acak 1 sampai 6 */
  int lempar; /* kounter lempar 1-6000 */
  int frekuensi[ UKURAN ] = { 0 }; /* menghampus frekuensi */

  srand( time( NULL ) ); /* benih pembangkit acak */

  /* melempar dadu 6000 kali */
  for ( lempar = 1; lempar <= 6000; lempar++ ) {
    muka = 1 + rand() % 6;
    ++frekuensi[ muka ]; /* mengganti 26-baris switch pada Gambar 4.8 */
  } /* akhir for */

  printf( "%s%17s\n", "Muka", "Frekuensi" );

  /* elemen-elemen frekuensi 1-6 dalam format tabular */
  for ( muka = 1; muka < UKURAN; muka++ ) {
    printf( "%4d%17d\n", muka, frekuensi[ muka ] );
  } /* akhir for */

  return 0; /* indikasi terminasi sukses */
} /* akhir main */



Muka        Frekuensi
   1              998
   2              987
   3             1022
   4             1043
   5              968
   6              982


Gambar 5.9 | Program pelemparan-dadu menggunakan array menggantikan switch

Menggunakan Array Karakter Untuk Menyimpan dan Memanipulasi String
Yang didiskusikan sejauh ini hanya array integer. Tetapi, array juga mampu menampung data sembarang tipe. Sekarang akan didiskusikan bagaimana menyimpan string di dalam array karakter. Sejauh ini, satu-satunya kapabilitas pemrosesan-string yang dijelaskan adalah menampilkan suatu string dengan printf. Sebuah string seperti “mataram” merupakan suatu array statik yang memuat karakter di dalam C.

Array karakter memiliki beberapa fitur unik. Suatu array karakter dapat diinisialisasi menggunakan sebuah literal string. Misalnya,

char string1[] = "pertama";

menginisialisasi elemen-elemen array string1 dengan karakter-karakter individual di dalam literal string “pertama”. Pada kasus ini, ukuran array string1 ditentukan oleh kompiler berdasarkan pada panjang string. String “pertama” memuat lima karakter ditambah dengan karakter terminasi-string yang disebut dengan karakter null. Jadi, array string1 sebenarnya memuat enam elemen. Konstanta karakter yang merepresentasikan karakter null adalah ‘\0’. Semua string dalam C diakhiri dengan karakter ini. Array karakter yang merepresentasikan sebuah string harus didefinisikan cukup besar untuk menampung jumlah karakter di dalam string ditambah dengan karakter null.

Array karakter juga dapat diinisialisasi dengan konstanta karakter di dalam sebuah daftar penginisialisasi. Definisi sebelumnya ekivalen dengan

char string1[] = { 'p', 'e', 'r', 't', 'a', ‘m’, ‘a’, '\0' };

Karena suatu string sebenarnya adalah sebuah array karakter, Anda dapat mengakses karakter-karakter tersebut secara individual di dalam string secara langsung menggunakan notasi subskript array. Sebagai contoh, string1[0] adalah karakter ‘p’ dan string1[3] adalah karakter ‘t’.

Anda juga dapat mengentrikan sebuah string secara langsung ke suatu array karakter dari papan-ketik menggunakan scanf dan penspesifikasi konversi %s. Sebagai contoh,

char string2[ 20 ];

menciptakan sebuah karakter array yang mampu menyimpan suatu string dengan maksimum 19 karakter dan sebuah karakter null. Statemen

scanf( "%s", string2 );

membaca sebuah string dari papan-ketik ke dalam string2. Nama array yang dilewatkan kepada scanf tanpa menggunakan operator &, yang digunakan untuk variabel tak-string. Operator & biasanya digunakan untuk menyediakan lokasi variabel di dalam memori kepada scanf sehingga suatu nilai dapat disimpan di lokasi tersebut. Pada bagian 5.5, ketika mendiskusikan pelewatan array kepada fungsi, Anda akan melihat bahwa nilai dari nama array adalah alamat awal suatu array; oleh karena itu, & tidak diperlukan. Fungsi scanf akan membaca karakter sampai ditemukan spasi, tab, garis-barum atau indikator end-of-file. String harus tidak boleh lebih panjang dari 19 karakter agar masih ada rung untuk karakter null. Jika pengguna mengetikkan 20 atau lebih karakter, maka program Anda akan bermasalah! Karena alasan ini, Anda sebainya menggunakan penspesifikasi konversi %19s sehingga scanf tidak menulis karakter ke dalam memori di luar batas akhir array s.

Array karakter yang merepresentasikan sebuah string dapat ditampilkan dengan printf dan penspesifikasi string %s. Array string2 dapat ditampilkan dengan statemen

printf( "%s\n", string2 );

Fungsi printf, seperti scanf, tidak memeriksa berapa besar karakter array. Karakter-karakter di dalam array ditampilkan sampai ditemukannya karakter null penghenti.

Gambar 5.10 mendemonstrasikan penginisialisasian sebuah array karakter dengan suatu literal string, pembacaan string ke dalam suatu array karakter, dan penampilan array karakter, dan pengaksesan karakter-karakter secara individual.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/* Gambar 5.10: gambar05_10.c
   Memperlakukan array karakter sebagai string */
#include <stdio.h>

/* fungsi main memulai eksekusi program */
int main( void )
{
  char string1[ 20 ]; /* mencadangkan memori untuk 20 karakter */
  char string2[] = "string literal"; /* mencadangkan memori untuk 15 karakter */
  int i; /* kounter */

  /* membaca string dari pengguna ke dalam array string1 */
  printf("Masukkan sebuah string: ");
  scanf( "%s", string1 ); /* masukan berakhir dengan karakter spasi */

  /* menampilkan string */
  printf( "string1 adalah: %s\nstring2 is: %s\n"
          "string1 dengan spasi di antara karakter adalah:\n",
           string1, string2 );

  /* menampilkan karakter sampai ditemukan karakter null */
  for ( i = 0; string1[ i ] != '\0'; i++ ) {
    printf( "%c ", string1[ i ] );
  } /* akhir for */

  printf( "\n" );
  return 0; /* indikasi terminasi sukses */
} /* akhir main */



Masukkan sebuah string: Teknik Elektro
string1 adalah: Teknik
string2 is: string literal
string1 dengan spasi di antara karakter adalah:
T e k n i k


Gambar 5.10 | Program untuk memperlakukan array karakter sebagai string

Gambar 5.10 menggunakan statemen for (baris 20) untuk menjelajahi array string1 menggunakan loop dan menampilkan karakter-karakter individual yang dipisahkan dengan spasi, menggunakan penspesifikasi konversi %c. Kondisi di dalam statemen for, string1[i] != ‘\0’, bernilai true jika belum ditemukan karakter null penghenti di dalam string.

Array Lokal Statik dan Array Lokal Otomatis
Bab 5 telah mendiskusikan penspesifikasi static. Variabel lokal static eksis selama program dijalankan, dan hanya dikenal di dalam tubuh fungsi. Anda dapat menerapkan static terhadap suatu definisi array lokal sehingga array tersebut tidak diciptakan dan diinisialisasi setiap kali fungsi dipanggil dan array tersebut tidak dihancurkan setiap kali fungsi selesai dieksekusi di dalam program. Hal ini mereduksi waktu eksekusi program, khususnya untuk program dengan fungsi-fungsi terpanggil yang memuat array besar.

Array static hanya diinisialisasi sekali pada saat kompilasi. Anda tidak perlu secara eksplisit menginisialisasi suatu array static, karena elemen-elemenya diinisialisasi nol oleh kompiler.

Gambar 5.11 mendemonstrasikan fungsi staticArrayInit (baris 22) dengan suatu array lokal static (baris 25) dan fungsi otomatisArrayInit (baris 44) dengan sebuah array otomatis lokal (baris 47). Fungsi staticArrayInit dipanggil dua kali (baris 12 dan 16). Array lokal static di dalam fungsi tersebut diinisialisasi dengan nol oleh kompiler (baris 25). Fungsi tersebut menampilkan array, menambahkan 5 pada tiap elemen dan menampilkan array tersebut kembali. Saat kedua kalinya fungsi tersebut dipanggil, array static memuat nilai-nilai yang disimpan selama pemanggilan fungsi yang pertama. Fungsi otomatisArrayInit juga dipanggil dua kali (baris 13 dan 17). Elemen-elemen dari array lokal otomatis di dalam fungsi tersebut diinisialisasi dengan nilai-nilai 1, 2, dan 3 (baris 47). Fungsi ini menampilkan array, menambahkan 5 pada tiap elemen, dan menampilkan array kembali. Ketika kedua kalinya fungsi tersebut dipanggil, elemen-elemen array diinisialisasi-ulang dengan 1, 2, dan 3 kembali karena array mempunyai durasi penyimpanan otomatis.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
/* Gambar 5.11: gambar05_11.c
   Array static diinisialisasi dengan nol */
#include <stdio.h>

void staticArrayInit( void ); /* prototipe fungsi */
void otomatisArrayInit( void ); /* protipe fungsi */

/* fungsi main memulai eksekusi program */
int main( void )
{
  printf( "Pemanggilan pertama terhadap tiap fungsi:\n" );
  staticArrayInit();
  otomatisArrayInit();

  printf( "\n\nPemanggilan kedua terhadap tiap fungsi:\n" );
  staticArrayInit();
  otomatisArrayInit();
  return 0; /* indikasi terminasi sukses */
} /* akhir main */

/* fungsi untuk mendemonstrasikan array lokal statik */
void staticArrayInit( void )
{
  /* menginisialisasi elemen dengan 0 ketika pertama kali fungsi dipanggil */
  static int array1[ 3 ];
  int i; /* kounter */

  printf( "\nNilai-nilai pada saat memasuki staticArrayInit:\n" );

  /* menampilkan isi array1 */
  for ( i = 0; i <= 2; i++ ) {
    printf( "array1[ %d ] = %d ", i, array1[ i ] );
  } /* akhir for */

  printf( "\nNilai-nilai saat keluar dari staticArrayInit:\n" );

  /* memodifikasi dan menampilkan isi array1 */
  for ( i = 0; i <= 2; i++ ) {
    printf( "array1[ %d ] = %d ", i, array1[ i ] += 5 );
  } /* akhir for */
} /* akhir fungsi staticArrayInit */

/* fungsi untuk mendemonstrasikan array lokal otomatis */
void otomatisArrayInit( void )
{
  /* menginisialisasi elemen saat pertama kali fungsi dipanggil */
  int array2[ 3 ] = { 1, 2, 3 };
  int i; /* kounter */

  printf( "\n\nNilai-nilai pada saat memasuki otomatisArrayInit:\n" );

  /* menampilkan isi array2 */
  for ( i = 0; i <= 2; i++ ) {
    printf("array2[ %d ] = %d ", i, array2[ i ] );
  } /* akhir for */

  printf( "\nNilai-nilai saat keluar dari otomatisArrayInit:\n" );

  /* memodifikasi dan menampilkan isi array2 */
  for ( i = 0; i <= 2; i++ ) {
    printf( "array2[ %d ] = %d ", i, array2[ i ] += 5 );
  } /* akhir for */
} /* akhir fungsi otomatisArrayInit */

Pemanggilan pertama terhadap tiap fungsi:

Nilai-nilai pada saat memasuki staticArrayInit:
array1[ 0 ] = 0 array1[ 1 ] = 0 array1[ 2 ] = 0
Nilai-nilai saat keluar dari staticArrayInit:
array1[ 0 ] = 5 array1[ 1 ] = 5 array1[ 2 ] = 5

Nilai-nilai pada saat memasuki otomatisArrayInit:
array2[ 0 ] = 1 array2[ 1 ] = 2 array2[ 2 ] = 3
Nilai-nilai saat keluar dari otomatisArrayInit:
array2[ 0 ] = 6 array2[ 1 ] = 7 array2[ 2 ] = 8

Pemanggilan kedua terhadap tiap fungsi:

Nilai-nilai pada saat memasuki staticArrayInit:
array1[ 0 ] = 5 array1[ 1 ] = 5 array1[ 2 ] = 5
Nilai-nilai saat keluar dari staticArrayInit:
array1[ 0 ] = 10 array1[ 1 ] = 10 array1[ 2 ] = 10

Nilai-nilai pada saat memasuki otomatisArrayInit:
array2[ 0 ] = 1 array2[ 1 ] = 2 array2[ 2 ] = 3
Nilai-nilai saat keluar dari otomatisArrayInit:
array2[ 0 ] = 6 array2[ 1 ] = 7 array2[ 2 ] = 8


Gambar 5.11 | Array statik diinisialisasi dengan nol jika tidak secara eksplisit diinisialisasi

5.5 Melewatkan Array Kepada Fungsi
Untuk melewatkan suatu argumen array kepada fungsi, diperlukan untuk menspesifikasi nama array tanpa adanya kurung kurawal. Sebagai contoh, jika array temperaturPerjam didefinisikan sebagai

int temperaturPerjam [ 24 ];

maka pemanggilan fungsi

modifikasiArray(temperaturPerjam, 24 )

melewatkan array temperaturPerjam dan ukurannya kepada fungsi modifikasiArray. Tidak seperti array char yang memuat string, array bertipe lain tidak memiliki karakter null sebagai terminator. Karena alasan ini, ukuran suatu array dilewatkan kepada fungsi, sehingga fungsi tersebut dapat memproses jumlah elemen secara benar. C secara otomatis melewatkan array kepada fungsi melalui referensi, yaitu fungsi terpanggil dapat memodifikasi nilai elemen array asli di dalam fungsi pemanggil. Nama array menjadi alamat dari elemen pertama dari array. Karena alamat awal array dilewatkan, fungsi terpanggil dapat mengetahui secara pasti dimana array disimpan. Oleh karena itu, ketika fungsi terpanggil memodifikasi elemen array di dalam tubuh fungsinya, yang terjadi adalah bahwa ia memodifikasi elemen aktual di dalam lokasi memori yang asli.

Gambar 5.12 mendemonstrasikan bahwa nama array sebenarnya merupakan alamat dari elemen pertama suatu array dengan menampilkan array, &array[0], dan &array menggunakan penspesifikasi konversi %p (penspesifikasi konversi spesial untuk menampilkan alamat). Penspesifikasi konversi %p menampilkan alamat sebagai bilangan heksadesimal. Bilangan heksadesimal (basis 16) memuat dijit dari 0 sampai 9 dan huruf A sampai F. Keluaran program menunjukkan bahwa kedua array dan &array[0] mempunyai nilai yang sama. Keluara program berbeda tergantung sistem yang dipakai.

Meskipun keseluruhan array dilewatkan melalui referensi, elemen-elemen array secara individual dilewatkan dengan nilai seperti variabel biasa. Untuk melewatkan suatu elemen array ke fungsi, digunakan nama elemen array tersubskript (skalar) sebagai argumen di dalam pemanggilan fungsi. Pada Bab 7, akan ditunjukkan bagaimana melewatkan skalar (variabel individual dan elemen array) kepada fungsi melalui referensi.

1
2
3
4
5
6
7
8
9
10
11
12
13
/* Gambar 5.12: gambar05_12.c
   Nama suatu array sama dengan &array[ 0 ] */
#include <stdio.h>

/* fungsi main memulai eksekusi program */
int main( void )
{
  char array[ 5 ]; /* mendefinisikan array berukuran 5 */

  printf( "    array = %p\n&array[0] = %p\n   &array = %p\n",
            array, &array[ 0 ], &array );
  return 0; /* indikasi terminasi sukses */
} /* akhir main */


    array = 0018FF40
&array[0] = 0018FF40
   &array = 0018FF40


Gambar 5.12 | Nama array sama dengan alamat dari elemen pertama array

Untuk suatu fungsi agar bisa menerima sebuah array melalui pemanggilan fungsi, daftar parameter fungsi tersebut harus menspesifikasikan bahwa suatu array akan diterima. Misalnya, header fungsi untuk fungsi modifikasiArray dapat dituliskan sebagai

void modifikasiArray( int b[], int ukuran )

mengindikasikan bahwa modifikasiArray berharap menerima suatu array integer di dalam parameter b dan jumlah elemen array di dalam parameter ukuran. Ukuran array tidak diapit oleh sepasang kurung siku. Jika dilakukan, kompiler akan memeriksa apakah ia lebih besar dari nol, kemudian mengabaikannya. Penetapan jumlah elemen array menjadi negatif akan menyebabkan error kompilasi. Karena array secara otomatis dilewatkan dengan referensi, ketika fungsi terpanggil menggunakan nama array b, ia akan merujuk kepada array yang ada di dalam pemanggil (array temperaturPerjam di dalam pemanggilan sebelumnya). Pada Bab 6, akan dikenalkan beberapa notasi lain dalam mengindikasikan bahwa suatu array sedang diterima oleh suatu fungsi. Seperti yang akan Anda lihat, notasi tersebut didasarkan pada relasi yang intim antara array dan pointer di dalam C.

Gambar 5.13 mendemonstrasikan perbedaan antara pelewatan keseluruhan array dan pelewatan suatu elemen array. Program pertama-tama menampilkan lima elemen dari array integer a (baris 20-220). Selanjutnya, a dan ukurannya dilewatkan kepada fungsi modifikasiArray (baris 27), dimana setiap elemen array a akan dikalikan dengan 2 (baris 54-55). Kemudian a ditampilkan ulang di dalam main (baris 32-34). Seperti yang ditunjukkan keluaran program, elemen-elemen array a termodifikasi oleh modifikasiArray. Sekarang program menampilkan nilai dari a[3] (baris 38) dan melewatkannya kepada fungsi modifikasiElemen (baris 40). Fungsi modifikasiElemen mengalikan argumennya dengan 2 (baris 64) dan menampilkan nilai baru tersebut. Ketika a[3] ditampilkan ulang di dalam main (baris 43), ternyata elemen tersebut tidak termodifikasi, karena elemen-elemen array individual dilewatkan dengan nilai.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
/* Gambar 5.13: gambar05_13.c
   Pelewatan array dan elemen array individual kepada fungsi */
#include <stdio.h>
#define UKURAN 5

/* prototipe fungsi */
void modifikasiArray( int b[], int ukuran );
void modifikasiElemen( int e );

/* fungsi main memulai eksekusi program */
int main( void )
{
  int a[ UKURAN ] = { 0, 1, 2, 3, 4 }; /* menginisialisasi a */
  int i; /* kounter */

  printf( "Efek pelewatan keseluruhan array dengan referensi: \n\n"
          "Nilai-nilai array asli adalah:\n" );

  /* menampilkan array asli */
  for ( i = 0; i < UKURAN; i++ ) {
    printf( "%3d", a[ i ] );
  } /* akhir for */

  printf( "\n" );

  /* melewatkan array a kepada fungsi modifikasiArray dengan referensi */
  modifikasiArray( a, UKURAN );

  printf( "Nilai-nilai array termodifikasi adalah:\n" );

  /* menampilkan array termodifikasi */
  for ( i = 0; i < UKURAN; i++ ) {
    printf( "%3d", a[ i ] );
  } /* akhir for */

  /* menampilkan nilai a[ 3 ] */
  printf( "\n\n\nEfek pelewatan elemen array "
          "dengan nilai:\n\nNilai a[3] adalah %d\n", a[ 3 ] );

  modifikasiElemen( a[ 3 ] ); /* melewatkan elemen array a[ 3 ] dengan nilai*/

  /* menampilkan nilai a[ 3 ] */
  printf( "Nilai a[ 3 ] adalah %d\n", a[ 3 ] );
  return 0; /* indikasi terminasi sukses */
} /* akhir main */

/* Di dalam fungsi modifikasiArray, "b" menunjuk ke array asli "a"
   di dalam memori */
void modifikasiArray( int b[], int ukuran )
{
  int j; /* kounter */
  /* mengalikan setiap elemen array dengan 2 */
  for ( j = 0; j < ukuran; j++ ) {
    b[ j ] *= 2;
  } /* akhir for */
} /* akhir fungsi modifikasiArray */

/* Di dalam fungsi modifikasiElemen, "e" adalah salinan lokal dari elemen array
   a[ 3 ] dilewatkan dari main */
void modifikasiElemen( int e )
{
  /* mengalikan parameter dengan 2 */
  printf( "Nilai di dalam modifikasiElemen adalah %d\n", e *= 2 );
} /* akhir fungsi modifikasiElemen */


Efek pelewatan keseluruhan array dengan referensi:

Nilai-nilai array asli adalah:
  0  1  2  3  4
Nilai-nilai array termodifikasi adalah:
  0  2  4  6  8

Efek pelewatan elemen array dengan nilai:

Nilai a[3] adalah 6
Nilai di dalam modifikasiElemen adalah 12
Nilai a[ 3 ] adalah 6

Gambar 5.13 | Pelewatan array dan elemen array individual kepada fungsi
Kadangkala ada situasi di dalam program Anda dimana sebuah fungsi tidak diijinkan untuk memodifikasi elemen array. Karena array selalu dilewatkan dengan referensi, modifikasi atas nilai-nilai di dalam suatu array sangat susah untuk dikendalikan. C menyediakan kualifier const untuk mencegah modifikasi atas nilai array di dalam suatu fungsi. Ketika sebuah parameter array diawali dengan kualifier const, elemen array menjadi konstanta di dalam tubuh fungsi, dan segala usaha untuk memodifikasi elemen array di dalam tubuh fungsi akan menyebabkan error kompilasi.

Gambar 5.14 mendemonstrasikan kualifier const. Fungsi cobaModifikasiArray (baris 20) didefinisikan dengan parameter const int b[], yang menspesifikasi bahwa array b merupakan konstanta dan tidak dapat dimodifikasi. Keluaran program menunjukkan pesan error yang dihasilkan kompiler. Ketiga pencobaan oleh fungsi untuk memodifikasi elemen array menghasilkan error kompilasi. Kualifier const akan didiskusikan kembali pada Bab 6.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/* Gambar 5.14: gambar05_14.c
   Mendemonstrasikan kualifier const dengan array */
#include <stdio.h>

void cobaModifikasiArray( const int b[] ); /* prototipe fungsi */

/* fungsi main untuk memulai eksekusi program */
int main( void )
{
  int a[] = { 10, 20, 30 }; /* menginisialisasi a */

  cobaModifikasiArray( a );

  printf("%d %d %d\n", a[ 0 ], a[ 1 ], a[ 2 ] );
  return 0; /* indikasi terminasi sukses */
} /* akhir main */

/* Di dalam fungsi cobaModifikasiArray, array b adalah const, jadi
   dapat digunakan untuk memodifikasi array asli a di dalam main. */
void cobaModifikasiArray( const int b[] )
{
  b[ 0 ] /= 2; /* error */
  b[ 1 ] /= 2; /* error */
  b[ 2 ] /= 2; /* error */
} /* akhir fungsi cobaModifikasiArray */


Compiling...

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


Gambar 5.14 | Kualifier tipe const


5.6 Pengurutan Array
Pengurutan data (penempatan data dengan urutan tertentu seperti urutan menaik atau menurun) merupakan salah satu aplikasi komputasi yang penting. Sebuah bank perlu mengurutkan semua nomor akun sehingga memudahkan banyak pekerjaan perbankan. Perusahaan telepon mengurutkan daftar pelanggan melalui nama terakhir dan nama pertama sehingga memudahkan untuk mencari nomor telepon. Hampir semua organisasi perlu mengurutkan datanya dan pada banyak kasus data yang perlu diurutkan berukuran sangat besar. Pengurutan data merupakan masalah yang sangat rumit dan merupakan bidang penelitian intensif dalam ilmu komputer. Pada bab ini, akan didiskusikan tentang skema pengurutan paling sederhana. Pada Bab 11, akan diinvestigasi skema pengurutan yang lebih kompleks dengan kinerja yang lebih baik.

Gambar 5.15 mengurutkan nilai elemen-elemen dari array a 10-elemen (baris 10) agar tertata dalam urutan menaik. Teknik yang digunakan adalah pengurutan bubble atau pengurutan sinking karena nilai yang lebih kecil secara bertahap mengambang ke atas array seperti gelembung air di permukaan air, sedangkan nilai yang lebih besar tenggelam ke dasar array. Tekniknya adalah dengan melakukan beberapa pass terhadap array. Pada setiap pass, pasangan-pasangan elemen yang berurutan dibandingkan. Jika sepasang elemen tertata dalam urutan menaik (atau jika kedua nilainya identik), maka akan dibiarkan apa adanya. Jika sepasang elemen tertata dalam urutan menurun, maka keduanya saling dipergantikan.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/* Gambar 5.15: gambar05_15.c
   Program ini mengurutkan nilai-nilai array menjadi urutan menaik */
#include <stdio.h>
#define UKURAN 10

/* fungsi main memulai eksekusi program */
int main( void )
{
  /* menginisialisasi a */
  int a[ UKURAN ] = { 2, 6, 4, 8, 10, 12, 89, 68, 45, 37 };
  int pass;
  int i; /* kounter perbandingan */
  int hold; /* lokasi sementara digunakan untuk menukar elemen */

  printf( "Item data dalam tatanan asli\n" );

  /* menampilkan array asli */
  for ( i = 0; i < UKURAN; i++ ) {
    printf( "%4d", a[ i ] );
  } /* akhir for */

  /* pengurutan bubble */
  /* loop untuk mengendalikan jumlah pass */
  for ( pass = 1; pass < UKURAN; pass++ ) {
   
    /* loop untuk mengendalikan jumlah perbandingan tiap pass */
    for ( i = 0; i < UKURAN - 1; i++ ) {
     
      /* membandingkan dua elemen bertetangga dan menukarnya jika
         elemen pertama lebih besar dari elemen kedua */
      if ( a[ i ] > a[ i + 1 ] ) {
        hold = a[ i ];
        a[ i ] = a[ i + 1 ];
        a[ i + 1 ] = hold;
         } /* akhir if */
       } /* akhir for dalam */
  } /* akhir for luar */

  printf( "\nItem data dalam urutan menaik\n" );

  /* menampilkan array terurut */
  for ( i = 0; i < UKURAN; i++ ) {
    printf( "%4d", a[ i ] );
  } /* akhir for */

  printf( "\n" );
  return 0; /* indikasi terminasi sukses */
 } /* akhir main */


Item data dalam tatanan asli
   2   6   4   8  10  12  89  68  45  37
Item data dalam urutan menaik
   2   4   6   8  10  12  37  45  68  89

Gambar 5.15 | Pengurutan bubble atas array

5.7 Studi Kasus: Menghitung Rerata, Median, dan Mode Menggunakan Array
Sekarang akan disajikan contoh yang lebih besar. Komputer umumnya digunakan untuk menganalisa data survey untuk mendapatkan hasil opini. Gambar 5.16 menggunakan array respon yang diinisialisasi dengan 99. Setiap respon diberi angka 1 sampai 9. Program akan menghitung rerata, median, dan mode dari 99 nilai yang didapatkan.

Rerata adalah rata-rata aritmatik atas 99 nilai. Fungsi rerata (baris 40) menghitung rerata dengan mencari total atas 99 nilai dan membagi hasilnya dengan 99.

Median adalah nilai tengah. Fungsi median (baris 61) menentukan median dengan memanggil fungsi pengurutanBubble (yang didefinisikan pada baris 133) untuk mengurutkan array respon menjadi tatanan menaik, kemudian memilih elemen tengah, jawaban[UKURAN/2], dari array terurut. Ketika terdapat jumlah elemen genap, median harus dihitung sebagai rerata atas dua nilai tengah. Fungsi median saat ini tidak menyediakan kapabilitas ini. Fungsi tampilArray (baris 156) dipanggil untuk menampilkan array respon.

Mode adalah nilai yang kemunculannya paling sering di antara 99 respon. Fungsi mode (baris 82) menentukan mode dengan menghitung jumlah respon tiap tipe, kemudian memilih nilai dengan hitungan tertinggi. Fungsi mode juga menghasilkan histogram untuk membantu menentukan mode secara grafikal. Gambar 5.17 memuat contoh keluaran program. Contoh ini mencakup banyak manipulasi array yang telah dipelajari, termasuk pelewatan array kepada fungsi.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
1661
167
168
169
/* Gambar 5.16: gambar05_16.c
   Program ini mengenalkan topik analisa survey.
   Program ini menghitung rerata, median, dan mode data */
#include <stdio.h>
#define UKURAN 99

/* protipe fungsi */
void rerata( const int jawaban[] );
void median( int jawaban[] );
void mode( int frek[], const int jawaban[] ) ;
void pengurutanBubble( int a[] );
void tampilArray( const int a[] );

/* fungsi main memulai eksekusi program */
int main( void )
{
  int frekuensi[ 10 ] = { 0 }; /* menginisialisasi array frekuensi */

  /* menginisialisasi array respon */
  int respon[ UKURAN ] =
  { 6, 7, 8, 9, 8, 7, 8, 9, 8, 9,
    7, 8, 9, 5, 9, 8, 7, 8, 7, 8,
    6, 7, 8, 9, 3, 9, 8, 7, 8, 7,
    7, 8, 9, 8, 9, 8, 9, 7, 8, 9,
    6, 7, 8, 7, 8, 7, 9, 8, 9, 2,
    7, 8, 9, 8, 9, 8, 9, 7, 5, 3,
    5, 6, 7, 2, 5, 3, 9, 4, 6, 4,
    7, 8, 9, 6, 8, 7, 8, 9, 7, 8,
    7, 4, 4, 2, 5, 3, 8, 7, 5, 6,
    4, 5, 6, 1, 6, 5, 7, 8, 7 };

  /* memproses respon */
  rerata( respon );
  median( respon );
  mode( frekuensi, respon );
  return 0; /* indikasi terminasi sukses */
} /* akhir main */

/* menghitung rerata atas semua nilai respon */
void rerata( const int jawaban[] )
{
  int j; /* kounter untuk mentotal elemen-elemen array */
  int total = 0; /* variabel untuk menampung jumlah elemen array */

  printf( "%s\n%s\n%s\n", "********", " Rerata", "********" );

  /* total nilai respon values */
  for ( j = 0; j < UKURAN; j++ ) {
    total += jawaban[ j ];
  } /* akhir for */

  printf( "Rerata adalah rata-rata dari nilai data.\n"
          "Rerata sama dengan total dari\n"
          "semua item data dibagi dengan jumlah\n"
          "item data ( %d ). Nilai rerata untuk\n"
          "contoh ini adalah: %d / %d = %.4f\n\n",
           UKURAN, total, UKURAN, ( double ) total / UKURAN );
} /* akhir fungsi rerata */

/* mengurutkan array dan menentukan median */
void median( int jawaban[] )
{
  printf( "\n%s\n%s\n%s\n%s",
          "********", " Median", "********",
          "Array respon tak-terurut adalah" );

  tampilArray( jawaban ); /* menampilkan array tak-terurut */

  pengurutanBubble( jawaban ); /* mengurutkan array */

  printf( "\n\nArray terurut adalah" );
  tampilArray( jawaban ); /* menampilkan array terurut */

  /* menampilkan elemen median */
  printf( "\n\nMedian adalah elemen %d dari\n"
          "array %d elemen terurut.\n"
          "Untuk kasus ini median adalah %d\n\n",
           UKURAN / 2, UKURAN, jawaban[ UKURAN / 2 ]);
} /* akhir fungsi median */

/* menentukan respon paling sering muncul */
void mode( int frek[], const int jawaban[] )
{
  int rating; /* kounter untuk mengakses elemen 1-9 dari array frek */
  int j; /* kounter untuk menyimpulkan elemen 0-98 dari array jawaban */
  int h; /* kounter untuk menampilkan histogram di dalam array frek */
  int terbesar = 0; /* merepresentasikan frekuensi terbesar */
  int nilaiMode = 0; /* merepresentasikan respon paling sering muncul */

  printf( "\n%s\n%s\n%s\n",
          "********", " Mode", "********" );

  /* menginisialisasi frekuensi dengan 0 */
  for ( rating = 1; rating <= 9; rating++ ) {
    frek[ rating ] = 0;
  } /* akhir for */

  /* menyimpulkan frekuensi */
  for ( j = 0; j < UKURAN; j++ ) {
    ++frek[ jawaban[ j ] ];
  } /* akhir for */

  /* output headers for result columns */
  printf( "%s%11s%19s\n\n%54s\n%54s\n\n",
          "Respon", "Frekuensi", "Histogram",
          "1 1 2 2", "5 0 5 0 5" );

  /* menampilkan hasil */
  for ( rating = 1; rating <= 9; rating++ ) {
    printf( "%8d%11d ", rating, frek[ rating ] );

    /* menjejak nilai mode dan nilai frekuensi terbesar */
    if ( frek[ rating ] > terbesar ) {
      terbesar = frek[ rating ];
      nilaiMode = rating;
    } /* akhir if */

    /* menampilkan batang histogram bar merepresentasikan nilai frekuensi */
    for ( h = 1; h <= frek[ rating ]; h++ ) {
      printf( "*" );
    } /* akhir for dalam */

    printf( "\n" ); /* baris baru pada keluaran */
  } /* akhir for luar */

  /* menampilkan nilai mode */
  printf( "Mode adalah nilai yang paling sering muncul.\n"
          "Untuk kasus ini, mode adalah %d yang muncul"
          " %d kali.\n", nilaiMode, terbesar );
} /* akhir fungsi mode */

/* function that sorts an array with bubble sort algorithm */
void pengurutanBubble( int a[] )
{
  int pass; /* kounter pass */
  int j; /* kounter perbandingan */
  int hold; /* lokasi sementara untuk menukar elemen */

  /* loop untuk mengendalikan jumlah pass */
  for ( pass = 1; pass < UKURAN; pass++ ) {

    /* loop untuk mengendalikan jumlah perbandingan tiap pass */
    for ( j = 0; j < UKURAN - 1; j++ ) {

      /* menukar elemen jika tidak terurut */
      if ( a[ j ] > a[ j + 1 ] ) {
        hold = a[ j ];
        a[ j ] = a[ j + 1 ];
        a[ j + 1 ] = hold;
         } /* akhir if */
       } /* akhir for dalam */
  } /* akhir for luar */
} /* akhir fungsi pengurutanBubble */

/* menampilkan isi array (20 nilai per baris) */
void tampilArray( const int a[] )
{
  int j; /* kounter */

  /* menampilkan isi array */
  for ( j = 0; j < UKURAN; j++ ) {

    if ( j % 20 == 0 ) { /* memulai baris baru untuk setiap 20 nilai */
      printf( "\n" );
    } /* akhir if */

    printf( "%2d", a[ j ] );
  } /* akhir for */
} /* akhir fungsi tampilArray */

Gambar 5.16 | Program untuk menganalisa data survey

********
 Rerata
********
Rerata adalah rata-rata dari nilai data.
Rerata sama dengan total dari
semua item data dibagi dengan jumlah
item data ( 99 ). Nilai rerata untuk
contoh ini adalah: 681 / 99 = 6.8788

********
 Median
********
Array respon tak-terurut adalah
 6 7 8 9 8 7 8 9 8 9 7 8 9 5 9 8 7 8 7 8
 6 7 8 9 3 9 8 7 8 7 7 8 9 8 9 8 9 7 8 9
 6 7 8 7 8 7 9 8 9 2 7 8 9 8 9 8 9 7 5 3
 5 6 7 2 5 3 9 4 6 4 7 8 9 6 8 7 8 9 7 8
 7 4 4 2 5 3 8 7 5 6 4 5 6 1 6 5 7 8 7

Array terurut adalah
 1 2 2 2 3 3 3 3 4 4 4 4 4 5 5 5 5 5 5 5
 5 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7
 7 7 7 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8
 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

Median adalah elemen 49 dari
array 99 elemen terurut.
Untuk kasus ini median adalah 7

********
 Mode
********
Respon  Frekuensi          Histogram
                                   1 1 2 2
                                 5 0 5 0 5
     1          1 *
     2          3 ***
     3          4 ****
     4          5 *****
     5          8 ********
     6          9 *********
     7         23 ***********************
     8         27 ***************************
     9         19 *******************
Mode adalah nilai yang paling sering muncul.
Untuk kasus ini, mode adalah 8 yang muncul 27 kali.


Gambar 5.17 | Contoh keluaran program penganalisa data survey

5.8 Pencarian Array
Anda akan sering menjumpai data dalam jumlah besar yang disimpan di dalam array. Pada kasus itu, akan menjadi penting untuk menentukan apakah array memuat suatu nilai yang cocok dengan nilai kunci. Proses pencarian elemen tertentu suatu array disebut dengan pencarian. Pada bagian ini, akan didiskusikan dua teknik pencarian, teknik pencarian linier dan teknik pencarian biner.

Pencarian Suatu Array Dengan Pencarian Linier
Pencarian linier (Gambar 5.18) membandingkan setiap elemen array dengan kunci pencarian. Karena array tidak terurut, maka adalah hal yang memungkinkan untuk menemukan kunci di elemen pertama atau bahkan di elemen terakhir array. Pada umumnya, program harus membandingkan kunci pencarian dengan setengah dari jumlah elemen di dalam array.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
/* Gambar 5.18: gambar05_18.c
   Pencarian linier pada suatu array */
#include <stdio.h>
#define UKURAN 100

/* prototipe fungsi */
int pencarianLinier( const int array[], int kunci, int ukuran );

/* fungsi main memulai eksekusi program */
int main( void )
{
  int a[ UKURAN ]; /* menciptakan array a */
  int x; /* kounter untuk menginisialisasi 0-99 array a */
  int kunciPencarian; /* nilai untuk dicari di dalam array a */
  int elemen; /* variabel untuk menampung lokasi kunciPencarian atau -1 */

  /* menciptakan data */
  for ( x = 0; x < UKURAN; x++ ) {
    a[ x ] = 2 * x;
  } /* akhir for */

  printf( "Masukkan kunci pencarian integer:\n" );
  scanf( "%d", &kunciPencarian );

  /* mencoba untuk mencari kunciPencarian di dalam array a */
  elemen = pencarianLinier( a, kunciPencarian, UKURAN );

  /* menampilkan hasil */
  if ( elemen != -1 ) {
    printf( "Nilai ditemukan di dalam elemen %d\n", elemen );
  } /* akhir if */
  else {
    printf( "Nilai tidak ditemukan\n" );
  } /* akhir else */

 return 0; /* indikasi terminasi sukses */
} /* akhir main */

/* membandingkan kunci dengan setiap elemen array sampai lokasi ditemukan
   atau sampai akhir array dicapai. Menghasilkan subskript elemen
   jika kunci ditemukan atau -1 jika tidak ditemukan */
int pencarianLinier( const int array[], int kunci, int ukuran )
{
  int n; /* kounter */
 
  /* menjelajah array */
  for ( n = 0; n < ukuran; ++n ) {
   
    if ( array[ n ] == kunci ) {
      return n; /* mengembalikan lokasi kunci */
    } /* akhir if */
  } /* akhir for */
 
  return -1; /* kunci tidak ditemukan */
} /* akhir fungsi pencarianLinier */

Masukkan kunci pencarian integer:
36
Nilai ditemukan di dalam elemen 18


Masukkan kunci pencarian integer:
37
Nilai tidak ditemukan

Gambar 5.18 | Pencarian linier atas suatu array

Pencarian Suatu Array Dengan Pencarian Biner
Metode pencarian linier bekerja dengan baik untuk array kecil atau array tak-terurut. Namun, untuk array besar, pencarian linier tidak efisien. Jika array telah terurut, teknik pencarian biner dengan kecepatan tinggi dapat dipakai.

Algoritma pencarian biner mengeliminasi setengah jumlah elemen di dalam suatu array terurut pada tiap perbandingan. Algoritma mencari elemen tengah dari array dan membandingkannya dengan kunci pencarian. Jik sama, kunci pencarian ditemukan dan subskript array dari elemen tersebut dijadikan nilai balik. Jika tidak sama, masalah tereduksi hanya melakukan pencarian setengah bagian array. Jika kunci pencarian kurang dari elemen tengah array, maka setengah bagian pertama array yang dicari, sebaliknya setengah bagian kedua array yang dicari. Pencarian berlanjut sampai kunci pencarian sama dengan elemen tengah subarray, atau sampai subarray hanya memuat satu elemen yang tidak sama dengan kunci pencarian (kunci pencarian tidak ditemukan).

Pada skenario terburuk, pencarian suatu array 1023-elemen hanya memerlukan 10 perbandingan menggunakan pencarian biner.  Pembagian 1024 dengan 2 secara berulang akan menghasilkan nilai-nilai 512, 256, 128, 64, 32, 16, 8, 4, 2, dan 1. Jumlah 1024  dibagi dengan 2 sebanyak 10 kali untuk mendapatkan nilai 1. Pembagian dengan 2 ekivalen dengan satu perbandingan dalam algoritma pencarian biner. Suatu array 1048576-elemen  hanya memerlukan maksimum 20 perbandingan untuk menemukan kunci pencarian. Array dengan satu miliar elemen hanya memerlukan maksimum 30 perbandingan untuk menemukan kunci pencarian.

Gambar 5.19 menyajikan versi iteratif dari fungsi pencarianBiner (baris 44-74). Fungsi ini menerima empat argumen, yaitu suatu array integer b yang akan dicari, sebuah integer kunciPencarian, subskript array rendah, dan subskript array tinggi. Jika kunci pencarian tidak cocok dengan elemen tengah subarray, maka subskript rendah atau tinggi dimodifikasi sehingga subarray yang lebih kecil dapat dicari. Jika kunci pencarian kurang dari elemen tengah, maka subskript tinggi ditetapkan menjadi tengah – 1 dan pencarian dilanjutkan pada elemen-elemen dari rendah sampai tengah – 1. Jika kunci pencarian lebih besar dari elemen tengah, maka subskript rendah ditetapkan menjadi tengah + 1 dan pencarian dilakukan pada elemen-elemen dari tengah + 1 sampai tinggi. Program menggunakan sebuah array 15 elemen. Program menggunakan fungsi tampilKepala (baris 77-96) untuk menampilkan subskript array dan fungsi tampilBaris (baris 110-120) untuk menampilkan setiap subarray selama proses pencarian biner. Elemen tengah di dalam setiap subarray ditandai dengan sebuah asterik (*) untuk mengindikasikan tempat dilakukannya perbandingan.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/* Gambar 5.19: gambar05_19.c
   Pencarian biner atas suatu array terurut */
#include <stdio.h>
#define UKURAN 15

/* prototipe fungsi */
int pencarianBiner(const int b[], int pencarianKunci, int rendah, int tinggi);
void tampilKepala( void );
void tampilBaris( const int b[], int rendah, int tengah, int tinggi);

/* fungsi main memulai eksekusi program */
int main( void )
{
  int a[ UKURAN ]; /* menciptakan array a */
  int i; /* kounter untuk inisialisasi elemen 0-14 dari array a */
  int kunci; /* nilai untuk dicari di dalam array a */
  int hasil; /* variabel untuk menampung lokasi kunci atau -1 */

  /* menciptakan data */
  for ( i = 0; i < UKURAN; i++ ) {
    a[ i ] = 2 * i;
  } /* akhir for */

  printf( "Masukkan angka dari 0 sampai 28: " );
  scanf( "%d", &kunci );

  tampilKepala();

  /* mencari kunci di dalam a */
  hasil = pencarianBiner( a, kunci, 0, UKURAN - 1 );

  /* menampilkan hasil */
  if ( hasil != -1 ) {
    printf( "\n%d ditemukan di dalam elemen array %d\n", kunci, hasil );
  } /* akhir if */
  else {
    printf( "\n%d tidak ditemukan\n", kunci );
  } /* akhir else */

  return 0; /* indikasi terminasi sukses */
} /* akhir main */

/* fungsi untuk melakukan pencarian biner */
int pencarianBiner( const int b[], int kunciPencarian, int rendah, int tinggi)
{
  int tengah; /* variabel untuk menampung elemen tengah array */

  /* loop sampai subskript rendah lebih dari tinggi */
  while ( rendah <= tinggi ) {

    /* menentukan elemen tengah dari subarray yang sedang dicari */
    tengah = ( rendah + tinggi ) / 2;

    /* menampilkan subarray yang digunakan dalam iterasi loop ini */
    tampilBaris( b, rendah, tengah, tinggi );

    /* jika kunciPencarian cocok dengan elemen tengah, tengah jadi nilai balik*/
    if ( kunciPencarian == b[ tengah ] ) {
      return tengah;
    } /* akhir if */

    /* jika kunciPencarian kurang dari elemen tengah, tetapkan tinggi baru */
    else if ( kunciPencarian < b[ tengah ] ) {
      tinggi = tengah - 1; /* mencari subarray rendah */
    } /* akhir else if */

    /* jika kunciPencarian lebih dari elemen tengah, tetapkan rendah baru */
    else {
      rendah = tengah + 1; /* mencari subarray tinggi */
    } /* akhir else */
  } /* akhir while */

  return -1; /* kunciPencarian tidak ditemukan */
} /* akhir fungsi pencarianBiner */

/* Menampilkan kepala untuk keluaran */
void tampilKepala( void )
{
  int i; /* kounter */

  printf( "\nSubskript:\n" );

  /* menampilkan kepala kolom */
  for ( i = 0; i < UKURAN; i++ ) {
    printf( "%3d ", i );
  } /* akhir for */

  printf( "\n" ); /* memulai garis bari pada keluaran */

  /* menampilkan baris karakter - */
  for ( i = 1; i <= 4 * UKURAN; i++ ) {
    printf( "-" );
  } /* akhir for */

  printf( "\n" ); /* memulai garis baru pada keluaran */
} /* akhir fungsi tampilKepala */

/* Menampilkan satu baris keluaran menunjukkan
   bagian array terkini yang sedang diproses. */
void tampilBaris( const int b[], int rendah, int tengah, int tinggi )
{
  int i; /* kounter untuk menjelajah array b */

  /* loop untuk menjelajah keseluruhan array */
  for ( i = 0; i < UKURAN; i++ ) {

    /* menampilkan spasi jika di luar rentang subarray terkini */
    if ( i < rendah || i > tinggi ) {
      printf( " " );
    } /* akhir if */
    else if ( i == tengah ) { /* menampilkan elemen tengah */
      printf( "%3d*", b[ i ] ); /* menandai nilai tengah */
    } /* akhir else if */
    else { /* menampilkan elemen lainnya di dalam subarray */
      printf( "%3d ", b[ i ] );
    } /* akhir else */
  } /* akhir for */

  printf( "\n" ); /* memulai baris baru pada keluaran */
} /* akhir fungsi tampilBaris */

Masukkan angka dari 0 sampai 28: 25

Subskript:
  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14
------------------------------------------------------------
  0   2   4   6   8  10  12  14* 16  18  20  22  24  26  28
         16  18  20  22* 24  26  28
             24  26* 28
             24*

25 tidak ditemukan


Masukkan angka dari 0 sampai 28: 8

Subskript:
  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14
------------------------------------------------------------
  0   2   4   6   8  10  12  14* 16  18  20  22  24  26  28
  0   2   4   6*  8  10  12
      8  10* 12
      8*

8 ditemukan di dalam elemen array 4

Masukkan angka dari 0 sampai 28: 6

Subskript:
  0   1   2   3   4   5   6   7   8   9  10  11  12  13  14
------------------------------------------------------------
  0   2   4   6   8  10  12  14* 16  18  20  22  24  26  28
  0   2   4   6*  8  10  12

6 ditemukan di dalam elemen array 3

Gambar 5.19 | Pencarian biner atas suatu array

5.9 Array Subskript-Jamak
Array dalam C dapat memuat subskript jamak. Kegunaan umum dari array subskript-jamak (disebut pula dengan array multidimensi) adalah untuk merepresentasikan tabel nilai yang memuat informasi yang ditata dalam baris dan kolom. Untuk mengidentifikasi elemen tabel tertentu, Anda harus menspesifikasikan dua subskript: Pertama untuk mengidentifikasi baris elemen dan kedua untuk mengidentifikasi kolom elemen. Tabel atau array yang memerlukan dua subskript untuk mengidentifikasi suatu elemen tertentu disebut dengan array subskript-ganda. Array subskript-jamak dapat memiliki lebih dari dua subskript.

Gambar 5.20 mengilustrasikan sebuah array subskript-ganda a. Array tersebut memuat tiga baris dan empat kolom, sehingga dikatakan sebagai array 3-kali-4. Secara umum, sebuah array dengan m baris dan n kolom dinamakan dengan array m-kali-n.



Gambar 5.20 | Array subskript-ganda dengan tiga baris dan empat kolom


Setiap elemen di dalam array a diidentifikasi pada Gambar 5.20 menggunakan nama elemen dengan format a[i][j]; a adalah nama array, dan i dan j adalah subskript yang secara unik dipakai untuk mengidentifikasi setiap elemen di dalam a. Nama-nama elemen pada baris pertama semua mempunyai subskript pertama 0; Nama-nama elemen pada kolom keempat semua mempunyai subskript kedua 3;

Sebuah array subskript-jamak dapat diinisialisasi ketika didefinisikan, sama seperti array subskript-tunggal. Sebagai contoh, array subskript-ganda int b[2][2] dapat didefinisikan dan diinisialisasi dengan

int b[ 2 ][ 2 ] = { { 1, 2 }, { 3, 4 } };

  
Nilai-nilai dikelompokkan baris demi baris  yang diapit kurung kurawal. Nilai-nilai dalam himpunan pertama menginisialisasi baris 0 dan nilai-nilai dalam himpunan kedua menginisialisasi baris 1. Jadi, nilai 1 dan 2 menginisialisasi elemen b[0][0] dan b[0][1], dan nilai 3 dan 4 menginisialisasi elemen b[1][0] dan b[1][1]. Jika tidak terdapat penginisialisasi yang cukup untuk baris tertentu, elemen yang tak terinisialisasi pada baris tersebut diinisialisasi dengan 0. Jadi,

int b[ 2 ][ 2 ] = { { 1 }, { 3, 4 } };

akan menginisialisasi b[0][0] dengan 1, b[0][1] dengan 0, b[1][0] dengan 3, dan b[1][1] dengan 4. Gambar 5.21 mendemonstrasikan pendefinisian dan penginisialisasian array subskript-ganda.

Program mendefinisikan tiga array yang memuat dua baris dan tiga kolom (enam elemen untuk setiap array). Definisi array1 (baris 11) menyediakan enam penginisialisasi dalam dua subdaftar. Subdaftar pertama menginisialisasi baris pertama (baris 0) dengan nilai 1, 2, dan 3; dan subdaftar kedua menginisialisasi baris kedua (baris 1) dengan nilai 4, 5, dan 6.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/* Gambar 5.21: gambar05_21.c
   Menginisialisasi array multidimensi */
#include <stdio.h>

void tampilArray( const int a[][ 3 ] ); /* prototipe fungsi */

/* fungsi main memulai eksekusi program */
int main( void )
{
  /* menginisialisasi array1, array2, array3 */
  int array1[ 2 ][ 3 ] = { { 1, 2, 3 }, { 4, 5, 6 } };
  int array2[ 2 ][ 3 ] = { 1, 2, 3, 4, 5 };
  int array3[ 2 ][ 3 ] = { { 1, 2 }, { 4 } };

  printf( "Nilai dalam array1 dalam baris adalah:\n" );
  tampilArray( array1 );

  printf( "Nilai dalam array2 dalam baris adalah:\n" );
  tampilArray( array2 );

  printf( "Nilai dalam array31 dalam baris adalah:\n" );
  tampilArray( array3 );
  return 0; /* indikasi terminasi sukses */
} /* akhir main */

/* fungsi untuk menampilkan array dengan dua baris dan tiga kolom */
void tampilArray( const int a[][ 3 ] )
{
  int i; /* kounter baris */
  int j; /* kounter kolom */

  /* loop melalui baris */
  for ( i = 0; i <= 1; i++ ) {
    /* menampilkan kolom */
    for ( j = 0; j <= 2; j++ ) {
      printf( "%d ", a[ i ][ j ] );
    } /* akhir for dalam */
    printf( "\n" ); /* memulai baris baru pada keluaran */
  } /* akhir for luar */
} /* akhir fungsi tampilArray */

Nilai dalam array1 dalam baris adalah:
1 2 3
4 5 6
Nilai dalam array2 dalam baris adalah:
1 2 3
4 5 0
Nilai dalam array31 dalam baris adalah:
1 2 0
4 0 0

Gambar 5.21 | Penginisialisasian array multidimensi

Banyak manipulasi array yang umum dijumpai menggunakan statemen repetisi for. Misalnya, statemen berikut menetapkan semua elemen pada baris ketiga suatu array a pada Gambar 5.20 menjadi nol:

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

Karena yang ditarget adalah baris ketiga, Anda harus mengetahui bahwa subskript pertama selalu 2. Loop hanya akan memvariasi subskript kedua (kolom). Statemen for tersebut sama dengan statemen penugasan:

a[ 2 ][ 0 ] = 0;
a[ 2 ][ 1 ] = 0;
a[ 2 ][ 2 ] = 0;
a[ 2 ][ 3 ] = 0;

Statemen for bersarang berikut menentukan total semua elemen di dalam array a.

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

Statemen for mentotal semua elemen array baris demi baris. Statemen for luar memulai dengan menetapkan baris (subskript baris) menjadi 0 sehingga semua elemen baris pertama ditotal oleh statemen for dalam. Statemen for luar kemudian menginkremen baris menjadi 1, dan semua elemen baris kedua ditotal. Selanjutnya, statemen for luar menginkremen baris menjadi 2, dan semua elemen baris ketiga ditotal. Hasilnya ditampilkan ketika statemen for bersarang selesai dieksekusi.

5.10 Manipulasi Array Dua-Dimensi
Gambar 5.22 melakukan beberapa manipulasi array yang umum dijumpai pada array nilaiMahasiswa berukuran 3-kali-4 menggunakan statemen for. Setiap baris array merepresentasikan seorang mahasiswa dan setiap kolom merepresentasikan nilai pada empat ujian yang diambil mahasiswa pada semester tertentu. Manipulasi array dilakukan menggunakan empat fungsi. Fungsi minimum (baris 43-62) menentukan nilai terkecil dari semua mahasiswa pada semester tertentu. Fungsi maksimum (baris 65-84) menentukan nilai tertinggi dari semua mahasiswa pada semester tertentu. Fungsi rerata (baris 87-98) menentukan rata-rata nilai seorang mahasiswa selama satu semester. Fungsi tampilArray (baris 101-120) menampilkan array subskript-ganda dalam format tabular.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/* Gambar 5.22: gambar05_22.c
   Contoh array subskript-ganda */
#include <stdio.h>
#define MAHASISWA 3
#define UJIAN 4

/* prototipe fungsi */
int minimum( const int nilai[][ UJIAN ], int pelajar, int test );
int maksimum( const int nilai[][ UJIAN ], int pelajar, int test );
double rerata( const int himpunanNilai[], int test );
void tampilArray( const int nilai[][ UJIAN ], int pelajar, int test );

/* fungsi main mengeksekusi program */
int main( void )
{
  int pelajar; /* kounter pelajar */

  /* menginisialisasi nilai mahasiswa untuk tiga orang (baris) */
  const int himpunanNilai[ MAHASISWA ][ UJIAN ] =
    { { 77, 68, 86, 73 },
      { 96, 87, 89, 78 },
      { 70, 90, 86, 81 } };

  /* menampilkan array himpunanNilai*/
  printf( "Array adalah:\n" );
  tampilArray( himpunanNilai, MAHASISWA, UJIAN );

  /* menentukan nilai terendah dan tertinggi */
  printf( "\n\nNilai terendah: %d\nNilai tertinggi: %d\n",
  minimum( himpunanNilai, MAHASISWA, UJIAN ),
  maksimum( himpunanNilai, MAHASISWA, UJIAN ) );

  /* menghitung nilai untuk tiap mahasiswa */
  for ( pelajar = 0; pelajar < MAHASISWA; pelajar++ ) {
    printf( "Rata-rata nilai untuk mahasiswa %d adalah %.2f\n",
      pelajar, rerata( himpunanNilai[ pelajar ], UJIAN ) );
  } /* akhir for */

  return 0; /* indikasi terminasi sukses */
} /* akhir main */

/* Mencari nilai minimum */
int minimum( const int nilai[][ UJIAN ], int pelajar, int test )
{
  int i; /* kounter pelajar */
  int j; /* kounter ujian */
  int nilaiBawah = 100; /* inisialisasi nilai tertinggi */

  /* loop menjelajah baris nilai */
  for ( i = 0; i < pelajar; i++ ) {

    /* loop menjelajah kolom nilai */
    for ( j = 0; j < test; j++ ) {

      if ( nilai[ i ][ j ] < nilaiBawah ) {
        nilaiBawah = nilai[ i ][ j ];
         } /* akhir if */
       } /* akhir for dalam */
  } /* akhir for luar */

  return nilaiBawah; /* menghasilkan nilai minimum */
} /* akhir fungsi minimum */

/* Mencari nilai maksimum */
int maksimum( const int nilai[][ UJIAN ], int pelajar, int test )
{
  int i; /* kounter pelajar */
  int j; /* kounter ujian */
  int nilaiAtas = 0; /* inisialisasi nilai terendah */

  /* loop menjelajah baris nilai */
  for ( i = 0; i < pelajar; i++ ) {

    /* loop menjelajah kolom nilai */
    for ( j = 0; j < test; j++ ) {

      if ( nilai[ i ][ j ] > nilaiAtas ) {
        nilaiAtas = nilai[ i ][ j ];
         } /* akhir if */
       } /* akhir for dalam */
  } /* akhir for luar */

  return nilaiAtas; /* menghasilkan nilai maksimum */
} /* akhir fungsi maksimum */

/* Menentukan rata-rata nilai untuk seorang mahasiswa */
double rerata( const int himpunanNilai[], int test )
{
  int i; /* kounter ujian */
  int total = 0; /* jumlah nilai ujian */

  /* total semua nilai untuk satu mahasiswa */
  for ( i = 0; i < test; i++ ) {
    total += himpunanNilai[ i ];
  } /* akhir for */
 
  return ( double ) total / test; /* rata-rata */
} /* akhir fungsi rerata */

/* Menampilkan Array */
void tampilArray( const int nilai[][ UJIAN ], int pelajar, int test )
{
  int i; /* kounter pelajar */
  int j; /* kounter ujian */

  /* menampilkan kepala kolom */
  printf( " [0] [1] [2] [3]" );

  /* menampilkan nilai dalam format tabular */
  for ( i = 0; i < pelajar; i++ ) {

    /* menampilkan label untuk baris */
    printf( "\nnilaiMahasiwa[%d] ", i );

    /* menampilkan nilai untuk satu mahasiswa */
    for ( j = 0; j < test; j++ ) {
      printf( "%-5d", nilai[ i ][ j ] );
       } /* akhir for dalam */
  } /* akhir for luar */
} /* akhir fungsi tampilArray */

Array adalah:
                [0]  [1]  [2]  [3]
nilaiMahasiwa[0] 77   68   86   73
nilaiMahasiwa[1] 96   87   89   78
nilaiMahasiwa[2] 70   90   86   81

Nilai terendah: 68
Nilai tertinggi: 96
Rata-rata nilai untuk mahasiswa 0 adalah 76.00
Rata-rata nilai untuk mahasiswa 1 adalah 87.50
Rata-rata nilai untuk mahasiswa 2 adalah 81.75

Gambar 5.22 | Contoh array subskript-ganda

Kesimpulan
§  Array adalah sekelompok lokasi memori yang berelasi oleh fakta bahwa semua memiliki nama dan tipe sama. Untuk menunjuk ke lokasi atau elemen tertentu di dalam array, nama array dan nomor posisi elemen tertentu di dalam array perlu dispesifikasi.

§  Nomor posisi yang diapit sepasang kurung siku lebih formal disebut dengan subskript (atau indeks). Indeks harus berupa integer atau ekspresi integer. Jika suatu program menggunakan sebuah ekspresi sebagai subskript, maka ekspresi tersebut dievaluasi lebih dahulu untuk menentukan subskript.

§  Array menempati ruang di dalam memori. Tipe setiap elemen dan jumlah elemen yang dibutuhkan setiap array dapat dispesifikasi sehingga komputer bisa mencadangkan jumlah memori yang sesuai untuk kebutuhan itu.

§  Elemen suatu array dapat pula diinisialisasi ketika array didefinisikan dengan definisi berikut menggunakan tanda sama dengan dan separang kurung kurawal, { }, yang memuat daftar penginisialisasi terpisahkan koma.

§  Jika terdapat penginisialisasi lebih sedikit daripada jumlah elemen di dalam array, maka sisa elemen diinisialisasi dengan 0. Hal penting untuk diingat adalah array tidak secara otomatis diinisialisasi dengan 0. Anda harus sedikitnya menginisialisasi elemen pertama dengan nol dan sisa elemen yang lain akan diinisialisasi secara otomatis dengan nol.

§  Array karakter memiliki beberapa fitur unik. Suatu array karakter dapat diinisialisasi menggunakan sebuah literal string.

§  Array karakter yang merepresentasikan sebuah string dapat ditampilkan dengan printf dan penspesifikasi string %s.

§  Variabel lokal static eksis selama program dijalankan, dan hanya dikenal di dalam tubuh fungsi. Anda dapat menerapkan static terhadap suatu definisi array lokal sehingga array tersebut tidak diciptakan dan diinisialisasi setiap kali fungsi dipanggil dan array tersebut tidak dihancurkan setiap kali fungsi selesai dieksekusi di dalam program.

§  Untuk melewatkan suatu argumen array kepada fungsi, diperlukan untuk menspesifikasi nama array tanpa adanya kurung kurawal.

§  Meskipun keseluruhan array dilewatkan melalui referensi, elemen-elemen array secara individual dilewatkan dengan nilai seperti variabel biasa. Untuk melewatkan suatu elemen array ke fungsi, digunakan nama elemen array tersubskript (skalar) sebagai argumen di dalam pemanggilan fungsi.

§  C menyediakan kualifier const untuk mencegah modifikasi atas nilai array di dalam suatu fungsi. Ketika sebuah parameter array diawali dengan kualifier const, elemen array menjadi konstanta di dalam tubuh fungsi, dan segala usaha untuk memodifikasi elemen array di dalam tubuh fungsi akan menyebabkan error kompilasi.

§  Array dalam C dapat memuat subskript jamak. Kegunaan umum dari array subskript-jamak (disebut pula dengan array multidimensi) adalah untuk merepresentasikan tabel nilai yang memuat informasi yang ditata dalam baris dan kolom. Untuk mengidentifikasi elemen tabel tertentu, Anda harus menspesifikasikan dua subskript: Pertama untuk mengidentifikasi baris elemen dan kedua untuk mengidentifikasi kolom elemen.

Soal
1.       Tulis statemen untuk melakukan hal berikut:
a)       Tampilkan nilai dari elemen ke tujuh dari array karakter f.
b)      Masukkan suatu nilai ke elemen 4 dari array pecahan subskript-tunggal b.
c)       Inisialisasi kelima elemen dari array integer subskript-tunggal g dengan 8.
d)      Salin array a ke dalam penggalan pertama dari array b. Asumsikan double a[11], b[34].
e)       Tentukan dan tampilkan nilai terendah dan tertinggi yang dimuat di dalam array pecahan w.

2.       Apakah yang dilakukan kode berikut?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/* soal5_2.c */
/* Apakah yang dilakukan program? */
#include <stdio.h>
#define UKURAN 10

int ApaIni( const int b[], int p ); /* prototipe fungsi */

/* fungsi main memulai eksekusi */
int main( void )
{
  int x; /* memuat nilai balik dari fungsi ApaIni */

  /* inisialisasi array a */
  int a[UKURAN] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

  x = ApaIni( a, UKURAN);

  printf( "Hasilnya adalah %d\n", x );
  return 0; /* indikasi terminasi sukses */
} /* akhir main */

int ApaIni ( const int b[], int p )
{
  /* kasus basis */
  if ( p == 1 ) {
    return b[ 0 ];
  } /* akhir if */
  else { /* langkah rekursi */
    return b[ p - 1 ] + ApaIni( b, p - 1 );
  } /* akhir else */
} /* akhir fungsi ApaIni */

3.       Modifikasilah program pada Gambar 5.18 untuk menggunakan suatu fungsi pencarianLinier rekursif dalam melakukan pencarian linier atas array. Fungsi tersebut harus menerima sebuah array integer dan ukuran array sebagai argumen. Jika kunci pencarian ditemukan, maka subskript array akan dijadikan nilai balik; sebaliknya, -1 dijadikan nilai balik.

4.       Modifikasilah program pada Gambar 5.19 untuk menggunakan fungsi pencarianBiner dalam melakukan pencarian biner atas array. Fungsi tersebut harus menerima sebuah array integer, subskript awal, dan subskript akhir sebagai argumen. Jika kunci pencarian ditemukan, maka subskript array dijadikan nilai balik; sebaliknya, -1 dijadikan nilai balik.

5.       Tulislah suatu fungsi rekursif tampilArray yang mengambil suatu array dan ukuran array sebagai argumen, yang menampilkan array, dan yang tidak menghasilkan nilai balik apapun. Fungsi ini harus berhenti memproses ketika menerima suatu array berukuran nol.

6.       Tulislah suatu fungsi rekursif balikString yang mengambil sebuah array karakter sebagai argumen, yang menampilkan array karakter secara terbalik, dan yang tidak menghasilkan nilai balik apapun. Fungsi ini harus berhenti memproses ketika menemukan karakter null di dalam string masukan.

7.       Tulislah suatu fungsi rekursif minimumRekursif yang mengambil sebuah array integer dan ukuran array sebagai argumen dan menghasilkan nilai balik berupa elemen terkecil di dalam array. Fungsi harus berhenti memproses dan menghasilkan  nilai balik ketika menerima suatu array dengan satu elemen.

8.       Tulislah suatu fungsi rekursif maksimumRekursif yang mengambil sebuah array integer dan ukuran array sebagai argumen dan menghasilkan nilai balik berupa elemen terbesar di dalam array. Fungsi harus berhenti memproses dan menghasilkan  nilai balik ketika menerima suatu array dengan satu elemen.

9.       Apakah yang dilakukan kode berikut?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/* soal5_9.c */
/* What does this program do? */
#include <stdio.h>
#define UKURAN 10

/* prototipe fungsi */
void suatuFungsi( const int b[], int indeksAwal, int ukuran);

/* fungsi main memulai eksekusi program */
int main( void )
{
  int a[UKURAN] = { 8, 3, 1, 2, 6, 0, 9, 7, 4, 5 }; /* inisialisasi a */

  printf( "Jawaban adalah:\n" );
  suatuFungsi( a, 0, UKURAN);
  printf( "\n" );
  return 0; /* indikasi terminasi sukses */
} /* akhir main */

/* Apa yang dilakukan fungsi ini? */
void suatuFungsi( const int b[], int indeksAwal, int ukuran )
{
  if (indeksAwal < ukuran) {
    suatuFungsi( b, indeksAwal + 1, ukuran);
    printf( "%d ", b[indeksAwal] );
  } /* akhir if */
} /* akhir fungsi suatuFungsi */

10.    Tulislah suatu program yang mensimulasikan pelemparan dua dadu. Program harus menggunakan rand untuk melemparkan dadu pertama, dan harus menggunakan rand kembali untuk melemparkan dadu kedua. Penjumlahan atas dua nilai kemudian dilakukan. [Perhatikan: Karena setiap dadu menghasilkan suatu nilai integer dari 1 sampai 6, maka penjumlahan dua nilai yang dihasilkan akan bervariasi dari 2 sampai 12, dengan 7 menjadi penjumlahan yang paling sering dijumpai dan 2 dan 12 menjadi penjumlahan yang paling jarang ditemui]. Gambar 5.22 menunjukkan 36 kombinasi yang mungkin dari dua dadu tersebut. Program Anda harus melemparkan kedua dadu tersebut sebanyak 36000 kali. Gunakan array subskript-tunggal untuk menyimpan jumlah kemunculan masing-masing penjumlahan. Tampilkan hasil dalam format tabular.



Gambar 5.23 | Keluaran pelemparan dua dadu






Posted by at

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)