Pencarian‌‌dan‌‌Pengurutan‌ ‌
(‌Searching‌‌and‌‌Sorting‌) ‌ ‌
Oleh‌‌:‌T
‌ im‌‌Penyusun‌‌MKU‌‌Pengantar‌‌Coding.‌  ‌
 ‌
 ‌
 ‌
 ‌
A. Capaian‌‌Pembelajaran‌  ‌
Mampu menjelaskan‌  ‌dan‌  ‌menerapkan‌  ‌konsep pencarian‌  ‌dan pengurutan‌‌
  data‌‌
  menggunakan‌  ‌metode‌‌
 
tertentu (P3,KU1,KU5,KU9)‌  ‌
 ‌
B. Indikator‌‌Pencapaian‌‌Kompetensi‌  ‌
Untuk‌  ‌mencapai‌  ‌kompetensi‌  ‌yang‌  ‌diharapkan,‌  ‌ditetapkan‌  ‌indikator‌  ‌sebagai‌  ‌berikut,‌  ‌Mahasiswa‌‌
 
mampu/dapat‌‌: ‌ ‌
●‌‌ketepatan‌‌menjelaskan‌‌konsep dan‌‌prinsip‌‌pencarian‌‌data‌‌dan‌‌pengurutan‌‌data‌  ‌
●‌‌ketepatan‌‌menuliskan‌‌kode‌‌untuk‌‌pencarian‌‌dan‌‌pengurutan data‌  ‌
●‌‌menyusun‌‌algoritma dan‌‌pemrograman‌‌untuk masalah‌‌pencarian‌‌dan‌‌pengurutan‌‌data‌  ‌
 ‌
C. Pokok‌‌–‌‌Pokok‌‌Materi‌  ‌
1. Konsep dan‌‌prinsip‌‌dalam‌‌pencarian‌‌data‌‌pengurutan data,‌‌
   ‌
2. Metode‌‌pencarian‌‌beruntun‌‌dan‌‌pencarian‌‌bagi‌‌dua,‌   ‌ ‌
3. Macam‌‌dan‌‌jenis‌‌metode‌‌pencarian‌‌dan‌‌pengurutan‌‌data,‌‌
   ‌
4. Menuliskan‌‌algoritma dan‌‌pemrograman‌‌untuk masalah‌‌pengurutan‌‌data‌  ‌
 ‌
D. Uraian‌‌Materi‌‌P
‌ encarian‌‌dan‌‌Pengurutan‌‌(S
‌ earching‌‌and‌‌Sorting‌) ‌ ‌
Aktifitas‌‌pencarian‌‌dan‌‌pengurutan‌‌(searching‌‌dan‌‌sorting)‌‌merupakan‌‌hal‌‌yang‌‌sering‌‌dilakukan‌‌
 
dalam‌‌dunia‌‌komputer.‌‌Kita‌‌acap‌‌kali‌‌menggunakan‌‌mesin‌‌pencari‌‌seperti‌‌google‌‌chrome,‌‌mozila‌‌firefox‌‌
 
dan‌‌lain-lain‌‌untuk‌‌mencari‌‌informasi‌‌di‌‌internet.‌‌Bahkan,‌‌dalam‌‌berbagai‌‌aplikasi‌‌sistem‌‌informasi,‌‌
 
 ‌
aktifitas‌‌ini‌‌menjadi‌‌fasilitas‌‌yang‌‌wajib‌‌ada.‌‌Berbagai‌‌kebutuhan‌‌akan‌‌informasi‌‌atau‌‌data,‌‌melibatkan‌‌
 
aktifitas‌‌pencarian‌‌dan‌‌atau‌‌pengurutan.‌  ‌
1. Pencarian‌‌(S
‌ earching‌) ‌ ‌
Searching‌‌
 atau‌‌
 pencarian‌‌
 data‌‌
 sering‌‌
 dilakukan‌‌
 untuk‌‌
 menyelesaikan‌‌
 suatu‌‌
 masalah‌‌
 dalam‌‌
 
pemrograman.‌  ‌Berbagai‌  ‌teknik‌  ‌pencarian‌  ‌juga‌  ‌telah‌  ‌banyak‌  ‌dikembangkan‌  ‌para‌  ‌ahli‌  ‌dan‌  ‌digunakan‌‌
 
secara‌‌luas‌‌pada‌‌berbagai‌‌aplikasi‌‌program‌‌komputer.‌‌
  Definisi‌‌
 tentang‌‌
 pencarian‌‌
 adalah‌‌
 bila‌‌
 diberikan‌‌
 
larik‌  ‌(a‌ rray‌) ‌ ‌L ‌ ‌yang‌  ‌sudah‌  ‌terdefinisi‌  ‌elemen-elemennya,‌  ‌dan‌  ‌X ‌ ‌adalah‌  ‌elemen‌  ‌bertipe‌  ‌sama‌  ‌dengan‌‌
 
elemen‌  ‌larik‌  ‌L.‌  ‌Mencari‌  ‌X ‌ ‌di‌  ‌dalam‌  ‌larik‌  ‌L.‌  ‌Pencarian‌  ‌adalah‌  ‌memeriksa‌  ‌keberadaan‌  ‌X.‌  ‌Hasil‌  ‌atau‌‌
 
keluaran‌‌
  pencarian‌‌
  dapat‌‌
  berupa‌‌
  pesan‌‌
  (m
‌ essage‌) ‌‌bahwa‌‌
  X ‌‌ditemukan‌‌
  atau‌‌
  tidak‌‌
  ditemukan‌‌
 dalam‌‌
 larik.‌‌
 
Hasil‌  ‌pencarian‌  ‌juga‌  ‌bisa‌  ‌berupa‌  ‌nilai‌  ‌boolean‌. ‌‌Untuk‌‌
  memahami‌‌
  bagaimana‌‌
  pencarian‌‌
  data‌‌
  dilakukan,‌‌
 
kita‌‌
  akan‌‌
 bahas‌‌
 teknik‌‌
 pencarian‌‌
 paling‌‌
 sederhana‌‌
 yang‌‌
 disebut‌‌
 Pencarian‌‌
 ‌Sequensial‌‌
 atau‌‌
 ‌Linear‌. ‌‌Contoh‌‌
 
metode‌‌adalah‌‌pencarian‌‌beruntun‌‌(s‌ equensial‌‌search‌)‌‌dan‌‌metode‌‌pencarian‌‌b‌ agi-dua‌‌(b‌ inary‌‌search‌).‌  ‌
 ‌
1.1. Metode‌‌Pencarian‌‌Beruntun/Linear‌‌(S
‌ equential‌‌Search‌) ‌ ‌ ‌
Metode‌  ‌pencarian‌  ‌beruntun‌  ‌(s‌ equential‌  ‌search‌) ‌ ‌atau‌  ‌pencarian‌  ‌lurus‌  ‌(l‌inear‌  ‌search‌),‌  ‌adalah‌‌
 
proses‌  ‌pencarian‌  ‌yang‌  ‌sangat‌  ‌sederhana‌  ‌dengan‌  ‌cara‌  ‌membandingkan‌  ‌setiap‌  ‌elemen‌  ‌larik‌  ‌(a‌ rray‌) ‌ ‌satu‌‌
 
persatu‌  ‌secara‌  ‌beruntun,‌  ‌mulai‌‌
  dari‌‌
  elemen‌‌
  pertama‌‌
  sampai‌‌
  elemen‌‌
  yang‌‌
  dicari‌‌
  ditemukan,‌‌
  atau‌‌
  seluruh‌‌
 
elemen‌  ‌telah‌  ‌diperiksa.‌  ‌Terdapat‌  ‌dua‌  ‌versi‌  ‌algoritma‌  ‌pencarian‌  ‌beruntun‌  ‌atau‌‌
  pencarian‌‌
  linear.‌‌
  Versi-1,‌‌
 
adalah‌  ‌pembandingan‌  ‌elemen‌  ‌dilakukan‌  ‌diawal‌  ‌pengulangan.‌  ‌Sedangkan‌‌
  versi-2,‌‌
  adalah‌‌
  pembandingan‌‌
 
elemen‌‌dilakukan‌‌di‌‌dalam‌‌badan‌‌pengulangan.‌‌
   ‌
Diumpamakan,‌‌kita‌‌memiliki‌‌sekumpulan‌‌data‌‌dalam‌‌suatu‌‌array‌‌seperti‌‌berikut:‌  ‌
data‌  ‌
70‌  ‌ 65‌  ‌ 85‌  ‌ 44‌  ‌ 75‌  ‌ 25‌  ‌ 55‌  ‌ 10‌  ‌ 50‌  ‌
‌0‌ ‌1‌ ‌2‌ ‌3‌ ‌4‌ ‌5‌ ‌6‌ ‌7‌ ‌8 ‌ ‌
Visualisasi‌‌
  data‌‌
  array‌‌
  di‌‌
  atas‌‌
  yang‌‌
  bernama‌‌
 ‌data‌‌
 dan‌‌
 bertipe‌‌
 integer‌‌
 dan‌‌
 kita‌‌
 mendeklarasikannya‌‌
 dengan‌‌
 
cara‌‌sebagai‌‌berikut:‌ Int‌‌‌data‌[9‌ ]‌ ;‌  ‌
Array‌  ‌di‌  ‌atas‌  ‌bernama‌  ‌data‌, ‌ ‌terdiri‌‌
  dari‌‌
  9 ‌‌elemen‌‌
  mulai‌‌
  nomor‌‌
  indeks‌‌
  0 ‌‌hingga‌‌
  indeks‌‌
  8,‌‌
  tipe‌‌
  data‌‌
  dari‌‌
 
array‌‌berupa‌‌tipe‌‌integer‌‌(int).‌  ‌
Dalam‌‌
  pencarian‌‌
  beruntun,‌‌
  data‌‌
 yang‌‌
 dicari‌‌
 disimpan‌‌
 pada‌‌
 suatu‌‌
 variable,‌‌
 misalnya‌‌
 ‌data_dicari‌‌
 
yang‌‌
  harus‌‌
  dideklarasikan‌‌
  sebagai‌‌
  variable‌‌
  bertipe‌‌
  integer‌‌
  juga.‌‌
 Setelah‌‌
 ‌data_dicari‌‌
 memiliki‌‌
 nilai‌‌
 (nilai‌‌
 
yang‌  ‌akan‌‌
  dicari‌‌
  dalam‌‌
  array),‌‌
  maka‌‌
  kita‌‌
  membandingkan‌‌
  setiap‌‌
  data‌‌
  pada‌‌
  array‌‌
  mulai‌‌
  dari‌‌
  indeks‌‌
  ke-0‌‌
 
hingga‌‌
  indeks‌‌
  terakhir.‌‌
 Bila‌‌
 ‌data_dicari‌‌
 adalah‌‌
 ‌sama‌‌
 dengan‌‌
 suatu‌‌
 data‌‌
 pada‌‌
 indeks‌‌
 tertentu,‌‌
 berarti‌‌
 data‌‌
 
ditemukan,‌‌maka‌‌posisi‌‌indeks‌‌lokasi‌‌data‌‌yang‌‌dicari‌‌tersebut‌‌mesti‌d
‌ icatat‌‌‌dan‌‌pencarian‌‌dihentikan.‌  ‌
 ‌
Salah‌  ‌satu‌  ‌bentuk‌  ‌algoritma‌  ‌pencarian‌‌
  beruntun/linier‌‌
  adalah‌‌
  seperti‌‌
  berikut,‌‌
  dimana‌‌
  pencarian‌‌
 
dilakukan‌‌
  terhadap‌‌
  suatu‌‌
  ‌array-A‌‌
  dan‌‌
  nilai‌‌
  yang‌‌
  dicari‌‌
  adalah‌‌
  x.‌ ‌ ‌Algoritma‌‌
 berikut‌‌
 ditulis‌‌
 dalam‌‌
 bentuk‌‌
 
algoritma‌b‌ ahasa‌‌verbal‌‌‌dan‌‌algoritma‌k
‌ ode‌‌semu‌‌‌(‌pseudo-code‌)‌‌: ‌ ‌
Algoritma‌‌Pencarian‌‌Linier‌‌(Array‌‌A,‌‌Nilai‌‌x)‌  ‌
Langkah‌‌1:‌‌di‌‌awali‌‌dengan‌S ‌ etel‌‌i‌‌ke‌‌1 ‌ ‌
Langkah‌‌2:‌j‌ika‌‌i‌ ‌>‌‌n‌‌maka‌‌lanjutkan‌‌ke‌‌langkah‌‌7 ‌ ‌
Langkah‌‌3:‌j‌ika‌‌A[i]‌‌=‌‌x‌‌maka‌‌lanjutkan‌‌ke‌‌langkah‌‌6 ‌ ‌
Langkah‌‌4:‌‌Setel‌‌i‌‌ke‌‌posisi‌‌‌i‌‌+‌‌1 ‌ ‌
Langkah‌‌5:‌‌Lanjutkan‌‌ke‌‌Langkah‌‌2 ‌ ‌
Langkah‌‌6:‌‌Elemen‌C ‌ etak‌‌x‌ ‌Ditemukan‌‌‌di‌‌indeks‌k‌ e-‌‌i‌‌dan‌‌lanjutkan‌‌ke‌l‌angkah‌‌8 ‌ ‌
Langkah‌‌7:‌‌Elemen‌‌cetak‌‌tidak‌‌ditemukan‌  ‌
Langkah‌‌8:‌‌Keluar‌  ‌
 ‌
Pseudocode‌‌(Kode‌‌Semu)‌  ‌
prosedur‌‌linear_search‌‌(daftar,‌‌nilai)‌  ‌
awal_prosedur‌  ‌
‌untuk‌‌setiap‌‌item‌‌dalam‌‌daftar‌  ‌
‌jika‌‌cocok‌‌item‌‌==‌‌nilai‌  ‌
‌mengembalikan‌‌lokasi‌‌item‌  ‌
‌berakhir‌‌jika‌  ‌
‌berakhir‌‌untuk‌  ‌
akhir_prosedur‌  ‌
Untuk‌‌mengetahui‌‌tentang‌‌implementasi‌‌pencarian‌‌linier‌‌dalam‌‌bahasa‌‌pemrograman‌‌C ‌ ‌
Misalnya‌  ‌kita‌  ‌memiliki‌  ‌array‌  ‌bernama‌  ‌data‌‌
  dengan‌‌
  banyak‌‌
  elemen‌‌
  6 ‌‌(N=6).‌‌
  array‌‌
  diisi‌‌
  secara‌‌
  langsung‌‌
 
dari‌‌dalam‌‌program‌‌dengan‌‌contoh-contoh‌‌nilai‌‌sembarang.‌  ‌
Langkah‌  ‌pertama‌  ‌dalam‌  ‌menyusun‌  ‌program‌  ‌adalah‌  ‌dengan‌‌
  menetapkan‌‌
  konstanta‌‌
  N ‌‌berupa‌‌
  banyaknya‌‌
 
elemen‌‌array,‌‌seperti‌‌berikut:‌   ‌ #‌ define‌‌N‌‌6 ‌ ‌
Kemudian‌‌
  kita‌‌
  deklarasikan‌‌
  suatu‌‌
  variabel‌‌
  global‌‌
  bernama‌‌
  data‌‌
  yang‌‌
  berupa‌‌
  array‌‌
 dengan‌‌
 N ‌‌elemen‌‌
 dan‌‌
 
bertipe‌i‌nt‌,‌‌sebagai‌‌berikut:‌ int‌‌data‌[N
‌ ]‌ ;‌  ‌
Fungsi‌  ‌yang‌  ‌kita‌  ‌buat‌‌
  hanyalah‌‌
  fungsi‌‌
  ‌main‌( ‌‌) ‌‌yang‌‌
  di‌‌
  dalamnya‌‌
  dideklarasikan‌‌
  beberapa‌‌
  variabel‌‌
  yang‌‌
 
dibutuhkan‌‌sebagai‌‌berikut:‌  ‌
int‌‌i;‌ ‌//untuk‌‌menyimpan‌‌nomor‌‌indeks‌‌perulangan‌  ‌
int‌‌tanda;‌ //nilai‌‌0‌‌berarti‌‌data‌‌yg‌‌dicari‌‌tidak‌‌ditemukan‌‌dan‌‌nilai‌‌1‌‌berarti‌‌ditemukan‌ 
int‌‌posisi;‌ ‌//variabel‌‌untuk‌‌menyimpan‌‌lokasi‌‌atau‌‌posisi‌‌dimana‌‌data‌‌ditemukan‌  ‌
int‌‌dataDicari;‌‌
  //variabel‌‌untuk‌‌menyimpan‌‌data‌‌yang‌‌akan‌‌dicari‌  ‌
Kemudian‌‌kita‌‌isi‌‌array‌‌secara‌‌langsung‌‌dengan‌‌nilai-nilai‌‌sembarang,‌‌misal:‌  ‌
data[0]‌‌=‌‌70;‌‌
  data[1]‌‌=‌‌30;‌ data[2]‌‌=‌‌45;‌‌   data[3]‌‌=‌‌10;‌  ‌
data[4]‌‌=‌‌80;‌ data[5]‌‌=‌‌50;‌  ‌
Setelah‌  ‌data‌  ‌terisi,‌  ‌kemudian‌  ‌kita‌  ‌meminta‌  ‌user‌  ‌memasukkan‌  ‌data‌  ‌yang‌  ‌ingin‌  ‌dicari‌  ‌dan‌  ‌ditangkap‌‌
 
melalui‌  ‌variabel‌  ‌dataDicari‌. ‌ ‌Data‌  ‌yang‌  ‌akan‌  ‌dicari‌  ‌kemudian‌  ‌dicocokan‌  ‌dengan‌  ‌setiap‌  ‌elemen‌  ‌pada‌‌
 
 ‌
array,‌  ‌jika‌  ‌data‌  ‌tersebut‌  ‌sama‌  ‌dengan‌  ‌dataDicari‌, ‌ ‌maka‌  ‌tanda‌  ‌diberi‌  ‌nilai‌  ‌1 ‌ ‌dan‌  ‌posisinya‌  ‌dicatat‌  ‌lalu‌‌
 
pencarian‌‌
  dihentikan,‌‌
  jika‌‌
  datanya‌‌
  tidak‌‌
  sama,‌‌
  maka‌‌
  tanda‌‌
  diberi‌‌
  nilai‌‌
  0 ‌‌dan‌‌
  pencarian‌‌
 serta‌‌
 pencocokan‌‌
 
dilanjutkan‌‌ke‌‌elemen‌‌berikut.‌‌Demikian‌‌dilakukan‌‌hingga‌‌data‌‌mencapai‌‌elemen‌‌terakhir.‌‌
   ‌
Perhatikan‌‌potongan‌‌program‌‌berikut‌‌ini:‌‌
   ‌
printf("Ketikkan‌‌data‌‌yang‌‌dicari:‌‌");‌  ‌
scanf("%d",‌‌&dataDicari);‌‌fflush(stdin);‌  ‌
 ‌
for(i=0;i<N;++i)‌  ‌
{‌  ‌
if(dataDicari‌‌==‌‌data[i])‌  ‌
{‌  ‌
posisi‌‌=‌‌i;‌‌
  //catat‌‌posisi‌‌data‌‌yg‌‌ditemukan‌  ‌
tanda‌‌=‌‌1;‌ ‌//1‌‌berarti‌‌TRUE‌‌artinya‌‌ditemukan‌  ‌
break;‌‌
  //keluar‌‌atau‌‌selesai‌‌pencarian‌  ‌
‌} ‌ ‌
else‌‌tanda‌‌=‌‌0;‌‌  //0‌‌berarti‌‌FALSE‌‌artinya‌‌tidak‌‌ditemukan‌  ‌
}‌  ‌
if(tanda)‌ ‌//jika‌‌ditemukan,‌‌maka‌‌tuliskan‌  ‌
‌{ ‌ ‌
printf("Data‌‌ditemukan,‌‌yaitu‌‌%d‌‌pada‌‌posisi‌‌%d\n‌‌",‌‌data[posisi],‌‌posisi);‌  ‌
‌} ‌ ‌
else‌ ‌//jika‌‌tidak‌‌ditemukan‌  ‌
{‌  ‌
printf("Data‌‌tidak‌‌ditemukan\n");‌  ‌
Bentuk‌‌kode‌‌lengkap‌‌dari‌‌penyelesaian‌‌masalah‌‌dapat‌‌dilihat‌‌dalam‌‌implementasi‌‌bahasa‌‌C/C++‌‌berikut:‌‌
   ‌
 ‌

 ‌

Contoh‌‌hasil‌‌eksekusi‌‌adalah‌‌:  
‌ ‌

 ‌

Contoh‌‌Kasus:‌  ‌
Buatlah‌  ‌sebuah‌  ‌program‌  ‌yang‌  ‌digunakan‌‌
  untuk‌‌
  mengisi,‌‌
  mencari‌‌
  dan‌‌
  menampilkan‌‌
  informasi.‌‌
  Program‌‌
 
harus‌‌modular‌‌atau‌‌terdiri‌‌dari‌‌fungsi-fungsi‌‌yang‌‌dibutuhkan.‌‌
   ‌
Analisi‌‌Kebutuhan:‌  ‌

✔ Penguraian‌‌masalah:‌  ‌
 ‌
Masalah‌‌dalam‌‌contoh‌‌kasus‌‌ini‌‌dapat‌‌dibagi‌‌menjadi‌‌beberapa‌‌masalah‌‌lebih‌‌kecil,‌‌yaitu:‌  ‌

◆ Masalah‌‌entri‌‌sejumlah‌‌data‌‌sesuai‌‌kebutuhan‌‌(atau‌‌ditetapkan‌‌sebagai‌‌ukuran‌‌array‌‌data.‌‌Kita‌‌
 
akan‌‌mengimplementasi‌‌fungsi‌‌entri‌‌data‌‌atau‌ i‌siNilai‌(‌‌) ‌ ‌
◆ Masalah‌‌mencari‌‌data‌‌tertentu‌‌sesuai‌‌keinginan‌‌dan‌‌akan‌‌dijadikan‌‌fungsi‌‌pencarian,‌‌misal‌‌
 
bernama‌c‌ ariNilai‌(‌‌) ‌ ‌
◆ Masalah‌‌menampilkan‌‌seluruh‌‌isi‌‌array‌‌dapat‌‌diimplemetasikan‌‌sebagai‌‌fungsi‌‌untuk‌‌
 
menampilkan‌‌dapat‌‌diberi‌‌nama‌‌fungsi‌t‌ampilkan‌(‌‌) ‌ ‌
✔ Kebutuhan‌‌konstanta‌‌:‌‌Konstanta‌‌yang‌‌didefinisikan‌‌bernama‌‌N‌‌dengan‌‌nilai‌‌tertentu,‌‌misal‌‌11.‌  ‌
✔ Kebutuhan‌‌variabel‌‌global‌‌:  ‌‌ ‌
Untuk‌‌menyimpan‌‌seluruh‌‌data‌‌dan‌‌dapat‌‌diakses‌‌dari‌‌seluruh‌‌tempat‌‌pada‌‌program,‌‌dibutuhkan‌‌
 
variabel‌‌array,‌‌misal‌‌bernama‌‌nilai[]‌‌bertipe‌‌double‌‌dengan‌‌jumlah‌‌elemen‌‌sebanyak‌‌N‌‌buah.‌  ‌

✔ Fungsi‌‌isiNilai‌‌dapat‌‌berupa:‌  ‌
void‌‌isiNilai()‌  ‌

{‌  ‌

double‌‌nilainya;‌  ‌

int‌‌i;‌  ‌

printf("\nMENGENTRI‌‌NILAI\n");‌  ‌

for(i=0;i<N;++i)‌  ‌

{‌  ‌

printf("\nKetikkan‌‌nilai‌‌ke-%d:‌‌",‌‌i);‌  ‌

scanf("%lf",‌‌&nilainya);‌  ‌

nilai[i]‌‌=‌‌nilainya;‌  ‌

}‌  ‌

printf("\nEntri‌‌Nilai‌‌selesai\n");‌  ‌

printf("Tekan‌‌tombol‌‌ENter!!!!");‌  ‌

getch();‌  ‌

}‌  ‌

✔ Fungsi‌ ‌cariNilai()‌‌dapat‌‌berupa:‌  ‌
void‌‌cariNilai()‌  ‌

{‌  ‌
 ‌
double‌‌nilainya;‌  ‌

int‌‌i,‌‌posisi,‌‌tanda;‌ ‌//‌‌deklarasi‌‌variabel‌i‌‌‌,‌‌variabel‌ p‌ osisi‌,‌‌dan‌‌variabel‌t‌anda‌  ‌

printf("\nKetikan‌‌nilai‌‌yang‌‌dicari:‌‌");‌ ‌//‌‌Meminta‌‌masukan‌‌nilai‌ ‌yang‌‌dicari‌  ‌

scanf("%lf",‌‌&nilainya);‌  ‌

//mulai‌‌mencari‌  ‌

for(i=0;i<N;++i)‌  ‌

{‌  ‌

if(nilai[i]‌‌==‌‌nilainya)‌  ‌

 ‌

tanda‌‌=‌‌1;‌‌//data‌‌ditemukan‌  ‌

posisi‌‌=‌‌i;‌  ‌

break;‌  ‌

}‌  ‌

else‌  ‌

{‌  ‌

tanda‌‌=‌‌0;‌‌//tdk‌‌ditemukan‌  ‌

continue;‌  ‌

}‌  ‌

}‌  ‌

if(tanda)‌  ‌

{‌  ‌

printf("\nData‌‌ditemukan‌‌pada‌‌posisi:‌‌%d\n",posisi);‌  ‌

}‌  ‌

else‌  ‌

{‌  ‌

printf("\nData‌‌tidak‌‌ditemukan\n");‌  ‌

}‌  ‌

}‌  ‌

✔ Fungsi‌‌tampilkan()‌‌dapat‌‌dibuat‌‌seperti‌‌berikut:‌  ‌
 ‌
void‌‌tampilkan()‌  ‌

{‌  ‌

int‌‌i;‌  ‌

 ‌

printf("\nDAFTAR‌‌NILAI\n\n");‌  ‌

for(i=0;i<N;++i)‌  ‌

{‌  ‌

printf("Nilai‌‌pada‌‌posisi‌‌%d:‌‌%0.2lf\n",‌‌i,‌‌nilai[i]);‌  ‌

}‌  ‌

printf("\nSelesai!!!‌‌Tekan‌‌tombol‌‌Enter...");‌  ‌

getch();‌  ‌

}‌  ‌

Implementasi‌‌lengkap‌‌dalam‌‌C‌‌untuk‌‌kasus‌‌di‌‌atas‌‌adalah‌‌sebagai‌‌berikut:‌  ‌

/*‌‌
  Program‌‌Cari‌‌nilai‌‌yg‌‌ditentukan‌ ‌*/‌  ‌
#include‌‌<stdio.h>‌  ‌
#define‌‌N‌‌8 ‌ ‌
void‌‌isiNilai();‌  ‌
void‌‌cariNilai();‌  ‌
void‌‌tampilkan();‌  ‌
double‌‌nilai[N];‌  ‌
 ‌
main()‌‌{ ‌ ‌
isiNilai();‌  ‌
tampilkan();‌  ‌
cariNilai();‌  ‌
}‌  ‌
void‌‌isiNilai()‌‌{ ‌
double‌‌nilainya;‌ ‌int‌‌i;‌  ‌
printf("\n\n‌ ‌PROGRAM‌‌PENCARIAN‌‌DATA‌‌DALAM‌‌LARIK‌‌(ARRAY)‌ ‌\n");‌  ‌
printf("\nMENGENTRI‌‌NILAI\n");‌  ‌
 ‌
for(i=0;i<N;++i)‌‌{ ‌ ‌
printf("\nKetikkan‌‌nilai‌‌ke-%d:‌‌",‌‌i);‌  ‌
scanf("%lf",‌‌&nilainya);‌  ‌
nilai[i]‌‌=‌‌nilainya;‌  ‌
}‌  ‌
printf("\nEntri‌‌Nilai‌‌selesai\n");‌  ‌
printf("Tekan‌‌tombol‌‌ENter!!!!");‌  ‌
getch();‌  ‌
}‌  ‌
void‌‌cariNilai()‌‌{ ‌ ‌
double‌‌nilainya;‌  ‌
int‌‌i,‌‌posisi,‌‌tanda;‌  ‌
printf("\nKetikan‌‌nilai‌‌yg‌‌dicari:‌‌");‌  ‌
scanf("%lf",‌‌&nilainya);‌  ‌
//mulai‌‌mencari‌  ‌
for(i=0;i<N;++i)‌‌{ ‌ ‌
if(nilai[i]‌‌==‌‌nilainya)‌‌{ ‌ ‌
tanda‌‌=‌‌1;‌‌//data‌‌ditemukan‌  ‌
posisi‌‌=‌‌i;‌  ‌
break;‌  ‌
}‌  ‌
else‌‌{ ‌ ‌
tanda‌‌=‌‌0;‌‌//tdk‌‌ditemukan‌  ‌
continue;‌  ‌
}‌  ‌
}‌  ‌
if(tanda)‌‌{ ‌ ‌
printf("\nData‌‌ditemukan‌‌pada‌‌posisi:‌‌%d\n",posisi);‌  ‌
}‌  ‌
else‌‌{ ‌ ‌
printf("\nData‌‌tidak‌‌ditemukan\n");‌  ‌
 ‌
}‌  ‌
}‌  ‌
 ‌
void‌‌tampilkan()‌‌{ ‌ ‌
int‌‌i;‌  ‌
printf("\nDAFTAR‌‌NILAI\n\n");‌  ‌
for(i=0;i<N;++i)‌  ‌
{‌  ‌
printf("Nilai‌‌pada‌‌posisi‌‌%d:‌‌%0.2lf\n",‌‌i,‌‌nilai[i]);‌  ‌
}‌  ‌
printf("\nSelesai!!!‌‌Tekan‌‌tombol‌‌Enter...");‌  ‌
getch();‌  ‌
}‌  ‌
Bentuk‌‌program‌‌dalam‌‌bahasa‌‌C++‌ ‌(‌‌DEV_C++)‌‌sebagai‌‌berikut,‌‌dengan‌‌menyesuaikan‌‌
 
statemen‌g‌ etch‌(),‌‌diganti‌‌dengan‌‌statemen‌‌yang‌‌setara‌g‌ etchar‌().‌‌Hasil‌‌eksekusi‌‌adalah‌‌: ‌ ‌

 ‌

Pencarian‌  ‌linier‌  ‌juga‌  ‌dapat‌  ‌digunakan‌  ‌untuk‌  ‌mencari‌  ‌semua‌  ‌data‌  ‌yang‌  ‌cocok‌  ‌pada‌  ‌sekelompok‌  ‌data.‌‌
 
Perhatikan‌  ‌perubahan‌  ‌pada‌  ‌fungsi‌  ‌cariNilai‌( ‌ ‌) ‌ ‌yang‌  ‌akan‌  ‌menghasilkan‌  ‌jumlah‌  ‌data‌  ‌yang‌  ‌cocok‌‌
 
ditemukan,‌‌sebagai‌‌berikut:‌  ‌

void‌c‌ ariNilai‌()‌  ‌
 ‌
{‌   ‌
double‌‌nilainya;‌  ‌
int‌‌i,‌‌konter,‌‌posisi,‌‌tanda;‌  ‌
printf("\nKetikan‌‌nilai‌‌yg‌‌dicari:‌‌");‌  ‌
scanf("%lf",‌‌&nilainya);‌  ‌
//mulai‌‌mencari‌  ‌
konter‌‌=‌‌0;‌  ‌
for(i=0;i<N;++i)‌  ‌
{‌  ‌
if(nilai[i]‌‌==‌‌nilainya)‌  ‌
{‌  ‌
konter++;‌  ‌
tanda‌‌=‌‌1;‌  ‌
printf("\nData‌‌ke-%d‌‌ada‌‌pada‌‌posisi:‌‌%d",konter,‌‌i);‌  ‌
‌} ‌ ‌
else‌  ‌
{‌  ‌
tanda‌‌=‌‌0;‌‌//tdk‌‌ditemukan‌  ‌
continue;‌  ‌
}‌  ‌
}‌  ‌
if(konter)‌  ‌
{‌  ‌
printf("\nData‌‌ditemukan‌‌sebanyak‌‌%d‌‌buah...\n",‌‌konter);‌  ‌
}‌  ‌
else‌  ‌
{‌  ‌
printf("\nData‌‌tidak‌‌ditemukan...‌‌\n");‌  ‌
}‌  ‌
}‌  ‌
Fungsi‌‌ini‌‌akan‌‌menuliskan‌‌ke‌‌layar‌‌berapa‌‌banyak‌‌data‌‌yang‌‌cocok‌‌dengan‌‌data‌‌yang‌‌dicari.‌  ‌
 ‌
Implementasi‌‌lengkap‌‌dalam‌‌C‌‌dapat‌‌dilihat‌‌pada‌‌barisan‌‌program‌‌berikut:‌  ‌

/*‌ ‌Cari‌‌nilai‌‌yg‌‌ditentukan‌ ‌*/‌  ‌

#include‌‌<stdio.h>‌  ‌
#define‌‌N‌‌8 ‌ ‌
void‌‌isiNilai();‌  ‌
void‌‌cariNilai();‌  ‌
void‌‌tampilkan();‌  ‌
double‌‌nilai[N];‌  ‌
 ‌
main()‌‌{‌  ‌
isiNilai();‌  ‌
tampilkan();‌  ‌
cariNilai();‌  ‌
‌} ‌ ‌
 ‌
void‌i‌siNilai‌()‌{‌  ‌ ‌
double‌‌nilainya;‌  ‌
int‌‌i;‌  ‌
printf("\nMENGENTRI‌‌NILAI\n");‌  ‌
for(i=0;i<N;++i)‌‌{ ‌ ‌
printf("\nKetikkan‌‌nilai‌‌ke-%d:‌‌",‌‌i);‌  ‌
scanf("%lf",‌‌&nilainya);‌  ‌
nilai[i]‌‌=‌‌nilainya;‌  ‌
‌} ‌ ‌
printf("\nEntri‌‌Nilai‌‌selesai\n");‌  ‌
printf("Tekan‌‌tombol‌‌ENter!!!!");‌  ‌
getch();‌  ‌
‌} ‌ ‌
 ‌
void‌c‌ ariNilai‌()‌ ‌{ ‌ ‌
double‌‌nilainya;‌  ‌
 ‌
int‌‌i,‌‌konter,‌‌posisi,‌‌tanda;‌  ‌
printf("\nKetikan‌‌nilai‌‌yg‌‌dicari:‌‌");‌  ‌
scanf("%lf",‌‌&nilainya);‌  ‌
//mulai‌‌mencari‌  ‌
konter‌‌=‌‌0;‌  ‌
for(i=0;i<N;++i)‌ ‌{ ‌ ‌
if(nilai[i]‌‌==‌‌nilainya)‌‌{ ‌ ‌
konter++;‌  ‌
tanda‌‌=‌‌1;‌  ‌
printf("\nData‌‌ke-%d‌‌ada‌‌pada‌‌posisi:‌‌%d",konter,‌‌i);‌  ‌
‌} ‌ ‌
else‌ ‌{ ‌ ‌
tanda‌‌=‌‌0;‌‌//tdk‌‌ditemukan‌  ‌
continue;‌  ‌
‌} ‌ ‌
}‌  ‌
if(konter)‌‌{ ‌ ‌
printf("\nData‌‌ditemukan‌‌sebanyak‌‌%d‌‌buah...\n",‌‌konter);‌  ‌
}‌  ‌
else‌ ‌{ ‌ ‌
printf("\nData‌‌tidak‌‌ditemukan...‌‌\n");‌  ‌
}‌  ‌
}‌  ‌
void‌‌tampilkan‌()‌ {‌  ‌ ‌
int‌‌i;‌  ‌
printf("\nDAFTAR‌‌NILAI\n\n");‌  ‌
for(i=0;i<N;++i)‌ ‌{ ‌ ‌
printf("Nilai‌‌pada‌‌posisi‌‌%d:‌‌%0.2lf\n",‌‌i,‌‌nilai[i]);‌  ‌
‌} ‌ ‌
printf("\nSelesai!!!‌‌Tekan‌‌tombol‌‌Enter...");‌  ‌
getch();‌  ‌
 ‌
}‌  ‌
 ‌
Hasil‌‌eksekusi‌‌program‌‌sekarang‌‌adalah‌‌: ‌ ‌

 ‌

Contoh‌‌Kasus‌  ‌

Kasus‌‌1:‌  ‌

Buatlah‌‌program‌‌yang‌‌dapat‌‌digunakan‌‌untuk‌‌mencari‌‌data‌‌nomor‌‌induk‌‌mahasiswa‌‌dari‌‌sekelompok‌‌nim‌‌
 
yang‌‌tersimpan‌‌dalam‌‌suatu‌‌array.‌  ‌

Jawab:‌  ‌

Analisis‌‌Kebutuhan‌‌program‌‌sbb:‌‌
   ‌

✔ Kebutuhan‌‌konstanta‌  ‌
■ Konstanta‌‌untuk‌‌menetapkan‌‌banyaknya‌‌data,‌‌beri‌‌nama‌‌N‌‌dengan‌‌nilai‌‌sembarang,‌‌misal‌‌10.‌  ‌
✔ Kebutuhan‌‌variabel‌‌global‌  ‌
■ Variabel‌‌untuk‌‌menyimpan‌‌data‌n
‌ im‌‌‌bertipe‌s‌ tring‌‌‌atau‌c‌ har‌[‌‌]‌‌berbentuk‌a‌ rray‌‌‌yang‌‌dapat‌‌
 
menampung‌N
‌ ‌‌data‌‌dan‌‌setiap‌n
‌ im‌‌‌berukuran‌‌sama,‌‌misal‌‌4‌‌(atau‌‌4‌‌karakter),‌‌misalnya:‌  ‌
char‌‌nim‌[N
‌ ]‌ [‌4]‌ ;‌  ‌

✔ Kebutuhan‌‌fungsi‌p
‌ encarian‌  ‌
 ‌
Fungsi‌‌yang‌‌akan‌‌dibuat‌‌merupakan‌‌fungsi‌‌yang‌‌memiliki‌‌nilai‌‌balik‌‌berupa‌‌nilai‌b
‌ oolean‌‌‌(dalam‌‌C ‌‌
digunakan‌‌tipe‌i‌nt‌)‌‌dimana‌n
‌ ilai‌‌0‌‌untuk‌‌menyatakan‌f‌ alse‌‌‌dan‌1‌ ‌‌menyatakan‌t‌ rue‌.‌‌Artinya,apabila‌‌
 
fungsi‌‌ini‌‌mengembalikan‌0‌ ‌‌berarti‌‌data‌‌yang‌‌dicari‌t‌ idak-ditemukan‌,‌‌sebaliknya,‌‌apabila‌‌nilai‌‌
 
baliknya‌1‌ ‌‌berarti‌‌data‌‌yang‌‌dicari‌b
‌ erhasil-ditemukan‌.‌‌Nilai‌‌balik‌‌tersebut‌‌dikirimkan‌‌dalam‌‌
 
variabel‌‌bernama‌s‌ tatus‌‌‌bertipe‌i‌nt‌.‌‌Fungsi‌‌ini‌‌juga‌‌memiliki‌p‌ assing‌‌parameter‌‌‌berupa‌‌string‌‌atau‌‌
 
array‌‌char‌‌‌yang‌‌merepresentasikan‌‌nomor‌‌induk‌‌mahasiswa‌‌yang‌‌akan‌‌dicari.‌  ‌

Perhatikan‌‌bagaimana‌‌fungsi‌‌ini‌‌ditulis‌‌sebagai‌‌berikut:‌  ‌

int‌‌cariData(char‌‌nimnya[])‌ ‌{ ‌ ‌
int‌‌i,‌‌status;‌  ‌
//cari‌‌nim‌‌tersebut‌‌di‌‌array‌‌nim‌  ‌
for(i=0;i<N;i++)‌ ‌{ ‌ ‌
if(!strcmp(nimnya,‌‌nim[i])){‌  ‌
status‌‌=‌‌1;‌  ‌
break;‌  ‌
}‌  ‌
else‌‌{ ‌ ‌
status‌‌=‌‌0;‌  ‌
}‌  ‌
}‌  ‌
return‌‌status;‌  ‌
}‌  ‌

Secara‌‌lengkap‌‌program‌‌dalam‌‌C‌‌adalah‌‌sebagai‌‌berikut:‌  ‌

/*‌ Nama‌‌File:‌‌search1.c‌  ‌
program‌‌ini‌‌memperlihatkan‌‌pembuatan‌‌dan‌‌penggunaan‌‌fungsi‌‌pencarian‌  ‌
data‌‌tertentu‌‌pada‌‌suatu‌‌array‌‌secara‌‌linier,‌‌jika‌‌data‌‌yng‌‌dicari‌  ‌
terdapat‌‌lebih‌‌dari‌‌1‌‌dalam‌‌array,‌‌maka‌‌hanya‌‌data‌‌pertama‌‌saja‌‌yg‌‌ditandai.‌‌*/‌  ‌
 ‌
#include‌‌<stdio.h>‌  ‌
#include‌‌<stdlib.h>‌  ‌
#include‌‌<string.h>‌  ‌
#define‌‌N‌‌5 ‌ ‌
int‌‌cariData(char‌‌nimnya[]);‌  ‌
char‌‌nim[N][4];‌  //variable‌‌global‌‌berupa‌‌array‌‌sejumlah‌‌nim‌‌mahasiswa‌  ‌
 ‌
void‌‌main()‌‌{ ‌ ‌
int‌‌i,‌‌status;‌  ‌
char‌‌nimnya[4];‌  ‌
 ‌
printf("Inputkan‌‌dulu‌‌nim‌‌mahasiswa\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
printf("Ketik‌‌nim‌‌ke-%d:‌‌",‌‌i+1);‌  ‌
 ‌
gets(nimnya);‌‌fflush(stdin);‌  ‌
strcpy(nim[i],‌‌nimnya);‌  ‌
}‌  ‌
printf("entri‌‌selesai...‌‌Tekan‌‌Enter...");‌  ‌
getch();‌ //‌‌jika‌‌tidak‌‌jalan,‌‌pada‌‌DEV-C++‌‌ganti‌‌dengan‌ ‌getchar()‌; ‌‌  ‌
printf("\nKetik‌‌NIM‌‌yang‌‌akan‌‌dicari:‌‌");‌  ‌
gets(nimnya);‌‌fflush(stdin);‌  ‌
status‌‌=‌‌cariData(nimnya);‌  ‌
if(status){‌  ‌
printf("Data‌‌nim:‌‌%s‌‌di‌‌temukan...\n",‌‌nimnya);‌  ‌
}‌  ‌
else‌ ‌{ ‌ ‌
printf("Data‌‌tidak‌‌ditemukan...\n");‌  ‌
‌} ‌ ‌
}‌  ‌
 ‌
int‌‌cariData(char‌‌nimnya[]){‌  ‌
int‌‌i,‌‌status;‌  ‌
//cari‌‌nim‌‌tersebut‌‌di‌‌array‌‌nim‌  ‌
for(i=0;i<N;i++){‌  ‌
if(!strcmp(nimnya,‌‌nim[i])){‌  ‌
status‌‌=‌‌1;‌  ‌
break;‌  ‌
}‌  ‌
else‌‌{ ‌ ‌
status‌‌=‌‌0;‌  ‌
}‌  ‌
}‌  ‌
return‌‌status;‌  ‌
}‌  ‌
 ‌
Hasil‌‌eksekusi‌‌: ‌ ‌

 ‌

 ‌
Kasus‌‌2.‌‌
   ‌
Buatlah‌‌suatu‌‌program‌‌yang‌‌memiliki‌‌fasilitas‌‌pencarian‌‌jamak,‌‌dimana‌‌setiap‌‌data‌‌yang‌‌ditemukan‌‌
 
bernilai‌‌sama,‌‌maka‌‌program‌‌akan‌‌menghitung‌‌jumlah‌‌data‌‌yang‌‌ditemukan‌‌tersebut.‌  ‌
Jawab:‌  ‌
 ‌
Mirip‌‌dengan‌‌kasus‌‌pertama,‌‌hanya‌‌saja‌‌program‌‌dilengkapi‌‌dengan‌k
‌ ounter‌‌‌untuk‌‌menghitung‌‌data‌ 
yang‌‌sama‌‌yang‌‌ditemukan‌‌selama‌‌pencarian.‌‌Perhatikan‌‌fungsi‌‌pencarian‌‌berikut‌‌ini:‌  ‌
void‌‌cariData(char‌‌namanya[]){‌  ‌
int‌‌i,‌‌jumlah‌‌=‌‌0,‌‌posisi;‌  ‌
 ‌
//cari‌‌nim‌‌tersebut‌‌di‌‌array‌‌nim‌  ‌
printf("Data‌‌yang‌‌dicari:‌‌%s\n",‌‌namanya);‌  ‌
for(i=0;i<N;i++){‌  ‌
if(!strcmp(namanya,‌‌nama[i])){‌  ‌
posisi‌‌=‌‌i;‌  ‌
jumlah++;‌  ‌
printf("Ada‌‌pada‌‌posisi:‌‌%d\n",‌‌posisi);‌  ‌
}‌  ‌
}‌  ‌
 ‌
Secara‌‌lengkap‌‌kode‌‌program‌‌dalam‌‌C‌‌adalah‌‌seperti‌‌berikut‌‌ini:‌  ‌
/*‌ Nama‌‌File:‌‌search2.c‌  ‌
program‌‌ini‌‌memperlihatkan‌‌pembuatan‌‌dan‌‌penggunaan‌‌fungsi‌‌pencarian‌  ‌
data‌‌tertentu‌‌pada‌‌suatu‌‌array‌‌secara‌‌linier.‌‌semua‌‌data‌‌yang‌‌sama‌‌
   ‌
pada‌‌array‌‌akan‌‌ditandai‌‌dan‌‌dihitung‌‌berapa‌‌data‌‌yg‌‌ditemukan‌ ‌*/‌  ‌
#include‌‌<stdio.h>‌  ‌
#include‌‌<stdlib.h>‌  ‌
#include‌‌<string.h>‌  ‌
#define‌‌N‌‌5 ‌ ‌
void‌‌cariData(char‌‌namanya[]);‌  ‌
char‌‌nama[N][4];‌ ‌//variable‌‌global‌‌berupa‌‌array‌‌sejumlah‌‌nim‌‌mahasiswa‌  ‌
 ‌
void‌‌main()‌‌{ ‌ ‌
int‌‌i;‌  ‌
char‌‌namanya[4];‌  ‌
printf("Inputkan‌‌dulu‌‌nama‌‌mahasiswa\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
printf("Ketik‌‌nama‌‌ke-%d:‌‌",‌‌i+1);‌  ‌
gets(namanya);‌‌fflush(stdin);‌  ‌
strcpy(nama[i],‌‌namanya);‌  ‌
}‌  ‌
printf("entri‌‌selesai...‌‌Tekan‌‌Enter...");‌  ‌
getch();‌  ‌
printf("\nKetik‌‌Nama‌‌yang‌‌akan‌‌dicari:‌‌");‌  ‌
gets(namanya);‌‌fflush(stdin);‌  ‌
cariData(namanya);‌‌//cari‌‌di‌‌array‌  ‌
}‌  ‌
 ‌
void‌‌cariData(char‌‌namanya[]){‌  ‌
int‌‌i,‌‌jumlah‌‌=‌‌0,‌‌posisi;‌  ‌
 ‌
//cari‌‌nim‌‌tersebut‌‌di‌‌array‌‌nim‌  ‌
printf("Data‌‌yang‌‌dicari:‌‌%s\n",‌‌namanya);‌  ‌
for(i=0;i<N;i++){‌  ‌
if(!strcmp(namanya,‌‌nama[i])){‌  ‌
posisi‌‌=‌‌i;‌  ‌
jumlah++;‌  ‌
printf("Ada‌‌pada‌‌posisi:‌‌%d\n",‌‌posisi);‌  ‌
}‌  ‌
}‌  ‌
printf("Banyaknya‌‌data‌‌yang‌‌ditemukan:‌‌%d‌‌buah‌‌\n",‌‌jumlah);‌  ‌
}‌  ‌
Contoh‌‌Hasil‌‌eksekusi‌‌adalah‌‌: ‌ ‌

 ‌
 ‌
Kasus‌‌3.‌‌
   ‌
Kembangkan‌‌program-program‌‌sebelumnya‌‌terkait‌‌pencarian‌‌dan‌‌implementasikan‌‌untuk‌‌mencari‌‌data‌‌
 
pada‌‌suatu‌a‌ rray‌‌of‌‌struct‌‌‌yang‌‌telah‌‌kita‌‌buat‌‌berupa‌‌tipe‌D
‌ ATAMHS.‌‌
   ‌
Jawab:‌  ‌
Program‌‌yang‌‌akan‌‌dikembangkan‌‌memiliki‌‌fasilitas‌‌untuk‌‌entri‌‌identitas‌‌mahasiswa,‌‌entri‌‌nilai‌‌(mid,‌‌
 
uas,‌‌tugas‌‌dan‌‌quis),‌‌fasilitas‌‌untuk‌‌menghitung‌‌nilai‌‌akhir,‌‌fasilitas‌‌untuk‌‌mengkonversi‌‌nilai‌‌akhir‌‌
 
menjadi‌‌nilai‌‌huruf‌‌serta‌‌fasilitas‌‌lainnya‌‌untuk‌‌menampilkan‌‌informasi,‌‌mencari‌‌data‌‌data‌‌tertentu.‌‌
 
Dengan‌‌demikian‌‌analisis‌‌yang‌‌kita‌‌lakukan‌‌sama‌‌dengan‌‌analisis‌‌kebutuhan‌‌untuk‌‌program‌‌serupa‌‌pada‌‌
 
Modul‌‌8‌‌hanya‌‌saja‌‌dilengkapi‌‌dengan‌‌kebutuhan‌‌fungsi‌‌pencarian.‌  ‌
Perhatikan‌‌implementasi‌‌fungsi‌‌pencarian‌‌berikut‌‌ini:‌‌
   ‌
int‌‌cariData(char‌‌nimnya[]){‌  ‌
int‌‌i,‌‌posisi;‌  ‌
 ‌
//cari‌‌nim‌‌tersebut‌‌di‌‌array‌‌nim‌  ‌
for(i=0;i<N;i++){‌  ‌
if(!strcmp(nimnya,‌‌dataMhs[i].mhs.nim)){‌  ‌
posisi‌‌=‌‌i;‌  ‌
break;‌  ‌
}‌  ‌
else‌‌{ ‌ ‌
posisi‌‌=‌‌-999;‌‌//nilai‌‌ini‌‌menunjukkan‌‌data‌‌tdk‌‌ditemukan‌  ‌
}‌  ‌
 ‌
}‌  ‌
return‌‌posisi;‌‌//posisi‌‌data‌‌dikirim‌‌sebagai‌‌nilai‌‌balik‌  ‌
}‌  ‌
 ‌
Fungsi‌‌pencarian‌c‌ ariData()‌‌‌hampir‌‌sama‌‌dengan‌‌fungsi‌‌pencarian‌‌yang‌‌pernah‌‌dibuat,‌‌hanya‌‌pada‌‌fungsi‌‌
 
cariData()‌‌‌ini‌‌nilai‌‌balik‌‌dari‌‌fungsi‌‌berupa‌‌nilai‌‌indeks‌‌atau‌‌posisi‌‌data‌‌tersebut‌‌pada‌a‌ rray‌‌of‌‌struct.‌  ‌
Mari‌‌kita‌‌lihat‌‌bagaimana‌‌kode‌‌keseluruhan‌‌dalam‌‌C‌‌berikut:‌  ‌
/*‌‌
  Nama‌‌File:‌‌search3.c‌  ‌
Program‌‌ini‌‌merupakan‌‌pengembangan‌‌dari‌‌program‌‌sebelumnya‌  ‌
dan‌‌memperlihatkan‌‌penggunaan‌‌fungsi‌‌pencarian.‌ ‌*/‌  ‌
 ‌
#include‌‌<stdio.h>‌  ‌
#include‌‌<stdlib.h>‌  ‌
#include‌‌<string.h>‌  ‌
 ‌
#define‌‌N‌‌30‌‌//banyaknya‌‌mahassiswa‌  ‌
#define‌‌MID‌‌0.25‌‌//prosentase‌‌nilai‌‌mid‌‌adalah‌‌25‌‌persen‌  ‌
#define‌‌UAS‌‌0.30‌‌//prosentase‌‌nilai‌‌uas‌‌adalah‌‌30‌‌persen‌  ‌
#define‌‌TGS‌‌0.30‌‌//prosentase‌‌nilai‌‌tugas‌‌adalah‌‌30‌‌persen‌  ‌
#define‌‌QSZ‌‌0.15‌‌//prosentase‌‌nilai‌‌quiz‌‌adalah‌‌15‌‌persen‌  ‌
 ‌
//mendefinisikan‌‌tipe‌‌bentukan‌‌berupa‌‌struct‌‌bernama‌‌MHS‌  ‌
typedef‌‌struct‌‌MHS{‌  ‌
char‌‌nama[30];‌‌//panjang‌‌nama‌‌mahasiswa‌‌adalah‌‌30‌‌karakter‌  ‌
char‌‌nim[4];‌ ‌//panjang‌‌nim‌‌mahasiswa‌‌adalah‌‌5‌‌karakter‌  ‌
}‌‌MHS;‌‌//nama‌‌tipe‌‌bentukan‌‌adalah‌‌MHS‌  ‌
 ‌
typedef‌‌struct‌‌NILAI{‌  ‌
double‌‌mid;‌‌    ‌
double‌‌uas;‌  ‌
double‌‌tugas;‌  ‌
double‌‌quiz;‌  ‌
double‌‌nAkhir;‌‌//dihitung‌‌dengan‌‌fungsi‌‌hitungAkhir()‌  ‌
char‌‌nHuruf;‌‌//diisi‌‌melalui‌‌pemanggilan‌‌fungsi‌‌konversiHuruf()‌  ‌
}‌‌NILAI;‌  ‌
 ‌
//kedua‌‌tipe‌‌MHS‌‌dan‌‌NILAI‌‌digunakan‌‌untuk‌‌tipe‌‌bentukan‌‌baru‌  ‌
//suatu‌‌stract‌‌of‌‌struct‌‌atau‌‌struct‌‌di‌‌dalam‌‌struct,‌‌sehingga‌  ‌
//struct‌‌yang‌‌baru‌‌memili‌‌seluruh‌‌data‌‌baik‌‌identitas‌‌maupun‌‌    ‌
//nilai2‌‌mahasiswa,‌‌sbb:‌  ‌
‌typedef‌‌struct‌‌DATAMHS{‌  ‌
 ‌ MHS‌‌mhs;‌  ‌
 ‌ NILAI‌‌nilai;‌  ‌
‌}‌‌DATAMHS;‌  ‌
 ‌
 ‌
//deklarasi‌‌fungsi‌‌yang‌‌akan‌‌digunakan‌  ‌
void‌‌judul();‌  ‌
void‌‌bacaMhs();‌  ‌
void‌‌bacaNilai(int‌‌i);‌‌//fungsi‌‌untuk‌‌mengisi‌‌nilai‌‌mahasiswa‌  ‌
void‌‌infoMhs(int‌‌i);‌  ‌
double‌‌hitungAkhir(double‌‌m,‌‌double‌‌u,‌‌double‌‌t,‌‌double‌‌q);‌  ‌
char‌‌konversiHuruf(double‌‌na);‌  ‌
int‌‌cariData(char‌‌nimnya[]);//fungsi‌‌ini‌‌mencari‌‌posisi‌‌data‌‌yg‌‌dicari‌  ‌
 ‌
//deklarasi‌‌variabel‌‌global‌‌berupa‌‌array‌‌of‌‌struct‌‌dari‌‌tipe‌‌DATAMHS‌‌sbb:‌  ‌
DATAMHS‌‌dataMhs[N];‌‌//banyak‌‌mahasiswa‌‌adalah‌‌N‌‌orang‌  ‌
 ‌
void‌‌main(){‌  ‌
int‌‌i,‌‌posisi;‌‌//konter‌‌perulangan‌‌untuk‌‌menampilkan‌‌data‌‌mahasiswa‌  ‌
char‌‌nimnya[4];‌  ‌
 ‌
printf("Contoh‌‌Pencarian\n\n");‌  ‌
//panggil‌‌fungsi‌‌judul()‌  ‌
judul();‌  ‌
//panggil‌‌fungsi‌‌bacaMhs()‌  ‌
bacaMhs();‌  ‌
printf("Menampilkan‌‌Identitas‌‌Seluruh‌‌Mahasiswa\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
//panggil‌‌fungsi‌‌infoMhs()‌‌mulai‌‌dari‌‌i=0,‌‌atau‌‌yg‌‌pertama‌  ‌
infoMhs(i);//nilai‌‌i‌‌adalah‌‌passing‌‌parameter‌‌yng‌‌menyatakan‌‌no‌‌indeks‌‌array‌  ‌
printf("\n");‌  ‌
}‌  ‌
 ‌
printf("\nKetikkan‌‌NIM‌‌yang‌‌dicari:‌‌");‌  ‌
gets(nimnya);‌‌fflush(stdin);‌  ‌
posisi‌‌=‌‌cariData(nimnya);‌  ‌
if(posisi‌‌!=‌‌-999){‌  ‌
printf("\nData‌‌ditemukan...\n");‌  ‌
infoMhs(posisi);‌‌//kirimkan‌‌nilai‌‌posisi‌‌data‌‌untuk‌‌ditampilkan‌  ‌
}‌  ‌
else‌‌printf("\nData‌‌tidak‌‌ditemukan....\n");‌  ‌
printf("Selesai...Tekan‌‌Enter...");‌  ‌
}‌  ‌
 ‌
void‌‌judul(){‌  ‌

printf("=====================================================‌
=============\n");‌  ‌
printf("Program‌‌Pengolahan‌‌Data‌‌Mahasiswa\n");‌  ‌
printf("Programmer:‌‌Antu\n");‌  ‌
 ‌
printf("Program‌‌ini‌‌digunakan‌‌untuk‌‌mencontohkan‌‌pembuatan‌‌fungsi‌‌tanpa‌‌nilai‌‌
 
balik\n");‌  ‌

printf("=====================================================‌
=============\n");‌  ‌
printf("Tekan‌‌tombol‌‌enter...");‌  ‌
getch();‌  ‌
}‌  ‌
 ‌
void‌‌bacaMhs(){‌  ‌
int‌‌i;‌‌//variable‌‌konter‌‌perulangan‌  ‌
char‌‌namanya[30];‌‌//penyimpan‌‌sementara‌‌nama‌‌mahasiswa‌  ‌
char‌‌nimnya[4];‌‌//penyimpan‌‌sementara‌‌nim‌‌mahasiswa‌  ‌
 ‌
printf("\nMembaca‌‌identitas‌‌sejumlah‌‌Mahasiswa\n");‌  ‌
printf("========================================\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
printf("Ketikkan‌‌nama‌‌Mahasiswa:‌‌");‌  ‌
gets(namanya);‌‌fflush(stdin);‌‌//baca‌‌nama‌‌mahasiswa‌  ‌
printf("Ketikkan‌‌NIM‌ ‌Mahasiswa:‌‌");‌  ‌
gets(nimnya);‌‌fflush(stdin);‌‌//baca‌‌nim‌‌mahasiswa‌  ‌
//masukan‌‌nama‌‌dan‌‌nim‌‌mahasiswa‌‌ke‌‌array‌‌of‌‌struct‌  ‌
strcpy(dataMhs[i].mhs.nama,‌‌namanya);‌‌//perhatikan‌‌cara‌‌mengakses‌‌field‌  ‌
strcpy(dataMhs[i].mhs.nim,‌‌nimnya);‌  ‌
//sekalian‌‌juga‌‌mengentri‌‌nilai2nya‌‌dg‌‌memanggil‌  ‌
//fungsi‌‌bacaNilai(),‌‌sbb‌  ‌
bacaNilai(i);‌  ‌
}‌  ‌
printf("\nEntri‌‌Data‌‌selesai...Tekan‌‌enter...");‌  ‌
getch();‌  ‌
}‌  ‌
 ‌
 ‌
void‌‌bacaNilai(int‌‌i){‌  ‌
double‌‌midnya,‌‌uasnya,‌‌tugasnya,‌‌quiznya,‌‌nAkhirnya;‌  ‌
char‌‌nHurufnya;‌  ‌
 ‌
printf("\nKetik‌‌nilai‌‌MID‌ ‌:‌‌");‌  ‌
scanf("%lf",‌‌&midnya);‌‌fflush(stdin);‌  ‌
printf("Ketik‌‌nilai‌‌UAS‌ ‌:‌‌");‌  ‌
scanf("%lf",‌‌&uasnya);‌‌fflush(stdin);‌  ‌
printf("Ketik‌‌nilai‌‌Tugas‌‌:‌‌");‌  ‌
scanf("%lf",‌‌&tugasnya);‌‌fflush(stdin);‌ 
printf("Ketik‌‌nilai‌‌Quiz‌ ‌:‌‌");‌  ‌
scanf("%lf",‌‌&quiznya);‌‌fflush(stdin);‌  ‌
//lalu‌‌masukkan‌‌ke‌‌array‌‌dataMhs,‌‌sbb‌  ‌
 ‌
dataMhs[i].nilai.mid‌‌=‌‌midnya;‌‌    ‌
dataMhs[i].nilai.uas‌‌=‌‌uasnya;‌‌    ‌
dataMhs[i].nilai.tugas‌‌=‌‌tugasnya;‌‌    ‌
dataMhs[i].nilai.quiz‌‌=‌‌quiznya;‌‌    ‌
//lalu‌‌panggil‌‌fungsi‌‌untuk‌‌menghitung‌‌nilai‌‌akhir‌‌dan‌‌
   ‌
//tampung‌‌nilai‌‌baliknya‌‌pada‌‌variabel‌‌nAkhirnya‌  ‌
nAkhirnya‌ ‌=‌‌hitungAkhir(midnya,‌‌uasnya,‌‌tugasnya,‌‌quiznya);‌  ‌
//lalu‌‌panggil‌‌fungsi‌‌untuk‌‌mengkonveri‌‌nilai‌‌akhir‌‌ke‌‌nilai‌‌huruf‌ 
//dg‌‌passing‌‌parameter‌‌berupa‌‌nilai‌‌akhir‌‌atau‌‌nAkhirnya‌  ‌
//tampung‌‌hasil‌‌atau‌‌nilai‌‌baliknya‌‌pada‌‌variabel‌‌nHurufnya‌  ‌
nHurufnya‌‌=‌‌konversiHuruf(nAkhirnya);‌  ‌
//simpan‌‌nilai‌‌akhir‌‌dan‌‌nilai‌‌huruf‌‌ke‌‌dataMhs‌  ‌
dataMhs[i].nilai.nAkhir‌‌=‌‌nAkhirnya;‌  ‌
dataMhs[i].nilai.nHuruf‌‌=‌‌nHurufnya;‌  ‌
printf("\n");‌  ‌
}‌  ‌
 ‌
//fungsi‌‌ini‌‌harus‌‌dimodifikasi‌‌melibatkan‌‌data‌‌nilai2‌  ‌
void‌‌infoMhs(int‌‌i){‌  ‌
char‌‌namanya[30];‌‌//penyimpan‌‌sementara‌‌nama‌‌mahasiswa‌  ‌
char‌‌nimnya[4];‌‌//penyimpan‌‌sementara‌‌nim‌‌mahasiswa‌  ‌
double‌‌nAkhirnya;‌  ‌
char‌‌nHurufnya;‌  ‌
 ‌
printf("\nInformasi‌‌Identitas‌‌Mahasiswa\n");‌  ‌
printf("========================================\n");‌  ‌
 ‌
//salin‌‌dulu‌‌data‌‌mahasiswa‌‌ke‌‌variabel‌‌sementara‌  ‌
 ‌
strcpy(namanya,‌‌dataMhs[i].mhs.nama);‌  ‌
strcpy(nimnya,‌‌dataMhs[i].mhs.nim);‌  ‌
//tampung‌‌dulu‌‌nilai‌‌akhir‌‌dan‌‌nilai‌‌huruf‌  ‌
nAkhirnya‌‌=‌‌dataMhs[i].nilai.nAkhir;‌  ‌
nHurufnya‌‌=‌‌dataMhs[i].nilai.nHuruf;‌  ‌
//tampilkan‌‌informasi‌‌mahasiswa‌‌yang‌‌diminta‌  ‌
printf("Nama‌‌Mahasiswa‌ ‌:‌‌%s\n",‌‌namanya);‌  ‌
printf("Nomor‌‌Induk‌‌Mahasiswa‌‌:‌‌%s\n",‌‌nimnya);‌  ‌
printf("\tNilai‌‌Akhir‌ ‌:‌‌%0.1lf\n",‌‌nAkhirnya);‌  ‌
printf("\tNilai‌‌Huruf‌ ‌:‌‌%c\n",‌‌nHurufnya);‌  ‌
printf("========================================\n");‌  ‌
}‌  ‌
 ‌
double‌‌hitungAkhir(double‌‌m,‌‌double‌‌u,‌‌double‌‌t,‌‌double‌‌q){‌  ‌
double‌‌nAkhirnya;‌  ‌
 ‌
nAkhirnya‌‌=‌‌m‌‌*‌‌MID‌‌+‌‌u‌‌*‌‌UAS‌‌+‌‌t‌‌*‌‌TGS‌‌+‌‌q‌‌*‌‌QSZ;‌  ‌
 ‌
return‌‌nAkhirnya;‌  ‌
}‌  ‌
 ‌
char‌‌konversiHuruf(double‌‌na){‌  ‌
char‌‌nHurufnya;‌  ‌
//tentukan‌‌nilai‌‌hurufnya‌  ‌
if((na‌‌>=‌‌81.0)‌‌&&‌‌(na<=‌‌100.0))‌  ‌
nHurufnya‌‌=‌‌'A';‌  ‌
else‌‌if(na‌‌>=‌‌76.0)‌  ‌
nHurufnya‌‌=‌‌'B';‌  ‌
else‌‌if(na‌‌>=‌‌56.0)‌  ‌
nHurufnya‌‌=‌‌'C';‌  ‌
else‌‌if(na‌‌>=‌‌45.0)‌  ‌
nHurufnya‌‌=‌‌'D';‌  ‌
else‌‌nHurufnya‌‌=‌‌'E';‌  ‌
 ‌
return‌‌nHurufnya;‌‌//kirim‌‌hasilnya‌‌sebagai‌‌nilai‌‌balik‌  ‌
}‌  ‌
 ‌
int‌‌cariData(char‌‌nimnya[]){‌  ‌
int‌‌i,‌‌posisi;‌  ‌
 ‌
//cari‌‌nim‌‌tersebut‌‌di‌‌array‌‌nim‌  ‌
for(i=0;i<N;i++){‌  ‌
if(!strcmp(nimnya,‌‌dataMhs[i].mhs.nim)){‌  ‌
posisi‌‌=‌‌i;‌  ‌
break;‌  ‌
}‌  ‌
else‌‌{ ‌ ‌
posisi‌‌=‌‌-999;‌‌//nilai‌‌ini‌‌menunjukkan‌‌data‌‌tdk‌‌ditemukan‌  ‌
}‌  ‌
}‌  ‌
return‌‌posisi;‌‌//posisi‌‌data‌‌dikirim‌‌sebagai‌‌nilai‌‌balik‌  ‌
}‌  ‌
 ‌
Hasil‌‌eksekusi‌‌program‌‌search3.cpp‌‌adalah‌‌:  
‌‌ ‌

 ‌
 ‌
2. Pengurutan‌‌(S
‌ orting‌)  ‌‌ ‌
 ‌
Pengurutan‌  ‌(s‌ orting‌)adalah‌  ‌proses‌  ‌mengatur‌  ‌sekumpulan‌  ‌objek‌  ‌menurut‌  ‌urutan‌  ‌atau‌  ‌susunan‌‌
 
tertentu‌  ‌[Munir‌  ‌2003].‌  ‌Urutan‌  ‌objek‌  ‌tersebut‌  ‌dapat‌  ‌menaik‌  ‌(a‌ scenmding‌) ‌ ‌atau‌  ‌menurun‌  ‌(d‌ escending‌).‌  ‌
Bila‌  ‌N ‌ ‌buah‌  ‌objek‌  ‌(atau‌  ‌data)‌  ‌disimpan‌  ‌di‌  ‌dalam‌  ‌larik‌  ‌L,‌  ‌maka‌  ‌pengurutan‌  ‌menaik‌  ‌berarti‌  ‌menyusun‌‌
 
elemen‌‌larik‌‌sedemikian‌‌sehingga:‌‌
   ‌
L[1]‌<
‌ ‌‌L[2]‌<
‌ ‌‌L[3]‌<
‌ ‌‌…‌<
‌ ‌‌L[N]‌‌
   ‌
Sedangkan‌‌pengurutan‌‌menurun‌‌berarti‌‌menyusun‌‌elemen‌‌larik‌‌sedemikian‌‌sehingga‌‌:  ‌‌ ‌
L[1]‌>
‌ ‌‌L[2]‌>
‌ ‌‌L[3]‌>
‌ ‌‌…‌>
‌ ‌‌L[N]‌‌
   ‌
Data‌  ‌yang‌  ‌diurut‌  ‌dapat‌  ‌berupa‌‌
  data‌‌
  bertipe‌‌
  data‌‌
  dasar‌‌
  atau‌‌
  bertipe‌‌
  terstruktur‌‌
  (r‌ ecord‌).‌‌
  Jika‌‌
  data‌‌
  bertipe‌‌
 
terstruktur,‌  ‌maka‌  ‌harus‌  ‌dispesifikasikan‌  ‌berdasarkan‌  ‌field‌  ‌apa‌  ‌data‌  ‌tersebut‌  ‌diurutkan.‌  ‌Field‌  ‌yang‌‌
 
dijadikan‌‌dasar‌‌pengurutan‌‌dikenal‌‌sebagai‌f‌ield‌‌‌kunci.‌‌
   ‌
Sorting‌  ‌atau‌  ‌pengurutan‌  ‌merupakan‌  ‌aktivitas‌  ‌yang‌  ‌sering‌  ‌dilakukan‌  ‌terhadap‌  ‌sekumpulan‌‌
  data.‌‌
 
Terdapat‌  ‌banyak‌  ‌bentuk‌  ‌Algoritma‌‌
  sorting,‌‌
  seperti‌‌
  selection‌‌
  sort,‌‌
  insertion‌‌
  sort,‌‌
  bubble‌‌
  sort,‌‌
  merge‌‌
  sort,‌‌
 
dll.‌  ‌Pada‌  ‌bahasan‌  ‌ini‌  ‌hanya‌  ‌akan‌  ‌dibahas‌  ‌pengurutan‌  ‌menggunakan‌  ‌algoritma‌  ‌selection‌  ‌sort‌  ‌sebagai‌‌
 
teknik‌  ‌paling‌  ‌mudah‌  ‌dalam‌  ‌mengurutkan‌  ‌sekumpulan‌  ‌data.‌  ‌Pengurutan‌  ‌mengacu‌  ‌pada‌  ‌pengaturan‌‌
  data‌‌
 
dalam‌  ‌format‌  ‌tertentu.‌  ‌Algoritme‌  ‌pengurutan‌  ‌menentukan‌  ‌cara‌  ‌untuk‌  ‌mengatur‌  ‌data‌  ‌dalam‌  ‌urutan‌ 
tertentu.‌  ‌Urutan‌  ‌paling‌  ‌umum‌  ‌dalam‌  ‌urutan‌  ‌numerik‌  ‌atau‌  ‌leksikografis‌. ‌‌Pentingnya‌‌
  pengurutan‌‌
  terletak‌‌
 
pada‌  ‌kenyataan‌  ‌bahwa‌  ‌pencarian‌  ‌data‌  ‌dapat‌  ‌dioptimalkan‌  ‌hingga‌  ‌tingkat‌  ‌yang‌  ‌sangat‌  ‌tinggi,‌  ‌jika‌  ‌data‌‌
 
disimpan‌‌
  dengan‌‌
  cara‌‌
  terurutkan.‌‌
  Pengurutan‌‌
 juga‌‌
 digunakan‌‌
 untuk‌‌
 merepresentasikan‌‌
 data‌‌
 dalam‌‌
 format‌‌
 
yang‌‌lebih‌‌mudah‌‌dibaca‌‌yang‌‌dapat‌‌dilihat‌‌dalam‌‌skenario‌‌kehidupan‌‌nyata.‌  ‌
 ‌

2.1. Metode-metode‌‌Pengurutan‌  ‌

Adanya‌‌kebutuhan‌‌terhadap‌‌proses‌‌pengurutan‌‌memunculkan‌‌bermacam-macam‌‌metode‌‌
 
pengurutan,‌‌yang‌‌sampai‌‌hari‌‌ini‌‌relatif‌‌cukup‌‌banyak‌‌metode‌‌yang‌‌ditemukan‌‌orang.‌‌Berarti‌‌juga‌‌relatif‌‌
 
banyak‌‌algoritma‌‌yang‌‌berhubungan‌‌dengan‌‌metode‌‌pengurutan‌‌ini.‌‌Metode‌‌pengurutan‌‌yang‌‌ditemukan‌‌
 
dalam‌‌literatur-literatur‌‌komputer‌‌antara‌‌lain‌‌:‌‌(1)‌‌Bubble‌‌Sort,‌‌(2)‌‌Selection‌‌Sort‌‌(Maximum‌‌Sort‌‌dan‌‌
 
Minimum‌‌Sort),‌‌(3)‌‌Insertion‌‌Sort,‌‌(4)‌‌Heap‌‌Sort,‌‌(5)‌‌Shell‌‌Sort,‌‌(6)‌‌Quick‌‌Sort,‌‌(7)‌‌Merge‌‌Sort,‌‌(8)‌‌Radix‌‌
 
Sort,‌‌dan‌‌(9)‌‌Tree‌‌Sort.‌‌
   ‌

 ‌

2.2. In-place‌‌Sorting‌‌dan‌‌Not-in-place‌‌Sorting‌  ‌
Algoritma‌‌pengurutan‌‌mungkin‌‌memerlukan‌‌beberapa‌‌ruang‌‌ekstra‌‌untuk‌‌perbandingan‌‌dan‌‌
 
penyimpanan‌‌sementara‌‌dari‌‌beberapa‌‌elemen‌‌data.‌‌Algoritma‌‌ini‌‌tidak‌‌memerlukan‌‌ruang‌‌ekstra‌‌dan‌ 
 ‌
penyortiran‌‌dikatakan‌‌terjadi‌‌di‌‌tempat,‌‌atau‌‌misalnya,‌‌di‌‌dalam‌‌larik‌‌atau‌‌array‌ ‌itu‌‌sendiri.‌‌Ini‌‌disebut‌‌
 
In-place‌‌Sorting.‌‌Jenis‌‌buble‌‌sort‌‌adalah‌‌contoh‌‌pengurutan‌‌di‌‌tempat.‌‌
   ‌

Namun,‌‌dalam‌‌beberapa‌‌algoritma‌‌pengurutan,‌‌program‌‌membutuhkan‌‌ruang‌‌yang‌‌lebih‌‌dari‌‌atau‌‌sama‌‌
 
dengan‌‌elemen‌‌yang‌‌diurutkan.‌‌Pengurutan‌‌yang‌‌menggunakan‌‌ruang‌‌yang‌‌sama‌‌atau‌‌lebih‌‌disebut‌‌
 
Not-in-place‌‌Sorting.‌‌Merge-sort‌‌adalah‌‌contoh‌‌Not-in-place‌‌Sorting.‌  ‌

 ‌

2.2.1. Stable‌‌dan‌‌Not‌‌Stable‌‌Sorting‌  ‌

Jika‌a‌ lgoritma‌‌pengurutan,‌‌setelah‌‌menyortir‌‌konten,‌‌tidak‌‌mengubah‌‌urutan‌‌konten‌‌serupa‌‌di‌‌mana‌‌
 
mereka‌‌muncul,‌‌itu‌‌disebut‌‌pengurutan‌‌stabil.‌  ‌

 ‌

Jika‌‌algoritme‌‌pengurutan,‌‌setelah‌‌menyortir‌‌konten,‌‌mengubah‌‌urutan‌‌konten‌‌serupa‌‌di‌‌mana‌‌mereka‌‌
 
muncul,‌‌itu‌‌disebut‌‌pengurutan‌‌tidak‌‌stabil.‌  ‌

 ‌

Stabilitas‌‌suatu‌‌algoritma‌‌penting‌‌saat‌‌ingin‌‌mempertahankan‌‌urutan‌‌elemen‌‌asli,‌‌seperti‌‌dalam‌‌tupel.‌  ‌

 ‌

2.2.2. Algoritma‌‌Sorting‌‌Adaptive‌‌dan‌‌Non-Adaptive‌  ‌
 ‌
Algoritma‌‌pengurutan‌‌dikatakan‌‌adaptif,‌‌jika‌‌memanfaatkan‌‌elemen‌‌yang‌‌sudah‌‌'diurutkan'‌‌dalam‌‌daftar‌‌
 
yang‌‌akan‌‌disortir.‌‌Artinya,‌‌saat‌‌menyortir‌‌jika‌‌daftar‌‌sumber‌‌memiliki‌‌beberapa‌‌elemen‌‌yang‌‌telah‌‌
 
diurutkan,‌‌algoritme‌‌adaptif‌‌akan‌‌mempertimbangkannya‌‌dan‌‌akan‌‌mencoba‌‌untuk‌‌tidak‌‌mengurut‌‌ulang.‌  ‌

Algoritm‌‌non-adaptif‌‌adalah‌‌algoritme‌‌yang‌‌tidak‌‌memperhitungkan‌‌elemen‌‌yang‌‌sudah‌‌disortir.‌‌Mereka‌‌
 
mencoba‌‌memaksa‌‌setiap‌‌elemen‌‌untuk‌‌diatur‌‌ulang‌‌untuk‌‌mengkonfirmasi‌‌urutannya.‌  ‌

2.2.3. Istilah-istilah‌‌Penting:‌  ‌
Increasing‌‌Order‌  ‌
Urutan‌‌nilai‌‌dikatakan‌‌naik,‌‌jika‌‌elemen‌‌yang‌‌berurutan‌‌lebih‌‌besar‌‌dari‌‌yang‌‌sebelumnya.‌‌Misalnya,‌‌1,‌‌3,‌‌
 
4,‌‌6,‌‌8,‌‌9‌‌berada‌‌dalam‌‌urutan‌‌naik,‌‌karena‌‌setiap‌‌elemen‌‌berikutnya‌‌lebih‌‌besar‌‌dari‌‌elemen‌‌sebelumnya.‌  ‌

Decreasing‌‌Order‌  ‌
Suatu‌‌urutan‌‌nilai‌‌dikatakan‌‌dalam‌‌urutan‌‌menurun,‌‌jika‌‌elemen‌‌yang‌‌berurutan‌‌lebih‌‌kecil‌‌dari‌‌yang‌‌
 
sekarang.‌‌Misalnya,‌‌9,‌‌8,‌‌6,‌‌4,‌‌3,‌‌1‌‌berada‌‌dalam‌‌urutan‌‌menurun,‌‌karena‌‌setiap‌‌elemen‌‌berikutnya‌‌lebih‌‌
 
kecil‌‌dari‌‌elemen‌‌sebelumnya.‌  ‌

Non-Increasing‌‌Order‌  ‌
Urutan‌‌nilai‌‌dikatakan‌‌dalam‌‌urutan‌‌tidak‌‌naik,‌‌jika‌‌elemen‌‌yang‌‌berurutan‌‌kurang‌‌dari‌‌atau‌‌sama‌‌dengan‌‌
 
elemen‌‌sebelumnya‌‌dalam‌‌urutan‌‌tersebut.‌‌Urutan‌‌ini‌‌terjadi‌‌ketika‌‌urutan‌‌berisi‌‌nilai‌‌duplikat.‌‌Misalnya,‌‌
 
9,‌‌8,‌‌6,‌‌3,‌‌3,‌‌1‌‌berada‌‌dalam‌‌urutan‌‌tidak‌‌bertambah,‌‌karena‌‌setiap‌‌elemen‌‌berikutnya‌‌kurang‌‌dari‌‌atau‌‌
 
sama‌‌dengan‌‌(dalam‌‌kasus‌‌3)‌‌tetapi‌‌tidak‌‌lebih‌‌besar‌‌dari‌‌elemen‌‌sebelumnya.‌  ‌

Non-Decreasing‌‌Order‌  ‌
Urutan‌‌nilai‌‌dikatakan‌‌dalam‌‌urutan‌‌tidak‌‌menurun,‌‌jika‌‌elemen‌‌yang‌‌berurutan‌‌lebih‌‌besar‌‌dari‌‌atau‌‌sama‌‌
 
dengan‌‌elemen‌‌sebelumnya‌‌dalam‌‌urutan‌‌tersebut.‌‌Urutan‌‌ini‌‌terjadi‌‌ketika‌‌urutan‌‌berisi‌‌nilai‌‌duplikat.‌‌
 
Misalnya,‌‌1,‌‌3,‌‌3,‌‌6,‌‌8,‌‌9‌‌berada‌‌dalam‌‌urutan‌‌tidak‌‌menurun,‌‌karena‌‌setiap‌‌elemen‌‌berikutnya‌‌lebih‌‌besar‌‌
 
dari‌‌atau‌‌sama‌‌dengan‌‌(dalam‌‌kasus‌‌3)‌‌tetapi‌‌tidak‌‌kurang‌‌dari‌‌yang‌‌sebelumnya.‌  ‌

Ini‌‌adalah‌‌algoritme‌‌pengurutan‌‌berbasis‌‌perbandingan‌‌di‌‌tempat.‌‌Di‌‌sini,‌‌sub-daftar‌‌dipertahankan‌‌yang‌‌
 
selalu‌‌diurutkan.‌‌Misalnya,‌‌bagian‌‌bawah‌‌larik‌‌dipertahankan‌‌untuk‌‌diurutkan.‌‌Sebuah‌‌elemen‌‌yang‌‌akan‌‌
 
'disisipkan'‌‌dalam‌‌sub-daftar‌‌yang‌‌diurutkan‌‌ini,‌‌harus‌‌menemukan‌‌tempat‌‌yang‌‌sesuai‌‌dan‌‌kemudian‌‌
 
harus‌‌disisipkan‌‌di‌‌sana.‌‌Karenanya‌‌namanya,‌‌semacam‌‌penyisipan.‌  ‌

 ‌

2.2.4. Selection‌‌Sorting‌  ‌
 ‌
Array‌‌dicari‌‌secara‌‌berurutan‌‌dan‌‌item‌‌yang‌‌tidak‌‌diurutkan‌‌dipindahkan‌‌dan‌‌dimasukkan‌‌ke‌‌dalam‌ 
sub-list‌‌yang‌‌diurutkan‌‌(dalam‌‌array‌‌yang‌‌sama).‌‌Algoritme‌‌ini‌‌tidak‌‌cocok‌‌untuk‌‌kumpulan‌‌data‌‌besar‌‌
 
karena‌‌kompleksitas‌‌kasus‌‌rata-rata‌‌dan‌‌terburuk‌‌adalah‌‌Ο‌‌(n2),‌‌di‌‌mana‌‌n‌‌adalah‌‌jumlah‌‌item.‌  ‌

 ‌

2.2.4.1. Bagaimana‌‌Selection‌‌Sort‌‌Bekerja?‌  ‌
Sebagai,‌‌contoh,‌‌misal‌‌kita‌‌tetapkan‌‌suatu‌‌array‌‌sebagai‌‌berikut:‌  ‌

 ‌

Untuk‌‌posisi‌‌pertama‌‌dalam‌‌daftar‌‌yang‌‌diurutkan,‌‌seluruh‌‌daftar‌‌dipindai‌‌secara‌‌berurutan.‌‌Posisi-1‌‌di‌‌
 
mana‌‌14‌‌disimpan‌‌saat‌‌ini,‌‌kita‌‌mencari‌‌seluruh‌‌daftar‌‌dan‌‌menemukan‌‌10‌‌adalah‌‌nilai‌‌terendah.‌  ‌

 ‌

Jadi‌‌kami‌‌mengganti‌‌14‌‌dengan‌‌10.‌‌Setelah‌‌satu‌‌iterasi‌‌10,‌‌yang‌‌kebetulan‌‌merupakan‌‌nilai‌‌minimum‌‌
 
dalam‌‌daftar,‌‌muncul‌‌di‌‌posisi‌‌pertama‌‌daftar‌‌yang‌‌diurutkan.‌  ‌

 ‌

Untuk‌‌posisi‌‌kedua,‌‌di‌‌mana‌‌33‌‌berada,‌‌kita‌‌mulai‌‌memindai‌‌daftar‌‌lainnya‌‌secara‌‌linier.‌  ‌

 ‌

Kami‌‌menemukan‌‌bahwa‌‌14‌‌adalah‌‌nilai‌‌terendah‌‌kedua‌‌dalam‌‌daftar‌‌dan‌‌seharusnya‌‌muncul‌‌di‌‌tempat‌‌
 
kedua.‌‌Kami‌‌menukar‌‌nilai-nilai‌‌ini.‌  ‌

 ‌

Setelah‌‌dua‌‌iterasi,‌‌dua‌‌nilai‌‌terkecil‌‌ditempatkan‌‌di‌‌awal‌‌dengan‌‌cara‌‌yang‌‌diurutkan.‌  ‌

 ‌

Proses‌‌yang‌‌sama‌‌diterapkan‌‌ke‌‌item‌‌lainnya‌‌dalam‌‌larik.‌  ‌

Berikut‌‌adalah‌‌penggambaran‌‌bergambar‌‌dari‌‌seluruh‌‌proses‌‌penyortiran‌‌- ‌ ‌
 ‌

 ‌

Sekarang,‌‌mari‌‌kita‌‌pelajari‌‌beberapa‌‌aspek‌‌pemrograman‌‌dari‌‌selection‌‌sort.‌  ‌

 ‌

2.4.2.‌‌Algoritma‌  ‌

Step‌‌1‌‌−‌‌Set‌‌MIN‌‌ke‌‌lokasi‌‌0 ‌ ‌
Step‌‌2‌‌−‌‌Cari‌‌elemen‌‌minimun‌‌pada‌‌daftar‌  ‌
Step‌‌3‌‌−‌‌Pertukarkan‌‌nilai‌‌pada‌‌lokasi‌‌tersebut‌‌dengan‌‌lokasi‌‌MIN‌  ‌
Step‌‌4‌‌−‌‌Naikan‌‌MIN‌‌untuk‌‌menunjuk‌‌lokasi‌‌element‌‌berikutnya‌  ‌
Step‌‌5‌‌−‌‌Ulangi‌‌hingga‌‌semua‌‌data‌‌dalam‌‌daftar‌‌jadi‌‌terurut‌  ‌
 ‌
 ‌
2.4.3.‌‌Pseudocode‌  ‌
procedure‌‌selection‌‌sort‌‌    ‌
‌list‌ :‌‌‌array‌‌dari‌‌item‌  ‌
‌n‌ :‌‌‌ukuran‌‌list‌  ‌
 ‌
f‌ or‌‌‌i‌= ‌ ‌1‌ ‌‌to‌‌n‌-‌ ‌1‌  ‌ ‌
/‌*‌‌set‌‌elemen‌‌saat‌‌ini‌‌sebagai‌‌minimum*/‌  ‌
‌min‌= ‌ ‌‌i ‌  ‌ ‌
   ‌
/‌*‌‌check‌‌the‌‌element‌‌to‌‌be‌‌minimum‌‌*/‌  ‌
 ‌
f‌ or‌‌‌j‌= ‌ ‌‌i+‌ 1‌ ‌‌to‌‌n  
‌‌ ‌
i‌f‌‌‌list‌[j‌]‌ ‌<‌ ‌‌list‌[m
‌ in‌]‌t‌hen‌  ‌
‌min‌= ‌ ‌‌j;‌ ‌ ‌
e‌ nd‌‌i‌f‌  ‌
e‌ nd‌‌f‌ or‌  ‌
 ‌
/‌*‌‌pertukarkan‌‌elemen‌‌minimum‌‌dengan‌‌elemen‌‌saat‌‌ini*/‌  ‌
i‌f‌‌‌indexMin‌!‌ =‌‌‌i‌ t‌hen‌  ‌
‌swap‌‌list‌[m ‌ in‌]‌a‌ nd‌‌‌list‌[i‌]‌  ‌ ‌
e‌ nd‌‌i‌f‌  ‌
e‌ nd‌‌f‌ or‌  ‌
end‌‌‌procedure‌  ‌
 ‌
 ‌
Kasus‌‌1:‌  ‌

Buatlah‌‌program‌‌untuk‌‌mngurutkan‌‌sejumlah‌‌data‌‌yang‌‌tersimpan‌‌dalam‌‌suatu‌‌array‌‌berukuran‌‌tertentu.‌‌
 
Hasil‌‌pengurutan‌‌ditampilkan‌‌ke‌‌layar.‌  ‌

Jawab:‌  ‌

Untuk‌‌menyelesaikan‌‌kasus‌‌ini,‌‌kita‌‌perlu‌‌melakukan‌‌analisis‌‌kebutuhan.‌  ‌

Analisis‌‌Kebutuhan:‌  ‌

✔ Kebutuhan‌‌konstanta‌  ‌
Perlu‌‌konstanta‌‌untuk‌‌menetapkan‌‌banyaknya‌‌elemen‌‌array,‌‌misal‌‌N‌‌dengan‌‌sembarang‌‌(misal‌‌nilai‌‌
 
10)‌‌sbb:‌  ‌

#define‌‌N‌‌10‌  ‌

✔ Kebutuhan‌‌variabel‌‌global‌  ‌
Variabel‌‌array‌‌dengan‌‌jumlah‌‌elemen‌‌adalah‌‌N,‌‌misal‌‌berinama‌d‌ ata[N]‌b‌ ertipe‌‌int,‌‌sbb:‌  ‌
 ‌
Int‌‌data[N];‌  ‌

✔ Kebutuhan‌‌fungsi‌  ‌
Fungsi‌‌untuk‌‌mengurutkan‌‌data‌‌dapat‌‌mengimplementasikan‌‌algoritma‌‌selection‌‌sort‌‌yang‌‌sudah‌‌
 
disampaikan.‌‌
   ‌

Implementasi‌‌dalam‌‌C‌‌,‌‌sebagai‌‌berikut:‌  ‌
/*‌ Nama‌‌File:‌‌sorting1.c‌  ‌
Program‌‌ini‌‌mendemonstrasikan‌‌pembuatan‌‌fungsi‌‌pengurutan‌‌atau‌‌sorting‌  ‌
metode‌‌selection‌‌sorting‌‌sebagai‌‌metoda‌‌paling‌‌simpel.‌  ‌
Sorting‌‌dalam‌‌contoh‌‌ini‌‌bersifat‌‌ascending‌‌atau‌‌terurut‌‌dari‌‌nilai‌‌
   ‌
kecil‌‌ke‌‌besar‌ ‌*/‌  ‌
 ‌
#include‌‌<stdio.h>‌  ‌
#include‌‌<stdlib.h>‌  ‌
 ‌
//konstanta‌‌N‌‌menunjukkan‌‌banyaknya‌‌data‌  ‌
#define‌‌N‌‌5 ‌ ‌
 ‌
//variabel‌‌global‌‌berupa‌‌array‌‌berisi‌‌data‌‌int‌  ‌
int‌‌data[N];‌  ‌
 ‌
void‌‌urutkan();‌  ‌
 ‌
main(){‌  ‌
int‌‌i;‌  ‌
int‌‌datanya;‌  ‌
 ‌
printf("Isikan‌‌datanya‌‌dulu‌‌berupa‌‌nilai‌‌bilangan‌‌bulat\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
printf("Data‌‌indeks‌‌ke-%d:‌‌",‌‌i);‌  ‌
scanf("%d",‌‌&datanya);‌‌fflush(stdin);‌  ‌
//isikan‌‌ke‌‌array‌‌data[]‌  ‌
data[i]‌‌=‌‌datanya;‌  ‌
}‌  ‌
printf("\nEntri‌‌selesai...‌‌Tekan‌‌enter...");‌  ‌
getch();‌  ‌
//panggil‌‌fungsi‌‌untuk‌‌mengurutkan‌‌data[]‌  ‌
urutkan();‌  ‌
//data‌‌yg‌‌telah‌‌diurut‌‌ditampilkan‌‌ke‌‌layar‌  ‌
printf("\nData‌‌terurut‌‌secara‌‌ascending...\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
//salin‌‌dulu‌‌data‌‌dari‌‌array‌  ‌
datanya‌‌=‌‌data[i];‌  ‌
printf("%d\t",‌‌datanya);‌  ‌
 ‌
}‌  ‌
printf("\n");//pindah‌‌baris‌  ‌
printf("Selesai...‌‌Tekan‌‌Enter...");‌  ‌
getch();‌  ‌
}‌  ‌
 ‌
void‌‌urutkan()‌‌{ ‌ ‌
‌//metode‌‌selection‌‌sort‌  ‌
‌int‌‌indexMin,i,j;‌  ‌
‌int‌‌temp;‌  ‌
 ‌
‌//loop‌‌untuk‌‌seluruh‌‌data‌‌    ‌
‌for(i‌‌=‌‌0;‌‌i‌‌<‌‌N-1;‌‌i++)‌‌{  ‌‌ ‌
 ‌
‌//‌‌elemen‌‌sekarang‌‌yang‌‌dianggap‌‌minimum‌  ‌
‌indexMin‌‌=‌‌i;‌  ‌
 ‌
‌//periksa‌‌elemen‌‌paling‌‌kecil‌  ‌
‌for(j‌‌=‌‌i+1;j‌‌<‌‌N;j++)‌‌{ ‌ ‌
‌if(data[j]‌‌<‌‌data[indexMin])‌‌{ ‌ ‌
‌indexMin‌‌=‌‌j;‌  ‌
‌} ‌ ‌
‌} ‌ ‌
‌if(indexMin‌‌!=‌‌i)‌‌{//kalau‌‌posisinya‌‌bukan‌‌posisi‌‌awal‌  ‌
‌//‌‌pertukarkan‌‌posisi‌‌data‌‌   ‌
‌temp‌‌=‌‌data[indexMin];‌  ‌
‌data[indexMin]‌‌=‌‌data[i];‌  ‌
‌data[i]‌‌=‌‌temp;‌  ‌
‌} ‌  ‌ ‌
‌} ‌ ‌
}‌   ‌ ‌
 ‌
Hasil‌‌eksekusi‌‌program‌‌sorting1.cpp‌‌adalah‌‌: ‌ ‌

 ‌
 ‌
Kasus‌‌2:‌  ‌
Buatlah‌‌program‌‌seperti‌‌pada‌‌kasus‌‌1‌‌tetapi‌‌urutannya‌‌dari‌‌besar‌‌ke‌‌kecil‌‌atau‌‌descending‌‌order.‌  ‌
Jawab:‌  ‌
 ‌
Analisis‌‌kebutuhan‌‌untuk‌‌kasus‌‌ini‌‌relatif‌‌sama‌‌dengan‌‌kasus‌‌no‌‌1,‌‌hanya‌‌saja‌‌fungsi‌‌untuk‌‌mengurutkan‌‌
 
data‌‌diubah‌‌dari‌‌pengurutan‌‌dengan‌‌sifat‌‌ascending‌‌atau‌‌dari‌‌kecil‌‌ke‌‌besar‌‌menjadi‌‌descending‌‌atau‌‌dari‌‌
 
besar‌‌ke‌‌kecil.‌‌Perubahan‌‌juga‌‌dilakukan‌‌pada‌‌penamaan‌‌variabel‌‌sesuai‌‌maksud‌‌dari‌‌isi‌‌variabel-variabel‌  ‌
tersebut.‌‌Perhatikan‌‌perubahan‌‌yang‌‌dilakukan‌‌pada‌‌fungsi‌u‌ rutkan().‌  ‌
‌Berikut:‌  ‌
void‌‌urutkan()‌‌{   ‌‌ ‌
//metode‌‌selection‌‌sort‌  ‌
‌int‌‌indexMaks,i,j;‌  ‌
‌int‌‌temp;‌  ‌
‌//loop‌‌untuk‌‌seluruh‌‌data‌‌    ‌
‌for(i‌‌=‌‌0;‌‌i‌‌<‌‌N-1;‌‌i++)‌‌{  ‌‌ ‌
‌//‌‌elemen‌‌sekarang‌‌yang‌‌dianggap‌‌nilai‌‌maksimum‌  ‌
‌indexMaks‌‌=‌‌i;‌  ‌
‌//periksa‌‌elemen‌‌paling‌‌besar‌  ‌
‌for(j‌‌=‌‌i+1;j‌‌<‌‌N;j++)‌‌{ ‌ ‌
‌if(data[j]‌‌>‌‌data[indexMaks])‌‌{‌‌//tanda‌‌'<'‌‌diganti‌‌dengan‌‌tanda‌‌'>'‌  ‌
‌indexMaks‌‌=‌‌j;‌  ‌
‌} ‌ ‌
‌} ‌ ‌
 ‌
‌if(indexMaks‌‌!=‌‌i)‌‌{//kalau‌‌posisinya‌‌bukan‌‌posisi‌‌awal‌  ‌
‌//‌‌pertukarkan‌‌posisi‌‌data‌‌    ‌
‌temp‌‌=‌‌data[indexMaks];‌  ‌
‌data[indexMaks]‌‌=‌‌data[i];‌  ‌
‌data[i]‌‌=‌‌temp;‌  ‌
‌} ‌  ‌ ‌
‌} ‌ ‌
}‌   ‌ ‌
Sehingga‌‌impelemtasi‌‌lengkap‌‌program‌‌C‌‌untuk‌‌kasus‌‌2‌‌adalah‌‌sebagai‌‌berikut:‌  ‌
/*‌ Nama‌‌File:‌‌sorting2.c‌  ‌
Program‌‌ini‌‌mendemonstrasikan‌‌penggunaan‌‌fungsi‌‌sorting‌‌dengan‌  ‌
sifat‌‌urutan‌‌adalah‌‌descending‌‌atau‌‌dari‌‌besar‌‌ke‌‌kecil‌ ‌*/‌  ‌
 ‌
#include‌‌<stdio.h>‌  ‌
#include‌‌<stdlib.h>‌  ‌
 ‌
//konstanta‌‌N‌‌menunjukkan‌‌banyaknya‌‌data‌  ‌
#define‌‌N‌‌5 ‌ ‌
 ‌
//variabel‌‌global‌‌berupa‌‌array‌‌berisi‌‌data‌‌int‌  ‌
int‌‌data[N];‌  ‌
 ‌
void‌‌urutkan();‌  ‌
 ‌
 ‌
main()‌  ‌
{‌ int‌‌i;‌  ‌
int‌‌datanya;‌  ‌
 ‌
printf("Isikan‌‌datanya‌‌dulu‌‌berupa‌‌nilai‌‌bilangan‌‌bulat\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
printf("Data‌‌indeks‌‌ke-%d:‌‌",‌‌i);‌  ‌
scanf("%d",‌‌&datanya);‌‌fflush(stdin);‌  ‌
//isikan‌‌ke‌‌array‌‌data[]‌  ‌
data[i]‌‌=‌‌datanya;‌  ‌
}‌  ‌
printf("\nEntri‌‌selesai...tekan‌‌enter...");‌  ‌
getch();‌  ‌
//panggil‌‌fungsi‌‌untuk‌‌mengurutkan‌‌data[]‌  ‌
urutkan();‌  ‌
//data‌‌yg‌‌telah‌‌diurut‌‌ditampilkan‌‌ke‌‌layar‌  ‌
printf("\nData‌‌terurut‌‌descending...\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
//salin‌‌dulu‌‌data‌‌dari‌‌array‌  ‌
datanya‌‌=‌‌data[i];‌  ‌
printf("%d\t",‌‌datanya);‌  ‌
}‌  ‌
printf("\n");//pindah‌‌baris‌  ‌
printf("Selesai‌‌...Tekan‌‌Enter...");‌  ‌
getch();‌  ‌
}‌  ‌
 ‌
void‌‌urutkan()‌‌{‌‌//metode‌‌selection‌‌sort‌  ‌
‌int‌‌indexMaks,i,j;‌  ‌
‌int‌‌temp;‌  ‌
 ‌
‌//loop‌‌untuk‌‌seluruh‌‌data‌‌    ‌
‌for(i‌‌=‌‌0;‌‌i‌‌<‌‌N-1;‌‌i++)‌‌{  ‌‌ ‌
 ‌
‌//‌‌elemen‌‌sekarang‌‌yang‌‌dianggap‌‌nilai‌‌maksimum‌  ‌
‌indexMaks‌‌=‌‌i;‌  ‌
 ‌
‌//periksa‌‌elemen‌‌paling‌‌besar‌  ‌
‌for(j‌‌=‌‌i+1;j‌‌<‌‌N;j++)‌‌{ ‌ ‌
‌if(data[j]‌‌>‌‌data[indexMaks])‌‌{‌‌//tanda‌‌'<'‌‌diganti‌‌dengan‌‌tanda‌‌'>'‌  ‌
‌indexMaks‌‌=‌‌j;‌  ‌
‌} ‌ ‌
‌} ‌ ‌
 ‌
‌if(indexMaks‌‌!=‌‌i)‌‌{//kalau‌‌posisinya‌‌bukan‌‌posisi‌‌awal‌  ‌
‌//‌‌pertukarkan‌‌posisi‌‌data‌‌    ‌
 ‌
t‌emp‌‌=‌‌data[indexMaks];‌  ‌
‌data[indexMaks]‌‌=‌‌data[i];‌  ‌
‌data[i]‌‌=‌‌temp;‌  ‌
‌} ‌  ‌ ‌
‌} ‌ ‌
}‌   ‌ ‌
 ‌
Hasil‌‌eksekusi‌‌program‌‌sorting02‌‌adalah:‌  ‌

 ‌
 ‌
Kasus‌‌3:‌  ‌
Modifikasilah‌‌program‌‌pada‌‌kasus‌‌2‌‌dimana‌‌bagian‌‌untuk‌‌mendisplaykan‌‌informasi‌‌dibuat‌‌menjadi‌‌
 
sebuah‌‌fungsi.‌  ‌
Jawab:‌  ‌
Untuk‌‌mendisplaykan‌‌data‌‌perlu‌‌dibuat‌‌suatu‌‌fungsi,‌‌misal‌‌bernama‌‌fungsi‌‌infokan().‌‌fungsi‌‌ini‌‌dibuat‌‌
 
tanpa‌‌parameter‌‌dan‌‌tanpa‌‌nilai‌‌balik,‌‌sehingga‌‌kebutuhan‌‌variabel‌‌dibuat‌‌bersifat‌‌lokal,‌‌kecual‌‌variabel‌‌
 
array‌‌‌data[].‌  ‌
Fungsi‌i‌nfokan()‌‌‌membutuhkan‌‌variabel‌‌lokal‌‌sebagai‌‌berikut:‌  ‌
✔ Variabel‌‌untuk‌‌konter‌‌perulangan,‌‌beri‌‌nama‌‌I‌‌bertipe‌‌int.‌‌Perulangan‌‌dibutuhkan‌‌untuk‌‌melakukan‌ 
pendisplayan‌‌setiap‌‌data‌‌dari‌‌array‌‌data[]‌‌dengan‌‌banyak‌‌perulangan‌‌sebanyak‌‌elemen‌‌array‌‌tersebut;‌  ‌
✔ Variabel‌‌untuk‌‌penampung‌‌data‌‌yang‌‌nilainya‌‌diambil‌‌dari‌‌array,‌‌berinama‌d‌ atanya‌‌‌dan‌‌bertipe‌i‌nt.‌  ‌
Contoh‌‌implementasinya‌‌dalam‌‌C‌‌adalah‌‌seperti‌‌berikut:‌  ‌
/*‌ Nama‌‌File:‌‌sorting3.c‌  ‌
Program‌‌ini‌‌mendemonstrasikan‌‌penggunaan‌‌fungsi‌‌sorting‌‌dan‌‌
   ‌
fungsi‌‌untuk‌‌mendisplay‌‌data‌ ‌*/‌  ‌
#include‌‌<stdio.h>‌  ‌
#include‌‌<stdlib.h>‌  ‌
//konstanta‌‌N‌‌menunjukkan‌‌banyaknya‌‌data‌  ‌
#define‌‌N‌‌5 ‌ ‌
//variabel‌‌global‌‌berupa‌‌array‌‌berisi‌‌data‌‌int‌  ‌
int‌‌data[N];‌  ‌
void‌‌urutkan();‌  ‌
void‌‌infokan();‌  ‌
 ‌
 ‌
main(){‌  ‌
int‌‌i;‌  ‌
int‌‌datanya;‌  ‌
 ‌
printf("Isikan‌‌datanya‌‌dulu‌‌berupa‌‌nilai‌‌bilangan‌‌bulat\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
printf("Data‌‌indeks‌‌ke-%d:‌‌",‌‌i);‌  ‌
scanf("%d",‌‌&datanya);‌‌fflush(stdin);‌  ‌
//isikan‌‌ke‌‌array‌‌data[]‌  ‌
data[i]‌‌=‌‌datanya;‌  ‌
}‌  ‌
printf("\nEntri‌‌selesai...tekan‌‌enter...");‌  ‌
getch();‌  ‌
//panggil‌‌fungsi‌‌untuk‌‌mengurutkan‌‌data[]‌  ‌
urutkan();‌  ‌
//data‌‌yg‌‌telah‌‌diurut‌‌ditampilkan‌‌ke‌‌layar‌  ‌
//dengan‌‌memanggil‌‌fungsi‌‌infokan()‌  ‌
infokan();‌  ‌
}‌  ‌
 ‌
void‌‌urutkan()‌‌{‌‌//metode‌‌selection‌‌sort‌  ‌
‌int‌‌indexMin,i,j;‌  ‌
‌int‌‌temp;‌  ‌
  //loop‌‌untuk‌‌seluruh‌‌data‌‌    ‌
‌for(i‌‌=‌‌0;‌‌i‌‌<‌‌N-1;‌‌i++)‌‌{  ‌‌ ‌
  ‌ ‌//‌‌elemen‌‌sekarang‌‌yang‌‌dianggap‌‌minimum‌  ‌
‌indexMin‌‌=‌‌i;‌  ‌
‌//periksa‌‌elemen‌‌paling‌‌kecil‌  ‌
‌for(j‌‌=‌‌i+1;j‌‌<‌‌N;j++)‌‌{ ‌ ‌
‌if(data[j]‌‌<‌‌data[indexMin])‌‌{ ‌ ‌
‌indexMin‌‌=‌‌j;‌  ‌
‌} ‌ ‌
‌} ‌ ‌
 ‌
‌if(indexMin‌‌!=‌‌i)‌‌{//kalau‌‌posisinya‌‌bukan‌‌posisi‌‌awal‌  ‌
‌//‌‌pertukarkan‌‌posisi‌‌data‌‌    ‌
‌temp‌‌=‌‌data[indexMin];‌  ‌
‌data[indexMin]‌‌=‌‌data[i];‌  ‌
‌data[i]‌‌=‌‌temp;‌  ‌
‌} ‌  ‌ ‌
‌} ‌ ‌
}‌   ‌ ‌
 ‌
void‌‌infokan(){‌  ‌
int‌‌i,‌‌datanya;‌   ‌
//data‌‌yg‌‌telah‌‌diurut‌‌ditampilkan‌‌ke‌‌layar‌  ‌
 ‌
printf("\nData‌‌terurut\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
//salin‌‌dulu‌‌data‌‌dari‌‌array‌  ‌
datanya‌‌=‌‌data[i];‌  ‌
printf("%d\t",‌‌datanya);‌  ‌
}‌  ‌
printf("\n");//pindah‌‌baris‌  ‌
printf("Selesai‌‌...Tekan‌‌Enter...");‌  ‌
getch();‌  ‌
}‌  ‌
 ‌
Hasil‌‌Eksekusi‌‌program‌‌sorting04.cpp‌‌: ‌ ‌

 ‌
 ‌
Kasus‌‌4:‌  ‌
Buatlah‌‌program‌‌pengolahan‌‌nilai‌‌mahasiswa‌‌seperti‌‌kasus-kasus‌‌sebelumnya,‌‌hanya‌‌saja‌‌program‌‌
 
diharapkan‌‌disertai‌‌dengan‌‌fasilitas‌‌pencarian‌‌dan‌‌pengurutan‌‌berdasarkan‌‌nilai‌‌akhir‌‌mahasiswa‌‌yang‌‌
 
bersangkutan.‌‌
   ‌
Jawab:‌  ‌
Kita‌  ‌mengacu‌  ‌ke‌  ‌kasus‌  ‌3 ‌ ‌pada‌  ‌pembahasan‌  ‌tentang‌  ‌pencarian,‌  ‌dimana‌  ‌struktur‌  ‌data‌  ‌yang‌  ‌digunakan‌‌
 
berupa‌  ‌array‌‌
  of‌‌
  struct‌‌
  of‌‌
  struct‌, ‌‌atau‌‌
  array‌‌
  dari‌‌
  suatu‌‌
  struct‌‌
  yang‌‌
  di‌‌
  dalamnya‌‌
  juga‌‌
  merupakan‌‌
  bentukan‌‌
 
struct,‌  ‌yaitu‌  ‌DATAMHS‌. ‌ ‌Pengembangan‌  ‌program‌  ‌tersebut‌  ‌terdapat‌  ‌pada‌  ‌penambahan‌  ‌fungsi‌  ‌untuk‌‌
 
melakukan‌  ‌pengurutan‌  ‌data‌  ‌mahasiswa.‌  ‌Perlu‌  ‌diingat,‌  ‌bahwa‌  ‌pengurutan‌  ‌yang‌  ‌akan‌  ‌dilakukan‌  ‌adalah‌‌
 
dalam‌  ‌rangka‌  ‌menentukan‌  ‌ranking‌  ‌mahasiswa‌  ‌berdasarkan‌  ‌perolehan‌  ‌nilai‌  ‌akhir‌  ‌atau‌  ‌variabel‌  ‌field‌‌
 
dataMhs[].nilai.nAkhir.‌  ‌
Fungsi‌‌untuk‌‌mengurutkan‌‌digunakan‌s‌ election‌‌sort,‌s‌ eperti‌‌yang‌‌sudah‌‌kita‌‌bahas‌‌sebelumnya.‌  ‌
Kebutuhan‌‌untuk‌‌implementasi‌‌fungsi‌‌pengurutan‌‌meliputi:‌  ‌
✔ Variabel‌  ‌indexMaks,‌  ‌digunakan‌  ‌untuk‌  ‌penampung‌  ‌sementara‌  ‌nomor‌  ‌indeks‌  ‌array‌  ‌yang‌  ‌dianggap‌‌
 
bernilai‌‌paling‌‌tinggi‌‌dan‌‌bertipe‌i‌nt;‌  ‌
✔ Variabel‌‌i,‌‌s‌ ebagai‌‌konter‌‌perulangan‌‌bertipe‌‌‌int;‌  ‌
 ‌
✔ Variabel‌‌‌j,‌s‌ ebagai‌‌penyimpan‌‌nomor‌‌indeks‌‌yang‌‌dibandingkan‌‌nilainya‌‌dengan‌‌data‌‌pada‌‌indeks‌‌‌i;‌  ‌
✔ Variabel‌t‌emp‌‌‌sebagai‌‌penampung‌‌sementara‌‌dari‌‌keseluruhan‌‌data‌‌pada‌s‌ truct‌‌‌bertipe‌D
‌ ATAMHS.‌  ‌
Secara‌‌keseluruhan,‌‌kebutuhan‌‌fungsi‌‌untuk‌‌kasus‌‌ini‌‌adalah:‌  ‌
✔ Fungsi‌  ‌judul(),‌  ‌merupakan‌  ‌fungsi‌  ‌tanpa‌  ‌parameter‌  ‌dan‌  ‌tanpa‌  ‌nilai‌  ‌balik,‌  ‌fungsi‌‌
  ini‌‌
  hanya‌‌
  bertugas‌‌
 
menampilkan‌‌judul‌‌program;‌  ‌
✔ Fungsi‌b‌ acaMhs()‌,‌‌merupakan‌‌fungsi‌‌untuk‌‌membaca‌‌identitas‌‌seluruh‌‌mahasiswa;‌  ‌
✔ Fungsi‌  ‌bacaNilai(int),‌  ‌merupakan‌  ‌fungsi‌  ‌untuk‌  ‌membaca‌  ‌komponen‌  ‌nilai‌  ‌dari‌  ‌mahasiswa‌  ‌yang‌‌
 
bersangkutan.‌  ‌Fungsi‌  ‌ini‌  ‌dipanggil‌  ‌dari‌  ‌dalam‌  ‌fungsi‌  ‌bacaMhs()‌, ‌‌karena‌‌
  itu‌‌
  membutuhkan‌‌
  passing‌‌
 
parameter‌i‌nt‌‌‌yang‌‌merepresentasikan‌‌nomor‌‌indeks‌a‌ rray‌‌‌dari‌‌data‌‌mahasiswa‌‌yang‌‌bersangkutan;‌  ‌
✔ Fungsi‌  ‌infoMhs(int),‌    ‌merupakan‌  ‌fungsi‌  ‌yang‌  ‌bertugas‌  ‌menampilkan‌  ‌informasi‌  ‌setiap‌  ‌mahasiswa‌‌
 
melalui‌‌passing‌‌parameter‌‌int‌‌sebagai‌‌nomor‌‌indeks‌‌data‌‌mahasiswa‌‌pada‌‌array‌‌of‌‌struct;‌  ‌
✔ Fungsi‌‌
  ‌hitungAkhir(double,‌‌
  double,‌‌
  double,‌‌
 double),‌‌
 ‌merupakan‌‌
 fungsi‌‌
 untuk‌‌
 menghitung‌‌
 nilai‌‌
 akhir‌‌
 
berdasarkan‌‌passing‌‌parameter‌‌nilai‌‌mid,‌‌nilai‌‌uas,‌‌nilai‌‌tugas‌‌dan‌‌nilai‌‌quiz;‌  ‌
✔ Fungsi‌  ‌konversiHuruf(double),‌  ‌merupakan‌  ‌fungsi‌  ‌untuk‌  ‌mengkonversikan‌  ‌nilai‌  ‌akhir‌‌
  menjadi‌‌
  nilai‌‌
 
huruf,‌  ‌sesuai‌  ‌dengan‌  ‌ketentuan‌  ‌yang‌  ‌ditetapkan.‌  ‌Passing‌‌
  parameter‌‌
  dari‌‌
  fungsi‌‌
  ini‌‌
  merupakan‌‌
  nilai‌‌
 
akhir‌‌hasil‌‌perhitungan‌‌oleh‌‌fungsi‌h‌ itungAkhir();‌  ‌
✔ Fungsi‌  ‌cariData(char[]),‌  ‌merupakan‌  ‌fungsi‌  ‌yang‌  ‌bertugas‌  ‌mencari‌  ‌data‌  ‌tertentu‌  ‌dalam‌  ‌array‌  ‌of‌ 
struct.‌‌Passing‌‌parameter‌‌dari‌‌fungsi‌‌merupakan‌‌nomor‌‌nim‌‌mahasiswa‌‌yang‌‌akan‌‌dicari.‌  ‌
✔ Fungsi‌  ‌urutkan(),‌‌
  fungsi‌‌
  untuk‌‌
  mengurutkan‌‌
  data‌‌
  secara‌‌
  descending‌‌
  (diurut‌‌
  dari‌‌
  nilai‌‌
  paling‌‌
  besar),‌‌
 
berdasarkan‌‌data‌‌nilai‌‌akhir‌‌setiap‌‌mahasiswa.‌  ‌
Fungsi-fungsi‌  ‌tersebut‌  ‌sudah‌  ‌kita‌  ‌buat‌  ‌pada‌  ‌pembahasan-pembahasan‌  ‌sebelumnya,‌‌
  walaupun‌‌
  tentu‌‌
  saja‌‌
 
terdapat‌  ‌perubahan‌  ‌untuk‌  ‌disesuaikan‌  ‌dengan‌  ‌kebutuhan‌  ‌pada‌  ‌penyelesaian‌  ‌kasus‌  ‌ini.‌  ‌Secara‌  ‌lengkap,‌‌
 
implementasi‌‌dari‌‌program‌‌dalam‌‌C‌‌dapat‌‌Anda‌‌pelajari‌‌dari‌‌listing‌‌kode‌‌berikut‌‌ini:‌  ‌
/*‌ Nama‌‌File:‌‌sorting4.c‌  ‌
Program‌‌ini‌‌mendemonstrasikan‌‌penggunaan‌‌fungsi‌‌sorting‌‌dengan‌  ‌
menggunakan‌‌array‌‌of‌‌struct‌‌dari‌‌data‌‌mahasiswa‌‌sebelumnya.‌  ‌
sifat‌‌urutan‌‌adalah‌‌descending‌‌atau‌‌dari‌‌besar‌‌ke‌‌kecil‌ ‌*/‌  ‌
 ‌
#include‌‌<stdio.h>‌  ‌
#include‌‌<stdlib.h>‌  ‌
#include‌‌<string.h>‌  ‌
 ‌
#define‌‌N‌‌3‌‌//banyaknya‌‌mahassiswa‌  ‌
#define‌‌MID‌‌0.25‌‌//prosentase‌‌nilai‌‌mid‌‌adalah‌‌25‌‌persen‌  ‌
#define‌‌UAS‌‌0.30‌‌//prosentase‌‌nilai‌‌uas‌‌adalah‌‌30‌‌persen‌  ‌
#define‌‌TGS‌‌0.30‌‌//prosentase‌‌nilai‌‌tugas‌‌adalah‌‌30‌‌persen‌  ‌
#define‌‌QSZ‌‌0.15‌‌//prosentase‌‌nilai‌‌quiz‌‌adalah‌‌15‌‌persen‌  ‌
 ‌
 ‌
//mendefinisikan‌‌tipe‌‌bentukan‌‌berupa‌‌struct‌‌bernama‌‌MHS‌  ‌
typedef‌‌struct‌‌MHS{‌  ‌
char‌‌nama[30];‌‌//panjang‌‌nama‌‌mahasiswa‌‌adalah‌‌30‌‌karakter‌  ‌
char‌‌nim[4];‌ ‌//panjang‌‌nim‌‌mahasiswa‌‌adalah‌‌5‌‌karakter‌  ‌
}‌‌MHS;‌‌//nama‌‌tipe‌‌bentukan‌‌adalah‌‌MHS‌  ‌
 ‌
typedef‌‌struct‌‌NILAI{‌  ‌
double‌‌mid;‌‌    ‌
double‌‌uas;‌  ‌
double‌‌tugas;‌  ‌
double‌‌quiz;‌  ‌
double‌‌nAkhir;‌‌//dihitung‌‌dengan‌‌fungsi‌‌hitungAkhir()‌  ‌
char‌‌nHuruf;‌‌//diisi‌‌melalui‌‌pemanggilan‌‌fungsi‌‌konversiHuruf()‌  ‌
}‌‌NILAI;‌  ‌
 ‌
//kedua‌‌tipe‌‌MHS‌‌dan‌‌NILAI‌‌digunakan‌‌untuk‌‌tipe‌‌bentukan‌‌baru‌  ‌
//suatu‌‌stract‌‌of‌‌struct‌‌atau‌‌struct‌‌di‌‌dalam‌‌struct,‌‌sehingga‌  ‌
//struct‌‌yang‌‌baru‌‌memili‌‌seluruh‌‌data‌‌baik‌‌identitas‌‌maupun‌‌    ‌
//nilai2‌‌mahasiswa,‌‌sbb:‌  ‌
‌typedef‌‌struct‌‌DATAMHS{‌  ‌
 ‌ MHS‌‌mhs;‌  ‌
 ‌ NILAI‌‌nilai;‌  ‌
‌}‌‌DATAMHS;‌  ‌
 ‌
//deklarasi‌‌fungsi‌‌yang‌‌akan‌‌digunakan‌  ‌
void‌‌judul();‌  ‌
void‌‌bacaMhs();‌  ‌
void‌‌bacaNilai(int‌‌i);‌‌//fungsi‌‌untuk‌‌mengisi‌‌nilai‌‌mahasiswa‌  ‌
void‌‌infoMhs(int‌‌i);‌  ‌
double‌‌hitungAkhir(double‌‌m,‌‌double‌‌u,‌‌double‌‌t,‌‌double‌‌q);‌  ‌
char‌‌konversiHuruf(double‌‌na);‌  ‌
int‌‌cariData(char‌‌nimnya[]);//fungsi‌‌ini‌‌mencari‌‌posisi‌‌data‌‌yg‌‌dicari‌  ‌
void‌‌urutkan();‌  ‌
 ‌
//deklarasi‌‌variabel‌‌global‌‌berupa‌‌array‌‌of‌‌struct‌‌dari‌‌tipe‌‌DATAMHS‌‌sbb:‌  ‌
DATAMHS‌‌dataMhs[N];‌‌//banyak‌‌mahasiswa‌‌adalah‌‌N‌‌orang‌  ‌
 ‌
void‌‌main(){‌  ‌
int‌‌i,‌‌posisi;‌‌//konter‌‌perulangan‌‌untuk‌‌menampilkan‌‌data‌‌mahasiswa‌  ‌
char‌‌nimnya[4];‌  ‌
 ‌
printf("Contoh‌‌Pengurutan\n\n");‌  ‌
//panggil‌‌fungsi‌‌judul()‌  ‌
judul();‌  ‌
//panggil‌‌fungsi‌‌bacaMhs()‌  ‌
bacaMhs();‌  ‌
 ‌
printf("\nMenampilkan‌‌Identitas‌‌Seluruh‌‌Mahasiswa\n");‌  ‌
printf("Tekan‌‌Enter...");‌  ‌
getch();‌  ‌
for(i=0;i<N;i++){‌  ‌
//panggil‌‌fungsi‌‌infoMhs()‌‌mulai‌‌dari‌‌i=0,‌‌atau‌‌yg‌‌pertama‌  ‌
infoMhs(i);//nilai‌‌i‌‌adalah‌‌passing‌‌parameter‌‌yng‌‌menyatakan‌‌no‌‌indeks‌‌array‌  ‌
printf("\n");‌  ‌
}‌  ‌
 ‌
printf("\nMencari‌‌Mahasiswa‌‌melalui‌‌NIM\n");‌  ‌
printf("Tekan‌‌Enter...");‌  ‌
getch();‌  ‌
printf("\nKetikkan‌‌NIM‌‌yang‌‌dicari:‌‌");‌  ‌
gets(nimnya);‌‌fflush(stdin);‌  ‌
posisi‌‌=‌‌cariData(nimnya);‌  ‌
if(posisi‌‌!=‌‌-999){‌  ‌
printf("\nData‌‌ditemukan...\n");‌  ‌
infoMhs(posisi);‌‌//kirimkan‌‌nilai‌‌posisi‌‌data‌‌untuk‌‌ditampilkan‌  ‌
}‌  ‌
else‌‌printf("\nData‌‌tidak‌‌ditemukan....\n");‌  ‌
 ‌
printf("\nMengurutkan‌‌data‌‌Mahasiswa\n");‌  ‌
printf("Tekan‌‌Enter...");‌  ‌
getch();‌  ‌
urutkan();‌  ‌
printf("Data‌‌diurutkan‌‌secara‌‌descending...\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
//panggil‌‌fungsi‌‌infoMhs()‌‌mulai‌‌dari‌‌i=0,‌‌atau‌‌yg‌‌pertama‌  ‌
infoMhs(i);//nilai‌‌i‌‌adalah‌‌passing‌‌parameter‌‌yng‌‌menyatakan‌‌no‌‌indeks‌‌array‌  ‌
printf("\n");‌  ‌
}‌  ‌
printf("Selesai...Tekan‌‌Enter...");‌  ‌
getch();‌  ‌
}‌  ‌
 ‌
void‌‌judul()‌  ‌
{‌ ‌printf("=============================================\n");‌  ‌
‌printf("Program‌‌Pengolahan‌‌Data‌‌Mahasiswa\n");‌  ‌
‌printf("Programmer:‌‌Antu\n");‌  ‌
‌printf("Program‌‌ini‌‌digunakan‌‌untuk‌‌mencontohkan‌‌pembuatan‌‌fungsi‌‌tanpa‌‌nilai‌‌balik\n");‌  ‌
‌printf("==============================================\n");‌ 
‌printf("Tekan‌‌tombol‌‌enter...");‌  ‌
‌getch();‌  ‌
‌} ‌ ‌
 ‌
void‌‌bacaMhs()‌  ‌
 ‌
{‌ int‌‌i;‌‌//variable‌‌konter‌‌perulangan‌  ‌
char‌‌namanya[30];‌‌//penyimpan‌‌sementara‌‌nama‌‌mahasiswa‌  ‌
char‌‌nimnya[4];‌‌//penyimpan‌‌sementara‌‌nim‌‌mahasiswa‌  ‌
 ‌
printf("\nMembaca‌‌identitas‌‌sejumlah‌‌Mahasiswa\n");‌  ‌
printf("========================================\n");‌  ‌
for(i=0;i<N;i++){‌  ‌
printf("Ketikkan‌‌nama‌‌Mahasiswa:‌‌");‌  ‌
gets(namanya);‌‌fflush(stdin);‌‌//baca‌‌nama‌‌mahasiswa‌  ‌
printf("Ketikkan‌‌NIM‌ ‌Mahasiswa:‌‌");‌  ‌
gets(nimnya);‌‌fflush(stdin);‌‌//baca‌‌nim‌‌mahasiswa‌  ‌
//masukan‌‌nama‌‌dan‌‌nim‌‌mahasiswa‌‌ke‌‌array‌‌of‌‌struct‌  ‌
strcpy(dataMhs[i].mhs.nama,‌‌namanya);‌‌//perhatikan‌‌cara‌‌mengakses‌‌field‌  ‌
strcpy(dataMhs[i].mhs.nim,‌‌nimnya);‌  ‌
//sekalian‌‌juga‌‌mengentri‌‌nilai2nya‌‌dg‌‌memanggil‌  ‌
//fungsi‌‌bacaNilai(),‌‌sbb‌  ‌
bacaNilai(i);‌  ‌
}‌  ‌
printf("\nEntri‌‌Data‌‌selesai...Tekan‌‌enter...");‌  ‌
getch();‌  ‌
}‌  ‌
 ‌
void‌‌bacaNilai(int‌‌i){‌  ‌
double‌‌midnya,‌‌uasnya,‌‌tugasnya,‌‌quiznya,‌‌nAkhirnya;‌  ‌
char‌‌nHurufnya;‌  ‌
 ‌
printf("\nKetik‌‌nilai‌‌MID‌ ‌:‌‌");‌  ‌
scanf("%lf",‌‌&midnya);‌‌fflush(stdin);‌  ‌
printf("Ketik‌‌nilai‌‌UAS‌ ‌:‌‌");‌  ‌
scanf("%lf",‌‌&uasnya);‌‌fflush(stdin);‌  ‌
printf("Ketik‌‌nilai‌‌Tugas‌‌:‌‌");‌  ‌
scanf("%lf",‌‌&tugasnya);‌‌fflush(stdin);‌ 
printf("Ketik‌‌nilai‌‌Quiz‌ ‌:‌‌");‌  ‌
scanf("%lf",‌‌&quiznya);‌‌fflush(stdin);‌  ‌
//lalu‌‌masukkan‌‌ke‌‌array‌‌dataMhs,‌‌sbb‌  ‌
dataMhs[i].nilai.mid‌‌=‌‌midnya;‌‌    ‌
dataMhs[i].nilai.uas‌‌=‌‌uasnya;‌‌    ‌
dataMhs[i].nilai.tugas‌‌=‌‌tugasnya;‌‌    ‌
dataMhs[i].nilai.quiz‌‌=‌‌quiznya;‌‌    ‌
//lalu‌‌panggil‌‌fungsi‌‌untuk‌‌menghitung‌‌nilai‌‌akhir‌‌dan‌   ‌ ‌
//tampung‌‌nilai‌‌baliknya‌‌pada‌‌variabel‌‌nAkhirnya‌  ‌
nAkhirnya‌ ‌=‌‌hitungAkhir(midnya,‌‌uasnya,‌‌tugasnya,‌‌quiznya);‌  ‌
/*‌‌lalu‌‌panggil‌‌fungsi‌‌untuk‌‌mengkonveri‌‌nilai‌‌akhir‌‌ke‌‌nilai‌‌huruf‌‌dengan‌  ‌
passing‌‌parameter‌‌berupa‌‌nilai‌‌akhir‌‌atau‌‌nAkhirnya,‌‌    ‌
tampung‌‌hasil‌‌atau‌‌nilai‌‌baliknya‌‌pada‌‌variabel‌‌nHurufnya‌ ‌*/‌  ‌
nHurufnya‌‌=‌‌konversiHuruf(nAkhirnya);‌  ‌
 ‌
//simpan‌‌nilai‌‌akhir‌‌dan‌‌nilai‌‌huruf‌‌ke‌‌dataMhs‌  ‌
dataMhs[i].nilai.nAkhir‌‌=‌‌nAkhirnya;‌  ‌
dataMhs[i].nilai.nHuruf‌‌=‌‌nHurufnya;‌  ‌
printf("\n");‌  ‌
}‌  ‌
//fungsi‌‌ini‌‌harus‌‌dimodifikasi‌‌melibatkan‌‌data‌‌nilai2‌  ‌
void‌‌infoMhs(int‌‌i)‌  ‌
{‌‌
  char‌‌namanya[30];‌‌   //penyimpan‌‌sementara‌‌nama‌‌mahasiswa‌  ‌
char‌‌nimnya[4];‌ ‌//penyimpan‌‌sementara‌‌nim‌‌mahasiswa‌  ‌
double‌‌nAkhirnya;‌  ‌
char‌‌nHurufnya;‌  ‌
 ‌
printf("\nInformasi‌‌Identitas‌‌Mahasiswa\n");‌  ‌
printf("========================================\n");‌  ‌
//salin‌‌dulu‌‌data‌‌mahasiswa‌‌ke‌‌variabel‌‌sementara‌  ‌
strcpy(namanya,‌‌dataMhs[i].mhs.nama);‌  ‌
strcpy(nimnya,‌‌dataMhs[i].mhs.nim);‌  ‌
//tampung‌‌dulu‌‌nilai‌‌akhir‌‌dan‌‌nilai‌‌huruf‌  ‌
nAkhirnya‌‌=‌‌dataMhs[i].nilai.nAkhir;‌  ‌
nHurufnya‌‌=‌‌dataMhs[i].nilai.nHuruf;‌  ‌
//tampilkan‌‌informasi‌‌mahasiswa‌‌yang‌‌diminta‌  ‌
printf("Nama‌‌Mahasiswa‌ ‌:‌‌%s\n",‌‌namanya);‌  ‌
printf("Nomor‌‌Induk‌‌Mahasiswa‌‌:‌‌%s\n",‌‌nimnya);‌  ‌
printf("\tNilai‌‌Akhir‌ ‌:‌‌%0.1lf\n",‌‌nAkhirnya);‌  ‌
printf("\tNilai‌‌Huruf‌ ‌:‌‌%c\n",‌‌nHurufnya);‌  ‌
printf("========================================\n");‌  ‌
}‌  ‌
 ‌
double‌‌hitungAkhir(double‌‌m,‌‌double‌‌u,‌‌double‌‌t,‌‌double‌‌q){‌  ‌
double‌‌nAkhirnya;‌  ‌
 ‌
nAkhirnya‌‌=‌‌m‌‌*‌‌MID‌‌+‌‌u‌‌*‌‌UAS‌‌+‌‌t‌‌*‌‌TGS‌‌+‌‌q‌‌*‌‌QSZ;‌  ‌
return‌‌nAkhirnya;‌  ‌
}‌  ‌
 ‌
char‌‌konversiHuruf(double‌‌na){‌  ‌
char‌‌nHurufnya;‌  ‌
//tentukan‌‌nilai‌‌hurufnya‌  ‌
if((na‌‌>=‌‌81.0)‌‌&&‌‌(na<=‌‌100.0))‌  ‌
nHurufnya‌‌=‌‌'A';‌  ‌
else‌‌if(na‌‌>=‌‌76.0)‌  ‌
nHurufnya‌‌=‌‌'B';‌  ‌
else‌‌if(na‌‌>=‌‌56.0)‌  ‌
nHurufnya‌‌=‌‌'C';‌  ‌
else‌‌if(na‌‌>=‌‌45.0)‌  ‌
nHurufnya‌‌=‌‌'D';‌  ‌
 ‌
else‌‌nHurufnya‌‌=‌‌'E';‌  ‌
 ‌
return‌‌nHurufnya;‌‌//kirim‌‌hasilnya‌‌sebagai‌‌nilai‌‌balik‌  ‌
}‌  ‌
 ‌
int‌‌cariData(char‌‌nimnya[]){‌  ‌
int‌‌i,‌‌posisi;‌  ‌
 ‌
//cari‌‌nim‌‌tersebut‌‌di‌‌array‌‌nim‌  ‌
for(i=0;i<N;i++){‌  ‌
if(!strcmp(nimnya,‌‌dataMhs[i].mhs.nim)){‌  ‌
posisi‌‌=‌‌i;‌  ‌
break;‌  ‌
}‌  ‌
else‌‌{ ‌ ‌
posisi‌‌=‌‌-999;‌‌//nilai‌‌ini‌‌menunjukkan‌‌data‌‌tdk‌‌ditemukan‌  ‌
}‌  ‌
}‌  ‌
return‌‌posisi;‌‌//posisi‌‌data‌‌dikirim‌‌sebagai‌‌nilai‌‌balik‌  ‌
}‌  ‌
 ‌
void‌‌urutkan()‌‌{‌‌//metode‌‌selection‌‌sort‌  ‌
‌int‌‌indexMaks,i,j;‌  ‌
‌DATAMHS‌‌temp;‌‌//variabel‌‌sementara‌‌berupa‌‌struct‌‌DATAMHS‌  ‌
 ‌
‌//loop‌‌untuk‌‌seluruh‌‌data‌‌    ‌
‌for(i‌‌=‌‌0;‌‌i‌‌<‌‌N-1;‌‌i++)‌‌{  ‌‌ ‌
 ‌
‌//‌‌elemen‌‌sekarang‌‌yang‌‌dianggap‌‌nilai‌‌maksimum‌  ‌
‌indexMaks‌‌=‌‌i;‌  ‌
 ‌
‌//periksa‌‌nilai‌‌akhir‌‌terbesar‌  ‌
‌for(j‌‌=‌‌i+1;j‌‌<‌‌N;j++)‌‌{ ‌ ‌
‌if(dataMhs[j].nilai.nAkhir‌‌>‌‌dataMhs[indexMaks].nilai.nAkhir)‌‌{   ‌‌ ‌
‌indexMaks‌‌=‌‌j;‌  ‌
‌} ‌ ‌
‌} ‌ ‌
 ‌
‌if(indexMaks‌‌!=‌‌i)‌‌{//kalau‌‌posisinya‌‌bukan‌‌posisi‌‌awal‌  ‌
‌//‌‌pertukarkan‌‌posisi‌‌data‌‌    ‌
‌temp‌‌=‌‌dataMhs[indexMaks];‌  ‌
‌dataMhs[indexMaks]‌‌=‌‌dataMhs[i];‌  ‌
‌dataMhs[i]‌‌=‌‌temp;‌  ‌
‌} ‌  ‌ ‌
‌} ‌ ‌
}‌  ‌
 ‌
 ‌
Hasil‌‌Eksekusi‌‌program‌‌sorting04.cpp‌‌adalah‌‌: ‌ ‌

 ‌
 ‌
 ‌
E. Aktivitas‌‌Pembelajaran‌  ‌
1. Mempelajari‌‌Modul‌‌Bahan‌‌Ajar‌  ‌
2. Mencari‌‌Bahan‌‌yang‌‌relevan‌  ‌
3. Diskusi‌  ‌
4. Latihan‌‌Mandiri‌  ‌
5. Memahami‌‌tugas‌  ‌
 ‌
F. Rangkuman‌  ‌
 ‌
Konsep‌‌tentang‌‌searching‌‌dan‌‌sorting,‌‌merupakan‌‌konsep‌‌penting‌‌dalam‌‌aktivitas‌‌pemrograman.‌‌
 
Terdapat‌‌banyak‌‌metode‌‌yang‌‌bisa‌‌digunakan,‌‌baik‌‌untuk‌‌metode‌‌dalam‌‌pencarian‌‌maupun‌‌
 
pengurutan.‌  ‌

Metode‌‌pencarian‌‌paling‌‌sederhana‌‌adalah‌‌metode‌‌pencarian‌‌linier,‌‌dimana‌‌data‌‌yang‌‌akan‌‌dicari‌‌
 
disisir‌‌satu‌‌persatu‌‌dimulai‌‌dari‌‌data‌‌pertama‌‌hingga‌‌data‌‌terakhir.‌‌Apabila‌‌dalam‌‌pencarian‌‌
 
tersebut‌‌data‌‌yang‌‌dicari‌‌ditemukan,‌‌maka‌‌pencarian‌‌dihentikan‌‌,‌‌sebaliknya,‌‌pencarian‌‌
 
diteruskan‌‌dengan‌‌menelusuri‌‌data‌‌berikutnya.‌  ‌

Metode‌‌yang‌‌digunakan‌‌dalam‌‌pengurutan‌‌juga‌‌memiliki‌‌beragam‌‌metode,‌‌dimana‌‌setiap‌‌
 
metode‌‌memiliki‌‌kelebihan‌‌dan‌‌kekurangannya‌‌sendiri.‌‌Metode‌‌paling‌‌sederhana‌‌dalam‌‌
 
pengurutan‌‌data‌‌adalah‌‌metode‌s‌ election‌‌sort‌.‌‌Metode‌‌ini‌‌melakukan‌‌pengurutan‌‌dengan‌‌cara‌‌
 
memilih‌‌data‌‌sementara‌‌dari‌‌sekumpulan‌‌data‌‌sebagai‌‌data‌‌pembanding‌‌terhadap‌‌data‌‌lain‌‌dalam‌‌
 
kelompok.‌‌Metode‌‌pengurutan‌‌dapat‌‌berupa‌‌pengurutan‌‌ascending‌‌atau‌‌descending‌‌yang‌‌akan‌‌
 
menentukan‌‌pilihan‌‌data‌‌dalam‌‌perbandingannya.‌  ‌

 ‌

G. Latihan‌‌Mandiri‌‌Teori‌‌
   ‌
1. Tulis‌‌kembali‌‌prosedur‌‌pengurutan‌‌dengan‌‌metode‌‌(1)‌‌Buble‌‌sort,‌‌(2)‌‌Selection‌‌Sort‌‌
 

(Maximum‌‌Sort‌‌dan‌‌Minimum‌‌Sort)),‌‌(3)‌‌Insertion‌‌Sort,‌‌(4)‌‌Heap‌‌Sort,‌‌(5)‌‌Shell‌‌Sort,‌‌
 
(6)‌‌Quick‌‌Sort,‌‌(7)‌‌Merge‌‌Sort,‌‌(8)‌‌Radix‌‌Sort,‌‌dan‌‌(9)‌‌Tree‌‌Sort.‌  ‌
 ‌
H. Tugas‌  ‌
1. Buat‌‌sebuah‌‌program‌‌yang‌‌dapat‌‌digunakan‌‌untuk‌‌mendata‌‌hasil‌‌pertandingan‌‌lompat‌‌
 
tinggi‌‌dari‌‌sejumlah‌‌peserta.‌‌Lalu‌‌urutkan‌‌peserta‌‌berdasarkan‌‌tinggi‌‌lompatan.‌  ‌
2. Buatlah‌‌program‌‌yang‌‌dapat‌‌digunakan‌‌untuk‌‌mengolah‌‌hasil‌‌pertandingan‌‌balap‌‌sepeda‌‌
 
sehingga‌‌program‌‌dapat‌‌menentukan‌‌dan‌‌menampilkan‌‌para‌‌juaran‌‌lomba.‌  ‌
 ‌

Daftar‌‌Rujukan‌  ‌
1. Rinaldi‌‌Munir.‌‌(2016).‌A
‌ lgoritma‌‌dan‌‌Pemrograman‌‌dalam‌‌Bahasa‌‌Pascal,‌‌C‌‌dan‌‌C++‌. ‌‌
Bandung:‌‌Informatika.‌‌
   ‌
2. Murali‌‌Chemutury.‌‌(2019).‌C
‌ omputer‌‌programming‌‌for‌‌beginners-‌‌a‌‌step-by-step‌‌guide‌.‌‌CRC‌‌
 
Press.‌  ‌
3. https://www.tutorialspoint.com/cprogramming‌  ‌
 ‌
4. https://www.javatpoint.com/c-programming-language-tutorial‌‌
   ‌