Kumpulan Kode Program Dalam Bahasa C

Oleh :

Richi Hariyanto, Amd

 Daftar Isi

Modul 1 : Pengantar Algoritma dan Pemrograman

Modul 2 : Pengulangan dalam bahasa C

A. For

B. While Do

C. Do While

Modul 3 : Pemilihan dalam bahasa C

A. Pemilihan Satu Kondisi

B. Pemilihan Dua Kondisi

C. Pemilihan Banyak Kondisi

Modul 4 : Prosedur dan Fungsi

A. Prosedur
B. Fungsi

Modul 5 : Array pada C

A. array sebagai variabel

B. array sebagai tipe bentukan

C. array sebagai tipe terstruktur

D. array multidimensi

E. array dinamis

Modul 6 : Pengurutan Array

A. Bubble Sort

B. Selection Sort

C. Insertion Sort

D. Shell Sort

Modul 7 : Pencarian Array

A. Sequential Search

B. Binary Search

Referensi
 Modul 1 : Pengantar Algoritma dan Pemrograman

Pengertian
Pemrograman merupakan kegiatan yang sangat penting diera teknologi informasi saat ini. Program
yang ada di desktop, web, smartphone, dll. Memerlukan kegiatan pemrograman. Pemrograman
yang dikerjakan dibuat berdasarkan analisis dan perancangan yang cermat. Pemrograman biasanya
mengimplementasikan algoritma yang dituliskan dengan bahasa pemrograman.
Algoritma merupakan sederetan langkah-langkah untuk menyelesaikan masalah. Algoritma biasa
dibuat secara runut agar dapat dieksekusi oleh komputer. Algoritma harus dipikirkan secara logika
agar lebih mudah dipetakan kedalam bahasa pemrograman. Secara logika kita dapat membayangkan
sebuah solusi yang harus diselesaikan pada suatu permasalahan. Contohnya prosedur memasak mi
instan. Maka solusi yang dibuat harus runut sebagai berikut :
1. rebus mi dalam 400 cc (2 gelas) air mendidih selama 3 menit sambil diaduk
2. Sementara mi direbus, campurkan bumbu, minyak bumbu, bubuk cabe dan kecap
manis ke dalam piring.
3. Tiriskan mi, kemudian campurkan bumbu di piring, diaduk hingga merata.
4. Mi goreng siap disajikan.

Algoritma dalam bentuk Gambar

Penulisan solusi secara runut tidak harus berupa poin-poin, kita bisa juga memanfaatkan gambar
agar orang lain dapat segera mengerti solusi yang kita buat. Sebagaimana solusi yang kita buat
untuk memasak mi berikut :
Algortima Dalam Bentuk Flow Chart
 Modul 2 : Pengulangan dalam bahasa C

Ada berapa jenis pengulangan yang sering digunakan ketika memrogram, yaitu For, While dan
Repeat (do while). For merupakan pengulangan dengan kondisi yang telah ditentukan diawal. baik
untuk nilai menaik atau menurun. sedangkan While dan Repeat merupakan pengulangan dengan
kondisi yang belum ditentukan. bedanya adalah While menspesifikasikan kondisi dimuka
sedangkan Repeat diakhir.
A. For

Flowchart diatas menunjukkan struktur pengulangan For. Seperti yang telah disebutkan diatas,
bahwa For digunakan untuk menghasilkan pengulangan yang telah ditentukan. Jumlah pengulangan
dapat dikenali sebelum program dieksekusi. Untuk melakukan pengulangan sederhana dengan For,
kita memerlukan variabel pencacah (counter). Variabel ini selalu bertambah tiap kali pengulangan
dilakukan. Sebagaimana pada flowchart, ketika counter telah bertambah sampai dengan angka 11.
Maka pengulangan akan berhenti.
Struktur For menaik :
for (counter = 1; counter <= 10; counter++)
{
// aksi
}

Struktur For menurun :

for (counter = 10; counter >= 0; counter--)
{
// aksi
}

Program pertama dengan for adalah mencetak angka 1, 2, 3, 4 dan 5. angka tersebut adalah default
dari fungsi for pada algoritma dan compiler. jadi kita hanya perlu menambahkan pernyataan cetak
untuk menghasilkan keluaran tersebut.
// Program pengulangan
#include
int main()
{
int i; // counter

// ulangi 5 kali
for (i = 1; i <= 5; i++)
{
printf(“%d\t”, i); // cetak pengulangan 1 sampai 5
}
}

Output:
1 2 3 4 5

Kita juga bisa menambahkan operasi aritmatika didalam pengulangan. Misalkan kita ingin membuat
deret angka kelipatan 5, yaitu 5, 25, 125, 625, 3125. pemecahannya adalah dengan mengalikan 5
dengan banyaknya pengulangan yang dibutuhkan. Nilai perkalian tersebut ditampung pada variabel
baru kemudian dicetak.
// Program pengulangan
#include
int main()
{
int i, sum;

sum = 1;
for (i = 1; i <= 5; i++)
{
sum = sum * 5;
printf("%d\t", sum);
}
}

Output:
1 5 25 125 625

For bersarang
Pengulangan for dapat berada di dalam pengulangan yang lainnya. Untuk melakukan pengulangan
ini, maka setiap pernyataan harus menggunakan variabel pengontrol pengulangan yang berbeda.
Struktur For bersarang :
for (i = 1; i <= 10; i++)
{
for (j = 1; j <= 10; j++)
{
// aksi
}
}

// For Bersarang : mencetak * sebanyak i dan j dalam size

#include
#define size 5
int main ()
{
int i,j;

for (i = 1; i <= size; i++)

{
for (j = 1; j <= size; j++)
{
printf("*");
}
printf ("\n");
}
}

Output :
*****
*****
*****
*****
*****

Contoh yang paling fenomenal untuk menjelaskan for bersarang ini adalah program membuat
segitiga. Program pertama adalah mencetak pengulangan y sebanyak nilai x.
#include

int main()
{
int x, y;

for(x = 1; x <= 5; x++)

{
for(y = 1; y <= x; y++)
{
printf(“%d”, y);
}
printf(“\n”);
}
return 0;
}

Output :
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5

// For bersarang : Mencetak nilai 1 sampai 9 menurun kebawah

#include
int main()
{
int x, y;

for(x = 1; x <= 9; x++)

{
for(y = x; y <= 9; y++)
{
printf(“%d”, y);
}
printf(“\n”);
}
return 0;
}

Output :
123456789
23456789
3456789
456789
56789
6789
789
89
9

Menghentikan pengulangan For (Break)

Break dapat dimanfaatkan untuk menghentikan aksi pengulangan yang sedang berjalan.
// Menggunakan pernyataan break dalam pernyataan for
#include
// fungsi main memulai eksekusi program
int main(void)
{
int x;

for (x = 1; x <= 10; x++) {

if (x == 5) {
break; // akhiri pengulangan jika x = 5
}

printf (“%d\t”, x);

}
printf (“\nPengulangan berhenti pada x = %d\n”, x);
return 0;
}

Output :
1 2 3 4
Pengulangan berhenti pada x = 5
Contoh lain untuk penggunaan break.
// mencari bilangan prima
#include
int main()
{
int i;
int bil;
int prima = 1;

scanf("%d", &bil);
for (i = 2; i <= bil/2; i++)
{
if (bil % i == 0)
prima = 0;
break;
}
if (prima == 1)
printf("%d bilangan prima\n", bil);
else
printf("%d bukan bilangan prima\n", bil);
}

Output :
19
19 bilangan prima

Melewatkan pengulangan For (Continue)

Continue dapat dimanfaatkan untuk melanjutkan (melewatkan) aksi pengulangan yang sedang
berjalan.
// continue pada for
#include
int main()
{
int x;

for (x = 1; x <= 10; x++)

{
// jika x adalah 5, lewatkan 5
if (x == 5) {
continue;
}
printf (“%d\t”, x);
}
return 0;
}

Output :
1 2 3 4 6 7 8 9 10
B. While Do

Flowchart diatas menunjukkan struktur pengulangan While. Seperti yang telah disebutkan diatas,
bahwa While digunakan untuk menghasilkan pengulangan bersyarat. Jumlah pengulangan
ditentukan oleh pengguna program. Pada pengulangan while, pernyataan aksi akan terus dilakukan
hingga kondisi bernilai benar. Jika salah, maka pernyataan aksi akan dilewatkan.
Struktur While :
while (kondisi)
{
// aksi
}

Program pertama dengan while adalah mencetak angka 1, 2, 3, 4 dan 5.

// Program pengulangan
#include
int main()
{
int i;

i = 1;
while (i <= 5) // kondisi harus benar, jika tidak lewatkan
{
printf(“%d\t”, i);
i++;
}
}

Output:
1 2 3 4 5

Contoh lainnya dari pengulangan while adalah program untuk menghitung rata-rata. Program ini
mulai menggunakan kondisi, dimana ketika angka yang dimasukkan pengguna bukan 0, maka
pengulangan akan terus dilakukan. Didalam while terdapat pernyataan aksi yang menaikkan counter
(i), menambahkan menjumlahkan N, dan menginputkan ulang N. Ketika angka yang diinputkan
adalah 0, maka pernyataan while {} akan dilewatkan, dilanjutkan dengan pemilihan. Dimana jika
counter i adalah 0, maka dinyatakan bahwa tidak ada angka yang dimasukkan pengguna, begitu
juga sebaliknya.
/* Program Hitung Rata-Rata Deret Angka */
#include

int main()
{
int N;
int i = 0;
int jumlah = 0;
float rerata;

printf("Inputkan nilai N (Integer) akhiri dengan 0 :\n");

printf("N : ");
scanf ("%d", &N);
while (N != 0)
{
i++;
jumlah = jumlah + N;
printf("N : ");
scanf ("%d", &N);
}
if (i != 0)
{
rerata = (float)jumlah / i;
printf ("Jumlah : %d\n", jumlah);
printf ("banyak N yang diinputkan : %d\n", i);
printf ("Rata-rata : %0.2f\n", rerata);
}
else
printf ("tidak ada data yang diinputkan\n");
}

Output :
Inputkan nilai N (Integer) akhiri dengan 0 :
N : 5
N : 6
N : 7
N : 8
N : 9
N : 10
N : 0
Jumlah : 45
banyak N yang diinputkan : 6
Rata-rata : 7.50

Dalam pernyataan kondisi, kita bisa memanfaatkan EOF (End Of File), ini berguna untuk menerima
masukan teks bebas oleh pengguna. ketika selesai, pengguna menekan Ctrl+D atau Ctrl + Z.
Program dibawah menghitung jumlah baris dari teks yang diinputkan pengguna.
#include

// count lines in input

main()
{
int c, nl;

nl = 0;
while ((c = getchar()) != EOF)
if (c == '\n')
++nl;
printf("%d\n", nl);
return 0;
}

Output :
Abc
Abc
CDE
FgH
4

C. Do While
Flowchart diatas menunjukkan struktur pengulangan Do-While. Seperti yang telah disebutkan
diatas, bahwa Do-While digunakan untuk menghasilkan pengulangan bersyarat. Jumlah
pengulangan ditentukan oleh pengguna program. Pada pengulangan Do-While, pernyataan aksi
akan terus dilakukan hingga kondisi bernilai salah. Jika kondisi telah terpenuhi, maka pernyataan
aksi tidak akan diulangi.
Struktur Do-While :
do {
// aksi
} while (kondisi)

Contoh Do-While untuk mencetak angka 1 sampai dengan 10.

// gunakan pernyataan pengulangan do-while
#include

int main()
{
int counter = 1;

// langsung di kerjakan
do {

printf (“%d ”, counter); // dicetak 1

} while (++counter <= 10); // selama masih kurang maka kembali ke do

return 0;
}

Output :
1 2 3 4 5 6 7 8 9 10

/* contoh baca nilai x */

/* Jumlahkan nilai yang dibaca dengan Repeat dan penanganan kasus kosong */
# include
int main()
{
// peubah
int sum;
int x;

// program
printf("Masukkan nilai x (int), akhiri dengan 0 :\n");
scanf("%d", &x);
if(x == 0)
{
printf("Kasus kosong \n");
}
else
{
sum = 0;
do // pengulangan disini
{
sum = sum + x;
scanf("%d", &x);
} while (x != 0);
printf("Jumlah = %d\n", sum);
}
return 0;
}

Output :
Masukkan nilai x (int), akhiri dengan 0 :
1
2
3
4
5
6
7
8
9
0
Jumlah = 45
 Modul 3 : Pemilihan dalam bahasa C

Pemilihan terjadi karena adanya kondisi percabangan pada algoritma. pemilihan dapat dilakukan
dengan dua cara yaitu menggunakan if dan case. if biasa digunakan pada satu atau dua kondisi
lebih. sedangkan case digunakan pada lebih dari satu kondisi. beda antara if dan case sebagai
berikut :

1. kondisi pada if bisa memakai semua operator logika dan relasional. pada case hanya
untuk karakter =

2. kondisi pada if bisa menggunakan seluruh tipe data (integer, real string, char) pada
case hanya integer dan char.

Untuk menjelaskan pemilihan ini, akan lebih nyaman jika dijelaskan menggunakan flowchart.

A. Pemilihan Satu Kondisi

Flowchart diatas menunjukkan pemilihan dengan satu kondisi. Dimana jika kondisi itu bernilai
benar, maka aksi akan dijalankan, namun jika salah maka aksi akan dilewatkan. Pernyataan tersebut
dalam bahasa C dituliskan sebagai berikut :
if (kondisi)

// aksi

contohnya :

if (x == 100)

printf(“Selamat, Nilai sempurna!\n”);

if (nilai >= 60)

printf (“Lulus\n”);

if ( rerataSemester >= 90 || UAS >= 90 )

printf( "Nilai Akhir Siswa A\n" );

if (ketemu == false)

printf(“Cari lagi?\n”);

scanf(“%c”, cari);

} // gunakan blok { } untuk pernyataan lebih dari satu

Contoh aplikasinya, kita dapat memanfaatkan pemilihan satu kondisi ini untuk menentukan suatu
program itu genap atau bukan.
// Program menentukan bilangan genap

#include <stdio.h>

int main()
{

int x;

printf(“Inputkan sebuah bilangan bulat : ”);

scanf(“%d”, &x);

if (i % 2 == 0)

printf(“%d Merupakan Bilangan Genap!\n”, x);

// end if

return 0;

Output :
Inputkan sebuah bilangan bulat : 4

4 Merupakan Bilangan Genap!

B. Pemilihan Dua Kondisi

Flowchart diatas menunjukkan pemilihan dengan dua kondisi. Dimana jika kondisi itu bernilai
benar, maka aksi pertama akan dijalankan, namun jika salah maka aksi kedua yang akan dijalankan.
Pernyataan tersebut dalam bahasa C dituliskan sebagai berikut :
if (kondisi)

// aksi 1

else

// aksi 2

contohnya :

if (x == 1)

printf(“Katakan Benar\n”);

else

printf(“Katakan Salah.\n”);

if (nilai >= 60) {

printf (“Lulus\n”);

else {

printf (“Gagal\n”);

Bentuk lain, bisa diungkapkan dengan menggunakan operator kondisi.

Printf (“%c\n”, nilai > 60 ? “Lulus” : “Gagal”);

atau
nilai >= 60 ? printf (“Lulus\n”) : printf (“Gagal\n”);

Contoh lengkapnya, kita dapat memanfaatkan pemilihan dua kondisi ini untuk mencari suatu
bilangan apakah bilangan itu positif atau negatif.
// Program Menentukan Positif / Negatif

#include <stdio.h>

int main()
{

int x;

printf("Inputkan sebuah bilangan : ");

scanf("%d", &x);

if(x > 0)

printf("%d Bilangan Positif\n", x);

else

printf("%d Bilangan Negatif\n", x);

return 0;

Output :
Inputkan sebuah bilangan : 5

5 Bilangan Positif

Inputkan sebuah bilangan : -5

-5 Bilangan Negatif

C. Pemilihan Banyak Kondisi

Flowchart diatas menunjukkan pemilihan pada banyak kondisi. Dimana jika kondisi pertama itu
bernilai benar, maka aksi pertama akan dijalankan. namun jika salah, maka akan dilanjutkan dengan
pemilihan kondisi kedua. Pada kondisi kedua ini, jika benar maka aksi kedua akan dijalankan. Jika
salah lagi, maka kondisi ketiga yang akan dijalankan. Flowchart ini cukup mewakili untuk banyak
kondisi lainnya. Jika semakin banyak, tentu kondisi dan aksi yang dijalankan akan semakin banyak
juga. Pernyataan tersebut dalam bahasa C dituliskan sebagai berikut :
if (kondisi1)

// aksi1

else

if (kondisi2)

// aksi 2

else

// aksi 3

Contoh lengkapnya, kita dapat memanfaatkan program sebelumnya yaitu menentukan bilangan
positif, negatif atau nol. Program ini sekaligus memperbaiki kesalahan pada program sebelumnya.
Disini akan ditambahkan aksi ketiga untuk menjebak ketika pengguna program menginputkan nol.
// Program Menentukan Positif, Negatif atau Nol

#include <stdio.h>
int main()
{

int x;

printf("Inputkan sebuah bilangan : ");

scanf("%d", &x);

if(x > 0)

printf("%d Bilangan Positif\n", x);

else

if (x < 0)

printf("%d Bilangan Negatif\n", x);

else

printf("Nol\n");

return 0;

Output :
Inputkan sebuah bilangan : 5

5 Bilangan Positif

Inputkan sebuah bilangan : -5

-5 Bilangan Negatif

Inputkan sebuah bilangan : 0

Nol

C. Pemilihan Banyak Kondisi (Case)

Penggunaan if else untuk banyak kondisi tentu akan merepotkan dan membuat penulisan program
menjadi kurang elegan. Teknik lain untuk mengatasi masalah ini adalah dengan menggunakan
case/switch. Pernyataan tersebut dalam bahasa C dituliskan sebagai berikut :
switch (ekspresi)

case nilai_1 : aksi_1;

break;

case nilai_2 : aksi_2;

break;

case nilai_n : aksi_n;

break;

default : aksi_x

Contoh lengkapnya adalah program persegi panjang. Case digunakan memilih rumus persegi
panjang yang ingin digunakan. Pilihan pertama menghitung luas persegi panjang, pilihan kedua
menghitung keliling persegi panjang, pilihan ketiga menghitung panjang diagonal, dan pilihan
keempat untuk keluar dari program.
// Program persegi panjang dengan case

#include <stdio.h>

#include <math.h>

int main()

int noMenu;

float panjang, lebar;

float luas, keliling, diagonal;

printf("Menu Menghitung Persegi Panjang\n");

printf("1. Hitung Luas\n");

printf("2. Hitung Keliling\n");

printf("3. Hitung Panjang Diagonal");

printf("4. Keluar dari Program");

printf("Inputkan pilihan Anda(1\2\3\4) =");

scanf("%d", &noMenu);

switch(noMenu)

case 1 : {

printf("Panjang = "); scanf("%f", &panjang);

printf("Lebar = "); scanf("%f", &lebar);

luas = panjang * lebar;

printf("Luas = %f\n", luas);

break;

case 2 : {

printf("Panjang = "); scanf("%f", &panjang);

printf("Lebar = "); scanf("%f", &lebar);

keliling = 2*panjang * 2*lebar;

printf("keliling = %f\n", keliling);

break;

case 3 : {

printf("Panjang = "); scanf("%f", &panjang);

printf("Lebar = "); scanf("%f", &lebar);

diagonal = sqrt((double)panjang*panjang + (double)lebar*lebar);

printf("Diagonal = %f\n", diagonal);

break;

case 4 :

printf ("Keluar program!\n");

break;

khusus untuk kompilasi file case.c :

$ gcc -lm case.c -o case

Output :
Menu Menghitung Persegi Panjang

1. Hitung Luas

2. Hitung Keliling

3. Hitung Panjang Diagonal

4. Keluar dari Program

Inputkan pilihan Anda(1\2\3\4) = 1

Panjang = 4.5

Lebar = 3.5 Luas = 15.75

 Modul 4 : Prosedur dan Fungsi

Prosedur
Penggunaan prosedur dan fungsi pada pemrograman terkait pada model pemrograman modular.
dimana pemrogram membuat prosedur atau fungsi untuk dipanggil pada bagian-bagian program, ini
diupayakan untuk menghindari coding secara berulang. kelebihan penggunaan prosedur dan fungsi
akan menghasilkan program yang lebih elegan, mudah ditelurusi dan dibaca.

Prosedur merupakan modul program yang mengerjakan tugas/aktifitas yang spesifik, dimana
pemrogram perlu mendefinisikan prototype terlebih dahulu, sebelum runtutan instruksi didalam
prosedur dilaksanakan. kemudian mendefinisikan realisasi setelah runtutan instruksi tersebut
dilaksanakan. dalam prosedur dikenal tidak memiliki pengembalian nilai (void). contoh :
// prototype
void baca(int *a, int *b)

// realisasi
void baca(int* a, int* b)
{
printf("a = "); scanf("%d", &a);
printf("b = "); scanf("%d", &b);
}
dalam prosedur, program memerlukan parameter untuk melakukan aktifitas pertukaran informasi
antara prosedur dan program. disebutkan bahwa parameter yang digunakan adalah parameter aktual
dan parameter formal. parameter aktual akan berkorespondensi dengan parameter formal. tiap-tiap
parameter aktual berpasangan dengan parameter formal yang bersesuaian.
void baca(int *a, int *b) // (int *a, int *b) => parameter formal pada bagian
header
baca(x,y); // (x, y) => parameter aktual pada pemanggilan prosedur
jenis parameter yang dapat digunakan pada prosedur adalah :
prosedur tanpa parameter
=> prosedur dapat dipanggil tanpa menggunakan parameter
contoh :
// Program Segitiga Bintang Pagar

#include <stdio.h>

void SegitigaBintangPagar();

main()
{
int a, B;

printf("Banyaknya Cetakan Segitiga = ");

 scanf("%d", &B);
for(a=1; a<=B; a++)
SegitigaBintangPagar(); // pemanggilan prosedur tanpa parameter
}

void SegitigaBintangPagar()
{
int N, i, j;

printf("Tinggi segitiga, N = ");

scanf("%d", &N);

// Cetak segitiga pertama

for (i=1; i<=N; i++)
{
for (j=1; j<=i; j++)
{
if(i!=j)
printf("*");
else
printf("#");
}
printf("\n");
}
// Cetak segitiga kedua
for (i=N-1; i>=1; i--)
{
for (j=1; j<=i; j++)
{
if(i!=j)
printf("*");
else
printf("#");
}
printf("\n");
}
}
parameter masukan
=> parameter aktual digunakan sebagai parameter masukan untuk mengisi parameter formal.
contoh :
// Program Segitiga
// Menghitung luas N buah segitiga

#include <stdio.h>
// prototype
void HitungLuasSegitiga(float a, float t);

main()
{
int i, N;
float a, t;

printf("Banyaknya segitiga = ");

scanf("%d", &N);
for(i=1; i<=N; i++)
{
printf("alas segitiga = ");
scanf("%f", &a);
printf("tinggi segitiga = ");
scanf("%f", &t);
HitungLuasSegitiga(a, t); // pemanggilan dengan parameter aktual sebagai
parameter masukan
}
}

void HitungLuasSegitiga(float alas, float tinggi)

{
float luas;

luas = (alas*tinggi)/2.0;
printf("Luas segitiga = %f\n", luas);
}
parameter keluaran
=> parameter aktual berfungsi sebagai tempat untuk mengisi informasi dari prosedur.
contoh :
// program segitiga
// menghitung luas N buah segitiga

#include <stdio.h>

// prototype
void HitungLuasSegitiga(float a, float t, float *L);

main()
{
int i, N;
float a, t;
float L;
 printf("Banyak Segitiga : ");
scanf("%d", &N);
for(i=1; i<=N; i++)
{
printf("alas segitiga = ");
scanf("%f", &a);
printf("tinggi segitiga = ");
scanf("%f", &t);
HitungLuasSegitiga(a, t, &L);
printf("Luas segitiga = %f\n", L); // parameter aktual sebagai parameter
keluaran
}
}

void HitungLuasSegitiga(float alas, float tinggi, float *luas)

{
*luas = (alas * tinggi) / 2.0;
}
parameter masukan/keluaran
=> parameter aktual berfungsi sebagai masukan dan keluaran dari prosedur.
contoh :
// Program Tambah Satu

#include <stdio.h>

// prototype
void TambahSatu(int *A, int *B);

main()
{
int X, Y, Z;

printf("X = ");
scanf("%d", &X);
printf("Y = ");
scanf("%d", &Y);

printf("Nilai X dan Y sebelum pemanggilan prosedur : \n");

printf("X = %d\n", X);
printf("Y = %d\n\n", Y);

TambahSatu(&X, &Y);
 printf("Nilai X dan Y sesudah pemanggilan prosedur : \n");
printf("X = %d\n", X);
printf("Y = %d\n\n", Y);
}

// realisasi
void TambahSatu(int *A, int *B)
{
*A = *A + 1;
*B = *B + 1;
printf("Nilai A dan B pada prosedur tambah : \n");
printf("A : %d\n", *A);
printf("B : %d\n\n", *B);
}

Fungsi
fungsi merupakan modul program yang memberikan pengembalian nilai dari tipe tertentu seperti
tipe dasar dan tipe bentukan. parameter pada fungsi hanya merupakan parameter masukan untuk
menghasilkan nilai.
// prototype
int max(int *a, int *b)

// realisasi

int max(int *a, int *b)

{

if (a>=b)
return a;

else
return b;

contoh pengembalian nilai dari tipe dasar :

// Program tabel fungsi
// Pengembalian nilai bertipe real

#include <stdio.h>
// prototype

float F(float x, float y);

// mengembalikan nilai F(x,y)=2x*x + 3y*y - 4xy, x, y = real

main()
{

float x;
float y;

printf("==============================================\n");

printf("= x y f(x,y) =\n");

printf("==============================================\n");

x = 3.2;
y = 3.3;

while(x <= 10.0)

{

printf("= %f %f %f =\n", x,y,F(x,y)); // F(x,y) =>

pemanggilan fungsi
x = x + 0.5;

y = y + 0.5;
}

printf("==============================================\n");
}

// realisasi

float F(float x, float y)

{

return 2*x*x + 3*y*y - 4*x*y;

}

contoh pengembalian nilai dari tipe bentukan :

// Program Jam
// Menghitung Jam Setelah Ditambah Satu Detik
#include <stdio.h>

typedef struct
{

int jj;
int mm;

int dd;
}Jam; // variabel global

Jam TambahSatuDetik(Jam J); // prototype

main()

{
Jam J;

printf("Jam Pertama :\n");

printf("Jam : "); scanf("%d", &J.jj);

printf("Menit : "); scanf("%d", &J.mm);

printf("Detik : "); scanf("%d", &J.dd);

TambahSatuDetik(J); // pemanggilan fungsi

}

// realisasi

Jam TambahSatuDetik(Jam J)
{

if(J.dd + 1 < 60)

J.dd = J.dd + 1;

else
{

J.dd = 0;
if(J.mm + 1)

J.mm = J.mm + 1;
else
 {
J.mm = 0;

if(J.jj + 1 < 24)

J.jj = J.jj + 1;
else

J.jj = 0;
}

printf("Jam yang baru %d:%d:%d\n", J.jj,J.mm,J.dd);

return J;

}
dalam penerapannya, prosedur dan fungsi dapat digunakan untuk berbagai kasus yang sama. jika
prosedur tidak dapat mengembalikan nilai, maka pemrogram dapat menambahkan variabel
penampung untuk mengisikan nilai yang dihasilkan dari pengubahan fungsi ke prosedur. sedangkan
jika pemrogram mengubah prosedur ke fungsi, tidak diperlukan lagi variabel penampung tersebut,
karena seperti pengertiannya, parameter fungsi hanya berupa masukan untuk menghasilkan nilai.
jadi secara default, nilai dikembalikan oleh fungsi.
contoh :
#include <stdio.h>

// prototype
void max(int a, int b);

main()

{
int a;

int b;
int maks;

printf("Ketik nilai a : ");

scanf("%d", &a);
printf("Ketik nilai b : ");
 scanf("%d", &b);

max(a, b);
}

// realisasi

void max(int a, int b)

{

int maks; // variabel penampung yang dimaksud

if (a >= b)
maks = a;

else
maks = b;

printf("Nilai maksimal dari kedua nilai a dan b adalah : %d\n", maks); //

prosedur tidak dapat mengembalikan nilai
}
prosedur diatas jika diubah menjadi fungsi adalah sebagai berikut :
#include <stdio.h>

// prototipe
int max(int a, int b);

void main()

{
int a;

int b;

printf("Ketik nilai a : ");

scanf("%d", &a);

printf("Ketik nilai b : ");

scanf("%d", &b);
 printf("Maksimum dari dua bilangan %d\n", max(a, b)); // max(a, b) =>
pemanggilan fungsi

// realisasi
int max(int a, int b)

{
return((a>b) ? a:b); // return mengembalikan nilai

}
 Modul 5 : Array pada C

Dalam pemrograman, satu variabel hanya dapat digunakan untuk menyimpan satu nilai. terdapat
banyak kasus dimana pemrogram menggunakan banyak variabel bertipe sama. jika variabel itu
dianalogikan sebagai lemari penyimpanan pakaian, tentu sangat tidak tepat jika menggunakan
banyak lemari untuk menyimpan pakaian yang sama. akan sangat baik jika memanfaatkan laci dari
lemari untuk menyimpan(mengindeks) pakaian. array dapat didefinisikan sebagai variabel
berindeks, struktur data yang menyimpan sekumpulan elemen yang bertipe data sama, setiap
elemen tersebut diakses langsung melalui indeks. array akan mengambil lokasi memori dikomputer
secara beruntutan.
A. array sebagai variabel
B. array sebagai tipe bentukan
C. array sebagai tipe terstruktur
D. array multidimensi
E. array dinamis
contoh array sebagai variabel :
#include <stdio.h>

int main()
{
int i;
int array[7]; // array sebagai variabel
int N;

N = 7;
printf("Isi dan cetak array dengan indeks 1 s/d 7\n");
// mengisi nilai Array dengan perulangan
for (i=1; i<=N; i++)
{
array[i] = i; // mengacu kepada i, i <= 7
}

// menampilkan nilai Array

for (i=1; i<=N; i++)
{
printf("i = %d, array[i] = %d\n", i, array[i]);
}
}

contoh array sebagai tipe bentukan :

// program array
// program untuk membaca array, mencetak array dan menghitung nilai rata-ratanya

#include <stdio.h>
#define Nmaks 100 // ukuran maksimum array
typedef int arrayInt[Nmaks]; // array sebagai tipe bentukan dengan konstanta

// prototype
void bacaArray(arrayInt A, int n);
void tulisArray(arrayInt A, int n);
void hitungArray(arrayInt A, int n, float *u);

main()
{
arrayInt A;
int k;
int n;
float u;

printf("Jumlah data array : ");

scanf("%d", &n);

printf("Baca data :\n");

bacaArray(A,n);

printf("Tulis data :\n");

tulisArray(A,n);

hitungArray(A,n,&u);
printf("Rata-rata data = %.2f\n", u);
}

void bacaArray(arrayInt A, int n)

{
int i; // pencatat indeks larik

for(i=0; i<n; i++)

{
printf("Nilai A[%d] : ", i);
scanf("%d", &A[i]);
}
}

void tulisArray(arrayInt A, int n)

{
int i;

for (i=0; i<n; i++)

printf("A[%d] = %d\n", i, A[i]);
}

void hitungArray(arrayInt A, int n, float *u)

{
int i;
float jumlah;

i = 1;
jumlah = 0;
for(i=0; i<n; i++)
jumlah = jumlah + A[i];

*u = jumlah/n;
}

array sebagai tipe terstruktur :

// program array dengan struct
// program untuk membaca array, mencetak array dan menghitung nilai rata-ratanya
menggunakan struct
// struct = tipe data bentukan

#include <stdio.h>
#define Nmaks 1000 // ukuran maksimum array
struct Nilai
{
char nama[100];
float mat;
float b_ind;
float b_ing;
float rerata;
};

typedef struct Nilai un[Nmaks]; // array sebagai tipe bentukan dengan struct

void bacaNilai(un A, int n);

void tulisNilai(un A, int n);
void totalNilai(un A, int n);

main()
{
un A;
int i, n;
float u;

printf("Jumlah Data Penilaian : ");

scanf("%d", &n);

bacaNilai(A, n);
tulisNilai(A, n);
totalNilai(A, n);
}

void bacaNilai(un A, int n)

{
int i;

for (i=0; i<n; i++)

{
printf("Nama : ");
scanf("%s", &A[i].nama);
printf("Nilai Matematika : ");
scanf("%f", &A[i].mat);
printf("Nilai Bahasa Indonesia : ");
scanf("%f", &A[i].b_ind);
printf("Nilai Bahasa Inggris : ");
scanf("%f", &A[i].b_ing);
}
}

void tulisNilai(un A, int n)

{
int i;

for (i=0; i<n; i++)

{
printf("Nama : %s\n", A[i].nama);
printf("Nilai Matematika : %.2f\n", A[i].mat);
printf("Nilai Bahasa Indonesia : %.2f\n", A[i].b_ind);
printf("Nilai Bahasa Inggris : %.2f\n", A[i].b_ing);
}
}

void totalNilai(un A, int n)

// tidak diperlukan lagi variabel keluaran karena rerata sudah tercakup pada
struct
{
int i;
 for (i=0; i<n; i++)
{
A[i].rerata = (A[i].mat + A[i].b_ind + A[i].b_ing) / 3;
printf("Nama : %s\n", A[i].nama);
printf("Nilai Rata-Rata : %.2f\n", A[i].rerata);
}
}

contoh array multidimensi :

// contoh array multidimensi
// program penilaian siswa
#include <stdio.h>
#define SISWA 4
#define MAPEL 4

// prototype fungsi
void cetakArray(const int nilai[][MAPEL], int siswa, int test);
int nilaiMinimum(const int nilai[][MAPEL], int siswa, int test);
int nilaiMaksimum(const int nilai[][MAPEL], int siswa, int test);
double rerata(const int aturNilai[], int test);

int main()
{
int i;

// inisial nilai siswa untuk empat siswa (baris) dan empat mata pelajaran
(kolom)
const int nilaiSiswa[SISWA][MAPEL] =
{
{77, 68, 86, 73},
{96, 87, 89, 78},
{70, 90, 86, 81},
{80, 91, 98, 87}
};

printf("Daftar Penilaian Siswa \n");

cetakArray(nilaiSiswa, SISWA, MAPEL);
printf("\n\nNilai terendah : %d\n", nilaiMinimum(nilaiSiswa, SISWA, MAPEL));
printf("Nilai tertinggi : %d\n", nilaiMaksimum(nilaiSiswa, SISWA, MAPEL));

// perulangan untuk menampilkan nilai rerata tiap siswa

for(i = 0; i < SISWA; i++)
{
printf("Nilai rata-rata siswa ke %d adalah %.2f\n",
i, rerata(nilaiSiswa[i], MAPEL));
}

return 0;
}

// realisasi
void cetakArray(const int nilai[][MAPEL], int siswa, int test)
{
// variabel lokal
int i;
int j;

printf(" [A] [B] [C] [D]");

// perulangan baris
for (i = 0; i < siswa; i++)
{
 // perulangan kolom
printf("\nNilai Siswa [%d] ", i);
for (j = 0; j < test; j++)
{
printf("%-5d", nilai[i][j]);
}
}
}

int nilaiMinimum(const int nilai[][MAPEL], int siswa, int test)

{
// variabel lokal
int i;
int j;
int nilaiTerendah = 100; // deklarasi variabel dan nilai terendah sementara

// perulangan baris
for (i = 0; i < siswa; i++)
{
// perulangan kolom
for (j = 0; j < test; j++)
{
if (nilai[i][j] < nilaiTerendah)
{
nilaiTerendah = nilai[i][j];
}
}
}

return nilaiTerendah;
}

int nilaiMaksimum(const int nilai[][MAPEL], int siswa, int test)

{
// variabel lokal
int i;
int j;
int nilaiTertinggi;

nilaiTertinggi = 0; // nilai tertinggi sementara

// perulangan baris
for (i = 0; i < siswa; i++)
{
// perulangan kolom
for (j = 0; j < test; j++)
{
if (nilai[i][j] > nilaiTertinggi)
{
nilaiTertinggi = nilai[i][j];
}
}
}
return nilaiTertinggi;
}

double rerata(const int aturNilai[], int test)

{
// variabel lokal
int i;
int total;

total = 0; // total nilai sementara

// perulangan untuk menghitung nilai rerata tiap siswa
for (i = 0; i < test; i++)
 {
total = total + aturNilai[i];
}

return (double) total / test;

}

ketika pemrogram membuat suatu array, maka pemrogram secara otomatis telah mengalokasikan
sejumlah memori untuk ditempatkan oleh array tersebut. alokasi memori ini tidak dapat diubah
ketika program dieksekusi. dapat dikatakan bahwa contoh-contoh array yang dibuat diatas bertipe
statis. dengan penggunaan malloc dan free, array dapat diperlakukan secara dinamis, dimana
pemrogram mengalokasikan sejumlah memori tertentu dengan malloc dan kemudian dapat di
bebaskan dengan free. batas dari alokasi memori dinamis bisa lebih besar jumlahnya dari memori
fisik yang terpasang dikomputer, namun hal tersebut jarang tercapai karena memori yang tersedia
mesti dibagikan pada banyak aplikasi. operator yang sering digunakan bersama malloc dan free
adalah sizeof. sizeof merupakan fungsi untuk menghitung tipe data pada argumen dalam satuan
byte, dan hasilnya menjadi return value.
// contoh array dinamis
#include <stdio.h>
#include <stdlib.h>

int main()
{
int i;
int x[7]; // x merupakan array statis
int *y; // deklarasi array dinamis dengan pointer

// inisial x[i] dengan nilai 0

for (i = 0; i < 7; i++)
x[i] = 0;
// endfor

// mengisi kembali x[i] dengan input dari pengguna

for (i = 0; i < 7; i++)
{
printf ("Masukkan nilai i : ");
scanf ("%d", &x[i]);
}

printf("_________________\n");
printf("array statis : \n");

// penulisan x[i] dengan perulangan

for (i = 0; i < 7; i++)
printf ("i ke %d,\tx[i] = %d\n", i, x[i]);
// endfor
y = (int *)malloc(7*sizeof(int)); // mengalokasikan memori 28 byte untuk y[7]
printf("_________________\n");
printf("array dinamis : \n");
// pengisian y[i] dengan perulangan
for (i = 0; i < 7; i++)
y[i] = x[i];

// penulisan y[i] dengan perulangan

for (i = 0; i < 7; i++)
printf ("i ke %d,\ty[i] = %d\n", i, y[i]);
free (y); // free memory
}
 Modul 6 : Pengurutan Array

Algoritma pengurutan memiliki banyak jenis, namun dari pengurutan tersebut ada yang
membutuhkan pemahaman yang lebih dari yang diketahui saat ini (array). misalnya tree sort yang
membutuhkan pemahaman terhadap konsep pohon. untuk array, terdapat 4 model yang sering
digunakan, dan biasanya memiliki varian-variannya, seperti :
1. Bubble Sort
2. Selection Sort
3. Insertion Sort
4. Shell Sort
contoh programnya :
#include
#define SIZE 10

void bubbleSort (int a[], int size);

int main()
{
int a[SIZE] = {4, 3, 8, 10, 7, 11, 51, 92, 43, 74};
int i;

printf ("= BubbleSort =\n\n");

printf ("Data sebelum diurutkan :\n");
for (i = 0; i < SIZE; i++)
{
printf ("%d\t", a[i]);
}

printf ("\n");
bubbleSort (a, SIZE);

printf ("\nData setelah diurutkan :\n");

for (i = 0; i < SIZE; i++)
{
printf ("%d\t", a[i]);
}

printf ("\n");
return 0;
}

void bubbleSort (int a[], int size)

{
int i;
int elemen;
int swap;

// loop untuk mengendalikan elemen array

for (elemen = 0; elemen < size; elemen++)
{
// loop untuk kendalikan angka sebagai perbandingan per elemen
 for (i = 0; i < size - 1; i++) { // bandingkan elemen
berdekatan dengan swap jika elemen pertama lebih besar dari elemen dua if
(a[i] > a[i + 1])
{
swap = a[i];
a[i] = a[i + 1];
a[i + 1] = swap;
}
}
}
}

1. Bubble sort
pada prinsipnya melakukan proses pertukaran dengan nilai yang ada disebelahnya sampai array
tersebut terurut.
void bubbleSort (int a[], int size)
{
int i;
int elemen;
int swap;

// loop untuk mengendalikan elemen array

for (elemen = 0; elemen < size; elemen++)
{
// loop untuk kendalikan angka sebagai perbandingan per elemen
for (i = 0; i < size - 1; i++) { // bandingkan elemen
berdekatan dengan swap jika elemen pertama lebih besar dari elemen dua if
(a[i] > a[i + 1])
{
swap = a[i];
a[i] = a[i + 1];
a[i + 1] = swap;
}
}
}
}

untuk elemen ke-0, perulangan akan dilanjutkan langsung pada elemen ke-1 dengan indeks ke-0,
karena elemen ke-0 tidak bernilai. elemen ke-1 yaitu a[0] akan dibandingkan dengan a[1] dari
elemen ke-2. ternyata elemen ke-1 yang bernilai 4 lebih besar dari elemen ke-2 yang bernilai 3.
maka proses pertukaran terjadi antara elemen ke-1 dengan elemen ke-2 menjadi a[0] = 3 dan a[1] =
4. setelah itu, elemen ke-1 akan dibandingkan dengan elemen ke-3 sampai dengan ke-10. ternyata,
elemen ke-1 bernilai lebih kecil dari elemen setelahnya, maka proses pertukaran tidak terjadi lagi.
pada elemen ke-2 yaitu a[1]. nilainya saat ini telah berubah menjadi 4. maka perbandingan nilai
akan diulang lagi dari elemen ke-0 sampai ke 10. jika lebih besar maka nilainya akan ditukarkan,
begitu seterusnya.
2. Selection Sort
algoritma ini memiliki prinsip yaitu memilih elemen bernilai maksimum dari array dan
menempatkannya pada elemen terujung.
void selectionSort (int a[], int size)
// a[0] sampai a[n-1] adalah array untuk diurutkan terurut
{
int elemen;
int i;
 int maks;
int swap;

// lakukan pengulangan untuk tiap elemen array

for (elemen = 0; elemen < size; elemen++)
{
// atur kondisi maksimum pada elemen tiap elemen, dimulai dari maks =
elemen 0
maks = elemen;
// cari indeks dari elemen maksimum di dalam array a[i..size]
for (i = elemen + 1; i < size; i++)
{
if (a[i] > a[maks]) // jika i lebih besar dari elemen sebelahnya maka
tukar
{
maks = i;
}
}
// setelah kondisi maksimum didapat, maka lakukan proses pertukaran
if (maks != elemen)
{
swap = a[maks];
a[maks] = a[elemen];
a[elemen] = swap;
}
}
}

3. Insertion sort
merupakan metode pengurutan dengan cara menyisipkan elemen array pada posisi yang tepat.
pencarian posisi ini dilakukan dengan cara menyisir array. selama proses penyisiran dilakukan
pergeseran elemen array. insertion sort cocok untuk persoalan menyisipkan elemen baru kedalam
sekumpulan array yang sudah terurut.
void insertionSort (int a[], int size)
{
int elemen;
int index;
int nilai;
typedef enum {true = 1, false = 0} boolean;
boolean selesai;

for (elemen = 0; elemen <= size-1; elemen++)

{
nilai = a[elemen];
index = elemen - 1;
selesai = false;

// repeat
while (index >= 0 && (!selesai))
{
if (a[index] > nilai)
{
a[index + 1] = a[index];
index--;
}
else
selesai = true;
}
a[index + 1] = nilai; // sisipkan nilai pada tempat yang tepat
}
}

4. Shell Sort
shell sort merupakan perbaikan dari insertion sort, dimana penyisipan array dikurangi oleh
pembagian pada pola tertentu.
void shellSort (int a[], int size)
{
int step;
int start;

step = size;
while (step > 1)
{
step = step / 3 + 1;
for (start - 1; start <= step; start++)
insertionSort(a, size, start, step);
}
}

void insertionSort (int a[], int size, int start, int step)
{
int elemen;
int index;
int nilai;
typedef enum {true = 1, false = 0} boolean;
boolean selesai;

while (elemen <= size)

{
nilai = a[elemen]; // sisipkan a[elemen] kedalam bagian yang sudah terurut

// cari posisi yang tepat untuk nilai didalam a[start..i-1] sambil

menggeser
index = elemen - step;
selesai = false;
while (index >= 0 && (!selesai))
{
if (a[index] > nilai)
{
a[index + step] = a[index];
index = index - step;
}
else
selesai = true;
}
// i < 1 atau selesai
a[index + step] = nilai; // sisipkan nilai pada tempat yang tepat
elemen = elemen + step;
}
}
 Modul 7 : Pencarian Array

Dalam algoritma pencarian dikenal ada dua model pencarian yang sering digunakan yaitu pencarian
beruntun (sequential search) dan pencarian bagi dua (binary search).
A. Sequential Search
pada prinsipnya pencarian beruntun membandingkan setiap elemen array satu persatu secara
beruntun. misalnya diberikan sederet angka 9, 10, 8, 6, 2, 1 dan diminta untuk mencari nilai 2, maka
komputer akan membandingkan nilai yang diberikan dengan nilai yang terdapat pada array, 9, 10, 8,
6 lalu 2 ditemukan. diketahui bahwa model pencarian beruntun ini ada dua yaitu :
int sequentialSearch(const int array[], int kunci, int n) {

int i;

// lakukan perulangan hingga kunci ditemukan

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

if (array[i] == kunci) {

return i;

return -1;

B. Binary Search
Binary Search terinspirasi dari pencarian yang kita lakukan sehari-hari, ketika kita mencari halaman
dari suatu buku, kita akan membuka buku tersebut menjadi dua bagian, kemudian kita akan melihat
halaman buku tersebut apakah lebih besar, lebih kecil atau sudah tepat. jika lebih besar atau lebih
kecil dari halaman yang kita cari, maka kita akan membagi kembali buku tersebut menjadi dua
bagian lagi sampai halaman yang dicari ditemukan.
int binarySearch(const int b[], int kata_kunci, int rendah, int tinggi) {

int tengah;

while (rendah <= tinggi) {

// menentukan elemen tengah dari subarray dalam pencarian

tengah = (rendah + tinggi) / 2;

// jika kata_kunci tepat dari elemen tengah, kembali ke tengah

if(kata_kunci == b[tengah]) {
return tengah;
}
// jika kata_kunci dari elemen tengah, set tinggi
else if ( kata_kunci < b[tengah]) {
tinggi = tengah -1;
}

// jika kata_kunci lebih besar dari elemen tengah, set rendah

else {
rendah = tinggi + 1; // pencarian tinggi dari array
}
}
return -1; // kata_kunci tidak ditemukan
}
Referensi :
Rinaldi Munir, Algoritma dan Pemrograman Pascal dan C
Dietel C/C++