TUGAS PERTEMUAN 12

Algoritma Pemrograman

PENGURUTAN DATA “SORTING”

DOSEN PENGAMPU:

Drs. Denny Kurniadi, M. Kom

Oleh:

Rizky Annisa

22076018

Pendidikan Informatika

PROGRAM STUDI PENDIDIKAN INFORMATIKA

JURUSAN ELEKTRONIKA

FAKULTAS TEKNIK

UNIVERSITAS NEGERI PADANG

2022
CONTOH KASUS 1
Buatlah program untuk mengurutkan sejumlah data yang tersimpan dalam
suatu array berukuran tertentu. Hasil pengurutan ditampilkan ke layar.

Analisis Kebutuhan
 Kebutuhan konstanta
Perlu konstanta untuk menetapkan banyaknya elemen array, misal N dengan
sembarang (misal nilai 5) sbb:
#define N 5

 Kebutuhan variabel global

Variabel array dengan jumlah elemen adalah N, misal berinama nilai[N]
bertipe int, sbb:
int nilai[N];

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

Implementasi dalam C :
/*Programmer: Rizky Annisa
NIM: 22076018

Nama program: contoh1

Desc:
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 3

//variabel global berupa array berisi data int

int nilai[N];
void urutkan();

main(){

printf ("\n\
n=======================================================
=======================================================
==\n");
printf ("\n\t\tSORTING BERSIFAT ASCENDING ATAU TERURUT DARI NILAI
TERKECIL KE TERBESAR\n");
printf ("\
n=======================================================
=======================================================
==\n\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
printf("\n*************************************************\n\n");

int i;
int nilainya;

printf ("\nKETIKKAN NILAI MAHASISWA\n");

printf ("_________________________\n");
for (i= 0; i < N; i++){
printf ("\nNilai Mahasiswa ke-%d: ", i);
scanf ("%d", &nilainya);
fflush (stdin);

//isikan ke array data[]

nilai[i] = nilainya;
}
printf ("\
n=======================================================
=============\n");
printf ("Entri selesai... Tekan enter...");
getch();

//panggil fungsi untuk mengurutkan data[]

urutkan();

printf ("\
n=======================================================
=============\n");
//data yg telah diurut ditampilkan ke layar
printf("\n\nNilai terurut secara ascending...\n\n");
 for (i = 0; i < N; i++){
//salin dulu data dari array
nilainya = nilai[i];
printf ("%d\t", nilainya);
}
printf ("\n\
n=======================================================
=============\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(nilai[j] < nilai[indexMin]) {
indexMin = j;
}
}

if(indexMin != i) {//kalau posisinya bukan posisi awal

// pertukarkan posisi data
temp = nilai[indexMin];
nilai[indexMin] = nilai[i];
nilai[i] = temp;
}
}
}
PROGRAM
OUTPUT

CONTOH KASUS 2
Buatlah program seperti pada kasus 1 tetapi urutannya dari besar ke kecil atau
descending order.

Analisis Kebutuhan
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(nilai[j] > nilai[indexMaks]) { //tanda '<'
diganti dengan tanda '>'
indexMaks = j;
}
}

if(indexMaks != i) {//kalau posisinya bukan posisi

awal
// pertukarkan posisi data
temp = nilai[indexMaks];
nilai[indexMaks] = nilai[i];
nilai[i] = temp;
}
}
}

Sehingga Implementasi lengkap dalam C untuk kasus 2 adalah sebagai berikut:

/*Programmer: Rizky Annisa
NIM: 22076018

Nama program: contoh2

Desc:
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 nilai[N];

void urutkan();

main(){

printf ("\n\
n=======================================================
=======================================================
=========\n");
printf ("\n\t\t\tSORTING BERSIFAT ASCENDING ATAU TERURUT DARI NILAI
TERBESAR KE TERKECIL\n");
printf ("\
n=======================================================
=======================================================
=========\n\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
printf("\n*************************************************\n\n");

int i;
int nilainya;

printf ("\nKETIKKAN NILAI MAHASISWA\n");

printf ("_________________________\n");
for (i = 0; i < N; i++){
printf ("\nNilai Mahasiswa ke-%d: ", i);
scanf ("%d", &nilainya);
fflush (stdin);

//isikan ke array data[]

 nilai[i] = nilainya;
}
printf ("\
n=======================================================
=============\n");
printf ("Entri selesai...tekan enter...");
getch();

//panggil fungsi untuk mengurutkan data[]

urutkan();

printf ("\
n=======================================================
=============\n");
//data yg telah diurut ditampilkan ke layar
printf ("\nNilai terurut secara ascending...\n\n");
for (i = 0; i < N; i++){
//salin dulu data dari array
nilainya = nilai[i];
printf ("%d\t", nilainya);
}
printf ("\n\
n=======================================================
=============\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 (nilai[j] > nilai[indexMaks]) { //tanda '<' diganti dengan tanda '>'
indexMaks = j;
}
}

if(indexMaks != i) {//kalau posisinya bukan posisi awal

// pertukarkan posisi data
temp = nilai[indexMaks];
nilai[indexMaks] = nilai[i];
nilai[i] = temp;
}
}
}
PROGRAM
OUTPUT

CONTOH KASUS 3
 Modifikasilah program pada kasus 2 dimana bagian untuk mendisplaykan informasi
dibuat menjadi sebuah fungsi.

Analisis Kebutuhan
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 nilai[].
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 nilai[]
dengan banyak perulangan sebanyak elemen array tersebut;
 Variabel untuk penampung data yang nilainya diambil dari array, beri
nama nilainya dan bertipe int.

Sehingga Implementasi dalam C untuk kasus 3 adalah sebagai berikut:

/*Programmer: Rizky annisa
NIM: 22076018

Nama program: contoh3

Desc:
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(){

printf ("\n\
n=======================================================
=======================================================
=========\n");
printf ("\n\t\t\t PENGGUNAAN FUNGSI SORTING DAN FUNGSI UNTUK
MENDISPLAY DATA\n");
printf ("\
n=======================================================
=======================================================
=========\n\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
printf("\n*************************************************\n\n");

int i;
int datanya;

printf ("\nKETIKKAN NILAI MAHASISWA\n");

printf ("_________________________\n");
for (i = 0; i < N; i++){
printf ("\nNilai Mahasiswa ke-%d: ", i);
scanf ("%d", &datanya);
fflush (stdin);

//isikan ke array data[]

data[i] = datanya;
}
printf ("\
n=======================================================
=============\n");
printf("Entri selesai...tekan enter...");
getch();

//panggil fungsi untuk mengurutkan data[]

urutkan();

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

//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;

//periksaelemen 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\
n=======================================================
=============\n"); //pindah baris
printf("Selesai... Tekan Enter...");
getch();
}

PROGRAM
OUTPUT
CONTOH 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.
Analisis Kebutuhan
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 variabel penampung data sementara dari
keseluruhan data pada struct bertipe DATAMHS.
Secara keseluruhan, kebutuhan fungsi untuk kasus ini adalah:
 Fungsi judul(), yang merupakan fungsi tanpa parameter tanpa nilai balik,
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(), oleh 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 dalam C dapat Anda pelajari dari listing kode berikut
ini:
/*Programmer: Rizky Annisa
NIM: 22076018

Nama program: contoh4

Desc:
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];

//panggil fungsi judul()

judul();
//panggil fungsi bacaMhs()
bacaMhs();
printf ("\nMenampilkan Identitas Seluruh Mahasiswa\n");
printf ("________________________________________\n");
printf ("\nTekan Enter...\n");
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=======================================================
=============\n");
}

printf ("\nMencari Mahasiswa melalui NIM\n");

printf ("______________________________\n");
printf ("\nTekan Enter...\n");
getch();
printf ("\nKetikkan NIM yang dicari: ");
gets(nimnya); fflush(stdin);
posisi = cariData(nimnya);
if (posisi != -999){
printf ("\
n=======================================================
=============\n");
 printf ("\nData ditemukan...\n");
infoMhs(posisi); //kirimkan nilai posisi data untuk ditampilkan
}
else
printf ("\
n=======================================================
=============\n");
printf ("\nData tidak ditemukan....\n");

printf ("\
n=======================================================
=============\n");
printf ("\n\nMengurutkan Data Mahasiswa\n");
printf ("____________________________\n");
printf ("\nTekan Enter...");
printf ("\
n=======================================================
=============\n");
getch();
urutkan();
printf ("\nData 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=======================================================
=============\n");
}
printf("Selesai... Tekan Enter...");
getch();
}

void judul(){

printf ("\n\
n=======================================================
=======================================================
=========\n");
printf ("\n\t\t\t PENGGUNAAN FUNGSI SORTING DENGAN MENGGUNAKAN
ARRAY OF STRUCT\n");
printf ("\
n=======================================================
=======================================================
=========\n\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
printf("\n*************************************************\n\n");
printf("Tekan tombol enter...\n");

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 ("\nKetikkan Nama Mahasiswa\t: ");
gets(namanya); fflush(stdin); //baca nama mahasiswa
printf ("Ketikkan NIM Mahasiswa\t: ");
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("Entri Data selesai...Tekan enter...\n");
printf
("======================================================
==============\n");
getch();
}
void bacaNilai(int i){
double midnya, uasnya, tugasnya, quiznya, nAkhirnya;
char nHurufnya;

printf ("______________________________________\n");
printf ("\nKetik Nilai MID\t\t: ");
scanf ("%lf", &midnya); fflush(stdin);
printf ("Ketik Nilai UAS\t\t: ");
scanf ("%lf", &uasnya); fflush(stdin);
printf ("Ketik Nilai Tugas\t: ");
scanf ("%lf", &tugasnya); fflush(stdin);
printf ("Ketik Nilai Quiz\t: ");
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=======================================================
=============\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 ("\
n=======================================================
=============\n");
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("\nNama Mahasiswa : %s\n", namanya);
printf("Nomor Induk Mahasiswa : %s\n", nimnya);
printf("\tNilai Akhir : %0.1lf\n", nAkhirnya);
printf("\tNilai Huruf : %c\n", nHurufnya);
}
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;
}
}
}
PROGRAM
OUTPUT
KASUS SORTING 1
Mengurutkan data pada array secara ascending (dari kecil ke besar).

Implementasi Dalam Bahasa C:

/*Programmer: Rizky Annisa

NIM: 22076018

Nama program: sorting1

Desc:
Mengurutkan data pada array secara accending (dari kecil ke besar)
*/

#include <stdio.h>

void urutkan(int nl[]);

main(){
printf ("\n\
n=======================================================================
================================================\n");
printf ("\n\t\t\tSORTING BERSIFAT ASCENDING ATAU TERURUT DARI NILAI
TERKECIL KE TERBESAR\n");
 printf ("\
n=======================================================================
================================================\n\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
printf("\n*************************************************\n\n");

int i, data;
int nilai[] = {87, 67, 88, 90, 55, 80, 70};

printf ("\n\t\t\tData Sebelum Diurutkan\n");

printf ("\t____________________________________________________\n\n");
for( i = 0; i < 7; i++){
printf("\t%d", nilai[i]);
}
printf ("\n\n\t====================================================\n");

urutkan(nilai);
printf ("\n\t\t\tData setelah diurutkan\n");
printf ("\t____________________________________________________\n\n");
for (i = 0; i < 7; i++){
printf("\t%d",nilai[i]);
}
}

void urutkan(int nl[]){

int i, j, posisi;
int terkecil, temp;

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

terkecil = nl[i];
posisi = i;
for (j = i+1; j < 7; j++){
if (nl[j] < terkecil){
terkecil = nl[j];
posisi = j;
}
}
//pertukarkan posisi data pada array
temp = nl[i];
nl[i] = nl[posisi];
nl[posisi] = temp;
}
}
PROGRAM

OUTPUT
KASUS SORTING 2
Mengurutkan data pada array secara descending (dari besar ke kecil).

Implementasi Dalam Bahasa C :

/*Programmer: Rizky Annisa

NIM: 22076018

Nama program: sorting2

Desc:
mengurutkan data pada array secara descending (dari besar ke kecil)
*/

#include <stdio.h>

void urutkan(int nl[]);

main(){

printf ("\n\
n==================================================================
=====================================================\n");
printf ("\n\t\t\tSORTING BERSIFAT ASCENDING ATAU TERURUT DARI
NILAI TERBESAR KE TERKECIL\n");
printf ("\
n==================================================================
=====================================================\n\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
printf("\n*************************************************\n\n");

int i, data;
int nilai[] = {87, 67, 88, 90, 55, 80, 70};
 printf ("\n\t\t\tData Sebelum Diurutkan\n");
printf ("\t____________________________________________________\n\n");
for(i = 0; i < 7; i++){
printf ("\t%d",nilai[i]);
}
printf ("\n\n\
t====================================================\n");

urutkan(nilai);
printf ("\n\t\t\tData setelah diurutkan\n");
printf ("\t____________________________________________________\n\n");
for (i = 0; i < 7; i++){
printf ("\t%d",nilai[i]);
}
printf ("\n");
}

void urutkan(int nl[]){

int i, j, posisi;
int terbesar, temp;

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

terbesar = nl[i];
posisi = i;
for (j = i+1; j < 7; j++){
if (nl[j] > terbesar){
terbesar = nl[j];
posisi = j;
}
}
//pertukarkan posisi data pada array
temp = nl[i];
nl[i] = nl[posisi];
nl[posisi] = temp;
}
}
PROGRAM

OUTPUT
KASUS SORTING 3
Mengurutkan data sejumlah mahasiswa berdasarkan IPK mahasiswa.

Implementasi Dalam Bahasa C :

/*Programmer: Rizky Annnisa
NIM: 22076018

Nama program: sorting3

Desc:
mengurutkan data mahasiswa berdasarkan ipk
(dari besar ke kecil)
*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define N 3

typedef struct mhs{

char nama[30];
char nim[5];
double ipk;
} MHS;

void entriData(MHS myMhs[]);

void urutkan(MHS mhsku[]);
void tampilkan(MHS mhs[], int i);

main(){

printf ("\n\
n==================================================================
=====================================================\n");
printf ("\n\t\t\t\tDATA MAHASISWA BERDASARKAN IPK (DARI BESAR KE
KECIL)\n");
printf ("\
n==================================================================
=====================================================\n\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
printf("\n*************************************************\n\n");

int i;
MHS mhs[N];
 entriData(mhs);
printf ("\n\t\t\tData Sebelum Diurutkan\n");
printf
("____________________________________________________________________\n\n");
for (i = 0; i < N; i++){
printf (" Mahasiswa ke-%d\n", i+1);
tampilkan(mhs, i);
}
printf("\n");

urutkan(mhs);
printf ("\n\t\t\tData Setelah Diurutkan:\n");
printf
("____________________________________________________________________\n\n");
for (i = 0; i < N; i++){
printf (" Mahasiswa ke-%d\n", i+1);
tampilkan(mhs, i);
}
}
void entriData(MHS myMhs[]){
char namanya[20], nimnya[5];
double ipknya;
int i;
printf ("\nEntri Data Mahasiswa\n");
printf ("==========================\n\n");
for (i = 0; i < N; i++){
printf (" Mahasiswa ke-%d\n", i+1);
printf ("__________________________\n\n");
printf ("Ketikkan Nama\t: ");
gets(namanya); fflush(stdin);
printf ("Ketikkan NIM\t: ");
gets(nimnya); fflush(stdin);
printf ("Ketikkan IPK\t: ");
scanf ("%lf", &ipknya); fflush(stdin);

//masukkan ke array
strcpy(myMhs[i].nama, namanya);
strcpy(myMhs[i].nim, nimnya);
myMhs[i].ipk = ipknya;
}
printf ("\
n==================================================================
==\n");
printf ("Entri Data selesai... Tekan enter...");
printf ("\
n==================================================================
==\n");
 getch();
}
void urutkan(MHS mhsku[]){
int i, j, posisi;
double terbesar;
MHS temp;

for(i=0;i<N;i++){
terbesar = mhsku[i].ipk;
posisi = i;
for(j=i+1;j<N;j++){
if(mhsku[j].ipk > terbesar){
terbesar = mhsku[j].ipk;
posisi = j;
}
}
//pertukarkan posisi data pada array
temp = mhsku[i];
mhsku[i] = mhsku[posisi];
mhsku[posisi] = temp;
}
}
void tampilkan(MHS mhs[], int i){
printf ("-----------------------------\n");
printf ("Nama : %s\n", mhs[i].nama);
printf ("NIM : %s\n", mhs[i].nim);
printf ("IPK : %0.2lf\n", mhs[i].ipk);
printf ("-----------------------------\n");
}

PROGRAM
OUTPUT
KASUS SORTING 4
Mengurutkan data hasil lomba berbasis nilai atau skor (membuat sumur).

Implementasi Dalam Bahasa C :

/*Programmer: Rizky Annisa
NIM: 22076018

Nama program: sorting4

Desc:
mengurutkan data hasil lomba berbasis nilai atau skor (membuat sumur)
(dari besar ke kecil)
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define N 2
#define PHI 3.14

typedef struct peserta{

char nama[20];
char noPeserta[4];
} PESERTA;

typedef struct sumur{

double diameter;
double tinggi;
double volume;
} SUMUR;

typedef struct lomba{

PESERTA psrt;
SUMUR smr;
} LOMBA;

//deklarasi fungsi2
void entriData(LOMBA lmb[]);
void entriLomba(LOMBA lmb[], LOMBA lom, int i);
void salin(LOMBA lmb[], LOMBA copy[]);
void tampilInfo(LOMBA lmb[]);
void urutkan(LOMBA lmb[]);
double hitVol(LOMBA lm);

main(){

printf ("\n\
n==================================================================
=====================================================\n");
printf ("\n\t\t\t\tDATA HASIL LOMBA MEMBUAT SUMUR (DARI BESAR KE
KECIL)\n");
printf ("\
n==================================================================
=====================================================\n\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
printf("\n*************************************************\n\n");

//deklarasi var lokal

LOMBA lmb1[N], lmb2[N];

//entri data N peserta lomba, sekaligus hitung volume sumur

entriData(lmb1);
//salin semua data pada array ke array lain, misal lmb2[]
salin(lmb1, lmb2);
printf ("\nIsi Array 1\n");
tampilInfo(lmb1);
printf ("\nIsi Array 2\n");
tampilInfo(lmb2);
 //urutkan data pada array lmb2
urutkan(lmb2);
//tampilkan hasil pengurutan
printf ("\nHasil Pengurutan\n");
tampilInfo(lmb2);
}

void entriData(LOMBA lmb[]){

int i;
LOMBA lomba;
PESERTA psrt;
SUMUR smr;

printf ("\nEntri Data\n");

printf ("========================\n");
for (i = 0; i < N; i++){
printf ("Peserta ke-%d\n", i+1);
printf ("Ketikkan nama : ");
gets(lomba.psrt.nama); fflush(stdin);
printf ("Ketikkan nomor: ");
gets(lomba.psrt.noPeserta); fflush(stdin);

//entri data perlombaan

printf ("Ketikkan Diamater dan kedalaman sumur (pisahkan dengan spasi):
");
scanf ("%lf%lf", &lomba.smr.diameter, &lomba.smr.tinggi); fflush(stdin);
lomba.smr.volume = hitVol(lomba);
entriLomba(lmb, lomba, i);
}
printf ("\nEntri Data selesai... Tekan Enter...");
getch();
}

void entriLomba(LOMBA lmb[], LOMBA lom, int i){

lmb[i] = lom;
printf ("\nNama: %s Nomor: %s\n", lmb[i].psrt.nama, lmb[i].psrt.noPeserta);
printf ("--------------------------------------------\n");
printf ("Diameter: %0.2lf Meter\n", lmb[i].smr.diameter);
printf ("Kedalaman : %0.2lf Meter\n", lmb[i].smr.tinggi);
printf ("Volume : %0.2lf Meter Kubik\n", lmb[i].smr.volume);
printf ("--------------------------------------------\n");
}

double hitVol(LOMBA lm){

double vol;

vol = lm.smr.diameter/2 * lm.smr.diameter/2 * lm.smr.tinggi * PHI;

//atau gunakan fungsi fow() sbb:
 //vol = pow(lm.smr.diameter/2, 2) * PHI * lm.smr.tinggi;
return vol;
}

void salin(LOMBA lmb[], LOMBA copy[]){

int i;
//salin satu persatu elemen array ke array lain
for(i=0;i<N;i++){
copy[i] = lmb[i];
}
}

void tampilInfo(LOMBA lmb[]){

int i;

printf ("\nData:\n");
printf ("--------------------------------------------\n");
for (i = 0; i < N; i++){
printf ("\nPeserta ke-%d\n", i+1);
printf ("\nNama: %s Nomor: %s\n", lmb[i].psrt.nama, lmb[i].psrt.noPeserta);
printf ("Diameter : %0.2lf Meter\n", lmb[i].smr.diameter);
printf ("Kedalaman: %0.2lf Meter\n", lmb[i].smr.tinggi);
printf ("Volume : %0.2lf Meter Kubik\n", lmb[i].smr.volume);
printf ("--------------------------------------------\n");
}
}

void urutkan(LOMBA lmb[]){

int i, j, posisi;
double terbesar;
LOMBA temp;

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

terbesar = lmb[i].smr.volume;
posisi = i;
for (j = i+1; j <N ;j++){
if (lmb[j].smr.volume > terbesar){
terbesar = lmb[j].smr.volume;
posisi = j;
}
}
//pertukarkan isi array
temp = lmb[i];
lmb[i] = lmb[posisi];
lmb[posisi] = temp;
}
}
PROGRAM
OUTPUT
KASUS SORTING 5
Mengelola data lomba membuat sumur untuk N orang peserta dan menentukan juara
1, 2 dan 3 serta dilengkapi dengan menu pilihan.

Implementasi Dalam Bahasa C :

/*Programmer: Rizky Annisa
NIM: 220760318

Nama program: sorting5

Desc:
mengelola data lomba membuat sumur untuk N peserta dan
menentukan juara 1, 2 dan 3, menggunakan menu
(dari besar ke kecil)
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define N 2
#define PHI 3.14

typedef struct peserta{

char nama[20];
char noPeserta[4];
} PESERTA;

typedef struct sumur{

double diameter;
double tinggi;
double volume;
} SUMUR;

typedef struct lomba{

PESERTA psrt;
SUMUR smr;
} LOMBA;

//deklarasi fungsi2
void judul();
void entriData(LOMBA lmb[]);
void entriLomba(LOMBA lmb[], LOMBA lom, int i);
void salin(LOMBA lmb[], LOMBA copy[]);
void tampilInfo(LOMBA lmb[]);
void urutkan(LOMBA lmb[]);
double hitVol(LOMBA lm);
void juara(LOMBA lmb[]);
void tampilkan(LOMBA lmb[], int i);
void menu(LOMBA lom1[], LOMBA lom2[]);
void cariData(LOMBA lmb[], int *pss, int *stat);

main(){

printf ("\n\
n=======================================================
=======================================================
=========\n");
printf ("\n\t\t\t\t PROGRAM PENGELOLAAN HASIL LOMBA MEMBUAT
SUMUR\n");
printf ("\
n=======================================================
=======================================================
=========\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
 printf("\n*************************************************\n\n");

//deklarasi var lokal

LOMBA lmb1[N], lmb2[N];

//entri data N peserta lomba, sekaligus hitung volume sumur

entriData(lmb1);
//salin semua data pada array ke array lain, misal lmb2[]
salin(lmb1, lmb2);
//urutkan data pada array lmb2
urutkan(lmb2);
//menu pilihan
menu(lmb1, lmb2);
}

void menu(LOMBA lom1[], LOMBA lom2[]){

int pilihan, posisi, stat;
char jawab;

do{
printf ("\nMENU PILIHAN\n");
printf ("=========================\n");
printf ("1. Cari Data Tertentu\n");
printf ("2. Tampilkan Para Juara\n");
printf ("3. Lihat Informasi\n");
printf ("0. Selesai\n");
printf ("=========================\n");
printf ("Ketikkan nomor pilihan (1, 2, 3 atau 0): ");
scanf ("%d", &pilihan); fflush(stdin);

switch (pilihan){
case 0: printf ("\nBye...bye...\n");
exit(1);
case 1: cariData(lom1, &posisi, &stat);
if (stat){
printf ("\nData yg ditemukan:\n");
tampilkan(lom1, posisi);
}
break;
case 2: juara(lom2); break;
case 3: tampilInfo(lom1); break;
default: printf ("\nNomor pilihan tidak ada... Tekan Enter");
getch();
}
printf ("\nMau ngulang lagi (Y/T): ");
jawab = getche();
} while (toupper(jawab)=='Y');
 printf ("\nTerima kasih.... Tekan Enter...");
getch();
}
void entriData(LOMBA lmb[]){
int i;
LOMBA lomba;
PESERTA psrt;
SUMUR smr;

printf ("\nEntri Data\n");

printf ("========================\n");
for (i = 0; i < N; i++){
printf ("Peserta ke-%d:\n", i+1);
printf ("Ketikkan nama : ");
gets(lomba.psrt.nama); fflush(stdin);
printf ("Ketikkan nomor: ");
gets(lomba.psrt.noPeserta); fflush(stdin);
//entri data perlombaan
printf ("Ketikkan Diamater dan kedalaman sumur (pisahkan dengan spasi):
");
scanf ("%lf%lf", &lomba.smr.diameter, &lomba.smr.tinggi); fflush(stdin);
lomba.smr.volume = hitVol(lomba);
entriLomba(lmb, lomba, i);
}
printf ("\nEntri Data selesai... Tekan Enter...");
getch();
}
void entriLomba(LOMBA lmb[], LOMBA lom, int i){
lmb[i] = lom;
printf ("\nNama: %s Nomor: %s\n", lmb[i].psrt.nama, lmb[i].psrt.noPeserta);
printf ("--------------------------------------------\n");
printf ("Diameter: %0.2lf Meter\n", lmb[i].smr.diameter);
printf ("Kedalaman : %0.2lf Meter\n", lmb[i].smr.tinggi);
printf ("Volume : %0.2lf Meter Kubik\n", lmb[i].smr.volume);
printf ("--------------------------------------------\n");
}
double hitVol(LOMBA lm){
double vol;

vol = lm.smr.diameter/2 * lm.smr.diameter/2 * lm.smr.tinggi * PHI;

//atau gunakan fungsi fow() sbb:
//vol = pow(lm.smr.diameter/2, 2) * PHI * lm.smr.tinggi;
return vol;
}

void salin(LOMBA lmb[], LOMBA copy[]){

int i;
//salin satu persatu elemen array ke array lain
 for (i = 0; i < N; i++){
copy[i] = lmb[i];
}
}
void tampilInfo(LOMBA lmb[]){
int i;

printf ("\nData:\n");
printf ("--------------------------------------------\n");
for (i = 0; i < N; i++){
printf ("\nPeserta ke-%d\n", i+1);
printf ("\nNama: %s Nomor: %s\n", lmb[i].psrt.nama,
lmb[i].psrt.noPeserta);
printf ("Diameter : %0.2lf Meter\n", lmb[i].smr.diameter);
printf ("Kedalaman: %0.2lf Meter\n", lmb[i].smr.tinggi);
printf ("Volume : %0.2lf Meter Kubik\n", lmb[i].smr.volume);
printf ("--------------------------------------------\n");
}
}
void urutkan(LOMBA lmb[]){
int i, j, posisi;
double terbesar;
LOMBA temp;

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

terbesar = lmb[i].smr.volume;
posisi = i;
for (j = i+1; j < N; j++){
if (lmb[j].smr.volume > terbesar){
terbesar = lmb[j].smr.volume;
posisi = j;
}
}
//pertukarkan isi array
temp = lmb[i];
lmb[i] = lmb[posisi];
lmb[posisi] = temp;
}
}
void juara(LOMBA lmb[]){
int i;
printf ("\nPARA JUARA\n");
printf ("--------------------------\n");
for (i = 0; i < 3; i++){
printf ("\nJuara ke-%d\n", i+1);
tampilkan(lmb, i);
}
printf ("\nTekan Enter...");
 getch();
}
void tampilkan(LOMBA lmb[], int i){
printf ("--------------------------------------------\n");
printf ("\nNama: %s Nomor: %s\n", lmb[i].psrt.nama, lmb[i].psrt.noPeserta);
printf ("Diameter : %0.2lf Meter\n", lmb[i].smr.diameter);
printf ("Kedalaman: %0.2lf Meter\n", lmb[i].smr.tinggi);
printf ("Volume : %0.2lf Meter Kubik\n", lmb[i].smr.volume);
printf ("--------------------------------------------\n");
}
void cariData(LOMBA lmb[], int *pss, int *stat){
char nomornya[4];
int i;
printf ("\nKetikkan nomor peserta yg dicari: ");
gets(nomornya); fflush(stdin);
for (i = 0; i < N; ++i){
if (!strcmp(lmb[i].psrt.noPeserta, nomornya)){
*stat = 1;
*pss = i;
break;
}
else *stat = 0;
}
if (*stat) printf ("\nData ditemukan...\n");
else printf ("\nData tidak fitemukan...\n");
}

PROGRAM
OUTPUT
KASUS SORTING 6
Pengelolaan data lomba membuta sumur untuk N orang peserta dan menentukan juara
1, 2 dan 3 serta 3 peserta terburuk.Lengkapi dengan menu pilihan.

Implementasi Dalam Bahasa C :

/*Programmer: Rizky Annisa
NIM: 22076018

Nama program: sorting6

Desc:
mengelola data lomba membuat sumur untuk N peserta dan
menentukan juara 1, 2 dan 3, seta informasi 3 peserta terburuk
menggunakan menu
(dari besar ke kecil)
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define N 3
#define PHI 3.14

typedef struct peserta{

char nama[20];
char noPeserta[4];
} PESERTA;

typedef struct sumur{

double diameter;
double tinggi;
double volume;
} SUMUR;

typedef struct lomba{

PESERTA psrt;
SUMUR smr;
} LOMBA;

//deklarasi fungsi2
void judul();
void entriData(LOMBA lmb[]);
void entriLomba(LOMBA lmb[], LOMBA lom, int i);
void salin(LOMBA lmb[], LOMBA copy[]);
void tampilInfo(LOMBA lmb[]);
void urutkan(LOMBA lmb[]);
double hitVol(LOMBA lm);
void juara(LOMBA lmb[]);
void pecundang(LOMBA lmb[]);
void tampilkan(LOMBA lmb[], int i);
void menu(LOMBA lom1[], LOMBA lom2[]);
void cariData(LOMBA lmb[], int *pss, int *stat);

main(){

printf ("\n\
n=======================================================
=======================================================
=========\n");
printf ("\n\t\t\t\t PROGRAM PENGELOLAAN HASIL LOMBA MEMBUAT
SUMUR\n");
printf ("\
n=======================================================
=======================================================
=========\n");
printf("\n Programer:\tRizky Annisa\n");
printf("\n NIM\t:\t22076018\n");
printf("\n Prodi\t:\tPendidikan Teknik Informatika\n");
printf("\n*************************************************\n\n");

//deklarasi var lokal

LOMBA lmb1[N], lmb2[N];

//entri data N peserta lomba, sekaligus hitung volume sumur

entriData(lmb1);
//salin semua data pada array ke array lain, misal lmb2[]
salin(lmb1, lmb2);
//urutkan data pada array lmb2
urutkan(lmb2);
//menu pilihan
menu(lmb1, lmb2);
}

void menu(LOMBA lom1[], LOMBA lom2[]){

int pilihan, posisi, stat;
char jawab;

do{
printf ("\nMENU PILIHAN\n");
printf ("=========================\n");
printf ("1. Cari Data Tertentu\n");
printf ("2. Tampilkan Para Juara\n");
printf ("3. Tampilkan Para Pecundang\n");
printf ("4. Lihat Informasi\n");
printf ("0. Selesai\n");
 printf ("=========================\n");
printf ("Ketikkan nomor pilihan (1, 2, 3, 4 atau 0): ");
scanf ("%d", &pilihan); fflush(stdin);

switch(pilihan){
case 0: printf ("\nBye...bye...\n");
exit(1);
case 1: cariData(lom1, &posisi, &stat);
if(stat){
printf ("\nData yg ditemukan:\n");
tampilkan(lom1, posisi);
}
break;
case 2: juara(lom2); break;
case 3: pecundang(lom2); break;
case 4: tampilInfo(lom1); break;
default: printf ("\nNomor pilihan tidak ada... Tekan Enter");
getch();
}
printf ("\nMau ngulang lagi (Y/T): ");
jawab = getche();
} while (toupper(jawab)=='Y');
printf ("\nTerima kasih.... Tekan Enter...");
getch();
}

void entriData(LOMBA lmb[]){

int i;
LOMBA lomba;
PESERTA psrt;
SUMUR smr;

printf ("\nEntri Data\n");

printf ("========================\n");
for (i = 0; i < N; i++){
printf ("Peserta ke-%d:\n", i+1);
printf ("Ketikkan nama : ");
gets(lomba.psrt.nama); fflush(stdin);
printf ("Ketikkan nomor: ");
gets(lomba.psrt.noPeserta); fflush(stdin);
//entri data perlombaan
printf ("Ketikkan Diamater dan kedalaman sumur (pisahkan dengan spasi):
");
scanf ("%lf%lf", &lomba.smr.diameter, &lomba.smr.tinggi); fflush(stdin);
lomba.smr.volume = hitVol(lomba);
entriLomba(lmb, lomba, i);
}
printf ("\nEntri Data selesai... Tekan Enter...");
 getch();
}

void entriLomba(LOMBA lmb[], LOMBA lom, int i){

lmb[i] = lom;
printf ("\nNama: %s Nomor: %s\n", lmb[i].psrt.nama, lmb[i].psrt.noPeserta);
printf ("--------------------------------------------\n");
printf ("Diameter: %0.2lf Meter\n", lmb[i].smr.diameter);
printf ("Kedalaman : %0.2lf Meter\n", lmb[i].smr.tinggi);
printf ("Volume : %0.2lf Meter Kubik\n", lmb[i].smr.volume);
printf ("--------------------------------------------\n");
}

double hitVol(LOMBA lm){

double vol;

vol = lm.smr.diameter/2 * lm.smr.diameter/2 * lm.smr.tinggi * PHI;

//atau gunakan fungsi fow() sbb:
//vol = pow(lm.smr.diameter/2, 2) * PHI * lm.smr.tinggi;
return vol;
}

void salin(LOMBA lmb[], LOMBA copy[]){

int i;
//salin satu persatu elemen array ke array lain
for (i = 0; i < N; i++){
copy[i] = lmb[i];
}
}

void tampilInfo(LOMBA lmb[]){

int i;

printf ("\nData:\n");
printf ("--------------------------------------------\n");
for (i = 0; i < N; i++){
printf ("\nPeserta ke-%d\n", i+1);
printf ("\nNama: %s Nomor: %s\n", lmb[i].psrt.nama,
lmb[i].psrt.noPeserta);
printf ("Diameter : %0.2lf Meter\n", lmb[i].smr.diameter);
printf ("Kedalaman: %0.2lf Meter\n", lmb[i].smr.tinggi);
printf ("Volume : %0.2lf Meter Kubik\n", lmb[i].smr.volume);
printf ("--------------------------------------------\n");
}
}

void urutkan(LOMBA lmb[]){

int i, j, posisi;
 double terbesar;
LOMBA temp;

for (i = 0; i < N-1; i++){

terbesar = lmb[i].smr.volume;
posisi = i;
for (j = i+1; j < N; j++){
if (lmb[j].smr.volume > terbesar){
terbesar = lmb[j].smr.volume;
posisi = j;
}
}
//pertukarkan isi array
temp = lmb[i];
lmb[i] = lmb[posisi];
lmb[posisi] = temp;
}
}

void juara(LOMBA lmb[]){

int i;

printf ("\nPARA JUARA\n");

printf ("--------------------------\n");
for (i = 0; i < 3; i++){
printf ("\nJuara ke-%d\n", i + 1);
tampilkan(lmb, i);
}
printf ("\nTekan Enter...");
getch();
}

void pecundang(LOMBA lmb[]){

int i, j = 1;

printf ("\nPARA PECUNDANG\n");

printf ("--------------------------\n");
for (i = N-1; i >= N-3; i--){
printf ("\nPecundang ke-%d\n", j);
tampilkan(lmb, i);
j++;
}
printf ("\nTekan Enter...");
getch();
}

void tampilkan(LOMBA lmb[], int i){

printf ("--------------------------------------------\n");
 printf ("\nNama: %s Nomor: %s\n", lmb[i].psrt.nama, lmb[i].psrt.noPeserta);
printf ("Diameter : %0.2lf Meter\n", lmb[i].smr.diameter);
printf ("Kedalaman: %0.2lf Meter\n", lmb[i].smr.tinggi);
printf ("Volume : %0.2lf Meter Kubik\n", lmb[i].smr.volume);
printf ("--------------------------------------------\n");
}

void cariData(LOMBA lmb[], int *pss, int *stat){

char nomornya[4];
int i;

printf ("\nKetikkan nomor peserta yg dicari: ");

gets(nomornya); fflush(stdin);
for (i = 0; i < N; ++i){
if (!strcmp(lmb[i].psrt.noPeserta, nomornya)){
*stat = 1;
*pss = i;
break;
}
else *stat = 0;
}
if (*stat) printf ("\nData ditemukan...\n");
else printf ("\nData tidak fitemukan...\n");
}

PROGRAM
OUTPUT