Laporan Full Algoritma

LAPORAN PRAKTIKUM
ALGORITMA DAN STRUKTUR DATA
Disusun Oleh :
NAMA : Nabiel Ilyasa pradana
NIM : 32602300046
PRODI TEKNIK INFORMATIKA

FAKULTAS TEKNOLOGI INDUSTRI
UNIVERSITAS ISLAM SULTAN AGUNG
SEMARANG
2024
i
HALAMAN PENGESAHAN
LAPORAN PRAKTIKUM
ALGORITMA DAN STRUKTUR DATA
Disusun Oleh :
Nabiel Ilyasa pradana

(32602300056)
Telah di setujui sebagai syarat untuk memenuhi mata kuliah Praktikum

Algoritma dan Struktur Data. Jurusan Teknik Informatika Fakultas Teknologi
Industri Universitas Islam Sultan Agung Semarang.
Hari :
Tanggal :
Asisten Praktikum
1. Muhammad Yaasiin (32602200107) 1………
Hidayatulloh
Laboran
1. Werdha Wiluberta, S.Kom 1………
2. Ilham Hidayat, S.Kom 2………
3. Bagas Afza .J.A., S.Kom. 3……..
Mengetahui,
Dosen Praktikum
Imam Much Ibnu Subroto, ST, M.Sc, Ph.D
ii
KATA PENGANTAR
Puji syukur penulis panjatkan kepada Allah SWT, yang telah memberikan
rahmat, taufik serta hidayah-Nya, sehingga laporan Sistem Operasi dapat
terselesaikan.
Tanpa lupa penulis mengucapkan terima kasih kepada :
1. Rektor UNISSULA Bapak Prof. Dr. Gunarto, S.H., M.HUM yang mengizinkan
penulis menimba ilmu di kampus ini.
2. Dekan Fakultas Teknologi Industri Ibu Dr, Novi Marlyana, ST., MT., IPU.,
ASEAN Eng
3. Dosen pengampu Bapak Dedy Kurniadi, ST, M.Kom yang telah memberi ilmu
tentang Algoritma dan Struktur Data.
4. Orang tua penulis yang telah mengizinkan untuk menyelesaikan laporan ini.
5. Dan kepada semua pihak yang tidak dapat saya sebutkan satu persatu.
Penulis menyadari bahwa dalam penyusunan laporan ini masih terdapat

banyak kekurangan, untuk itu penulis mengharap kritik dan saran dari pembaca
untuk sempurnanya laporan ini. Semoga dengan ditulisnya laporan ini dapat
menjadi sumber ilmu bagi setiap pembaca.
Semarang, 6 Januari 2024
PENULIS
iii
DAFTAR ISI
LAPORAN PRAKTIKUM....................................................................................I
HALAMAN PENGESAHAN...............................................................................II
KATA PENGANTAR.........................................................................................III
DAFTAR GAMBAR...........................................................................................VI
DAFTAR TABEL................................................................................................VI
BAB I STRUKTUR DASAR ALGORITMA......................................................1
1.1 TUJUAN PRAKTIKUM................................................................................1

1.2 DASAR TEORI............................................................................................1
3.2.1 Sekuensial.............................................................................................1
3.2.2 Seleksi...................................................................................................2
3.2.3 Perulangan...........................................................................................3
3.2.4 Flowchart..............................................................................................4
1.3 LATIHAN...................................................................................................7
1.4 TUGAS.....................................................................................................11
1.5 KESIMPULAN...........................................................................................25
BAB II ARRAY 2D DAN 3D..............................................................................26
2.1 TUJUAN PRAKTIKUM..............................................................................26

2.2 DASAR TEORI..........................................................................................26
2.2.1 Pengertian Array................................................................................26
2.2.2 Array Multidimensi............................................................................26
2.2.3 Array Dua Dimensi............................................................................26
2.2.4 Array Tiga Dimensi............................................................................27
2.3 LATIHAN.................................................................................................28
2.4 TUGAS.....................................................................................................36
2.5 KESIMPULAN...........................................................................................51
iv
BAB III METODE SORTING DAN SEARCHING.........................................53
3.1 TUJUAN PRAKTIKUM..............................................................................53

3.2 DASAR TEORI..........................................................................................53
3.2.1 Pencarian Data...................................................................................53
3.2.2 Pengertian Sorting.............................................................................53
3.2.3 Algoritma Bubble Short.....................................................................54
3.3 LATIHAN.................................................................................................55
3.4 TUGAS.....................................................................................................60
3.5 KESIMPULAN...........................................................................................84
BAB IV REKURSI..............................................................................................85
4.1 TUJUAN...................................................................................................85
4.2 DASAR TEORI..........................................................................................85
4.2.1 Pengertian Rekursi.............................................................................85
4.2.2 Fibonance...........................................................................................85
4.3 LATIHAN.................................................................................................86
4.4 TUGAS.....................................................................................................91
4.5 KESIMPULAN.........................................................................................102
BAB V LINKED LIST, STACK, DAN QUEUE............................................104
5.1 TUJUAN.................................................................................................104
5.2 DASAR TEORI........................................................................................104
5.2.1 Metode List.......................................................................................104
5.2.2 Metode Stack.....................................................................................105
5.2.3 Metode LIFO....................................................................................105
5.2.4 Metode Queue...................................................................................106
5.2.5 Pengertian Linked List.....................................................................106
5.3 LATIHAN...............................................................................................106
5.4 TUGAS...................................................................................................118
5.5 KESIMPULAN.........................................................................................134
DAFTAR GAMBAR
GAMBAR 1. 1 STRUKTUR SEKUENSIAL.....................................................................1
GAMBAR 1. 2 STRUKTUR SELEKSI............................................................................2
GAMBAR 1. 3 STRUKTUR PERULANGAN PERTAMA..................................................3
GAMBAR 1. 4 STRUKTUR PERULANGAN KEDUA.......................................................4
GAMBAR 1. 5 OUTPUT LATIHAN 1 LINGKARAN.......................................................8
GAMBAR 1. 6 OUTPUT LATIHAN 1 PERSEGI PANJANG..............................................8
GAMBAR 1. 7 FLOWCHART LATIHAN 1....................................................................9
GAMBAR 1. 8 OUTPUT LATIHAN 2.........................................................................10
GAMBAR 1. 9 FLOWCHART LATIHAN 2..................................................................10
GAMBAR 1. 10 OUTPUT TUGAS 1...........................................................................12
GAMBAR 1. 11 FLOWCHART TUGAS 1...................................................................12
GAMBAR 1. 12 OUTPUT TUGAS 2 LUAS.................................................................15
GAMBAR 1. 13 OUTPUT TUGAS 2 KELILING..........................................................15
GAMBAR 1. 14 OUTPUT TUGAS 2 DIAGONAL........................................................15
GAMBAR 1. 16 OUTPUT TUGAS 3 LUAS.................................................................18
GAMBAR 1. 17 OUTPUT TUGAS 3 KELILING..........................................................19
GAMBAR 1. 18 OUTPUT TUGAS 3 DIAGONAL.......................................................19
GAMBAR 2. 1 TABEL ARRAY 2 DIMENSI.................................................................27

GAMBAR 2. 2 ARRAY 3 DIMENSI...........................................................................27
GAMBAR 2. 3 OUTPUT LATIHAN 1..........................................................................29
GAMBAR 2. 4 FLOWCHART LATIHAN 1...................................................................29
GAMBAR 2. 9 OUTPUT TUGAS 1.............................................................................38
GAMBAR 2. 10 FLOWCHART TUGAS 1....................................................................39
GAMBAR 3. 1OUTPUT LATIHAN 1...........................................................................56

GAMBAR 3. 6 FLOWCHART TUGAS 1......................................................................63
GAMBAR 3. 7 TUGAS 2...........................................................................................64
GAMBAR 3. 9 FLOWCHART TUGAS 2......................................................................68
GAMBAR 3. 12 OUTPUT TUGAS 4 ASCENDING 1.....................................................76
GAMBAR 3. 16 OUTPUT TUGAS 4 DESCENDING 1...................................................78

GAMBAR 4. 6 FLOWCHART TUGAS 1.....................................................................93
GAMBAR 4. 11 OUTPTUT TUGAS 4.........................................................................99
GAMBAR 4. 12 FLOWCHART TUGAS 4.................................................................100
GAMBAR 4. 13 OUTPUT TUGAS 5.........................................................................101
GAMBAR 5. 1 SENARAI.........................................................................................104
GAMBAR 5. 2 SENARAI TUNGGAL........................................................................104
GAMBAR 5. 3 SENARAI GANDA............................................................................105
GAMBAR 5. 4 SENARAI SIRKULAR.......................................................................105
GAMBAR 5. 5 OUTPUT LATIHAN 1.......................................................................110
GAMBAR 5. 6 FLOWCHART LATIHAN 1................................................................110
GAMBAR 5. 7 OUTPUT LATIHAN 2.......................................................................116
GAMBAR 5. 8 FLOWCHART LATIHAN 2................................................................117
DAFTAR TABEL
TABEL 1. 1 SIMBOL - SIMBOL FLOWCHART.............................................................5
i
BAB 1
STRUKTUR DASAR ALGORITMA

BAB I
STRUKTUR DASAR ALGORITMA
1.1 Tujuan Praktikum

Adapun tujuan dari praktikum ini yaitu :
1. Mahasiswa dapat memahami dan mengetahui jenis struktur dasar
algoritma.
2. Mahasiswa dapat memahami dan mengetahui struktur sekuensial.
3. Mahasiswa dapat memahami dan mengetahui struktur seleksi.
4. Mahasiswa dapat memahami dan mengetahui struktur pengulangan.
1.2 Dasar Teori

Sebuah Algoritma adalah serangkaian langkah tertentu yang bertujuan
untuk memecahkan suatu masalah atau mencapai tujuan tertentu.
Berikut landasan teori umum yang terkait dengan algoritma: Tentang
algoritma: Algoritma adalah sekumpulan algoritma yang terdefinisi dengan
baik untuk memecahkan suatu masalah atau mencapai tujuan tertentu.
Kompleksitas waktu dan ruang: Kompleksitas waktu mengukur waktu
yang dibutuhkan suatu algoritma untuk menyelesaikan suatu masalah.
Kompleksitas spasial mengukur jumlah memori yang dibutuhkan suatu
algoritma.
contoh: Notasi O (O besar) digunakan untuk merepresentasikan
kompleksitas waktu kasus terburuk suatu algoritma.
Divide and Conquer: Pendekatan membagi dan menaklukkan
melibatkan pembagian masalah menjadi submasalah yang lebih kecil,
menyelesaikan submasalah tersebut, dan menggabungkan solusi untuk
memecahkan masalah utama.
Pemrograman Dinamis: Pemrograman Dinamis adalah suatu
pendekatan untuk memecahkan masalah dengan membaginya menjadi sub-
masalah yang lebih kecil dan menyimpan solusi dari sub-masalah tersebut.
1
2
NP merupakan permasalahan mendasar dalam teori kompleksitas

komputasi yang menanyakan apakah semua permasalahan yang dapat
diselesaikan dalam waktu polinomial oleh mesin Turing juga dapat
diselesaikan oleh mesin Turing nondeterministik dalam waktu polinomial.
("Introduction to Algorithms" oleh Thomas H. Cormen, Charles E.
Leiserson, Ronald L. Rivest, dan Clifford Stein.)
Bab ini membahas tentang konversi kode dari bahasa C++ ke bahasa C
dan sebaliknya, dengan tujuan agar pembaca dapat membedakan antara
bahasa C dan bahasa C++ untuk keperluan studi informatika di masa depan.
Bab ini mencakup konsep sekuensial, seleksi, dan perulangan. Untuk
seleksi, terdapat if dan else if, sedangkan untuk perulangan, terdapat for,
while, dan do-while. Dengan pemahaman konsep ini, pembaca diharapkan
dapat mengimplementasikan konsep tersebut dalam kedua bahasa
pemrograman tersebut dengan baik dan sesuai kebutuhan.
1.2.1 Sekuensial
Sekuensial adalah struktur algoritma paling dasar yang berisi rangkaian
instruksi yang diproses secara sekuensial, satu per satu, mulai dari instruksi
pertama hingga instruksi terakhir. (Dasar et al., n.d.)
1. Tiap instruksi dikerjakan satu kali; tidak ada instruksi yang di ulang.
2. Menyatakan langkah-langkah yang berurutan; Urutan yang dimaksud
adalah urutan dalam melakukan eksekusi.
3. Urutan instruksi yang dilaksanakan sama dengan urutan instruksi
sebagaimana yang tertulis di dalam teks algoritmanya.
4. Akhir dari instruksi terakhir merupakan akhir algoritma.
Pada struktur sekuensial, langkah-langkah yang dilakukan dalam algoritma
diproses secara berurutan, sebagaimana diperlihatkan pada ilustrasi berikut:
3
Gambar 1. 1 Struktur sekuensial
Gambar 1.1, langkah 1 adalah langkah yang akan dieksekusi pertama

kali. Setelah langkah 1 dieksekusi, kemudian langkah 2 dieksekusi dan
diikuti dengan langkah 3.
1.2.2 Seleksi
Seleksi atau percabangan adalah perintah yang memungkinkan
pemilihan atas perintah yang akan dijalankan sesuai dengan kondisi tertentu
yang menentukan alur perjalanan program. Seleksi bertujuan untuk memilih
atau mengondisikan apakah statement/ pernyataan tersebut akan dijalankan
atau tidak, jika pernyataan itu benar maka perintah akan dilaksanakan atau
dijalankan. Aliran seleksi dalam bahasa pemrograman C dinyatakan dengan
statement if dan switch.
Struktur seleksi menyatakan pemilihan langkah yang didasarkan oleh
suatu kondisi (pengambilan keputusan). Gambar 1.2 mengilustrasikan
diagram alir struktur seleksi yang melibatkan dua alternatif. Dalam hal ini,
simbol belah ketupat digunakan untuk mewakili langkah pengambilan
keputusan.
4
Gambar 1. 2 Struktur seleksi
Seperti Gambar 1.2, langkah 1 hanya akan dijalankan ketika kondisi

bernilai benar, sedangkan langkah 2 hanya akan dijalankan ketika kondisi
bernilai salah.
1.2.3 Perulangan
Perulangan atau looping adalah sebuah instruksi yang bertujuan untuk
mengulang beberapa baris perintah secara berulang-ulang selama kondisi
masih memenuhi. Perulangan dalam bahasa pemrograman C dapat
dilakukan dengan menggunakan statement for, while, dan do-while.
Perulangan ditujukan untuk mengefisienkan kerja program ataupun
mengefisienkan listing dari coding dari program tersebut, sebagai contoh,
jika anda ingin menampilkan 10 tulisan “JANGAN LUPA BELAJAR”,
Anda bisa saja menuliskannya dengan menggunakan struktur sekuensial,
dengan cara seperti ini, berarti Anda memberikan 10 instruksi untuk
menuliskan kesepuluh tulisan tersebut. Cara seperti ini memang praktis
untuk jumlah perulangan yang sedikit (misalnya 2 atau 3 perulangan), tetapi
tidak cocok untuk jumlah yang banyak seperti 10 perulangan atau lebih.
Agar lebih praktis, Anda bisa menggunakan struktur perulangan. Struktur
perulangan pertama
5
Gambar 1. 3 Struktur Perulangan pertama
Seperti gambar 1.3, proses dapat berupa satu atau beberapa langkah.
Pada bentuk ini, ada kemungkinan proses tidak dijalankan sama sekali
sekiranya di awal kondisi bernilai salah. Diagram alir pada Gambar 1.3
menunjukkan bahwa sebelum proses dijalankan pertama kali, kondisi diuji
terlebih dahulu. Jika kondisi bernilai benar maka proses dijalankan,
kemudian kondisi diuji lagi. Sepanjang kondisi masih bernilai benar proses
akan tetap dijalankan. Namun, begitu kondisi bernilai salah maka
pengulangan berakhir. Struktur perulangan kedua
Gambar 1. 4 Struktur perulangan kedua
Seperti gambar 1.4, proses dapat berupa satu atau beberapa langkah.
Pada bentuk ini, proses dijalankan minimal satu kali. Diagram alir pada
Gambar 1.4 menunjukkan bahwa setelah proses dijalankan pertama kali,
kondisi kemudian diuji. Jika kondisi bernilai salah maka proses dijalankan,
kemudian kondisi diuji lagi. Sepanjang kondisi masih bernilai salah proses
akan tetap dijalankan. Namun, begitu kondisi bernilai benar maka
pengulangan berakhir.
6
1.2.4 Flowchart
Flowchart bisa diartikan sebagai diagram alir atau bagan yang
menggambarkan langkah langkah dan struktur suatu algoritma atau
program. Ilustrasi ini dinyatakan dalam simbol, setiap simbol mempunyai
makna tertentu untukproses tertentu. Simbol-simbol flowchart yang
umumnya digunakan adalah simbol-simbol flowchart standart yang
dikeluarkan oleh ANSI dan ISO. Aturan umum dalam flowchart:
1. Semua simbol dari flowchart dihubungkan oleh garis aliran (arrows)
yang mengindikasikan arah aliran bukan garis biasa.
2. Garis aliran memasuki bagian atas simbol dan keluar dari bagian bawah,
kecuali untuk simbol keputusan (decision), yang memiliki garis aliran
yang keluar dari bawah atau samping.
3. Aliran proses bergerak dari atas ke bawah.
4. Awal dan akhir pada flowchart disimbolkan dengan terminal.
Berikut ini adalah tabel dari simbol-simbol dalam flowchart yang sering
digunakan. (Umam, 2021)
Tabel 1. 1 Simbol - Simbol Flowchart
Simbol Nama Fungsi Contoh
Menandakan 7
Star
Start (awal)/
Terminator
End (akhir) End
1.3
program.
Menunjukkan
Star
arah aliran
Flow line
proses pada Luas = P *
L
program
Menunjukkan
proses yang Jumlah =

dilakukan jumlah + 10
Proses
computer
(perhitungan/
pengolahan)
Menandakan
Input/ Input
proses input/ jari - jari
output data
output data
Menandakan
pernyataan
usia=17?
pilihan, berisi
suatu kondisi
Decision
yang selalu
atau
menghasilkan
kondisi
2 nilai
keluaran
yaitu benar
atau salah
8
Latihan
1. Contoh Seleksi
a. Kode Program
#include<iostream>
using namespace std;
int main (){
char jenis;
int panjang, lebar, luas, jari; float luaslingkaran;
cout<<"NAMA : NABIEL ILYASA PRADANA";
cout<<"\nNIM : 32602300046";
cout<< "\npilih persegi panjang atau
lingkaran<L> :";
cin>> jenis;
if(jenis =='P' || jenis == 'p')
{ cout<< "panjang = ";
cin>> panjang;
cout<< "lebar = ";
cin>> lebar;
luas = panjang * lebar;
cout<< "luas = " << luas << endl;
}else if(jenis == 'L' || jenis == 'l')
{ cout<< "jari-jari =";
cin>> jari;
luaslingkaran = 3.14 * jari * jari;
cout<< "luas = " << luaslingkaran<< endl;
}else
cout << "salah pilih" << endl;
}
b. Output
Gambar 1. 5 Output Latihan 1 Lingkaran

9
Gambar 1. 6 Output Latihan 1 persegi panjang

10
c. Flowchart
Gambar 1. 7 Flowchart Latihan 1
d. Penjelasan
Gambar 1.7 menunjukan contoh percabangan braching (if)
antara pilihan “p” untuk perhitungan luas persegi dan “L” untuk
perhitungan luas lingkaran. Dalam coding perhitungan tersebut
menggunakan deklarasi variable dengan tipe variable integer (int),
float dan karakter (char).
Dalam coding di tiper char yang di masukan adalah bertipe
pilihan diamana jika kita ingin menghitung luas persegi kita
masukan perintah “P”. Sehingga output yang akan keluar adalah
perhitungan persegi dengan integer panjang dan lebar.
Namun, apabila kita ingin menghitung luas lingkaran masukan
perintah “L”. Sehingga output yang keluar adalah perhitungan luas
lingkaran dengan integer jari-jari.
2. Contoh Perulangan
a. Kode Program
#include <iostream>
int main() {
int l=0;
11
cout<<"NAMA : NABIEL ILYASA PRADANA";

cout<<"\nNIM : 32602300046\n";
for (int j=0; j<=10; j++) {
for (int k=j; k<=l; k++) {
cout<<k<<" ";
}
l+=2;
cout<<"\n";
}
}
b. Output
Gambar 1. 8 Output Latihan 2
c. Flowchart
d. Penjelasan
12
Pada Gambar 1.9 merupakan hasil dari perulangan atau looping.

Kode untukmelakukan looping ada for dan while. Diatas merupakan
contoh looping dengan for. Bisa kita lihat disini dalam membentuk
perulangan for berlaku komposisi “for ( inisialisasi; syarat
pengulangan; pengubah nilai pecacahan)”.
Inisialisasi adalah bagian untuk memberikan nlai awal untul
variabel- variabel tertentu. Contohnya ketika kita ingin memulai
perhitungan dari angka 9 maka pada bagian inisialisasi dimasukan
angka 9 (variabel=9). Kemudian ada syarat pengulangan. Syarat
pengulangan adalah sampai mana kita ingin melakukan looping atau
bisa di artikan angka terakhir yang kita inginkan itu apa. Contoh
ketika kita ingin melakukan looping sampai angka 10 kita masukan
tanda lebih dari sama dengan<=10 (variabel<=10).
Dan yang terakhir adalah pengubah nilai pecacahan. Pengubah
nilai pecacahan adalah mengatur hasil looping itu naik atau turun.
Contoh kita ingin melakukan looping dari terkecil ke terbesar kita
masukan variabel++ misal kita ingin kelipatan 2 maka masukan
variabel+=2. Sedangkan jika ingin dari terbesar ke terkecil masukan
variable—jika kita ingin berkelipatan 3 maka masukan variabel-=3.
1.4 Tugas
1. Modifikasilah program perulangan pada contoh 2 dengan struktur while
menggunakan bahasa C.
a. Kode Program
#include <stdio.h> #include <stdio.h>
int main(){
int l=0;
int j=0;
printf("Nama : NABIEL ILYASA PRADANA");
printf("\nNIM : 32602300046");
printf("\n");
13
while (j<=10){
int k=j;
while (k<=l){
printf("%d ",k);
k++;
}
j++;
l+=2;
printf("\n");
}
}
b. Output
Gambar 1. 10 Output Tugas 1
c. Flowchart
Gambar 1. 11 Flowchart Tugas 1
d. Penjelasan
Pada Gambar 1.11 merupakan hasil dari perulangan atau
looping. Ini merupakan bahasa pemrogreaman C. Diatas merupakan
14
contoh while. Bisa kita lihat disini dalam membentuk perulangan

while berlaku komposisi “while ( inisialisasi; syarat pengulangan;
pengubah nilai pecacahan)”.
Inisialisasi bagian untuk memberikan nlai awal untul variabel-
variabel tertentu. Syarat pengulangan adalah sampai mana kita ingin
melakukan looping atau bisa di artikan angka terakhir yang kita
inginkan itu apa. Contoh ketika kita ingin melakukan looping
sampai. angka 10 kita masukan tanda lebih dari sama dengan <=10
(variabel<=10).
Pengubah nilai pecacahan adalah mengatur hasil looping itu naik
atau turun. Contoh kita ingin melakukan looping dari terkecil ke
terbesar kita masukan variabel++ misal kita ingin kelipatan 2 maka
masukan variabel+=2. Sedangkan jika ingin dari terbesar ke terkecil
masukan variable—jika kita ingin berkelipatan 3 maka masukan
variabel-=3.
2. Buatlah program yang dapat menghitung luas, keliling, dan diagonal
persegi panjang. Diagonal dihitung dengan rumus: Diagonal =
akar(panjang2 + lebar2). Akar dapat dikerjakan dengan fungsi sqr().
Masukan berupa panjang dan lebar. Program berupa pilihan untuk luas,
keliling, dan diagonal.
a. Kode Program
#include <iostream>
#include <cmath>
int main() {
cout<<" "<< endl << endl;
cout<< "Nama: NABIEL ILYASA PRADANA"<< endl;

cout<< "Nim: 32602300046"<< endl << endl;
float panjang, lebar;

cout << "Masukkan panjang : ";
15
cin >> panjang;

cout << "Masukkan lebar : ";
cin >> lebar;
int pilihan;
cout << "Pilih operasi yang ingin dihitung:\n";
cout << "1. Luas\n2. Keliling\n3. Diagonal\n";
cout <<"pilihan : ";
cin >> pilihan;
switch (pilihan) {
case 1: {
float luas = panjang * lebar;
cout << "Luas persegi panjang adalah: " <<
luas << endl;
break;
}
case 2: {
float keliling = 2 * (panjang + lebar);
cout << "Keliling persegi panjang adalah: "
<< keliling << endl;
break;
}
case 3: {
float diagonal = sqrt(pow(panjang, 2) +
pow(lebar, 2));
cout << "Diagonal persegi panjang adalah: "
<< diagonal << endl;
break;
}
default:
cout << "Pilihan tidak valid." << endl;
}
return 0;
}
16
b. Output
Gambar 1. 12 Output Tugas 2 Luas
Gambar 1. 13 Output Tugas 2 Keliling
Gambar 1. 14 Output Tugas 2 Diagonal

17
c. Flowcart
d. Penjelasan
Pada Gambar 1.13 sampai Gambar 1.15 di Output menjelaskan
output dari kode program C++ untuk mencari hitungan Luas,
Keliling, Diagonal dari Persegi Panjang. Pada progam diatas saya
menyertakan modul iostream untuk menangani input/output
program dan juga menggunakan namespace std agar penggunaan
fungsi cout lebih sederhana. Fungsi main menggunakan tipe non
void, artinya harus memiliki nilai balik return value, Ada enam
variabel yang di deklarasikan yaitu pilihan, diagonal, keliling, luas,
panjang dan lebar masing-masing bertipe float (bilangan pecahan),
kecuali pilihan. Karena variable pilihan hanya untuk
mendeklarasikan pilihan untuk menghitung luas, keliling atau
diagonal. Pengguna akan memasukan panjang dan lebar nilainya
akan di input ke variabel panjang dan lebar melalui fungsi cin.
3. Modifikasilah program nomor 2 menjadi bahasa C.

a. Kode Program
#include <stdio.h>
18
#include <math.h>
int main() {
char jenis;
int panjang, lebar, luas, keliling;
float diagonal;
printf("\n\nNAMA : NABIEL ILYASA PRADANA");

printf("\n\nNIM : 32602300046");
printf("\n\nKode LUAS Persegi panjang = L");
printf("\n\nkode hitungan keliling persegi panjang =
K");
printf("\n\nkode hitungan diagonal persegi panjang =
D");
printf("\n\nMasukan kode perhitungan : ");
scanf("%c", &jenis);
printf("============================================");
if (jenis == 'L' || jenis == 'l') {

printf("\n>>>>>penghitungan Luas Persegi
Panjang<<<<" "\n");
printf("masukkan panjang=");
scanf("%d", &panjang);
printf("\n\nmasukkan lebar=");
scanf("%d", &lebar);
luas = panjang * lebar;
printf("\
n======================================");
printf("\nluas persegi panjang = %d", luas);
} else if (jenis == 'K' || jenis == 'k') {
printf("\n>>>>>penghitungan Keliling Persegi
Panjang<<<<" "\n");
printf("masukkan panjang=");
printf("\n\nmasukkan lebar=");
keliling = 2 * (panjang + lebar);
19
printf("\n============================");
printf("\nkeliling persegi panjang = %d",
keliling);
} else if (jenis == 'D' || jenis == 'd') {
printf("\n>>>>>>perhitungan diagonal persegi
panjang<<<<\n");
printf("\nmasukkan panjang= ");
printf("\nmasukkan lebar= ");
diagonal = sqrt(panjang * panjang + lebar *
lebar);
printf("\n===================================");
printf("\ndiagonal persegi panjang = %f",
diagonal);
} else {
printf("\nkode tidak valid");
}
return 0;
}
b. Output
Gambar 1. 16 Output Tugas 3 Luas

20
Gambar 1. 17 Output Tugas 3 Keliling
Gambar 1. 18 Output Tugas 3 Diagonal
c. Flowchart

21
d. Penjelasan
Pada gambar 1.19 merupakan hasil dari program diatas.
Program tersebut merupakan program yang menampilkan masukan
nilai panjang dan masukan nilai lebar. Program tersebut digunakan
untuk menentukan atau mencari nilai diagonal, luas dan keliling.
Header yang digunakan adalah iostream dan math.h. iostream
adalah kepanjangan dari Input Output Stream yang digunakan untuk
memanggil fungsi yang ada pada library file-header tersebut seperti
fungsi input yaitu cin dan fungsi output yaitu cout. Sedangkan
math.h berisi prototype yang berfungsi sebagai pustaka matematika.
Pada program ini akan melakukan perintah memasukan nilai
panjang, setelah itu program akan menginput nilai variable panjang,
kemudian program ini kembali melakukan perintah supaya
memasukan nilai lebar, dan program menginputkan nilai pada
variable lebar. Selanjutnya program akan membuat variable diagonal
beripe data flloat. Program akan menghitung hasil diagonal dengan
memasukan hasil rumus pitagoras kedalam variabel luas bertipe data
integer dan memasukan nilai panjang*lebar. Untuk membuat
variabel keliling bertipe data integer dan memasukan dan
memasukan nilai (panjang+lebar)/2. Kemudian akhir dari program
ini akan menampilkan nilai diagonal, luas, dan keliling.
4. Buatlah program agar hasil outputnya menjadi persegi seperti gambar di
bawah ini dalam bahasa C, dengan ketentuan panjang sisinya di
inputkan.
a. Kode Program
#include <stdio.h>#include <stdio.h>
22
int main() {
printf("\nNIM : 32602300046");
printf("\n");
int panjangSisi;
// Input panjang sisinya
printf("Masukkan panjang sisinya: ");
scanf("%d", &panjangSisi);
// Membuat persegi
for (int i = 1; i <= panjangSisi; i++) {
for (int j = 1; j <= panjangSisi; j++) {
if (i == 1 || i == panjangSisi || j == 1 ||
j == panjangSisi) {
printf("* ");
} else {
printf(" "); // Spasi untuk bagian
dalam persegi
}
}
printf("\n");
}
return 0;
}
b. Output

23
c. Flowchart
d. Penjelasan
Pada nomor.4 ini menjelaskan tentang Program Bahasa C untuk
menampilkan Persegi berlubang atau hollow square. Program ini
menggunakan tipe data sederhana berupa integer. Integer yang saya
masukkan ada int I, int j, int N; Kita memerlukan int N, karena untuk
pendeklarasian penampilan untuk tampilan awal memasukkan berapa
baris atau sisi dari persegi yang ingin dibuat. Program ini dibuat
dengan struktur Looping for karena lebih mudah dipahami.
5. Buatlah simulasi menu program dengan tampilan dibawah ini
menggunakan WHILE.
MENU PILIHAN
1. Dangdut
2. Pop
3. Rock
4. Exit
Pilihan Anda (1/2/3/4) ? ...
Apabila dipilih menu no 1, maka akan tampil teks “Anda memilih menu
1”. Demikian pula untuk menu 2 dan 3. Kemudian setelah itu muncul
teks “Tekan ENTER untuk kembali ke menu utama”. Artinya begitu kita
24
tekan ENTER menu pilihan akan muncul kembali, dst. Akan tetapi bila
yang dipilih menu 4 (EXIT), program langsung berhenti
a. Kode Program
#include <stdio.h>
int main() {
int pilihan;
// Menampilkan menu secara berulang sampai pengguna
memilih untuk keluar (pilihan 4)
while (1) {
printf("MENU PILIHAN\n");
printf("1. Dangdut\n");
printf("2. Pop\n");
printf("3. Rock\n");
printf("4. Exit\n");
printf("Pilihan Anda: ");

scanf("%d", &pilihan);
switch (pilihan) {
case 1:
printf("Anda memilih Dangdut\n");
break;
case 2:
printf("Anda memilih Pop\n");
break;
case 3:
printf("Anda memilih Rock\n");
break;
case 4:
printf("Program keluar. Terima kasih!\
n");
return 0; // Keluar dari program
default:
printf("Pilihan tidak valid. Silakan
pilih lagi.\n");
}
25
return 0;
}
b. Output
c. Flowchart
d. Penjelasan
Program Bahasa C yang memilih pilihan genre lagu dari
26
Dangdut, Pop dan Rock. Lalu pilihan ke-empat adalah exit. Dimana
exit mengakhiri pilihan dan quit program. Dipanggil menggunakan “
if ” agar bisa memilih pilihan menu genre music favorit.. Bertipe
data char dan integer.
1.5 Kesimpulan
Bab ini mempelajari tentang bahasa C dan bahasa C++ dimana kita
harus merubah kode bahasa C++ ke kode bahasa C, dan juga kita merubah
dari kode bahasa C ke kode bahasa C++. Tujuan dari pratikum Bab 1 ini kita
agar bisa membedakkan antara bahasa C dan bahasa C++ yang akan
bermanfaat dikemudian hari sebagai mahasiswa informatika.
Pada pratikum ini membahas tentang sekuensial, seleksi, dan
perulangan, seleksi ada if dan else if, dan di perulangan ada looping.
Looping sendiri terdapat for, while dan do-while.
BAB 2
ARRAY 2D DAN 3D

BAB II
ARRAY 2D DAN 3D
1. Mengenal array 2 dimensi dan array 3 dimensi
2. Mengerti dan memahami penggunaan array 2 dimensi dan 3 dimensi.
2.2 Dasar Teori

Array adalah struktur data yang memungkinkan penyimpanan elemen-
elemen data bertipe serupa dalam urutan tertentu. Kelebihan array meliputi
kemampuannya untuk menyimpan data secara terstruktur dan efisien,
memudahkan pengelolaan data dalam program, serta memungkinkan akses
cepat terhadap elemen-elemen data tersebut. Namun, array juga memiliki
beberapa kelemahan, seperti ukuran array yang harus ditentukan pada saat
deklarasi dan tidak fleksibel untuk penambahan atau pengurangan elemen.
Penggunaan array sangat bermanfaat dalam menyimpan dan mengelola

data dalam berbagai konteks. Misalnya, dalam sebuah program, array dapat
digunakan untuk menyimpan daftar nama-nama mahasiswa dalam sebuah
kelas, hasil pengukuran suhu harian selama sebulan, atau nilai-nilai dari
sebuah eksperimen. Dengan menggunakan array, data-data tersebut dapat
diakses dan dikelola dengan lebih efisien.
Salah satu kegunaan yang paling umum dari array adalah untuk
melakukan operasi matematika atau statistik pada kumpulan data.
Contohnya, array dapat digunakan untuk menghitung rata-rata dari sejumlah
nilai, mencari nilai terbesar atau terkecil dalam kumpulan data, atau
mengurutkan data secara ascending atau descending. Dengan demikian,
array memungkinkan penggunaan yang fleksibel dan efisien dalam berbagai
aplikasi yang melibatkan manipulasi data.
2.2.1 Pengertian Array

Array adalah sebuah variable yang menyimpan sekumpulan data yang
memiliki tipe yang sama. Setiap data tersebut menempati lokasi atau Alamat
memori yang berbeda – beda dan selanjutnya disebut dengan elemen array.
28
Elemen array itu kemudian dapat kita akses melalui indeks yang
terdapat didalamnya.
Untuk mendeklarasikan
sebuah array dalam C++, kita harus
menggunakan tanda [] (bracket). (Kasani et al., 2019)
2.2.2 Array Multidimensi

Array Multidimensi yaitu array yang terdiri dari beberapa subskrip
array. Sebagai contoh, array 2 dimensi adalah array yang mempunyai 2
subskrip array, 3 dimensi mempunyai 3 subskrip array dan seterusnya.
Array seperti ini sering digunakan untuk pemrosesan matrik.
2.2.3 Array Dua Dimensi

Array dua dimensi adalah array yang memiliki dua buah elemen bertipe
array. Dengan kata lain, array dua dimensi memiliki dua buah subskrip,
yang biasanya dipresentasikan dengan baris dan kolom.
Contoh sederhana adalah data yang tertulis dalam tabel
berikuit ini :
Gambar 2. 1 Tabel array 2 dimensi
Jika dibuat programnya adalah sebagai berikut :

int data_hp [3] [4];
Bentuk umum pendeklarasian sebuah array dua dimensi adalah
sebagai berikut :
tipe_data
nama_array[jumlah_elemen_baris][jumlah_elemen
_kolom];
29
2.2.4 Array Tiga Dimensi

Array tiga dimensi merupakan array yang memiliki tiga buah subskrip
dan lebih kompleks apabila dibandingkan dengan array dua dimensi. Di
sini, subskrip yang ada akan dipresentasikan dengan sumbu x, y dan z atau
panjang, lebar dan tinggi seperti yang ditunjukkan oelh gambar berikut.
Gambar 2. 2 Array 3 Dimensi
Bentuk umum pendeklarasian sebuah array tiga dimensi adalah sebagai

berikut :
tipe_data
nama_array[jumlah_elemen_x][jumlah_elemen_y][
jumlah_elemen_z];
2.3 Latihan
1. Latihan 1
a. Kode Program
#include <iostream>

main()
{
int i, j;
int data[2][2];
cout << "Input Data" << endl;
30
for (i = 0; i <= 1; i++)

{
for (j = 0; j <= 1; j++)
{
cout << "data[" <> data[i][j];
}
}
cout << "Matrik yang diinputkan : " << endl;
for (i = 0; i <= 1; i++)
{
for (j = 0; j <= 1; j++)
{
cout << data[i][j] << " ";
}
cout << endl;
}
}
b. Output
Gambar 2. 3 Output latihan 1

31
c. Flowchart
Gambar 2. 4 flowchart latihan 1
d. Penjelasan
Program latihan 1 diatas merupakan program Array 2 Dimensi
berisi matrik 2x2 yang mana terdapat 2 baris x dan 2 kolom y. library
yang digunakan merupakan iostream yang berisi syntax cin, cout,
endl. Tipe data yang digunakan merupakan tipe data integer yang
membutuhkan bracket[] untuk menyimpan variabel yang mana
bracket pertama digunakan untuk menyimpan data x dan bracket yang
kedua digunakan untuk menyimpan data y. untuk menginputkan nilai
kita menggunakan perulanagan jenis for, perulangan pertama
digunakan untuk memasukkan data x dan perulangan kedua digunakan
untuk memasukkan data y.
2. Latihan 2
a. Kode Program
#include <iostream>
int main()
{
32
float nilai[2][3];
int baris, kolom;
for (baris = 0; baris < 2; baris++)

{
for (kolom = 0; kolom < 3; kolom++)
{
cout << "Nilai [" << baris + 1 << "][" <<
kolom + 1 << "] = ";
cin >> nilai[baris][kolom];
}
}
cout << endl;
cout << "Matriks Nilai yang dimasukkan :" << endl
<< endl;
{
{
cout << nilai[baris][kolom] << " ";
}
cout << endl;
}
cout << endl;
float jml_nilai1 = 0, jml_nilai2 = 0;
float rerata1, rerata2;
float jml_nilaicol1 = 0, jml_nilaicol2 = 0,
jml_nilaicol3 = 0;
float reratacol1, reratacol2, reratacol3;
{
if (baris == 0)
{
33
jml_nilai1 = jml_nilai1 + nilai[baris]

[kolom];
}
else
{
for (kolom = 0; kolom < 3; kolom++) //
Corrected loop condition here
jml_nilai2 = jml_nilai2 + nilai[baris]
[kolom];
}
}
rerata1 = jml_nilai1 / 3;
cout << "Rerata baris ke 1 = " << rerata1 << endl;
cout << "Rerata baris ke 2 = " << rerata2 << endl;
// per kolom
cout << endl;
{
if (kolom == 0)
{
jml_nilaicol1 = jml_nilaicol1 +
nilai[baris][kolom];
}
else if (kolom == 1)
{
}
else
{
}
}
34
reratacol1 = jml_nilaicol1 / 2;
cout << "Rerata kolom ke 1 = " << reratacol1 <<
endl;
endl;
endl;
return 0;
}
b. Output

35
c. Flowchart
d. Penjelasan
Output diatas adalah hasil dari program yang menggunakan
array matriks 2x3 (2 baris dan 3 kolom) beserta rerata baris dan
kolomnya. Karena terdapat nilai rerata maka tipe data yang
digunakan adalah float yang dapat menampilkan bilangan pecahan
atau desimal. untuk menginputkan data yang kita masukkan maka
kita menggunaka perulangan jenis for yang mana perulangan
pertama untuk baris 1 kemudian lanjut kolom 1 dan seterusnya. Dan
untuk membuat program ini agar berjalan sesuai yang diinginkan
maka digunakanlah fungsi seleksi (if – else) yang mana jika inputan
yang pertama benar maka statement yang ada dalam fungsi if akan
dijalankan, dan jika salah maka statement yang ada didalam else
akan dijalankan. Dan apabila semua data telah diinputkan maka data
akan dicetak serta dioperasikan perhitungan rerata untuk menghitung
rerata data yang di inputkan.
3. Latihan 3
a. Kode Program
#include <iostream>

36
main()
{
int i, j, k, x = 1;
int matrik[3][3][4];
cout << " 3 dimensi array " << endl
<< endl;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
for (k = 0; k < 5; k++)
{
matrik[i][j][k] = x;
cout << " " << matrik[i][j][k];
x++;
}
cout << endl;
}
cout << endl;
}
}
b. Output

37
c. Flowchart
Gambar 2. 8 flowchart latihan
d. Penjelasan
Gambar diatas adalah keluaran dari program yang menggunakan

array 3 dimensi yang berisikan 3 baris x 3 kolom. Array tiga dimensi
dapat diilustrasikan menjadi sebuah bangun ruang yang mempunyai
lebar panjang dan tinggi. Untuk memasukkan data diatas
digunakanlah perulangan jenis for yang mana perulangan pertama
digunakan untuk memasukkan data lebar, perulangan kedua untuk
memasukkan data panjang dan perulangan ketiga digunakan untuk
memasukkan data tinggi.
2.4 Tugas
1. Ubahlah kode latihan 2 ke bahasa C!
a. Kode Program
#include <stdio.h>
38
int main()
{
printf("\nNIM : 32602300046");
printf("\n");
float nilai[2][3];
// Input nilai matriks
for (int baris = 0; baris < 2; baris++)
{
for (int kolom = 0; kolom < 3; kolom++)
{
printf("Nilai [%d][%d] = ", baris + 1, kolom
+ 1);
scanf("%f", &nilai[baris][kolom]);
}
}
// Menampilkan matriks nilai
printf("\nMatriks Nilai yang dimasukkan :\n");
{
{
printf("%f ", nilai[baris][kolom]);
}
printf("\n");
}
float jml_nilai1 = 0, jml_nilai2 = 0;
float rerata1, rerata2;
float jml_nilaicol1 = 0, jml_nilaicol2 = 0,
jml_nilaicol3 = 0;
float reratacol1, reratacol2, reratacol3;
// Menghitung rerata per baris
{
if (baris == 0)
{
jml_nilai1 += nilai[baris][kolom];
39
}
else
{
jml_nilai2 += nilai[baris][kolom];
}
}
printf("\nRerata baris ke 1 = %f\n", rerata1);
printf("Rerata baris ke 2 = %f\n", rerata2);
// Menghitung rerata per kolom
{
if (kolom == 0)
{
jml_nilaicol1 += nilai[baris][kolom];
}
else if (kolom == 1)
{
}
else
{
}
}
printf("Rerata kolom ke 1 = %f\n", reratacol1);
return 0;
}
40
b. Output
Gambar 2. 9 Output tugas 1
c. Flowchart
Gambar 2. 10 flowchart tugas 1
d. Penjelasan
Program ini menampilkan array matriks 2x3 (2 baris dan 3
kolom) beserta rerata setiap baris dan kolomnya. Karena ini
menggunakan bahasa C dan kita membutuhkan fungsi makro dan
konstanta digunakanlah library stdlib.h ,serta fungsi input dan output
yang terdapat dalam library stdio.h. tipe data yang digunakan adalah
tipe data integer yang digunakan untuk menyimpan variabel data
dengan kombinasi perulangan jenis for untuk memasukkan data dan
mengeluarkanya, serta ditambahan operasi perhitungan untuk mencari
rerata setiap baris dan kolomnya.
2. Jalankan program brikut :
a. Kode Program
41
#include <iostream>

int main()
{
cout << "Nama: NABIEL ILYASA PRADANA" << endl;
cout << "Nim: 32602300046" << endl
<< endl;
const int rows = 3;

const int cols = 2;
typedef int matrik[rows][cols];

matrik elemen1, elemen2, hasil_jumlah;
int baris, kolom;
for (baris = 0; baris < rows; baris++)

{
for (kolom = 0; kolom < cols; kolom++)
{
cout << "Elemen A[" << baris + 1 << "][" <<
kolom + 1 << "] = ";
cin >> elemen1[baris][kolom];
}
}
cout << endl;

{
{
cout << "Elemen B[" << baris + 1 << "][" <<
kolom + 1 << "] = ";
}
}
42
cout << endl;

{
{
hasil_jumlah[baris][kolom] = elemen1[baris]
[kolom] + elemen2[baris][kolom];
}
}
cout << "Hasil Penjumlahan Elemen A dan Elemen B
adalah : " << endl;

{
{
cout << "Hasil Jumlah [" << baris + 1 << "]
[" << kolom + 1 << "] = " << hasil_jumlah[baris][kolom]
<< endl;
}
}
return 0;
}
b. Output

43
c. Flowcart
d. Penjelasan
Program diatas adalah terapan dari array 3x2 (3 baris dan 2
kolom) yang menggunakan Elemen A dan Elemen B untuk
menyimpan datanya. Tipe data yang digunakan dalah Typedef yang
digunakan untuk mendeklarasika tipe data lain. Kemudian dari data
hasil inputan dikeluarkanlah hasil penjumlahan dari baris dan olom
tersebut.
3. Modifikasilah program nomor 2 dengan menginputkan jumlah baris dan
jumlah kolom. Kemudian tambahkan operasi pengurangan dan
perkalian didalamnya!
a. Kode Program
#include <iostream>

int main()
{
44
cout << "Nim: 32602300046" << endl

<< endl;
int rows, cols;

cout << "Masukkan jumlah baris matriks: ";
cin >> rows;
cout << "Masukkan jumlah kolom matriks: ";
cin >> cols;
typedef int matrik[10][10]; // Assuming maximum size

is 10x10
matrik elemen1, elemen2, hasil_jumlah, hasil_kurang,
hasil_kali;
int baris, kolom;
cout << "Masukkan elemen-elemen matriks A:" << endl;

{
{
cout << "Elemen A[" << baris + 1 << "][" <<
kolom + 1 << "] = ";
}
}
cout << "Masukkan elemen-elemen matriks B:" << endl;
{
{
cout << "Elemen B[" << baris + 1 << "][" <<
kolom + 1 << "] = ";
}
}
// Penjumlahan
45

{
{
hasil_jumlah[baris][kolom] = elemen1[baris]
[kolom] + elemen2[baris][kolom];
}
}
// Pengurangan
{
{
hasil_kurang[baris][kolom] = elemen1[baris]
[kolom] - elemen2[baris][kolom];
}
}
// Perkalian
{
{
hasil_kali[baris][kolom] = 0;
for (int i = 0; i < cols; i++)
{
hasil_kali[baris][kolom] +=
elemen1[baris][i] * elemen2[i][kolom];
}
}
}
cout << "Hasil Penjumlahan Elemen A dan Elemen B
adalah : " << endl;
{
{
46
cout << "Hasil Jumlah [" << baris + 1 << "]

[" << kolom + 1 << "] = " << hasil_jumlah[baris][kolom]
<< endl;
}
}
cout << "Hasil Pengurangan Elemen A dan Elemen B
adalah : " << endl;
{
{
cout << "Hasil Kurang [" << baris + 1 << "]
[" << kolom + 1 << "] = " << hasil_kurang[baris][kolom]
<< endl;
}
}
cout << "Hasil Perkalian Elemen A dan Elemen B

adalah : " << endl;
{
{
cout << "Hasil Kali [" << baris + 1 << "]["
<< kolom + 1 << "] = " << hasil_kali[baris][kolom] <<
endl;
}
}
return 0;
}
47
b. Output
c. Flowchart
d. Penjelasan
Output diatas adalah hasil dari program array matriks 3x2 yang
merupakan hasil pengubahan dari tugas 2 yang ditambahkan operasi
pengurangan dan perkalian. Program ini menggunakan bahasa C++
yang mana diperlukanya library iostream yang jika dibuat dengan
48
bahasa C seperti tugas 2 maka menggunakan library stdio.h. untuk

menginputkan data maka digunakanlah perulangan for sebanyak data
yang ingin dimasukkan. Jika semua data telah diinputkan maka akan
dilakukan operasi penjumlahan, pegurangan, dan perkalian, kemudian
hasilnya akan dikeluarkan dengan menggunakan syntax cout yang
dikombinasikan dengan for.
4. Jalankan program berikut dan ganti ke dalam bahasa C++
a. Kode Program
#include <iostream>
int main()
{
cout << "Nim: 32602300046" << endl
<< endl;
char h = 'F'; // Untuk sesuaikan dengan ASCII huruf
'F' pada C++
string nama[4][3] = {
{"Angsa", "Anjing", "Anoa"},
{"Banteng", "Badak", "Beruang"},
{"Camar", "Capung", "Cendrawasih"},
{"Dara", "Domba", "Duyung"}};
cout << "Daftar Hewan sesuai abjad : \n\n";
for (int i = 0; i < 4; i++)
{
++h;
cout << "Kelompok " << h << endl;
for (int s = 0; s < 3; s++)
{
cout << s + 1 << ". " << nama[i][s] << endl;
}
cout << endl;
}
return 0;
}
b. Output
49
c. Flowchart
d. Penjelasan
Output ini adalah hasil dari program array 3 dimensi yang mana
berisikan kelompok, Nomor Urut, dan Juga hewan dengan Awalan A-
D. data diatas disimpan dalam tipe data integer dan dikeluarkan
dengan perulangan jenis for untuk mempermudah dalam
pengelompokanya.
5. Buatlah program untuk membentuk sebuah kelompok dimana jumlah

kelompok dan jumlah anggota diinputkan. Kemudian tampilkan kembali
kelompok dan anggota yang telah diinputkan seperti gambar berikut :
a. Kode Program
#include <iostream>
50
#include <vector>
#include <string>
int main()
{
cout << "Nim: 32602300046" << endl
<< endl;
int jumlahKelompok, jumlahAnggota;
cout << "Masukkan jumlah kelompok: ";
cin >> jumlahKelompok;
cout << "Masukkan jumlah anggota per kelompok: ";
cin >> jumlahAnggota;
vector<vector<string>> kelompok(jumlahKelompok,
vector<string>(jumlahAnggota));
// Input anggota untuk setiap kelompok
for (int i = 0; i < jumlahKelompok; ++i)
{
cout << "\nKelompok " <> kelompok[i][j];
}
}
// Menampilkan kelompok dan anggota yang telah
diinputkan
cout << "\nKelompok dan Anggota yang Telah
Diinputkan:\n";
for (int i = 0; i < jumlahKelompok; ++i)
{
cout << "Kelompok " << i + 1 << ": ";
for (int j = 0; j < jumlahAnggota; ++j)
{
cout << kelompok[i][j];
if (j < jumlahAnggota - 1)
{
51
cout << ", ";

}
}
cout << endl;
}
return 0;
}
b. Output
c. Flowachart
d. Penjelasan
Gambar 2.17 Merupakan hasil dari program pengelompokan
Mahasiswa yang menggunakan libray iostream yang berisi cin, cout,
endl dan tipe data yang digunakan adalah integer untuk menyimpan
angka serta tipe data string ntuk menyimpan sebuah kalimat serta
menggunakan perulangan jenis for untuk meringkas kerja system.
52
2.5 Kesimpulan
BAB II ini merupakan bab yang membahas tentang array 2D dan 3D.
pengertian array yaitu sebuah variabel yang digunakan untuk menyimpan
sekumpulan data yang memiliki tipe sama. Array ada yang memiliki 1
dimensi, 2 dimensi, dan juga 3 dimensi. Array dikatakan hanya mempunyai
1 dimensi apabila hanya memiliki 1 indeks, jika memiliki 2 indeks maka
disebut array 2 dimensi, begitu juga jika memiliki 3 indeks maka disebut
dengan array 3 dimensi dan lebih komplek dari array 2 dimensi dan 1
dimensi. Array biasa digunakan untuk penerapan matriks.
Arrray itu seperti lemari yang terdiri dari beberapa rak dan berisi
beberapa kotak yang diumpamakan rak itu adalah dimennsi 1 dan kotak
adalah dimensi kedua, dimana kita dapat menyimpan disalah satu kotak
tersebut dan dapat kita letakkan disalah satu rak yang terdapat didalam
lemari tersebut.
Pada bab II ini mahasiswa menjadi lebih memahami tentang array baik
yang 2 dimensi maupun yang 3 dimensi serta juga penerapanya dalam
perhitungan matriks terutama dalam bahasa pemrograman C, C++ yang
sesuai dengan urutan eksekusi program programnya dengan
menggabungkan beberapa perintah.
BAB 3
SORTING DAN SEARCHING

BAB III
METODE SORTING DAN SEARCHING

1. Mengerti dan Memahami Metode Pencarian Data.
2. Dapat menggunakan Metode Pencarian Data dalam Program.
3. Memahami penggunaan metode Sorting.
3.2 Dasar Teori

BAB III ini membahas tentang metode pengurutan (sorting) dan
pencarian (searching) dalam algoritma. Pengurutan adalah proses mengatur
ulang data sehingga tersusun secara teratur sesuai dengan aturan tertentu,
seperti urutan naik (ascending) atau urutan turun (descending). Dalam BAB
ini, metode pengurutan yang dibahas antara lain adalah Bubble Sort
(pengurutan gelembung), Insertion Sort (pengurutan penyisipan), Selection
Sort (pengurutan seleksi), dan Quick Sort (pengurutan cepat).
Sementara itu, pencarian adalah proses untuk menemukan suatu data

dalam kumpulan data. Pencarian dilakukan terhadap seluruh data yang
tersimpan dalam memori komputer. BAB ini memberikan pemahaman yang
lebih mendalam tentang penggunaan metode sorting dan searching dalam
algoritma. Pembahasan mencakup penerapan metode-metode tersebut dalam
program-program latihan dan tugas, baik dalam bentuk kode program
maupun hasil output yang dihasilkan. Dengan memahami konsep dan
penerapan metode sorting dan searching, pembaca diharapkan mampu
mengimplementasikan algoritma-algoritma ini secara efektif dalam
pemrograman komputer.
1.2.5 Pencarian Data.

Pencarian (searching) merupakan tindakan untuk mendapatkan suatu
data dalam kumpulan data. Dalam kehidupan sehari-hari ,seringkali kita
berurusan dengan pencarian , misalnya untuk menemukan nomor telepon
seseorang pada buku telepon atau mencari suatu istilah dalam kamus.
53
54
Terdapat beragam algoritma pencarian untuk keperluan mencari data.

Perlu diketahui ,yang di maksud dengan algoritma pencarian adalah
“algoritma yang menerima sebuah argument a dan mencoba untuk
menemukan sebuah rekaman yang memiliki kunci a”.
Pencarian data dilakukan terhadap data dapat dilakukan terhadap data
yang secara keseluruhan berada dalam memory computer ataupun terhadap
data yang berada dalam penyimpan eksternal. (Nurhayati, 2010)
1.2.6 Pengertian Sorting

Sorting merupakan suatu proses untuk menyusun kembali humpunan
obyek menggunakan aturan tertentu. Sorting disebut juga sebagai suatu
algoritma untuk meletakkan kumpulan elemen data kedalam urutan tertentu
berdasarkan satu atau beberapa kunci dalam tiap-tiap elemen. Pada dasarnya
ada dua macam urutan yang biasa digunakan dalam suatu proses sorting:
1. Urut naik (ascending)
Mengurutkan dari data yang mempunyai nilai paling kecil sampai
paling
besar.
2. Urut turun (descending)
Mengurutkan dari data yang mempunyai nilai paling besar sampai
paling
kecil.
Metode-metode sorting yang akan dibahas kali ini meliputi:
a. Bubble sort (Metode Gelembung)
b. Insertion Sort (Metode Penyisipan) Desertion Sort.
c. Selection Sort (Metode Seleksi)
d. Quick Sort (Metode Quick)
Metode gelembung (bubble sort) sering juga disebut dengan metode

penukaran (exchange sort) adalah metode yang mengurutkan data dengan
55
cara membandingkan masing-masing elemen, kemudian melakukan

penukaran bila perlu. Metode ini mudah dipahami dan diprogram, tetapi bila
dibandingkan dengan metode lain yang kita pelajari, metode ini merupakan
metode yang paling tidak efisien.
1.2.7 Algoritma Bubble Short

1. Membandingkan data ke-i dengan data ke-(i+1) (tepat bersebelahan). Jika
tidak sesuai maka tukar (data ke-i = data ke- (i+1) dan data ke-(i+1) =
data ke-i). Apa maksudnya tidak sesuai? Jika kita menginginkan
algoritme menghasilkan data dengan urutan ascending (A-Z) kondisi
tidak sesuai adalah data ke-i > data ke-i+1, dan sebaliknya untuk urutan
descending (A-Z).
2. Membandingkan data ke-(i+1) dengan data ke-(i+2). Kita melakukan
pembandingan ini sampai data terakhir. Contoh: 1 dgn 2; 2 dgn 3; 3 dgn
4; 4 dgn 5 ... ; n-1 dgn n.
3. Selesai satu iterasi, adalah jika kita sudah selesai membandingkan antara
(n-1) dgn n. Setelah selesai satu iterasi kita lanjutkan lagi iterasi
berikutnya sesuai dengan aturan ke-1. mulai dari data ke-1 dgn data ke-2,
dst.
4. roses akan berhenti jika tidak ada pertukaran dalam satu iterasi.
3.3 Latihan
1. Latihan 1
a. Kode Program
#include <iostream>

int cari(int data[], int n, int k)
{
int posisi = -1; // Initialize posisi to -1
for (int i = 0; i < n; i++)
{
if (data[i] == k)
56
{
posisi = i;
break; // Break out of the loop if the element is
found
}
}
return posisi;
}
int main()
{
cout << "Nim: 32602300046" << endl << endl;
const int arraySize = 8;
int data[arraySize]; int dicari;
cout << "Masukkan Data : ";
for (int a = 0; a < arraySize; a++)
{
cin >> data[a];
}
cout << "Masukkan Data yang dicari : ";
cin >> dicari;
int posisi = cari(data, arraySize, dicari);
if (posisi != -1)
{
cout << "Posisi " << dicari << " dalam larik data:" <<
posisi << "\n";
} else
{
cout << "Data tidak ditemukan dalam larik.\n";
}
return 0;
}
57
b. Output
Gambar 3. 1Output latihan 1
c. Flowchart
d. Penjelasan
Pada gambar 3.2 merupakan hasil dari program diatas. Program
diatas adalah program yang menampilkan Masukkan data. Program
tersebut memerintahkan agar memasukkan data selama 8 kali.
Kemudian program akan menampilkan masukkan data yang dicari
agar dapat mencari posisi dalam matrik data.
Header yang digunakan dalam program tersebut adalah iostream
iostream adalah header yang menjalankan perintah cin dan cout.
2. Latihan 2
a. Kode Program
#include <iostream>
58

int main()
{
cout << "Nim: 32602300046" << endl
<< endl;
int i, j, n, data[10], simpan;
cout << "Masukkan banyak data: ";

cin >> n;
for (i = 1; i <= n; i++)

{
cout << "Data " <> data[i];
}
cout << "Awal = ";
for (i = 1; i <= n; i++)
cout << data[i] << " ";
cout << endl;
for (i = 1; i <= n - 1; i++)
{
for (j = 1; j <= n - i; j++)
{
if (data[j] > data[j + 1])
{
// Tukar nilai
simpan = data[j];
data[j] = data[j + 1];
data[j + 1] = simpan;
}
}
}
cout << "Hasil = ";
for (i = 1; i <= n; i++)
cout << data[i] << " ";
return 0;
}
59
b. Output
c. Flowchart
d. Penjelasan
Pada gambar 3.3 merupakan hasil dari program di atas. Program
diatas merupakan program yang menampilkan masukkan banyak data.
Untuk mencari hasil dari sorting yang dilakukan pada program
tersebut.
60
Header yang digunakan dalam program tersebut adalah iostream.

Iostream merupakan header yang menjalankan perintah cin dan cout.
Dan main merupakan program yang dijalankan paling utama.
3.4 Tugas
1. Ubahlah script di bawah ini menggunkan bahasa C.
#include <iostream>
int data[10],data2[10];
int n;
void tukar(int a,int b)
{
int t;
t = data[b];
data[b] = data[a];
data[a] = t;
}
void Input()
{
cout<<"Masukkan jumlah data = ";cin>>n;
cout<<"--------------------------------------"<<endl;
for(int i=0;i<n;i++)
{
cout<<"Masukkan data ke-"<<(i+1)<<" = ";cin>>data[i];
data2[i] = data[i];
}
cout<<endl;
}
void Tampil()
{
{
cout<<data[i]<<" ";
}
cout<<endl;
}void bubble_sort()
61
{
{
for(int j=n-1;j>=i;j--)
{
if(data[j]<data[j-1]) tukar(j,j-1);
}
Tampil();
}
cout<<endl;
}
main()
{
cout<<"* Bubble Sort *"<<endl;
Input();
cout<<"Proses Bubble Sort,,,,,,,"<<endl;
cout<<"-------------------------------------"<<endl;
Tampil();
bubble_sort();
cout<<"-------------------------------------"<<endl;}
Jawaban :
a. Kode Program
#include <stdio.h>
int data[10], data2[10];

int n;
void tukar(int a, int b)
{
int t;
t = data[b];
data[b] = data[a];
data[a] = t;
}
void Input()
{
printf("Masukkan jumlah data = ");
scanf("%d", &n);
62
printf("--------------------------------------\n");
for (int i = 0; i < n; i++)
{
printf("Masukkan data ke-%d = ", i + 1);
scanf("%d", &data[i]);
data2[i] = data[i];
}
printf("\n");
}
void Tampil()
{
for (int i = 0; i < n; i++)
{
printf("%d ", data[i]);
}
printf("\n");
}
void bubble_sort()
{
for (int i = 1; i < n; i++)
{
for (int j = n - 1; j >= i; j--)
{
if (data[j] < data[j - 1])
tukar(j, j - 1);
}
Tampil();
}
printf("\n");
}
int main()
{
printf("\n|Nama : NABIEL ILYASA PRADANA");
printf("\n|NIM : 32602200046
\n ");
63
printf("* Bubble Sort *\n");

Input();
printf("Proses Bubble Sort,,,,,,,\n");
printf("-------------------------------------\n");
Tampil();
bubble_sort();
printf("-------------------------------------\n");
return 0;
}
b. Output
Gambar 3. 5 Output tugas
c. Flowchart

64
d. Penjelasan
Program Pada gambar 3.5 merupakan hasil dari program di atas.
Program diatas merupakan program yang menggunakan bahasa C.
Program diatas menampilkan *Bubble sort* kemudiam masukkan
jumlah data. Program ini akan menampilkan nilai yang belum urut
kemudian akan mengurutkan nilai dari terbesar ke terkecil. Program
tersebut dijalankan dengan maksud untuk mengurutkan data dengan
menggunakan Bubble sort. Program tersebut meminta user untuk
memasukkan atau menginputkan banayak data terlebih dahulu.
Setelah menginputkan banyak data maka sdengan pengulangan, kata
―masukkan data‖ akan diuangi sebanyk data yang diinginkan
kemudian user akan diminta menginputkan data sebanyak data yang
dimasukakan tadi. Setelah data terkumpul maka sorting akan
dilakukan dengan metode bubble sort yang mengurutkan data daroi
terbesar ke terkecil. Header yang digunakan dalam program tersebut
adalah stdio.h. Stdio.h merupakan header yang menjalankan perintah
printf dan scanf.
2. Jalankan program akan menghasilkan tampilan seperti berikut:
Gambar 3. 7 Tugas 2
#include <iostream>
int cari (int data[], int n,int k,int m) {
int posisi,i,ketemu,pencacah=0;
if (n <= 0)
posisi=-1;
else{
ketemu = 0;
65
i=1;
while ((i<n+1)&&! ketemu)
if (data[i] == k) {
pencacah++;
cout<<"Pencacah " <<pencacah <<endl;
if (pencacah != m) {
cout<<"Ketemu"<<pencacah << endl;
posisi=i;
ketemu = 1;
}
Else
I--;
}
Else
i++;
if (!ketemu)
}
return posisi;
}
i nt main() {
int data [9]={10,9,4,6,3,4,2,5,0};
int dicari;
int ke;
dicari=4;
ke =2;
cout<<"Posisi " <<dicari<<" yang ke-"<<ke<<" dalam larik
data: " <<(cari(data,8,dicari,ke))<<"\n";
ke =1;
dicari = 0;
ke=1;
return 0;
}
Jawaban:
66
a. Kode Program
#include <iostream>

int cari(int data[], int n, int k, int m)
{
int posisi = -1, pencacah = 0;
if (n <= 0)
posisi = -1;
else
{
for (int i = 0; i < n; i++)
{
if (data[i] == k)
{
pencacah++;
if (pencacah == m)
{
cout << "ketemu " << m << endl;
posisi = i;
break;
}
}
}
if (pencacah >= m)
{
cout << "posisi " << k << " yang ke-" << m
<< " dalam larik data : " << posisi << endl;
}
else
{
cout << "posisi " << k << " yang ke-" << m
<< " dalam larik data : -1" << endl;
}
}
return posisi;
}
int main()
67
{
cout << " " << endl
<< endl;
cout << "Nama: NABIEL ILYASA PRADNA" << endl;
cout << "Nim : 32602300046" << endl
<< endl;
int data[9] = {10, 9, 4, 6, 3, 4, 2, 5, 7};
int dicari, ke;
dicari = 4;
ke = 2;
cari(data, 9, dicari, ke);
cout << "Pencacah 1" << endl;
ke = 1;
dicari = 0;
ke = 1;
return 0;
}
b. Output

68
c. Flowcart
d. Penjelasan
diatas merupakan program yang menampilkan pencacah 1, pencacah
2, poisi 4 yang ke 2 dalam larik data, pencacah 1, ketemu 1, posisi 4
yang ke-1 dalam larik data, posisi 0 yang ke-1 dalam larik data.
Kemudian pencacah akan menampilkan pencacah berada dalam
posisi mana pada data yang ada. Pencacah ini ada dua kali yaitu
pencacah satu dan 2. Sehingga output yang dihasilkan pun ada dua
pencacah. Header yang digunakan dalam program tersebut adalah
iostream. Iostream merupakan header untuk menjalankan perintah cin
dan cout. Main merupakan perintah pertama yang dijalankan oleh
program tersebut.
3. Ubahlah Script pada latihan 1 dengan menggunakan metode Insertion
Sort secara descending!
#include <iostream>
#include <conio.h>
int cari (int data[],int n,int k)
{
69
int posisi,i,ketemu; if (n <= 0)

posisi=-1; else{
ketemu = 0; i=1;
while ((i<n-1)&&! ketemu) if (data[i] == k)
{
posisi=i; ketemu=1;
}
else
i++;
if (!ketemu)
posisi = -1;
}
return posisi;
}
int main()
{
cout<<"NAMA : NABIEL ILYASA PRADANA"<<endl;
cout<<"NIM : 32602300046 "<<endl<<endl;
int data [8]; int dicari;
cout <<"Masukkan Data : " ; for(int a=0;a<8;a++)
{
cin >> data[a];
}
cout << "Masukkan Data yang dicari : "; cin >>dicari;
cout<<"Posisi " <<dicari<<" dalam larik data: "
<<(cari(data,8,dicari))<<"\n"; getch();
}
Jawaban :
a. Kode Program
#include <iostream>

int A[] = {2, 3, 4, 6, 7, 8, 9, 1, 5, 0};
int n = 10;
void SortingDesc()
{
int i, j, temp;
for (i = 0; i < n; i++)
70
{
for (j = n - 1; j > i; j--)
{
if (A[j] > A[j - 1])
{
temp = A[j];
A[j] = A[j - 1];
A[j - 1] = temp;
}
}
}
}
void show()
{
int i;
for (i = 0; i < n; i++)
{
cout << A[i] << " ";
}
}
int main()
{
int pil;
cout << "Nama = NABIEL ILYASA PRADNA\n";
cout << "NIM = 32602300046\n\n";
cout << "Program Shorting Array\n"
<< endl;
cout << "Sebelum di Urutkan = ";
show();
cout << "\nData Descending tekan 1 dan enter\n\n";
cout << "Input Pilihan Anda : ";
cin >> pil;
switch (pil)
{
case 1:
SortingDesc();
cout << "\nData Setelah di urutkan\n\nDescending
:";
71
show();
break;
}
}
b. Output
c. Flowchart
d. Penjelasan
Output Program diatas merupakan program yang menghasilkan
tampilan Program Shorting Array. Yang menghasilkan urutan nomor
secara descending dengan menggunakan intersection sort.
Program diatas adalah program yang menggunakan bahasa C++.
Dengan menggunakan header iostream. Iostream adalah header yang
72
digunakan untuk menjalankan perintah cin dan cout. Dan main adalah
yang pertama dijalankan oleh iostream.
4. Buatlah program pengurutan data dengan menggunakan semua metode
pengurutan untuk mengurutkan angka secara ascending dan descending!
a. Kode Program
#include <iostream>
// Fungsi untuk menu sorting

void bubbleSort(int arr[], int n, bool ascending);
void insertionSort(int arr[], int n, bool ascending);
void selectionSort(int arr[], int n, bool ascending);
void quickSort(int arr[], int low, int high, bool
ascending);
// Fungsi untuk menu utama
int main()
{
int choice, n;
std::cout << "NAMA : NABIEL ILYASA PRADANA\n";
std::cout << "NIM : 32602300046\n\n";
std::cout << "Pilih metode sorting:\n";
std::cout << "1. Bubble Sort\n";
std::cout << "2. Insertion Sort\n";
std::cout << "3. Selection Sort\n";
std::cout << "4. Quick Sort\n";
std::cout << "Pilihan: ";
std::cin >> choice;
bool ascending;
std::cout << "Pilih arah pengurutan:\n";
std::cout << "1. Ascending\n";
std::cout << "2. Descending\n";
std::cout << "Pilihan: ";
int orderChoice;
std::cin >> orderChoice;
if (orderChoice == 1)
ascending = true;
else if (orderChoice == 2)
ascending = false;
73
else
{
std::cout << "Pilihan tidak valid.";
return 1;
}
std::cout << "Masukkan jumlah data: ";
std::cin >> n;
int arr[n];
std::cout << "Masukkan data:\n";
for (int i = 0; i < n; ++i)
{
std::cin >> arr[i];
}
switch (choice)
{
case 1:
bubbleSort(arr, n, ascending);
break;
case 2:
insertionSort(arr, n, ascending);
break;
case 3:
selectionSort(arr, n, ascending);
break;
case 4:
quickSort(arr, 0, n - 1, ascending);
break;
default:
std::cout << "Pilihan tidak valid.";
return 1;
}
std::cout << "Hasil setelah pengurutan:\n";
for (int i = 0; i < n; ++i)
{
std::cout << arr[i] << " ";
}
std::cout << std::endl;
return 0;
74
}
// Implementasi fungsi Bubble Sort
void bubbleSort(int arr[], int n, bool ascending)
{
for (int i = 0; i < n - 1; ++i)
{
for (int j = 0; j < n - i - 1; ++j)
{
if ((ascending && arr[j] > arr[j + 1]) || (!
ascending && arr[j] < arr[j + 1]))
{
// Tukar elemen
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
// Implementasi fungsi Insertion Sort
void insertionSort(int arr[], int n, bool ascending)
{
for (int i = 1; i < n; ++i)
{
int key = arr[i];
int j = i - 1;
while ((j >= 0) && ((ascending && arr[j] > key)
|| (!ascending && arr[j] < key)))
{
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
// Implementasi fungsi Selection Sort
void selectionSort(int arr[], int n, bool ascending)
{
75
for (int i = 0; i < n - 1; ++i)

{
int min_idx = i;
for (int j = i + 1; j < n; ++j)
{
if ((ascending && arr[j] < arr[min_idx]) ||
(!ascending && arr[j] > arr[min_idx]))
{
min_idx = j;
}
}
// Tukar elemen
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
}
}
// Implementasi fungsi Quick Sort
int partition(int arr[], int low, int high, bool
ascending)
{
int pivot = arr[high];
int i = (low - 1);
for (int j = low; j <= high - 1; ++j)
{
if ((ascending && arr[j] < pivot) || (!ascending
&& arr[j] > pivot))
{
i++;
// Tukar elemen
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
// Tukar elemen
int temp = arr[i + 1];
arr[i + 1] = arr[high];
76
arr[high] = temp;
return (i + 1);
}
void quickSort(int arr[], int low, int high, bool
ascending)
{
if (low < high)
{
int pi = partition(arr, low, high, ascending);
quickSort(arr, low, pi - 1, ascending);
quickSort(arr, pi + 1, high, ascending);
}
}
b. Output
1) Ascending
Gambar 3. 12 Output tugas 4 ascending 1

77

78
2) Descending
Gambar 3. 16 Output tugas 4 descending 1

79

80
c. Flowchart
d. Penjelasan
Program diatas adalah program yang menggunakan bahasa C++.
Program diatas merupakan program yang menampilkan data sebelum
diurutkan dan memberikan perintah untuk menekan 1 dan enter untuk
mencari data yang telah diurutkan.
Header yang digunakan dalam program tersebut adalah iostream,
conio.h, time.h, windows.h dan define MAX 1.
81
1. Ascending
2. Descending
5. Ubahlah script dibawah ini dengan menggunakan bahasa C++.
#include <stdio.h>
void tampilkan_larik (int data[],int n) {

int i;
for(i=0;i< n ;i++)
printf("%d ",data[i]);
printf("\n");
}
int partisi(int data[],int p,int r){
int pivot= data[r];
int i = p-1;
int j;
for (j=p;j<r;j++){
if (data[j]<= pivot) {
i++;
int tmp = data[i];
data[i]= data[j];
data[j]= tmp;
}
}
int tmp = data[i+1];
data[i+1]= data[r];
data[r]= tmp;
return i+1;
}
void quick_sort(int data[],int p,int r) {
int q ;
if (p<r){
q = partisi(data,p,r);
quick_sort(data,p,q-1);
quick_sort(data,q+1,r);
}
}
82
int main(){
int jum_data = 9;
int i;
int data[]= {25,57,48,37,12,92,80,33,1};
quick_sort(data,0,jum_data-1);
printf("hasil pengurutan : \n");
tampilkan_larik(data,jum_data);
return 0;
}
Jawab:
a. Kode Program
#include <iostream>
void tampilkan_larik(int data[], int n)

{
std::cout << "Hasil pengurutan data: ";
for (int i = 0; i < n; i++)
{
std::cout << data[i];
if (i < n - 1)
{
std::cout << ", ";
}
}
std::cout << std::endl;
}
void insertion_sort(int data[], int n)
{
for (int i = 1; i < n; i++)
{
int key = data[i];
int j = i - 1;
while (j >= 0 && data[j] > key)
{
data[j + 1] = data[j];
j = j - 1;
}
83
data[j + 1] = key;
}
}
int main()
{
int n;
std::cout << "NAMA : NABIEL ILYASA PRADANA\n";
std::cout << "NIM : 32602300046\n\n";
std::cout << "Masukkan banyak data yang ingin
diurutkan: ";
std::cin >> n;
int data[n];
std::cout << "Masukkan data-datanya:\n";
for (int i = 0; i < n; i++)
{
std::cout << "Data ke-" <> data[i];
}
insertion_sort(data, n);
tampilkan_larik(data, n);
return 0;
}
b. Output

84
c. Flowchart
d. Penjelasan
Program diatas merupakan program yang menampilkan masukkan
data-datanya. Dan memberikan perintah untuk memassukkan data
agar mendapatkan hasil pengurutan yang benar.
Header yang digunakan pada program tersebut adalah iostream
dan conio.h. iostream merupakan header yang melakukan perintah cin
dan cout.
3.5 Kesimpulan
Sorting merupakan suatu proses untuk menyusun kembali humpunan
obyek menggunakan aturan tertentu. Sorting disebut juga sebagai suatu
algoritma untuk meletakkan kumpulan elemen data kedalam urutan tertentu
berdasarkan satu atau beberapa kunci dalam tiap-tiap elemen. Pada dasarnya
ada dua macam urutan yang biasa digunakan dalam suatu proses sorting:
1. Urut naik (ascending) mengurutkan dari data yang mempunyai nilai
paling kecil sampai paling besar.
85
2. Urut turun (descending) Mengurutkan dari data yang mempunyai nilai

paling besar sampai paling kecil.
BAB 4
REKURSI

BAB IV
REKURSI
4.1 Tujuan
Adapun tujuan dilakukannya praktikum ini:
1. Memahami mengenai konsep rekursif
2. Mampu memecah kan permasalahan dengan konsep rekursif
4.2 Dasar Teori

Rekursi adalah suatu metode dalam matematika dan pemrograman
komputer di mana sebuah fungsi didefinisikan dengan memanggil dirinya
sendiri. Dalam konteks aritmatika, rekursi dapat diterapkan dalam beberapa
konsep yang umumnya digunakan dalam pemrograman komputer.
Pertama, dalam konsep pangkat, bilangan selain 0, jika dipangkatkan

dengan 0, nilainya adalah 1. Jika sebuah bilangan x dipangkatkan dengan
bilangan bulat positif y, hasilnya adalah x dikalikan dengan x sebanyak y-1
kali. Konsep ini dapat dijelaskan dengan rekursi, di mana pemangkatan x
pangkat y dapat dihitung dengan cara memangkatkan x pangkat (y-1)
kemudian dikalikan dengan x.
Kemudian, dalam konsep faktorial, faktorial dari sebuah bilangan n,

dituliskan sebagai n! dan didefinisikan sebagai hasil perkalian dari semua
bilangan bulat positif kurang dari atau sama dengan n. Dalam rekursi,
faktorial dari n dapat dihitung dengan memanggil fungsi faktorial untuk (n-
1) dan mengalikannya dengan n.
Terakhir, dalam deret Fibonacci, setiap elemen dalam deret tersebut

dihasilkan dengan menjumlahkan dua elemen sebelumnya. Deret Fibonacci
dapat dihitung menggunakan rekursi dengan mendefinisikan setiap elemen
sebagai penjumlahan dari dua elemen sebelumnya.
Dengan menggunakan rekursi, konsep-konsep aritmatika seperti

pemangkatan, faktorial, dan deret Fibonacci dapat diimplementasikan secara
elegan dan efisien dalam pemrograman komputer. Namun, perlu
diperhatikan bahwa penggunaan rekursi harus dilakukan dengan hati-hati
karena dapat
85
86
menyebabkan overhead memori dan kinerja yang tidak efisien jika tidak
diimplementasikan dengan benar.
4.2.1 Pengertian Rekursi

Rekursif adalah suatu kemampuan subrutin untuk memanggil dirinya
sendiri. Adapun suatu subrutin yang memanggil dirinya sendiri seperti itu
dinamakan subrutin rekursi. Pada beberapa persoalan, kemampuan seperti
ini sangat berguna karena mempermudah solusi. Namun demikian rekursi
juga memiliki kelemahan, yakni memungkinkan terjadinya overflow pada
stack ( tidak lagi mampu menangani permintaan pemanggilan subrutin
karena kehabisan memori ). Itu sebabnya harus ada jaminan bahwa proses
rekursi akan berhenti pada waktu tertentu, yang menyebabkan pemanggilan
fungsi berakhir.
4.2.2 Fibonance
Fibonacci merupakan sebuah pola bilangan yang didapatkan dari
penjumlahan dua bilangan sebelumnya pada sebuah deret tersebut.
Berikut contoh program dari Fibonacci :
#include <iostream>
int Fibonacci(int n ) {
if ( n == 0 || n==1 ) {
return n;
} else {
return ( fibonacci ( n – 1 ) + fibonacci ( n – 2));
}
int main() {
int n, i, j = 0;
cout << “ Masukan batas jumlah bilangan Fibonacci : “;
cin >> n;
cout << “ Hasil bilangan Fibonacci : \n”;
for ( i = 0; i < = n; i++ ) {
cout << “ Fibonacci ke – “<< i<<”:”
<<fibonacci(j)<<endl;
87
j++;
}
return 0;
}
Berikut adalah penjelasan source code programnya :
1. Baris 5 : Membuat fungsi bernama Fibonacci yang bertipe integer dan
menerima masukan sebuah integer yang diberi nama variable n.
2. Baris 6 – 7 : Cek kondisi jika nilai dari variable n adalah 0 atau 1 maka
akan mengembalikan nilai n.
3. Baris 8 – 9 : Jika variable n bernilai selain 0 dan 1 maka akan
melakukan operasi rekursif dimana hasil operasi fibonacci n – 1
ditambah dengan hasil operasi Fibonacci n – 2.
4. Baris 15 : Mendeklarasikan variable n, i,dan j dimana variable n
digunakan untuk batas jumlah bilangan Fibonacci yang akan
ditampilkan, variable i digunakan untuk pengulangan dan variable j
digunakan untuk memasukan nilai ke fungsi Fibonacci secara berurutan.
5. Baris 17 – 18 : Menginputkan nilai kedalam variable n.
6. Baris 20 – 14 : Melakukan perulangan sebanyak nilai n da menginputkan
nilai j kedalam fungsi Fibonacci srta menampilkan hasil operasi
Fibonacci (Tobing & Chandra, 2022).
4.3 Latihan
1. Latihan 1
a. Algoritma
SUBRUTIN faktor
JIKA n = 0 ATAU 1 MAKA
NILAI-BALIK 1 SEBALIKNYA
NILAI-BALIK n x factorial(n-1)
AKHIR-JIKA AKHIR-SUBRUTIN
b. Kode Program
#include <stdio.h>
long int factorial(unsigned int n)

88
{
if (n == 0 || n == 1)
{
return 1;
}
else
{
return n * factorial(n - 1);
}
}
int main()
{
int n;
long int hasil;
printf("Nama : Nabiel Ilyasa pradana\n");
printf("Nim : 32602300046 \n\n");
printf("n = ");
scanf("%d", &n);
hasil = factorial(n);
printf("%d! = % ld", n, hasil);
return 0;
}
c. Output

89
d. Flowchart
e. Penjelasan
Pada gambar 4.1 merupakan hasil dari progam diatas. Program
diatas merupakan program yang menggunakan bahasa C. Program
tersebut menghasilkan tampilan –n = 1 yang dimaksud agar kita
mengisi angka yang ingin di faktorialkan, kemudian tekan enter untuk
mengetahui hasil dari factorial.
Header yang digunakan pada program ini adalah stdio.h Stdio.h
merupakan header yang berfugsi untuk operasi input dan output.
Stdio.h merupakan singkatan dari standar input output header.
2. Latihan 2
Algoritma
SUBRUTIN fib(n)
JIKA n = 0 MAKA
NILAI-BALIK 0
SEBALIKNYA JIKA n = 1
NILAI-BALIK 1
SEBALIKNYA
NILAI-BALIk fib(n-1) + fib(n-2) AKHIR-JIKA
90
AKHIR-SUBRUTIN
a. Kode Program
#include <iostream>

long int fib(unsigned int n)
{
if (n == 0)
{
return 0;
}
else if (n == 1)
{
return 1;
}
else
{
return fib(n - 1) + fib(n - 2);
}
}
int main()
{
int n;
long int hasil;
cout << " NAMA : Nabiel Ilyasa pradana\n";
cout << " NIM : 32602300046\n\n";
cout << " n = ";
cin >> n;
hasil = fib(n);
cout << "Fibonacci(" << n << ") = " << hasil;
return 0;
}
91
b. Output
c. Flowchart
d. Penjelasan
diatas merupakan program yang menggunakan bahasa C++. Yang
menghasilkan tampilan untuk mencari deret
fibonacci. Dengan cara memasukan nilai n kemudian tekan enter
untuk mengetahui hasilnya.
Pada program diatas merupakan program yang menggunakan
header iostream. Iostream merupakan header yang melakukan
perintah cin dan cout dan main merupakan fungsi yang pertama
dijalankan.
92
4.4 Tugas
1. Berikut merupakan algoritma untuk mengihitung nilai Y n dengan berupa
bilangan bulat lebih besar daripada nol yang dihitung secara rekursif.
SUBRUTIN pangkat(y, n)
JIKA n = 1 MAKA NILAI
BALIK y SEBALIKNYA
NILAI BALIK y x pangkat(y, n-1)
AKHIR JIKA AKHIR
SUBRUTIN
Buatlah progam menggunakan bahasa C/C++ untuk menghitung nilai Y
pangkat n tersebut berdasarkan algoritma diatas.
Jawaban :
a. Kode Program
#include <iostream>
#include <conio.h>
int pangkat(int y, int b)
{
int hasil = 1;
for (int i = 1; i <= b; i++)
{
hasil = hasil * y;
}
return hasil;
}
int main()
{
int i, j;
cout << "NAMA : Nabiel Ilyasa pradana\n";
cout << "NIM : 32602300046\n\n";
cout << "* *Program menghitung pangkat \n";
cout << "== == == == == == == == == == == =\n";
cout << "Masukan angka :";
cin >> i;
93
cout << "Masukan pangkat :";

cin >> j;
cout << "Hasilnya :";
cout << pangkat(i, j);
}
b. Output
c. Flowchart
d. Penjelasan
tersebut merupakan program yang menampilkan program menghitung
pangkat. Lalu hasil dari program tersebut memberi perintah agar
94
memasukan angka dan pangkat. Kemudian program akan mencetak

hasil pangkat dari angka dan pangkat yang dimasukkan.
Header yang digunakan adalah <iostream> dan conio.h.
Iostream merupakan header yang menjalankan perintah cin dan cout.
Sedangkan conio.h merupakan program untuk membersihkan layer
dan menahan tampilan.
2. Ubahlah program yang telah dibuat nomor 1 kedalam bahasa C.
Jawaban :
a. Kode Program
#include <stdio.h>
#include <conio.h>
int pangkat(int y, int n)
{
int pangkat = 1;
for (int i = 1; i <= n; i++)
{
pangkat = pangkat * y;
}
return pangkat;
}
int main()
{
int i, j;
printf("Nim : 32602300046\n");
printf("* *Program menghitung pangkat * *\n");
printf("== == == == == == == == == == == == ==\n");
printf("Masukan Angka :\n");
scanf("%d", &i);
printf("Masukan Pangkat :\n");
scanf("%d", &j);
printf("Hasil pangkat :\n");
printf("%d", pangkat(i, j));
}
95
b. Output
c. Flowchart
d. Penjelasan
diatas merupakan program yang menghasilkan tampilan program
menghitung pangkat. Yang artinya program diatas dibuat untuk
mencari sebuah pangkat dari suatu bilangan. Agar dapat mendapatkan
hasil dari pangkat suatu bilangan, anda harus memasukkan angka dan
pangkat kemudian tekan enter untuk mengetahui hasilnya.
96
3. Buatlah algoritma dari subrutin untuk membali suatu bilangan dengan

cara rekursi. Sebagai contoh, bilangan 1261 ditampilkan menjadi 1621.
Jawaban :
Algoritma:
SUBRUTIN membalik(x, y)
WHILE x > 0;
FOR i = 0, 1<=y, i++
MAKA NILAI BALIK membalik(x*10)+(y%10)
AKHIR FOR
AKHIR WHILE
AKHIR SUBRUTIN
a. Kode Program
#include <iostream>
#include <conio.h>
class membalik
{
public:
int proses();
void keluaran();
private:
int x, balik;
};
int membalik::proses()
{
cout << "Nama : Nabiel Ilyasa pradana\n";
cout << "NIM : 32602300046\n\n";
cout << "~<membalik angka yang ingin dibalik>~"
<< endl
<< endl;
cout << "masukan angka : ";
cin >> x;
balik = 0;
while (x > 0)
97
for (int i = 0; i <= x; i++)

{
balik = (balik * 10) + (x % 10);
x /= 10;
}
return balik;
}
void membalik::keluaran()
{
cout << "angka yang telah dibalik menjadi :" <<
balik << endl;
}
int main(int argc, char **argv)
{
membalik bilangan;
bilangan.proses();
bilangan.keluaran();
return 0;
}
b. Output

98
c. Flowchart
d. Penjelasan
diatas merupakan program yang menampilkan memballik angka yang
ingin dibalik. Kemudian terdapat tampilan masukkan angka, dalam
tampilan ini anda diperintahkan untuk memasukkan angka yang ingin
dibalik kemudian tekan enter dan akan mengkasilkan angka yang
sudah dibalik.
4. Buatlah program menggunakan bahasa C/C++ berdasarkan algoritma
pada soal nomor 3.
Jawaban:
a. Kode Program
#include <iostream>
#include <conio.h>
class membalik
{
public:
int proses();
99
void keluaran();
private:
int x, balik;
};
int membalik::proses()
{
cout << "Nim : 32602300046\n\n";
cout << "Membalik angka yang ingin dibalik\n";
cout << "Masukan angka : ";
cin >> x;
balik = 0;
while (x > 0)
for (int i = 0; i <= x; i++)
{
balik = (balik * 10) + (x % 10);
x /= 10;
}
return balik;
}
void membalik::keluaran()
{
cout << "angka yang telah dibalik menjadi :" <<
balik << endl;
}
int main(int argc, char **argv) {
membalik bilangan;
bilangan.proses();
bilangan.keluaran();
return 0;
}
100
b. Output
Gambar 4. 11 Outptut Tugas 4
c. Flowchart
d. Penjelasan
Pada gambar 4.11 merupakan hasil dari program diatas. Gambar
diatas adalah gambar yang menampilkan masukkan angka. Kemudian
memerintahkan kita untuk memasukan data secara acak dan jumlah
sesuain keinginan. Dalam gambar tersebut menunjukan adanya
pertukaran data, sehingga menghasilkan angka yang urut.
Program diatas merupakan program yang menggunakan header
iostream dan conio.h. Iostream merupakan header yang berfungsi
menjalankan perintah cin dan cout. Sedangkan conio.h merupakan
header untuk menahan tampilan.
5 Ubahlah program yang telah dibuat pada soal nomor 4 kedalam bahasa
C.
101
a. Kode Program
#include <stdio.h>
int x, balik;
void proses()
{
printf("Nama : nabiel Ilyasa pradana\n");
printf("Nim : 32602300046\n\n");
printf("Membalik angka yang ingin dibalik\n");
printf("Masukkan angka : ");
scanf("%d", &x);
balik = 0;
int sisa;
int temp = x;
while (temp > 0)
{
sisa = temp % 10;
balik = (balik * 10) + sisa;
temp /= 10;
}
}
void keluaran()
{
printf("Angka yang telah dibalik menjadi : %d\n",
balik);
}
void membalik()
{
proses();
keluaran();
}
int main()
{
membalik();
return 0;
}
102
b. Output
c. Flowchart
d. Penjelasan
diatas merupakan program yang menggunakan bahasa java. Program
diatas menampilkan program membalik angka, masukkan angka yang
ingin dibalik ( untuk menampilkan angka yang sudah dibalik, yang
dihasilkan oleh program tersebut ).
4.5 Kesimpulan
Rekursi adalah suatu kemampuan subrutin untuk memanggil dirinya
sendiri. Adapun suatu subruti yang memanggil dirinya seperti itu dinamakan
subrutin rekursi. Pada beberapa persoalan, kemampuan seperti itu sangat
berguna karena mempermudah solusi. Namun demikian rekursi juga
memiliki kelemahan, yakni memungkinkan terjadinya overflow pada stack
103
( tidak lagi mampu menangani permintaan pemanggilan subrutin karena

kehabisan memori ). Itu sebabnya harus ada jaminan bahwa proses rekursi
akan berhenti pada suatu waktu tertentu, yang menyebabkan pemanggilan
fungsi berakhir. Berikut kelebihan dan kekurangan rekursi :
1. Kelebihan Rekursif
a. Sangat mudah untuk melakukan perulangan dengan Batasan yang
luas dalam artian melakukan perulangan dalam skala yang besar.
b. Dapat melakukan perulangan dengan Batasan fungsi.
2. Kekurangan Rekursif
a. Tidak bisa melakukan nested loop atau looping bersarang.
b. Biasanya membuat fungsi sulit untuk dipahami, hanya cocok untuk
persoalan tertentu saja.
c. Memerlukan stack yang lebih besar, sebab setiap kali fungsi
dipanggil, variable lokal dan parameter formal akan ditempatkan ke
stack dan ada kalanya akan menyebabkan stack tak cukup lagi ( stack
overflow ).
d. Proses agak berbelit – belit karena terdapat pemanggilan fungsi yang
berulang – ulang dan pemanggilan data yang ditumpuk.
BAB 5
LINKED LIST, STACK, QUEUE

BAB V
LINKED LIST, STACK, DAN QUEUE
5.1 Tujuan
Adapun tujuan dari praktikum ini adalah sebagai berikut :
1. Mengenal penggunaan metode LINKED LIST
2. Mengenal penggunaan metode STACK
3. Penggunaan metode QUEUE
5.2 Dasar Teori

BAB V ini membahas materi Linked List, Stack, dan Queue dalam
algoritma. Linked List adalah struktur data dasar yang memungkinkan
penambahan elemen-elemen data secara dinamis, di mana setiap elemen
memiliki referensi ke elemen berikutnya. Terdapat tiga jenis Linked List:
senarai tunggal (singly linked list), senarai ganda (doubly linked list), dan
senarai sirkular (circular linked list). Konsep ini memberikan fleksibilitas
dalam mengelola data dengan memungkinkan penambahan atau
penghapusan elemen tanpa harus memindahkan seluruh data.
Selanjutnya, Stack adalah struktur data yang menggunakan prinsip Last

In First Out (LIFO), di mana elemen yang terakhir dimasukkan akan
menjadi yang pertama diambil. Stack umumnya digunakan untuk
mengevaluasi ekspresi matematika, pelacakan pemanggilan fungsi dalam
pemrograman, dan dalam berbagai aplikasi lain yang memerlukan
penanganan data berdasarkan urutan terbalik.
Sedangkan Queue adalah struktur data dengan prinsip First In First Out
(FIFO), di mana elemen yang pertama dimasukkan akan menjadi yang
pertama diambil. Queue biasanya digunakan untuk mengantri tugas atau
data yang harus diproses sesuai dengan urutan kedatangan.
Dalam BAB ini, kita akan mempelajari konsep dan implementasi dari
Linked List, Stack, dan Queue, serta penerapannya dalam pemrograman.
Terdapat beberapa operasi yang dapat dilakukan pada Queue, seperti
create(), IsEmpty(), IsFull(), Enqueue (penambahan data), Dequeue
(penghapusan data), Clear(), dan tampil (menampilkan isi Queue). Dengan
memahami konsep dan operasi-operasi ini, kita dapat menggunakan struktur
data ini secara efektif dalam menyelesaikan berbagai masalah pemrograman
104
105
5.2.1 Metode List

List atau senarai adalah sebuah pemikiran / konsep struktur data yang
sangat dasar pada pemrograman agar lebih fleksibel, dimana setiap elemen
akan ditambahkah saat dibutuhkan. Struktur data ini digunakan untuk
menyimpan sejumlah objek data biasanya secara terurut sehingga
memungkinkan penambahan, pengurangan, dan pencarian atas elemen data
yang tersimpan dalam senarai secara lebih efektif.
Gambar 5. 1 Senarai
Jenis – jenis senarai berantai ada 3 :

1. Senarai Tunggal bila struktur data sebuah node hanya memiliki satu
tautan atas node berikutnya dalam sebuah senarai, maka senarai tersebut
dinamakan sebagai senarai tanggal.
Gambar 5. 2 Senarai Tunggal
2. Senarai Ganda berbeda halnya dengan senarai tanggal, pada senarani

ganda, struktur data atas tiap – tiap node memiliki rujukan pada node
sebelum dan berikutnya. Sebagian algoritma membutuhkan taut ganda.
Contohnya sorting dan reverse traversing.
Gambar 5. 3 Senarai Ganda
3. Senarai Sirkular pada dua jenis senarai sebelumnya. Node terakhir dalam
senarai tersebut merujuk pada null yang artinya akhir dari sebuah senarai,
begitu pula null sebagai node sebelumnya pada node pertama bila senarai
yang dimaksudkan adalah senarai ganda. Pada senarai sirkular, informasi
rujukan pada node terakhir akan merujuk pada node pertama. Dan
106
rujukan pada node pertama akan merujuk pada node terakhir bila yang
digunakan sebagai dasar implementasi adalah senarai ganda.
Gambar 5. 4 Senarai Sirkular
5.2.2 Metode Stack

Sebuah koleksi objek yang menggunakan prinsip LIFO ( Last In First
Out ), yaitu data yang terakhir kali dimasukan akan pertama kali keluar dari
tumpukan tersebut. Tumpukan dapat diimplementasikan sebagai
representasi berkait atau kontigu ( dengan table fix ).
Ciri tumpukan :
1. TOP merupakan sebutan untuk elemen paling atas dari suatu stack
2. Elemen TOP merupakan elemen yang paling akhir ditambahkan.
3. Elemen TOP diketahui
4. Penambahan dan penghapusan elemen selalu dilakukan di TOP
5.2.3 Metode LIFO

Pemanfaatan tumpukan :
1. Perhitungan ekspresi aritmatika ( postfix )
2. Algoritma backtracking ( runut balik )
107
3. Algoritma rekursif
5.2.4 Metode Queue
Queue antrian adalah ordered list dengan penyisipan di satu ujung,
sedang penghapusan di ujung lain. Ujuang penyisipan biasanya disebut rear
/ tail, sedang ujung penghapusan disebut front/head. Fenomena yang
muncul adalah elemen yang lebih dulu disisipkan akan juga lebih dulu
diambil. Queue berdisiplin FIFO ( First In, First Out ) . Queue merupakan
kasus khusus ordered list. Dengan karakteristik terbatas itu maka kita dapat
melakukan optimasi, representasi ADT Queue untuk memperoleh kerja
paling optimal (Timnat et al., 2012)
.
5.2.5 Pengertian Linked List

Linked List atau dikenal juga dengan sebutan senarai berantai adalah
struktur data yang terdiri dari urutan record data dimana setiap revord
memiliki field yang menyimpan alamat / referensi dari record selanjutnya
( dalam urutan ). Elemen data yang dihubungkan dengan link pada Linked
List disebut Node. Biasanya didalam suatu linkedlist, terdapat istilah head
dan tail.
1. Head adalah elemen yang berada pada posisi pertama dalam suatu linked
list
2. Tail adalah elemen yang berada pada posisi terakhir dalam suatu linked
list.
Ada beberapa macam Linked List, yaitu :
a) Single Linked List
b) Double Linked List
c) Circular Linked List
d) Multiple Linked List
5.3 Latihan
1. Latihan 1
a. Kode Program
108
#include <iostream>
#include <cstring>
typedef struct
{
char nim[10];
char nama[50];
float nilai;
} nilaiMatkul;
typedef struct
{
int first;
int last;
nilaiMatkul data[10];
} queue;
void createEmpty(queue *Q)
{
(*Q).first = -1;
(*Q).last = -1;
}
int isEmpty(queue *Q)
{
return (Q->first == -1);
}
int isFull(queue *Q)
{
return (Q->last == 9);
}
void add(char nim[], char nama[], float nilai, queue *Q)
{
if (!isFull(Q))
{
if (isEmpty(Q))
{
Q->first = 0;
}
Q->last++;
109
strcpy(Q->data[Q->last].nim, nim);
strcpy(Q->data[Q->last].nama, nama);
Q->data[Q->last].nilai = nilai;
}
else
{
printf("Queue penuh\n");
}
}
void del(queue *Q)
{
if (!isEmpty(Q))
{
if (Q->first == Q->last)
{
createEmpty(Q);
}
else
{
for (int i = Q->first; i < Q->last; i++)
{
strcpy(Q->data[i].nim, Q->data[i +
1].nim);
strcpy(Q->data[i].nama, Q->data[i +
1].nama);
Q->data[i].nilai = Q->data[i + 1].nilai;
}
Q->last--;
}
}
else
{
printf("Queue kosong\n");
}
}
void printfQueue(queue Q)
{
110
if (!isEmpty(&Q))
{
cout << "-- -- -- -- -- -- Isi queue -- -- -- --
-- -\n";
for (int i = Q.last; i >= Q.first; i--)
{
cout << "Elemen ke : " << i << endl;
cout << "NIM : " << Q.data[i].nim << endl;
cout << "Nama : " << Q.data[i].nama << endl;
cout << "Nilai: " << Q.data[i].nilai <<
endl;
}
cout << "-- -- -- -- -- -- --\n";
}
else
{
cout << "\nQueue kosong\n";
}
}
int main()
{
queue Q;
createEmpty(&Q);
printfQueue(Q);
printf("--------------------------------------\n");
printf("NIM : 32602300046\n\n");
add("13507701", "Rangga", 64.67, &Q);
add("13507702", "Anggy", 75.11, &Q);
add("13507703", "Intan", 84.63, &Q);
printfQueue(Q);
del(&Q);
del(&Q);
printfQueue(Q);
return 0;
}
111
b. Output
c. Flowchart

112
d. Penjelasan
Kode yang diubah :
add(“13507701”, “Rangga”, “64.67”, &Q);
add(“13507702”, “Anggy”, “75.11”, &Q);
add(“13507703”, “Intan”, “84.63”, &Q);
menjadi
add(“13507701”, “Rangga”, 64.67, &Q);
add(“13507702”, “Anggy”, 75.11, &Q);
add(“13507703”, “Intan”, 84.63, &Q);
diganti karena parameter pada nilai tersebut adalah float
Elemen yang digunakan pada program :
1. Header iostream dan stdio.h yaitu header yang berisi fungsi input
dan output.
2. Header cstring yaitu header yang mendefinisikan beberapa fungsi
untuk memanipulasi string dan array
3. using namespace std untuk mempermudah ketika cin dan cout
4. Int yaitu tipe data untuk bilangan decimal
5. Array yaitu variable menampung nilai bertipe data sama
6. For fungsi untuk melakukan perulangan
Proses jalannya program :
1. queue Q; membuat variable Q dengan tipe data queue
2. creativeEmpty(&Q); memanggil fungsi creativeEmpty
3. printQueue(Q); memanggil fungsi printQueue dengan parameter
yang diganti variable Q
4. add(“1357701”, “Rangga”, 64.67, &Q);
5. add(“1357701”, “Rangga”, 64.67, &Q);
6. add(“1357701”, “Rangga”, 64.67, &Q);
7. Memaggil fungsi add dengan parameter yang diganti dengan data –
data seperti diatas
8. printfQueue(Q); memanggil fungsi printfQueue dengan parameter
113
9. del(&Q); memanggil fungsi del dengan parameter yang diganti

dengan variable Q
10.del(&Q); memanggil fungsi del dengan parameter yang diganti
dengan variable Q
11.printfQueue(Q); memanggil fungsi printfQueue dengan parameter
12.program berhenti
2. Latihan 2
a. Kode Program
#include <iostream>
#include <cstring>
#include <iomanip>
struct DAT
{
int id;
char
fname[20];
char
mname[20];
char
lname[20];
char
address[80];
double salary;
char tele_no[15];
};
struct NODE
{
DAT data;
NODE *N;
NODE *P;
NODE(const int i, const char *f, const char *m,
const char *l, const char *ad, const double s, const
char *tel)
114
{
data.id = i;
strcpy(data.fname, f);
strcpy(data.mname, m);
strcpy(data.lname, l);
strcpy(data.address, ad);
data.salary = s;
strcpy(data.tele_no, tel);
N = NULL;
P = NULL;
}
};
class StackLinkedList
{
private:
NODE *front;
public:
StackLinkedList()
{
front = NULL;
}
~StackLinkedList()
{
destroyList();
}
void push(NODE *);
NODE *pop();
void destroyList();
};
void StackLinkedList::push(NODE *n)
{
if (front == NULL)
{
front = n;
}
else
{
115
front->P = n;
n->N = front;
front = n;
}
}
NODE *StackLinkedList::pop()
{
NODE *temp;
if (front == NULL) // no nodes return
NULL;
else if (front->N == NULL)
{ // there is only one node
NODE *temp2 = front;
temp = temp2;
front = NULL;
return temp;
}
else
{ // there are more than one node
NODE *temp2 = front;
temp = temp2;
front = front->N;
front->P = NULL;
return temp;
}
}
void StackLinkedList::destroyList()
{
while (front != NULL)
{
NODE *temp = front;
front = front->N;
delete temp;
}
}
void disp(NODE *N)
{
if (N == NULL)
116
{
cout << "\nStack is Empty!!!" << endl;
}
else
{
cout << "\nId No. : " << N->data.id << " ";
cout << "\nFull Name : " << N->data.fname << "
";
cout << N->data.mname << " ";
cout << N->data.lname << endl;
cout << "Address : " << N->data.address <<
endl;
cout << "Salary : " << setprecision(15) << N-
>data.salary << endl;
cout << "Tele_no : " << N->data.tele_no <<
endl
<< endl;
}
}
int main()
{
cout << "NAMA : Nabiel Ilyasa pradana\n";
cout << "NIM : 32602300046\n";
StackLinkedList *Stack = new StackLinkedList();
NODE No1(101, "Anggy", "Eka", "P", "Semarang 120",
7851243.9475, "07502334121");
NODE No2(102, "Wa Ode", "Kanartia", "Ningsi", "Timor
leste 121", 5681125.9457, "07507534127");
NODE No3(103, "Fatimah", "Nurul", "Intan", "Irian
Jaya 123", 2344003.48345, "075078654129");
Stack->push(&No1);
Stack->push(&No2);
Stack->push(&No3);
disp(Stack->pop());
disp(Stack->pop());
disp(Stack->pop());
delete Stack;
return 0;
117
}
b. Output
c. Flowchart
d. Penjelasan
Kode yang diubah :
118
Menghilangkan kode delete stack; karena agar bisa decompile elemen

yang digunakan pada program :
1. Header iostream dan stdio.h yaitu header yang berisi fungsi input
dan output.
2. Header cstring yaitu header yang mendefinisikan beberapa fungsi
untuk memanipulasi string dan array
3. using namespace std untuk mempermudah ketika cin dan cout
4. Int yaitu tipe data untuk bilangan decimal
5. Array yaitu variable menampung nilai bertipe data sama
6. For fungsi untuk melakukan perulangan
119
Proses jalannya program :

1. StackLinkedList * Stack = new StackLinkedList(); membuat
pointer stack yang berisi nilai hasil dari fungsi StackLinkedList()
2. NodeNo1(101, “Anggy”, “Eka”, “P”, “Semarang 120”,
7851243.9475, “07502334121”);
3. NodeNo2(102, “Wa Ode”, “Kanartia”, “Ningsih”, “Timor Leste
12”, 5681125.9457, “07502334127”);
4. NodeNo3(103, “Fatimah”, “Nurul”, “Intan”, “Irian Jaya 123”,
7851243.9475, “07502334129”);
5. Memanggil fungsi NODE dengan parameter yang diganti dengan
data – data diatas
6. PrintfQueue(Q); memanggil fungsi printfQueue dengan parameter
diganti variable Q;
7. del(&Q); memanggil fungsi del dengan parameter yang diganti
dengan alamat variable Q
8. disp(Stack-> pop()); memanggil funngsi disp dengan paratemer
yang diganti dengan stack -> pop();
9. Program berhenti
5.4 Tugas
1. Tugas 1
Benarkah listing program sehingga dapat di-compile!
Jawaban :
a. Kode Program
#include <iostream>

class Node
{
int data;
Node *next;
public:
Node(){};
120
void SetData(int aData)

{
data = aData;
}
void SetNext(Node *aNext)
{
next = aNext;
}
int Data()
{
return data;
}
Node *Next()
{
return next;
}
};
class List
{
Node *head;
public:
List()
{
head = NULL;
}
void Print();
void Append(int data);
void Delete(int data);
};
void List::Print()
{
Node *tmp = head;
if (tmp == NULL)
{
cout << "NULL" << endl;
return;
}
if (tmp->Next() == NULL)
121
{
cout << tmp->Data();
cout << " --> ";
cout << "EMPTY" << endl;
}
else
{
do
{
cout << " --> ";
tmp = tmp->Next();
} while (tmp != NULL);

}
}
void List::Append(int data)
{
if (data != 300)
{
Node *newNode = new Node();
newNode->SetData(data);
newNode->SetNext(NULL);
Node *tmp = head;
if (tmp != NULL)
{
while (tmp->Next() != NULL)
{
tmp = tmp->Next();
}
tmp->SetNext(newNode);
}
else
{
head = newNode;
}
}
122
}
void List::Delete(int data)
{
if (data != 300)
{
Node *tmp = head;
if (tmp == NULL)
return;
{
delete tmp;
head = NULL;
}
else
{
Node *prev = NULL;
do
{
if (tmp->Data() == data)
break;
prev = tmp;
tmp = tmp->Next();
// Adjust the pointers
prev->SetNext(tmp->Next());
// Delete the current node
delete tmp;
}
}
}
int main()
{
cout << "NIM : 32602300046\n";
List list;
list.Append(100);
list.Print();
list.Append(200);
123
list.Print();
list.Append(300);
list.Print();
list.Append(400);
list.Print();
list.Append(500);
list.Print();
list.Delete(400);
list.Print();
list.Delete(300);
list.Print();
list.Delete(200);
list.Print();
list.Delete(500);
list.Print();
list.Delete(100);
list.Print();
return 0;
}
b. Output

124
c. Flowchart
d. Penjelasan
menghasilkan tampilan untuk mencari linked list.
Header yang digunakan pada program ini adalah iostream untuk
memerintah cout dan cin. Pada script pertama kita disuruh mencari
kesalahannya untuk menghasilkan output seperti gambar diatas.
Sebenarnya penulisan script Cuma mengandung sedikit semisalnya
kurangnya.
125
2. Tugas 2
Ubah program sehingga menjadi seperti hasil ouput dibawah
ini(Gunakan Listing program 1).
Jawaban :
a. Kode Program
#include <iostream>

class Node
{
int data;
Node *next;
public:
void SetData(int aData)
{
data = aData;
}
void SetNext(Node *aNext)
{
next = aNext;
}
int Data()
{
return data;
}
Node *Next()
{
return next;
126
}
};
class List
{
Node *head;
public:
List()
{
head = NULL;
}
void Print();
void Append(int data);
void Delete(int data);
};
void List::Print()
{
Node *tmp = head;
if (tmp == NULL)
{
cout << " Empty " << endl;
return;
}
{
cout << " --> ";
}
else
{
do
{
cout << " --> ";
tmp = tmp->Next();
}
127
}
void List::Append(int data)
{
if (data <= 500)
{
Node *newNode = new Node();
newNode->SetData(data);
newNode->SetNext(NULL);
Node *tmp = head;
if (tmp != NULL)
{
while (tmp->Next() != NULL)
{
tmp = tmp->Next();
}
tmp->SetNext(newNode);
}
else
{
head = newNode;
}
}
}
void List::Delete(int data)
{
if (data <= 500)
{
Node *tmp = head;
if (tmp == NULL)
{
return;
}
{
delete tmp;
head = NULL;
}
else
128
{
Node *prev = NULL;
do
{
if (tmp->Data() == data)
{
break;
}
prev = tmp;
tmp = tmp->Next();
if (prev != NULL)
{
prev->SetNext(tmp->Next());
delete tmp;
}
}
}
}
int main()
{
cout << "NIM : 32602300046\n";
List list;
list.Append(100);
list.Print();
list.Append(200);
list.Print();
list.Append(300);
list.Print();
list.Append(400);
list.Print();
list.Append(500);
list.Print();
list.Delete(400);
list.Print();
list.Delete(300);
list.Print();
129
list.Delete(200);
list.Print();
list.Delete(500);
list.Print();
list.Delete(100);
list.Print();
return 0;
}
b. Output
c. Flowchart

130
d. Penjelasan
menghasilkan tampilan untuk mencari linked list.
Header yang digunakan pada program diatas adalah iostream
yang akan memerintah int main untuk dijalankan dan menampilkan
list. Dengan menggunakan bahasa C++ yang menghasilkan tampilan
untuk mencari linked list. Setelah itu program dapat dijalankan.
3. Ubahlah program menjadi bahasa C
Jawaban :
a. Kode Program
#include <stdio.h>
#include <stdlib.h>
struct Node
{
int data;
struct Node *next;
};
typedef struct Node Node;
typedef struct List
{
Node *head;
} List;
void printList(Node *n)
{
if (n == NULL)
{
printf("Empty\n");
return;
}
if (n->next == NULL)
{
printf("%d -> NULL\n", n->data);
131
}
else
{
while (n != NULL)
{
printf("%d -> ", n->data);
n = n->next;
}
printf("NULL\n");
}
}
void append(List *list, int data)
{
if (data <= 500)
{
Node *newNode = (Node *)malloc(sizeof(Node));
newNode->data = data;
newNode->next = NULL;
Node *tmp = list->head;
if (tmp != NULL)
{
while (tmp->next != NULL)
{
tmp = tmp->next;
}
tmp->next = newNode;
}
else
{
list->head = newNode;
}
}
}
void deleteNode(List *list, int data)
{
if (data <= 500)
{
132
Node *tmp = list->head;

if (tmp == NULL)
{
return;
}
if (tmp->next == NULL)
{
free(tmp);
list->head = NULL;
}
else
{
Node *prev = NULL;
do
{
if (tmp->data == data)
{
break;
}
prev = tmp;
tmp = tmp->next;
prev->next = tmp->next;
free(tmp);
}
}
}
int main()
{
printf("Nama : nabiel Ilyasa pradana\n");
printf("Nim : 32602300046\n\n");
List list;
list.head = NULL;
append(&list, 100);
printList(list.head);
append(&list, 200);
append(&list, 300);
133
append(&list, 400);
append(&list, 500);
deleteNode(&list, 400);
return 0;
}
b. Output

134
c. Flowchart
Gambar 5. 14 Flowchart Tugas 3 Penjelasan

diatas merupakan program yang meggunakan bahasa C. Yang
menghasilkan tampilan untuk mencari Linked List.
Pada program diatas merupakan program yang menggunakan
header stdio.h. Stdio.h merupakan header yang melakukan perintah
int main (). Dan main merupakan fungsi yang pertama dijalankan
untuk menampilkan list tersebut.
5.5 Kesimpulan
Pada bab ini dijelaskan fungsi dari linked list, stack dan queue dan
beserta perbandingannya. Stack dan queue yang berukuran besar dengan
jumlah maksimal yang tidka diketahui menggunakan linked list. Untuk
perangkat yang lebih kecil menggunakan small handled devices. Linked list
disebut juga senarai berantai. Senarai berantai yaitu struktur data yang
135
terdiri dari urutan record data dimana setiap recordnya memiliki field untuk
menyimpan referensi record selanjutnya.
Daftar pustaka
BIBLIOGRAPHY Andeswari. (2015). buble shorting object. surabaya:
Informatic engenering.
Arraffi, A. (2019). Tipe data larik (array).
Umam, K. (2021). buku ajar algoritma pemrograman komputer dengan python.
Lengkoh Barat Bangkes Kadur Pemekasan: Nurul Falah.
uttami7. (2021). pengembangan shorting. surakarta: ilalang tulisan sejahtra.
Wijaya, H. (2021). Algoritma Sequential Searching untuk Pencarian Identitas
Mahasiswa dalam Penilaian Monitoring dan Evaluasi Kuliah Kerja Nyata
Tematik. Akademika Jurnal, 6-10.
Lampiran

Laporan Full Algoritma

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Laporan Full Algoritma

Diunggah oleh

Hak Cipta:

Format Tersedia

LAPORAN PRAKTIKUM

ALGORITMA DAN STRUKTUR DATA

PRODI TEKNIK INFORMATIKA

Nabiel Ilyasa pradana

Telah di setujui sebagai syarat untuk memenuhi mata kuliah Praktikum

Imam Much Ibnu Subroto, ST, M.Sc, Ph.D

Tanpa lupa penulis mengucapkan terima kasih kepada :

Penulis menyadari bahwa dalam penyusunan laporan ini masih terdapat

Semarang, 6 Januari 2024

BAB I STRUKTUR DASAR ALGORITMA......................................................1

1.1 TUJUAN PRAKTIKUM................................................................................1

BAB II ARRAY 2D DAN 3D..............................................................................26

2.1 TUJUAN PRAKTIKUM..............................................................................26

3.1 TUJUAN PRAKTIKUM..............................................................................53

BAB V LINKED LIST, STACK, DAN QUEUE............................................104

GAMBAR 2. 1 TABEL ARRAY 2 DIMENSI.................................................................27

GAMBAR 3. 1OUTPUT LATIHAN 1...........................................................................56

GAMBAR 4. 1 OUTPUT LATIHAN 1.........................................................................87

UNIVERSITAS ISLAM SULTAN AGUNG

1.1 Tujuan Praktikum

1.2 Dasar Teori

NP merupakan permasalahan mendasar dalam teori kompleksitas

Gambar 1. 1 Struktur sekuensial

Gambar 1.1, langkah 1 adalah langkah yang akan dieksekusi pertama

Gambar 1. 2 Struktur seleksi

Seperti Gambar 1.2, langkah 1 hanya akan dijalankan ketika kondisi

Gambar 1. 3 Struktur Perulangan pertama

Gambar 1. 4 Struktur perulangan kedua

proses yang Jumlah =

Gambar 1. 5 Output Latihan 1 Lingkaran

Gambar 1. 6 Output Latihan 1 persegi panjang

Gambar 1. 7 Flowchart Latihan 1

cout<<"NAMA : NABIEL ILYASA PRADANA";

Gambar 1. 8 Output Latihan 2

Gambar 1. 9 Flowchart Latihan 2

Pada Gambar 1.9 merupakan hasil dari perulangan atau looping.

Gambar 1. 10 Output Tugas 1

Gambar 1. 11 Flowchart Tugas 1

contoh while. Bisa kita lihat disini dalam membentuk perulangan

using namespace std;

cout<< "Nama: NABIEL ILYASA PRADANA"<< endl;

float panjang, lebar;

cin >> panjang;

Gambar 1. 12 Output Tugas 2 Luas

Gambar 1. 13 Output Tugas 2 Keliling

Gambar 1. 14 Output Tugas 2 Diagonal

Gambar 1. 15 Flowchart Tugas 2

3. Modifikasilah program nomor 2 menjadi bahasa C.

printf("\n\nNAMA : NABIEL ILYASA PRADANA");

if (jenis == 'L' || jenis == 'l') {

Gambar 1. 16 Output Tugas 3 Luas

Gambar 1. 17 Output Tugas 3 Keliling

Gambar 1. 18 Output Tugas 3 Diagonal

Gambar 1. 19 Flowchart Tugas 3

Gambar 1. 20 Output Tugas 4

Gambar 1. 21 Flowchart Tugas 4

printf("Pilihan Anda: ");

Gambar 1. 22 Output Tugas 5

Gambar 1. 23 Flowchart Tugas 5

UNIVERSITAS ISLAM SULTAN AGUNG

2.2 Dasar Teori

Penggunaan array sangat bermanfaat dalam menyimpan dan mengelola

2.2.1 Pengertian Array

2.2.2 Array Multidimensi