Pencarian dan Pengurutan

(Searching and Sorting)

Oleh : Tim Penyusun MKU Pengantar Coding.
Lisensi Dokumen:
Copyright © 2020 Universitas Negeri Padang
Seluruh dokumen di e-Learning Universitas Negeri Padang, hanya digunakan untuk kalangan Internal
Universitas, untuk kebutuhan Perkuliahan Online. Penggunaan dokumen ini di luar UNP tidak diizinka
dan tidak diperbolehkan melakukan penulisan ulang, kecuali mendapatkan ijin terlebih dahulu dari
Penulis dan Universitas Negeri Padang.

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 Pencarian dan Pengurutan (Searching 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 (Searching)
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 (array) 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 (message) 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 (sequensial search) dan metode pencarian bagi-dua (binary search).

1.1. Metode Pencarian Beruntun/Linear (Sequential Search)

Metode pencarian beruntun (sequential search) atau pencarian lurus (linear search), adalah
proses pencarian yang sangat sederhana dengan cara membandingkan setiap elemen larik (array) 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 dicatat 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 bahasa verbal dan algoritma kode semu (pseudo-code) :
Algoritma Pencarian Linier (Array A, Nilai x)
Langkah 1: di awali dengan Setel i ke 1
 Langkah 2: jika i > n maka lanjutkan ke langkah 7
Langkah 3: jika 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 Cetak x Ditemukan di indeks ke- i dan lanjutkan ke langkah 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 int, 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 isiNilai( )
 Masalah mencari data tertentu sesuai keinginan dan akan dijadikan fungsi pencarian, misal
bernama cariNilai( )
 Masalah menampilkan seluruh isi array dapat diimplemetasikan sebagai fungsi untuk
menampilkan dapat diberi nama fungsi tampilkan( )
 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 posisi, dan variabel tanda
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 getch(), diganti dengan statemen yang setara getchar(). 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 cariNilai()
{
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 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();
}

void cariNilai() {
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 nim bertipe string atau char[ ] berbentuk array yang dapat
menampung N data dan setiap nim berukuran sama, misal 4 (atau 4 karakter), misalnya:
char nim[N][4];

 Kebutuhan fungsi pencarian

Fungsi yang akan dibuat merupakan fungsi yang memiliki nilai balik berupa nilai boolean (dalam C
digunakan tipe int) dimana nilai 0 untuk menyatakan false dan 1 menyatakan true. Artinya,apabila
fungsi ini mengembalikan 0 berarti data yang dicari tidak-ditemukan, sebaliknya, apabila nilai
baliknya 1 berarti data yang dicari berhasil-ditemukan. Nilai balik tersebut dikirimkan dalam
variabel bernama status bertipe int. Fungsi ini juga memiliki passing 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 kounter 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 array of struct yang telah kita buat berupa tipe DATAMHS.
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 cariData() 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 array 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 (Sorting)
Pengurutan (sorting)adalah proses mengatur sekumpulan objek menurut urutan atau susunan
tertentu [Munir 2003]. Urutan objek tersebut dapat menaik (ascenmding) atau menurun (descending).
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 (record). Jika data bertipe
terstruktur, maka harus dispesifikasikan berdasarkan field apa data tersebut diurutkan. Field yang
dijadikan dasar pengurutan dikenal sebagai field 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 algoritma 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

for i = 1 to n - 1
/* set elemen saat ini sebagai minimum*/
min = i

/* check the element to be minimum */

for j = i+1 to n
if list[j] < list[min] then
min = j;
end if
end for

/* pertukarkan elemen minimum dengan elemen saat ini*/

if indexMin != i then
swap list[min] and list[i]
end if
end for
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 data[N] bertipe 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 urutkan().
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
temp = 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 infokan() 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 datanya dan bertipe int.
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 selection sort, seperti 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 int;
 Variabel i, sebagai konter perulangan bertipe int;
 Variabel j, sebagai penyimpan nomor indeks yang dibandingkan nilainya dengan data pada indeks i;
 Variabel temp sebagai penampung sementara dari keseluruhan data pada struct bertipe DATAMHS.
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 bacaMhs(), 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 int yang merepresentasikan nomor indeks array 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 hitungAkhir();
 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 selection 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). Algoritma dan Pemrograman dalam Bahasa Pascal, C dan C++.
Bandung: Informatika.
2. Murali Chemutury. (2019). Computer 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