Febryan AlfaridziRelated papers
MAKALAH STRUKTUR DATA
Puji Syukur kami panjatkan kehadirat Allah SWT karena berkat limpahan rahmat dari-NYA kami dapat menyelesaikan makalah ini tepat pada waktunya, walaupun dalam keadaan yang sangat sederhana.
STRUKTUR HADITS
Yang dimaksud dengan struktur Hadits disini ialah unsur-unsur yang harus ada dalam sebuah Hadits, yaitu harus ada Sanad, Matan dan Rawi Haditsnya. 1 Sebagai gambaran awal saya sajikan sebuah hadits yang terdiri dari Sanad, Matan, dan Rawi Haditsnya : عنه هللا رضي مالك بن أنس سمعت قال أبي سمعت قال معتمر حدثنا مسدد حدثنا والكسل العجز من بك أعوذ إني اللهم ( يقول سلم و عليه هللا صلى النبي كان : قال ا فتنة من بك وأعوذ والهرم والجبن ) القبر عذاب من بك وأعوذ والممات لمحيا -البخاري ))روه Artinya : Musaddad telah memberitahu kami, dia berkata : Muktamir telah memberitahu kami, dia berkata : Aku mendengar ayahku berkata: Aku mendengar Anas bin Maalik, radiyallahu 'anhu berkata :" Dahulu Nabi berdoa : (Ya Allah,Aku berlindung kepada-Mu dari ketidakmampuan dan kemalasan, kepengecutan dan kepikunan dan aku berlindung kepada-Mu dari cobaan hidup dan kematian dan berlindung kepada-Mu dari siksa kubur)" (H.R. Bukhori). B. Sanad 1. Pengertian Sanad Sanad menurut bahasa artinya sandaran atau sesuatu yang dijadikan sebagai sandaran, dikatakan demikian karena suatu hadis bersandar kepadanya. Sedangkan pengertian sanad menurut istilah ilmu hadis, banyak ulama yang mengemukakannya, diantaranya ialah: 2 a. As Suyuti dalam bukunya Tadrib ar Rawi, hal 41 , menulis:
LAPORAN PRAKTIKUM
STRUKTUR DATA
SEMESTER GENAP TAHUN AKADEMIK 2018/2019
Disusun oleh :
Nama
NIM
Prodi
Kelompok
: Febryan Alfaridzi
: 1818057
: TEKNIK INFORMATIKA S1
: 25
PROGRAM STUDI TEKNIK INFORMATIKA S-1
FAKULTAS TEKNOLOGI INDUSTRI
INSTITUT TEKNOLOGI NASIONAL MALANG
2019
LEMBAR PERSETUJUAN
PRAKTIKUM STRUKTUR DATA
SEMESTER GENAP TAHUN AKADEMIK 2018/2019
NAMA
NIM
PRODI
Disusun Oleh
: Febryan Alfaridzi
: 1818057
: TEKNIK INFORMATIKA S-1
Mengetahui,
Kepala Laboratorium
Rekayasa Perangkat Lunak
Menyetujui,
Dosen Pembimbing
(Ali Mahmudi,B.Eng,.PhD)
NIP.P.1031000429
(Hani Zulfia Zahro’, S.kom,M.kom)
NIP.P/Y.1031500480
PROGRAM STUDI TEKNIK INFORMATIKA S-1
FAKULTAS TEKNOLOGI INDUSTRI
INSTITUT TEKNOLOGI NASIONAL MALANG
2019
ii
KATA PENGANTAR
Dengan memanjatkan puji syukur kehadirat Tuhan Yang Maha Esa, karena
atas berkah rahmat dan karunia-Nya sehingga kami dapat menyelesaikan Laporan
Praktikum Mata Kuliah, guna persyaratan dalam menempuh mata kuliah.
Laporan ini disusun berdasarkan percobaan dan teori dasar yang ada dalam
buku panduan praktikum ,teori yang diperoleh praktikan dari perkuliahan, dan
tidak lupa yaitu Internet sehingga praktikan dapat menambah tidak hanya
menguasai teori saja namun juga memahami serta mengaplikasikannya.
Terwujudnya laporan ini, tentunya tidak lepas dari bantuan-bantuan yang
telah kami terima. Pada kesempatan ini, kami menyampaikan terima kasih yang
sebesar-besarnya kepada yang terhormat:
1. Ibu Hani Zulfia Zahro’, S.kom,M.kom selaku dosen pembimbing
Praktikum Struktur Data.
2. Bapak Joseph Agus Pranoto,ST. selaku dosen mata kuliah Struktur
Data.
3. Bapak Ali Mahmudi, B.Eng.,PhD. selaku Ketua Pelaksana Praktikum
Mata Kuliah Jurusan Teknik Informatika ITN Malang.
4. Instruktur Lab. Rekayasa Perangkat Lunak Teknik Informatika yang
telah memberi petunjuk kepada kami selama pelaksanaan praktikum.
5. Rekan-rekan yang telah membantu dalam pelaksanaan dan penyelesaian
laporan ini.
Dalam menyusun laporan ini kami menyadari bahwa laporan ini masih
memiliki kekurangan, karena itu segala kritik dan saran yang membangun akan
kami nanti demi perbaikan penyusunan laporan selanjutnya.
Harapan kami laporan praktikum ini bermanfaat bagi penulis sendiri
maupun pembaca sekalian.
Malang,
Mei 2019
Penulis
iii
DAFTAR ISI
KATA PENGANTAR ........................................................................................ ii
DAFTAR ISI ..................................................................................................... iii
DAFTAR GAMBAR .......................................................................................... v
DAFTAR TABEL ............................................................................................. vi
BAB I POINTER, STRUCTURE, REKURSIF ................................................ 1
I.1 Landasan Teori ........................................................................................... 1
I.2 Langkah-langkah Praktikum ....................................................................... 6
I.3 Tugas Praktikum ke-1 : Program Implementasi Pointer ............................... 6
I.4 Tugas Praktikum ke-2 : Program implementasi Struct ................................. 7
I.5 Tugas Praktikum ke-3 : Program Menghitung Nilai Faktorial...................... 8
I.6 Tugas Rumah ke-1 : Program Implementasi Pointer .................................... 9
I.7 Tugas Rumah ke-2 : Program Implementasi Struct .................................... 10
I.8 Tugas Rumah ke-3 : Program Menara Hanoi............................................. 12
I.9 Kesimpulan ............................................................................................... 13
BAB II Stack dan Queue ................................................................................... 1
II.1 Landasan Teori .......................................................................................... 1
II.2 Langkah-langkah Praktikum ...................................................................... 8
II.3 Tugas Praktikum ke-1 : Program Implementasi Stack ................................ 8
II.4 Tugas praktikum ke-2: Program Implementasi Queue .............................. 11
II.5 Tugas Rumah ke-1 : Program Membalikkan Nama mengguakan Stack .... 14
II.6 Tugas Rumah ke-2 : Program Antrian Bank ............................................. 15
II.7 Kesimpulan ............................................................................................. 17
BAB III SORTING ............................................................................................ 1
III.1 Landasan Teori......................................................................................... 1
III.2 Langkah-langkah Praktikum ..................................................................... 4
III.3 Tugas Praktikum ke-1 : Sorting menggunakan Bubble Sort ...................... 5
III.4 Tugas Praktikum ke-2 : Sorting menggunakan Exchange Sort .................. 6
III.5 Tugas Praktikum ke-3 : Sorting menggunakan Insertion Sort .................... 7
III.6 Tugas Praktikum ke-4 : Sorting menggunakan Selection Sort ................... 8
III.7 Tugas Praktikum ke-5 : Sorting menggunakan Quick Sort ........................ 9
iv
III.8 Tugas Rumah ke-1 : Program mengurutkan Data Aslab .......................... 11
III.9 Tugas Rumah ke-2 : Program Sorting menggunakan Quick Sort............. 13
III.10 Kesimpulan .......................................................................................... 14
BAB IV SEARCHING ....................................................................................... 1
IV.1 Landasan Teori ........................................................................................ 1
IV.2 Langkah-langkah Praktikum..................................................................... 4
IV.3 Tugas Praktikum ke-1 : Program Implementasi Sequential Search............ 5
IV.4 Tugas Praktikum ke-2 : Program Implementasi Binary Search ................. 6
IV.5 Tugas Praktikum ke-3 : Program Implementasi Interpolation Search ........ 7
IV.6 Tugas Rumah ke-1 : Program Mencari Data Aslab ................................... 9
IV.7 Kesimpulan ............................................................................................ 11
BAB V LINKED LIST ....................................................................................... 1
V.1 Landasan Teori.......................................................................................... 1
V.2 Langkah-langkah Praktikum ...................................................................... 3
V.3 Tugas Praktikum ke-1 : Single Linked List ................................................ 4
V.4 Tugas Praktikum ke-2 : Double Linked List Input Data ............................. 7
V.5 Tugas Rumah ke-1 : Menampilkan Hubungan Orang tua Anak .................. 9
V.6 Tugas Rumah ke-2 : Implementasi Double Linked List .......................... 13
V.6 Kesimpulan ............................................................................................. 17
BAB VI TREE .................................................................................................... 1
VI.1 Landasan Teori (Tree) ............................................................................. 1
VI.2 Langkah-Langkah Praktikum .................................................................. 4
VI.3 Tugas Praktikum ke-1 : Tree .................................................................... 4
VI.4 Tugas Rumah ke-1 : Program Implementasi Tree .................................... 8
VI.5 Kesimpulan ........................................................................................... 12
BAB VII KESIMPULAN................................................................................... 1
DAFTAR PUSTAKA ......................................................................................... 2
v
DAFTAR GAMBAR
Gambar 1.1 Program Implementasi Pointer ...................................................... 6
Gambar 1.2 Program Implementasi Struct ........................................................ 7
Gambar 1.3 Program Menghitung Nilai Faktorial ............................................. 8
Gambar 1.4 Program Implementasi Pointer ...................................................... 9
Gambar 1.5 Program Implementasi Struct ...................................................... 11
Gambar 1.6 Program Menara Hanoi ............................................................... 12
Gambar 2.1 Program Implementasi Stack....................................................... 10
Gambar 2.2 Program Implementasi Queue ..................................................... 13
Gambar 2.3 Program Membalikkan Nama Menggunakan Stack ..................... 14
Gambar 2.4 Program Antrian Bank ................................................................ 16
Gambar 3.1 Program Sorting menggunakan Bubble Sort .................................. 5
Gambar 3.2 Program Sorting menggunakan Exchange Sort .............................. 6
Gambar 3.3 Program Sorting menggunakan Insertion Sort ............................... 7
Gambar 3.4 Program Sorting menggunakan Selection Sort .............................. 9
Gambar 3.5 Program Sorting menggunakan Quick Sort ................................. 10
Gambar 3.6 Program mengurutkan Data Aslab............................................... 12
Gambar 3.7 Program Sorting menggunakan Quick Sort ................................. 14
Gambar 4.1 Program Implementasi Sequeantial Search .................................... 5
Gambar 4.2 Program Implementasi Binary Search ........................................... 7
Gambar 4.3 Program Implementasi Interpolation Search .................................. 8
Gambar 4.4 Program Mencari Data Aslab ...................................................... 10
Gambar 5.1 Program Single Linked List .......................................................... 7
Gambar 5.2 Program Double Linked List Input Data........................................ 9
Gambar 5.3 Program Menampilkan Hubungan Orang tua Anak ..................... 12
Gambar 5.4 Program Implementasi Double Linked List ................................. 16
Gambar 6.1 Program Tree ................................................................................ 7
Gambar 6.2 Program Implementasi Tree ........................................................ 10
Gambar 6.3 Notasi Tingkat Program Implementasi Tree ................................ 11
Gambar 6.4 Diagram Venn Program Implementasi Tree ................................. 11
vi
DAFTAR TABEL
Perbedaan pointer dengan variabel biasa .......................................................... 2
Perbandingan Array dengan Linked List ........................................................... 1
Istilah – istilah dalam Tree ............................................................................... 2
I-1
BAB I
POINTER, STRUCTURE, REKURSIF
Jumlah Pertemuan
: 2 x 50 menit
Tujuan Praktikum
:
1. Praktikan mampu memahami pengertian pointer, structure, rekursif
dengan menggunakan C++.
2. Praktikan mengetahui Aturan main dari pointer,structure,rekursif.
3. Praktikan dapat mengoperasikan sebuah program menggunakan
metode pointer, structure, dan rekursif.
Alat dan bahan :
1. Perangkat komputer
2. Perangkat lunak: Dev C++
3. Modul Struktur Data 2019
I.1 Landasan Teori
1.1 Pengertian Pointer
Pointer adalah suatu variabel penunjuk, berisi nilai yang menunjuk
alamat suatu lokasi memori tertentu. Jadi pointer tidak berisi nilai data,
melainkan berisi suatu alamat memori atau null, jika pointer tidak berisi data
maka disebut null pointer. Untuk mendeklarasikan variabel sebagai pointer,
maka hanya menambahkan tanda asterik (*) di depan nama variabel. Dan
untuk mendapatkan alamat dari variabel adalah dengan menggunakan
operator &. Berikut ini bentuk umum dari pendeklarasian variabel yang
bertipe pointer.
Tipe_data *nama_pointer;
Jika ingin menyimpan alamat dari variabel x, kita dapat menggunakan
suatu variabel misalnya
Int alamat_x = &x;
Maka alamat_x adalah suatu variabel yang berisi alamat dimana nilai
x disimpan. Variabel alamat_x disebut variabel pointer atau sering disebut
dengan pointer saja.
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
II-2
1.2 Pointer tanpa tipe data
Ada cara khusus untuk membuat pointer yang dideklarasikan tersebut
tanpa merujuk ke semua tipe data, yaitu dengan mendeklarasikan pointer
tersebut sebagai pointer tanpa tipe data atau disebut “void pointer”. Bentuk
umumnya adalah :
Void *nama_pointer;
Perbedaan pointer dengan variabel biasa
Variabel Biasa
Berisi data/nilai
Pointer
Berisi alamat memori dari suatu
variabel tertentu
Operasi yang bisa dilakukan seperti Membutuhkan operator khusus:”&”
layaknya operasi biasa +,-,*,/
yang menunjuk alamat dari suatu
variabel tertentu. Operator “&” hanya
dapat dilakukan kepada variabel dan
akan
menghasilkan
alamat
dari
variabel itu. Contoh : p = &n
Yang kedua : Operator “*”. Operator
ini bersifat menggunakan nilai dari
alamat variabel yang ditunjuk oleh
pointer tersebut. Contoh : int *p;
Bersifat statis
Bersifat dinamis
Deklarasi : int a;
Deklarasi : int *a;
II-3
1.3 Aturan Pointer
Variabel pointer dapat dideklarasikan dengan tipe data apapun.
Pendeklarasian variabel pointer dengan tipe data tertentu digunakan untuk
menyimpan alamat memori yang berisi data sesuai dengan tipe data yang
dideklarasikan, bukan untuk berisi nilai bertipe data tertentu.
Tipe data digunakan sebagai lebar data untuk alokasi memori
(misalnya char berarti lebar datanya 1 byte, dst).
Jika suatu variabel pointer dideklarasikan bertipe float, berarti variabel
pointer tersebut hanya bisa digunakan untuk menunjuk alamat memori yang
berisi nilai bertipe float juga.
1.4 Pointer Pada Array
Array adalah suatu variabel yang menyimpan sekumpulan data yang
memiliki tipe sama. Setiap data tersebut menempati lokasi atau alamat
memory yang berbeda – beda dan selanjutnya di sebut dengan elemen array.
Elemen array tersebut kemudian dapat kita akses melalui indeks yang terdapat
di dalamnya namun penting sekali untuk diperhatikan bahwa dalam C++,
indeks array selalu di mulai dari 0, bukan 1.
1.5 Pengertian Struct
Struct (struktur) adalah kumpulan elemen – elemen data yang
digabungkan menjadi satu kesatuan. Masing – masing elemen data tersebut
dikenal dengan sebutan field. Field data tersebut dapat memiliki tipe data
yang sama ataupun berbeda. Walaupun field – field tersebut berada dalam
satu kesatuan, masing – masing field tersebut tetap dapat diakses secara
individual.
Field – field tersebut digabungkan menjadi satu dengan tujuan untuk
kemudahan dalam operasinya. Misalnya ingin mencatat data – data
mahasiswa dan pelajar dalam sebuah program. Untuk membedakannya kita
dapat membuat sebuah struct mahasiswa yang terdiri dari field nama, nim,
program studi dan ipk. Serta sebuah record pelajar yang terdiri dari field –
II-4
field nama, nim, alamat dan nilai. Dengan demikian akan lebih mudah untuk
membedakan keduanya.
Bentuk umum :
Struct nama_struct{
Tipe_data1 field1;
Tipe_data2 field2;
Tipe_dataN fieldN;
};
1.6 Penggunaan dan Pengaksesan Elemen Terstruktur
Untuk menggunakan struct, tulis nama struct beserta dengan fieldnya
yang dipisahkan dengan tanda titik (“.”). Misalnya anda ingin menulis nim
seorang mahasiswa ke layar maka penulisan yang benar adalah sebagai
berikut:
- Mahasiswa.nim = “1818057”;
- Cout << mahasiswa.nim;
Jika x adalah pointer bertipe mahasiswa* maka field dari x dapat
diakses dengan mengganti tanda titik dengan tanda panah (“->”).
- Cout << mahasiswa->nim;
1.7 Pengertian Rekursif
Rekursif adalah salah satu metode dalam dunia matematika, rekursif
didefinisikan sebagai sebuah fungsi yang mengandung fungsi itu sendiri.
Dalam dunia pemrograman, rekursif diimplementasikan dalam sebuah fungsi
yang memanggil dirinya sendiri dan prosesnya terjadi secara berulang –
ulang.
1.8 Fase dalam Rekursif
1.8.1 Fase Awal
Fase awal merupakan fase dimana fungsi tersebut
memanggil dirinya sendiri.
II-5
1.8.2 Terminate
Terminate merupakan fase dimana fungsi tersebut berhenti
memanggil dirinya sendiri.
1.8.3 Fase Balik
Fase balik merupakan fase mengunjungi kembali kondisi –
kondisi dari fase awal yang telah terbentuk dan mengembalikan
nilai yang telah didapat dan fase terminal.
1.9 Implementasi Rekursif
1.9.1 Faktorial
Dalam matematika, factorial dari bilangan asli n adalah
hasil perkalian antara bilangan bulat positif yang kurang dari atau
sama dengan n. Faktorial ditulis sebagai n! dan disebut n factorial.
Secara umum dapat dituliskan sebagai :
n! = n * (n – 1) * (n – 2) . (n – 3) * … * 3 * 2 * 1
1.9.2 Fibonacci
Fibonacci adalah kumpulan deret angka seperti berikut ini
“1, 1, 2, 3, 5, 8, 13, 21, 34, 55, …”. Setiap bilangan setelah
bilangan kedua merupakan jumlah dari dua bilangan sebelumnya.
Dengan demikian 2 dari 1+1, 3 dari 2+1, 5 dari 3+2 dan demikian
dijabarkan sebagai berikut :
Jika n = 0, maka FN = 0, jika n = 1, maka Fn = 1
Jika n > 1, maka Fn = F(n-1)+F(n-2)
Implementasi dari fungsi Fibonacci dari definisi diatas
dapat dinyatakan sebagai berikut : Karena Fn = n untuk n < 2, kita
dapat menyederhanakan dengan pernyataan If.
II-6
I.2 Langkah-langkah Praktikum
1. Script ditulis dengan menggunakan Dev C++
2. Script dicompile dengan menggunakan Dev C++
3. Aplikasi dijalankan dengan menggunakan Dev C++
I.3 Tugas Praktikum ke-1 : Program Implementasi Pointer
1. Listing Program :
#include <iostream>
using namespace std;
int main(){
int *a,*b,*c=NULL;
int d = 10;
a = &d;
cout<<"Nilai d : "<<d<<" disimpan pada alamat "<<a<<endl;
cout<<"Nilai
b
:
"<<b<<"
->
disebut
dangling
pointer"<<endl;
cout<<"Nilai c : "<<c<<" -> disebut null pointer";
return 0;
}
2. Tampilan Program :.
Gambar 1.1 Program Implementasi Pointer
3. Analisa Program
Pertama – tama mendeklarasikan 3 buah pointer, d memiliki nilai
10 dan memiliki alamat 0xb4fd64. Ketika b ditampilkan maka yang tampil
adalah alamat nya karena belum diisi data. c merupakan null pointer yang
artinya adalah kosong.
II-7
I.4 Tugas Praktikum ke-2 : Program implementasi Struct
1. Listing Program :
#include <iostream>
#include <cstdlib>
using namespace std;
struct mahasiswa{
char nim[11], nama[50];
char alamat[100];
float ipk;
};
main(){
mahasiswa mhs;
cout<<"Masukkan NIM : ";cin>>mhs.nim;
fflush(stdin);
cout<<"Masukkan Nama : ";cin>>mhs.nama;
fflush(stdin);
cout<<"Alamat : ";cin>>mhs.alamat;
cout<<"IPK : ";cin>>mhs.ipk;
cout<<"================================="<<endl;
cout<<"NIM : "<<mhs.nim<<endl;
cout<<"Nama : "<<mhs.nama<<endl;
cout<<"Alamat : "<<mhs.alamat<<endl;
cout<<"IPK : "<<mhs.ipk<<endl;
}
2. Tampilan Program :.
Gambar 1.2 Program Implementasi Struct
II-8
3. Analisa Program :
Program diatas merupakan contoh penggunaan struct. Struct
mahasiswa berisi dengan elemen Nim, Nama, Alaman bertipe data char
dan Ipk bertipe data float yang kemudian Mahasiswa menjadi tipe data
untuk variabel mhs
I.5 Tugas Praktikum ke-3 : Program Menghitung Nilai Faktorial
1. Listing Program :
#include <iostream>
using namespace std;
int faktorial(int angka){
if(angka<=1){
return 1;
}
else {
return angka*faktorial(angka-1);
}
}
main(){
int bil;
cout<<"===Mencari Nilai Faktorial==="<<endl;
cout<<"==Dari Bilangan Desimal=="<<endl;
cout<<"======================================="<<endl;
for(bil=0; bil<=5 ;bil++){
cout<<"Hasil
Faktorial
(
"<<bil<<"
)
"<<faktorial(bil);
cout<<endl;
}
}
2. Tampilan Program :
Gambar 1.3 Program Menghitung Nilai Faktorial
=
II-9
3. Analisa Program :
Program diatas adalah program untuk mencari nilai factorial
sebuah bilangan, merupakan contoh penerapan rekursif. Apabila angka <=
maka akan mereturnkan 1, tapi jika tidak maka akan mereturnkan angka *
factorial (angka – 1). Disitulah akan terjadi pemanggilan fungsi secara
terus menerus hingga kondisi if terpenuhi .
I.6 Tugas Rumah ke-1 : Program Implementasi Pointer
1. Listing Program :
#include <iostream>
using namespace std;
main(){
int x,*y,*z;
x=1;
y=&x;
z=&x;
cout<<y<<endl;
cout<<*y<<endl;
cout<<z<<endl;
cout<<*z<<endl;
}
2. Tampilan Program :
Gambar 1.4 Program Implementasi Pointer
3. Analisa Program :
Variabel x berisi data nilainya 1. y mengambil alamat dari variabel
x, maka ketika *y dikeluarkan akan menampilan data yang ada pada
alamat x. Begitupun dengan pointer z, karena sama sama mengambil
alamat dari variabel x.
II-10
I.7 Tugas Rumah ke-2 : Program Implementasi Struct
1. Listing Program :
#include <iostream>
using namespace std;
struct mahasiswa{
float tugas,quiz,mid,uas,akhir;
string nama,nim,kelas,jurusan;
string nilai;
};
int main(){
mahasiswa mhs;
int jumlahmahasiswa;
cout<<"DATA NILAI STRUKTUR DATA"<<endl;
cout<<"--------------------------"<<endl;
cout<<"Inputan jumlah mahasiswa : ";cin>>jumlahmahasiswa;
cout<<endl;
for(int a=1; a<=jumlahmahasiswa ;a++){
cout<<"Mahasiswa ke-"<<a<<endl;
cout<<"------------------------------------"<<endl;
cout<<"Input Nama\t\t : ";cin>>mhs.nama;
cout<<"Input NIM\t\t : ";cin>>mhs.nim;
cout<<"Input Kelas\t\t : ";cin>>mhs.kelas;
cout<<"Input Jurusan\t\t : ";cin>>mhs.jurusan;
cout<<endl;
cout<<"Input Nilai Tugas\t : ";cin>>mhs.tugas;
cout<<"Input Nilai Quiz\t : ";cin>>mhs.quiz;
cout<<"Input Nilai MID\t\t : ";cin>>mhs.mid;
cout<<"Input Nilai UAS\t\t : ";cin>>mhs.uas;
cout<<endl<<endl;
mhs.akhir = (mhs.tugas+mhs.quiz+mhs.mid+mhs.uas)/4;
cout<<"Nilai Akhir Anda\t : "<<mhs.akhir<<endl;
if(mhs.akhir >= 80 && mhs.akhir <= 100){
mhs.nilai = "A";
}
else if(mhs.akhir >= 75 && mhs.akhir <80){
mhs.nilai = "B+";
}
else if(mhs.akhir >= 70 && mhs.akhir <75){
mhs.nilai = "B";
}
else if(mhs.akhir >= 50 && mhs.akhir <70){
mhs.nilai = "C";
}
else if(mhs.akhir >= 0 && mhs.akhir <50){
mhs.nilai = "D";
}
else{
mhs.nilai = "Salah input nilai";
}
cout<<"Nilai Huruf Anda\t : "<<mhs.nilai<<endl;
cout<<"=====================================================
========"<<endl<<endl;
}
II-11
}
2. Tampilan Program :
Gambar 1.5 Program Implementasi Struct
3. Analisa Program :
Pertama – tama membuat struct yang berisi bermacam elemen.
Inputan jumlah mahasiswa adalah menggunakan variabel pada fungsi main
bukan menggunakan elemen pada struct. Rata – rata nilai didapat dari 4
nilai mahasiswa yang jumlahkan kemudian di bagikan dan nilai huruf
dibuat menggunakan percabangan if.
II-12
I.8 Tugas Rumah ke-3 : Program Menara Hanoi
1. Listring Program :
#include <iostream>
using namespace std;
int hanoi(int n, char dari, char bantu, char tujuan){
if (n == 1)
cout
<<"Pindahkan
piring
dari
"<<dari<<"
"<<tujuan<<"\n";
else{
hanoi(n-1, dari, tujuan, bantu);
hanoi(1, dari, bantu, tujuan);
hanoi(n-1, bantu, dari, tujuan);
}
}
main(){
int jumlah_piring;
cout<<"=====Permainan Hanoi====="<<endl<<endl;
cout<<"Masukkan Jumlah piring: ";
cin>>jumlah_piring;
cout<<endl;
hanoi(jumlah_piring,'A','B','C');
}
2. Tampilan Program :
Gambar 1.6 Program Menara Hanoi
ke
I-13
3. Analisa Program :
Program diatas adalah contoh implementasi rekursif pada C++.
Pemanggilan fungsi dirinya sendiri akan terus berjalan apabila kondisi n
masih tidak sama dengan 1. Fungsi akan berhenti memanggil dirinya
sendiri ketika kondisi if telah terpenuhi. Pada fungsi main, jumlah piring
merupakan inputan user dan hasil eksekusi program tergantung pada
inputan user tersebut.
I.9 Kesimpulan
1. Pointer adalah sebuah variabel yang meyimpan alamat memory, untuk
mendapatkan alamat dari sebuah variabel adalah dengan menggunakan
operator &, sedangkan untuk memanggil data yang ada di alamat tersebut
adalah menggunakan operator *.
2. Struct adalah kumpulan elemen – elemen data yang digabungkan menjadi
satu kesatuan yang masing – masing elemen data tersebut disebut dengan
field.
3. Rekursif adalah fungsi yang memanggil fungsi itu sendiri dan prosesnya
terjadi secara berulang – ulang.
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
II-1
BAB II
Stack dan Queue
Jumlah Pertemuan
: 2 x 60 menit
Tujuan Praktikum
:
1. Praktikan dapat memahami pengertian dari Stack dan Queue
2. Agar Praktikan mengetahui dan memahami Operasi-operasi yang
digunakan di metode Stack dan Queue
3. Praktikan dapat mengoprasikan atau menerapkan metode Stack dan
Queue kedalam sebuah program.
Alat / bahan
:
1. Perangkat komputer
2. Perangkat lunak: Dev C++
3. Modul Struktur Data 2019
II.1 Landasan Teori
2.1 Pengertian Stack (Tumpukan)
Stack (Tumpukan) adalah kumpulan elemen – elemen data yang
disimpan dalam satu lajur linear. Kumpulan elemen – elemen data hanya
boleh diakses pada satu lokasi saja yaitu posisi atas (TOP) tumpukan.
Tumpukan digunakan dalam algoritman pengimbas (parsing), algoritma
penilaian (evaluation) dan algoritman penjajahan balik (backtrack). Elemen –
elemen di dalam tumpukan dapat bertipe integer, real, record dalam bentuk
sederhana atau terstruktur.
Stack adalah suatu tumpukan dari benda. Konsep utamanya adalah
LIFO (Last In First Out), benda yang terakhir masuk dalam stack akan
menjadi benda pertama yang dikeluarkan dari stack. Tumpukan disebut juga
“Push Down Stack” yaitu penambahan elemen baru (PUSH) dan pengeluaran
elemen dari tumpukan (POP).
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
II-2
2.2 Operasi Dalam Stack (Tumpukan)
Operasi yang sering diterapkan pada struktur data Stack (Tumpukan)
adalah Push dan Pop. Operasi – operasi yang dapat diterapkan adalah sebagai
berikut :
1. Push
: digunakan untuk menambah item pada Stack pada
Tumpukan paling atas.
2. Pop
: digunakan untuk mengambil item pada Stack pada
Tumpukan paling atas.
3. Clear
: digunakan untuk mengosongkan Stack.
4. Create Stack
: membuat Tumpukan baru, dengan jumlah elemen
kosong.
5. IsEmpty
: fungsi yang digunakan untuk mengecek apakah
Stack sudah kosong.
6. IsFull
: fungsi yang digunakan untuk mengecek apakah
Stack sudah penuh.
2.3 Macam – macam Stack (Tumpukan)
1. Stack dengan Array
Sesuai dengan sifat stack, pengambilan atau penghapusan
elemen dalam stack harus dimulai dari elemen teratas.
2. Double Stack dengan Array
Metode ini adalah teknik khusus yang dikembangkan untuk
menghemat pemakaian memori dalam pembuatan dua stack
dengan array. Intinya adalah penggunaan hanya sebuah array untuk
menampung dua stack.
II-3
2.4 Inisialisasi Stack (Tumpukan)
Pada mulanya isi top dengan -1, karena array dalam C dimulai dari 0,
yang berarti stack adalah Kosong! Top adalah suatu variabel penanda dalam
Stack menunjukkan elemen teratas Stack sekarang. Top Of Stack akan selalu
bergerak hingga mencapai Max Of Stack sehingga menyebabkan Stack penuh.
2.5 Fungsi Is Full
Untuk memeriksa apakah stack sudah penuh? Cukup dengan cara
memeriksa Top Of Stack, jika sudah sama dengan MAX_STACK-1 maka
dapat dinyatakan bahwa stack yang ada sudah penuh, tetapi jika masih lebih
kecil dari MAX_STACK-1 maka dapat dinyatakan bahwa stack belum penuh.
2.6 Fungsi Is Push
Untuk memasukkan elemen ke stack, selalu menjadi elemen teratas
stack. Tambah satu (increment) nilai Top Of Stack terlebih dahulu setiap kali
ada penambahan elemen stack, asalkan stack masih belum punah, kemudian
isikan nilai baru ke stack berdasarkan index Top Of Stack setelah ditambah
satu.
2.7 Fungsi Pop
Untuk mengambil elemen teratas dari stack, ambil dahulu nilai elemen
teratas stack dengan mengakses Top Of Stack, tumpukan nilai yang akan
diambil terlebih dahulu, baru di decrement (dikurangi) nilai Top Of Stack
sehingga jumlah elemen stack berkurang.
2.8 Fungsi Print
Untuk menampilkan semua elemen – elemen stack. Dengan cara
looping semua nilai array secara terbalik. Karena kita harus mengakses dari
indeks array tertinggi terlebih dahulu baru ke indeks yang paling kecil.
2.9 Algoritma Pop Stack :
1. Jika berupa operan, maka masukkan ke stack hasil
2. Jika berupa operator, maka :
II-4
a. Pop nilai pertama dari stack hasil
b. Pop nilai kedua dari stack hasil
c. Lakukan operasi sesuai dengan operator yang didapat
2.10 Notasi Aritmetik (Prefix, Postfix, Prefix)
Notasi aritmetika biasa ditulis dalam notasi Infix, missal A+B+C.
Notasi infix mudah dimengerti ooleh manusia, hanya saja dalam notasi infix
perlu diperhatikan prioritas pengerjaan karena berhubungan dengan hirarki
operator pada computer. Prioritas pengerjaannya adalah :
1. Tanda kurung : ( … )
2. Eksponensial atau pangkat : ^
3. Perkalian, pembagian : *, /
4. Penjumlahan, pengurangan : +, Prefix adalah keadaan dimana symbol operator diletakkan sebelum
dua operand. Postfix adalah keadaan dimana symbol operator diletakkan
sesudah dua operand.
2.11 Aturan Pengerjaan
1. Baca soal dari depan ke belakang.
2. Jika soal berupa operand, maka masukkan ke postfix.
3. Jika berupa operator, maka :
a) Jika stack masih kosong, push ke stack.
b) Jika derajat operator soal > derajat operator top of stack.
Push operator soal ke stack
c) Selama derajat operator soal <= derajat operator top of stack.
Pop top of stack dan masukkan kedalam postfix
II-5
Setelah semua dilakukan, push operator soal ke
stack
d) Jika sudah semua soal dibaca, pop semua isi stack dan push ke
postfix sesuai dengan urutannya.
2.12 Pengertian Queue
Queue atau antrian merupakan struktur data linear dimana
penambahan komponen dilakukan ujung, sementara pengurangan dilakukan
diujung lain. Kaidah utama dalam konsep queue adalah FIFO yang
merupakan singkatan dari First In First Out, artinya adalah data yang pertama
kali dimasukkan atau disimpan, maka data tersebut adalah yang pertama kali
akan diakses atau dikeluarkan.
Sebuah queue di dalam program komputer dideklarasikan sebagai
sebuah tipe bentukan baru. Sebuah struktur data dari sebuah queue setidaknya
harus mengandung dua tiga variabel, yakni variabel head yang akan berguna
sebagai penanda bagian depan antrian, variable tail yang akan berguna
sebagai penanda bagian belakang antrian dan array dari yang akan
menyimpan data-data yang dimasukkan ke dalam queue tersebut.
2.13 Operasi Pada Queue
Operasi Enqueue, digunakan untuk memasukkan sebuah data atau
nilai ke dalam queue. Pada proses enqueue, tail -lah yang berjalan seiring
masuknya data baru ke dalam antrian, sedangkan head akan tetap pada posisi
ke-1.
Operasi Dequeue, digunakan untuk menghapuskan sebuah data atau
nilai yang paling awal masuk ke dalam queue. Operasi ini menaikkan nilai
head satu level.
Operasi Is Full, Untuk mengecek apakah Antrian sudah penuh atau
belum Dengan cara mengecek nilai Tail, jika Tail >= MAX-1 (karena MAX-1
adalah batas elemen array pada C, berarti sudah penuh.
II-6
Operasi Is Empty, Untuk memeriksa apakah Antrian kosong atau
belum Dengan cara memeriksa nilai Tail, jika Tail = -1 maka empty. Kita
tidak memeriksa Head, karena Head adalah tanda untuk kepala antrian
(elemen pertama dalam antrian) yang tidak akan berubah-ubah Pergerakan
pada Antrian terjadi dengan penambahan elemen Antrian kebelakang, yaitu
menggunakan nilai Tail.
Operasi Clear, Untuk menghapus elemen-elemen Antrian dengan
cara membuat Tail dan Head = -1, Penghapusan elemen-elemen Antrian
sebenarnya tidak menghapus arraynya, namun hanya mengeser indeks
pengaksesan-nya ke nilai -1 sehingga elemen - elemen antrian tidak lagi
terbaca.
2.14 Implementasi Queue dengan Linear Array
Untuk setiap struktur data queue yang diimplementasikan dengan
array, posisi front (depan) back (belakang) akan selalu ada. Dua hal yang
menarik perhatian adalah queue bergerak dari indeks kecil menuju indeks
yang besar dan diperlukan dua buah penunjuk (Head dan Tail).
Pada struktur antrian linier terdapat dua pintu yaitu head dan tail.
Dimana head ditempatkan pada awal array (index 0) dan tail ditempatkan
pada max -1, sehingga dalam pemrograman dibutuhkan 2 variabel head dan
tail.
2.15 Implementasi Queue dengan Circular Array
Circular array adalah suatu array yang dibuat seakan-akan merupakan
sebuah lingkaran dengan titik awal (head) dan titik akhir (tail) saling
bersebelahan jika array tersebut masih kosong. Posisi head dan tail pada
gambar diatas adalah bebas asalkan saling bersebelahan.
Dengan circular array, meskipun posisi terakhir telah dipakai, elemen
baru tetap dapat ditambahkan pada posisi pertama jika posisi pertama dalam
keadaan kosong. Jika akhir = MAX dan awal = 1, nilai head dan Tail
mencapai maksimum, maka akan dikembalikan ke posisi awal. Operasi-
II-7
operasi yang terdapat pada circular array tidak jauh berbeda dengan operasi
pada linear array.
Aturan – aturan dalam queue yang menggunakan circular array adalah
1. Proses penghapusan dilakukan dengan cara nilai depan (front)
ditambah 1 : depan += 1
2. Proses penambahan elemen sama dengan linear array yaitu nilai
belakang ditambah 1 : belakang += 1
3. Jika depan = maks dan ada elemen yang akan dihapus, maka nilai
depan = 1
4. Jika belakang = maks dan depan tidak 1, maka jika ada elemen yang
akan ditambahkan, nilai belakang = 1
5. Jika hanya tinggal 1 elemen di queue (depan = belakang), dan akan
dihapus maka depan diisi 0 dan belakang diisi dengan 0 (queue
kosong)
2.15.1 Inisialisasi Queue
Inisialisasi queue adalah proses pemberian nilai 0 untuk
field depan dan belakang dari queue dan juga pemberian nilai maks
ke maks_queue yang menunjukan banyaknya maksimal data dalam
queue. Karena dalam bahasa C++ elemen sebuah array dimulai
dengan 0 maka proses inisialisasi nilai depan dan belakang bukan
0 tetapi -1 sehingga ketika ada proses penambahan elemen
(enqueue) akan bernilai 0 sehingga elemen tersebut akan disimpan
dalam elemen antrian pada posisi 0.
2.15.2 Fungsi Dalam Queue Circular Array
Terdapat fungsi – fungsi yang mirip antara Queue Circular
dan Queue Linear.
II-8
1. Fungsi Is Empty
2. Fungsi Is Full
3. Fungsi Enqueue
4. Fungsi Dequeue
II.2 Langkah-langkah Praktikum
1. Script ditulis dengan menggunakan Dev C++
2. Script dicompile dengan menggunakan Dev C++
3. Aplikasi dijalankan dengan menggunakan Dev C++
II.3 Tugas Praktikum ke-1 : Program Implementasi Stack
1. Listing Program :
#include <iostream>
#define MAXSTACK 100
using namespace std;
typedef int itemType;
typedef struct
{
int item[MAXSTACK];
int jml;
} Stack;
void init(Stack *s)
{
s->jml=0;
};
int kosong(Stack *s)
{
return (s->jml==0);
}
int penuh(Stack *s)
{
return (s->jml==MAXSTACK);
}
void isi(itemType x, Stack *s)
{
if(penuh(s))
{
cout<<" Maaf data sudah penuh"<<endl;
cout<<"-------------------------------------------------"<<endl;
}
II-9
else
{
s->item[s->jml]=x;
++(s->jml);
}
}
void ambil(Stack *s, itemType *x)
{
if(kosong(s))
{
cout<<" Maaf data masih kosong"<<endl;
cout<<"-------------------------------------------------"<<endl;
}
else
{
--(s->jml);
*x=s->item[s->jml];
s->item[s->jml]=0;
cout<<" Data "<<*x<<" berhasil diambil"<<endl;
cout<<"-------------------------------------------------"<<endl;
}
}
void tampil(Stack *s)
{
if(kosong(s))
{
cout<<" Maaf data masih kosong"<<endl;
cout<<"-------------------------------------------------"<<endl;
}
else cout<<endl;
for(int i=s->jml-1;i>=0;i--)
{
cout<<"Data "<<s->item[i]<<endl;
}
}
void hapus(Stack *s)
{
s->jml=0;
cout<<" Semua data berhasil dihapus"<<endl;
cout<<"-------------------------------------------------"<<endl;
}
int main()
{
int pil;
Stack tumpukan;
itemType data;
init(&tumpukan);
do
{
cout<<"Selamat datang di Aplikasi stack"<<endl;
cout<<"1. PUSH(Memasukan)"<<endl;
II-10
cout<<"2. POP(Mengangkat/Memanggil)"<<endl;
cout<<"3. Display(Menampilkan)"<<endl;
cout<<"4. Delete(Hapus)"<<endl;
cout<<"5. Exit"<<endl;
cout<<"Masukkan pilihan : ";cin>>pil;
cout<<"-------------------------------------------------"<<endl;
switch(pil)
{
case 1:
cout<<"Masukkan data : ";cin>>data;
cout<<"-------------------------------------------------"<<endl;
isi(data,&tumpukan);
break;
case 2:
ambil(&tumpukan,&data);
break;
case 3:
tampil(&tumpukan);
break;
case 4:
hapus(&tumpukan);
break;
}
}
while(pil!=5);
cout<<" Terima Kasih"<<endl;
cout<<"-------------------------------------------------"<<endl;
return 0;
}
2. Tampilan Program :
Gambar 2.1 Program Implementasi Stack
II-11
3. Analisa Program :
Pertama user akan menginputkan pilihan, kemudian masuk ke
dalam percabangan switch. Setiap pilihan telah diisi dengan fungsi telah di
atur di luar fungsi main. Ketika mengeluarkan data yang dikeluarkan
adalah dari yang terakhir di inputkan oleh user nantinya.
II.4 Tugas praktikum ke-2: Program Implementasi Queue
1. Listing Program :
#include <iostream>
#define max 8
using namespace std;
typedef struct{
int data[max];
int head;
int tail;
}Queue;
Queue antrian;
void init(){
antrian.head = -1;
antrian.tail = -1;
}
int kosong(){
if(antrian.tail==-1){
return 1; //data kosong
}
else{
return 0; //data berisi
}
}
int penuh(){
if(antrian.tail==max-1){
return 1; //data penuh
}
else{
return 0; //data berisi
}
}
void masuk(){
int data;
cout <<"Masukkan bilangan = ";
cin >>data;
if(penuh()==0){
antrian.tail++;
antrian.data[antrian.tail]=data;
cout<<"\n"<<antrian.data[antrian.tail]<<" masuk ";
}
else{
II-12
cout <<"Data penuh";
}
}
int keluar(){
int i;
if(kosong()==1){
cout<<"Kosong cuy";
}
else{
int x=antrian.data[antrian.head+1];
for(i=antrian.head;i<antrian.tail;i++){
antrian.data[i]=antrian.data[i+1];
}
antrian.tail--;
cout <<x <<" berhasil dikeluarkan ";
return x;
}
}
void clear(){
init();
cout <<"Data telah dikosongkan";
}
void tampil(){
if(kosong()==0){
for(int i=antrian.head+1;i<=antrian.tail;i++){
cout <<antrian.data[i]<<" ";
}
}
else{
cout <<"Data masih kosong";
}
}
int main(){
int pil;
init();
cout<<"*-------------------------------*"<<endl;
cout<<"* Q u e u e ( A N T R I A N ) *"<<endl;
cout<<"*-------------------------------*"<<endl;
do{
cout<<"\n";
cout<<"\n********************************";
cout<<"\n1. Masukkan Data";
cout<<"\n2. Keluarkan Data";
cout<<"\n3. Kosongkan Data";
cout<<"\n4. Cetak Data";
cout<<"\n\nSilahkan
Masukan
Pilihan
Anda
";cin>>pil;
cout<<"\n";
switch (pil){
case 1:
masuk();
break;
case 2:
keluar();
:
II-13
break;
case 3:
clear();
break;
case 4:
tampil();
break;
default :
cout<<"\n
Maaf,
Tidak
ada
dalam
pilihan";
}
} while(pil>=1 && pil<= 4);
return 0;
}
2. Tampilan Program :
Gambar 2.2 Program Implementasi Queue
3. Analisa Program :
Data – data yang dimasukkan oleh user dapat di tampilkan dengan
memilih pilihan nomor 4. Jika user memilih mengeluarkan data, maka data
di indeks ke dua akan bergeser ke indeks pertama begitupun data yang
berada pada indeks ke-2 dan seterusnya akan bergeser ke indeks
sebelumnya.
II-14
II.5 Tugas Rumah ke-1 : Program Membalikkan Nama mengguakan Stack
1. Listing Program :
#include <iostream>
#include <cstdlib>
#include <cstring>
using namespace std;
int main(){
char masukkan[30];
int panjang;
cout<<"Masukkan kalimat : ";gets (masukkan);
cout<<endl;
cout<<"Kalimat awal : "<<masukkan;
panjang = strlen(masukkan);
cout<<"\nDibalik jadi : ";
for(int a=panjang; a>=1 ;a--){
char stack = masukkan[a-1];
cout<<stack;
}
}
2. Tampilan Program :
Gambar 2.3 Program Membalikkan Nama Menggunakan Stack
3. Analisa Program :
Inputan pada masukkan kalimat adalah menggunakan tipe data
char. Agar dapat menginputkan dengan spasi maka harus menggunakan
library cstdlib. Strlen digunakan untuk mengetahui berapa jumlah karakter
inputan user tadi, kemudian digunakan untuk menampilkan karakter dari
yang terakhir sampai ke awal.
II-15
II.6 Tugas Rumah ke-2 : Program Antrian Bank
1. Listing Program :
#include <iostream>
#include <windows.h>
using namespace std;
struct antri{
int data;
};
antri ant[15];
struct identitas{
char nama[20];
};
identitas id[15];
int main(){
int cek=0, y=0;
char pil;
do {
cout<<"\n|| PROGRAM BANK ||"<<endl<<endl;
cout<<"1. Masukan Antrian"<<endl;
cout<<"2. Proses Antrian"<<endl;
cout<<"3. Keluar"<<endl;
cout<<endl;
cout<<"Masukkan pilihan = ";
cin>>pil;
cout<<endl;
if(pil!='1' && pil !='2' && pil !='3' ){
system("cls");
cout<<"PILIHAN 1 - 3 WOYYY !!!!"<<endl;
}
else{
if(pil=='1'){
if(cek==15 && y==15){
cout<<"Maaf Antrian Penuh :)";
}
cout<<endl;
system("cls");
cout<<"Nama\t: ";
cin>>id[cek].nama;
cout<<endl;
cek++;
system("cls");
cout<<"Antrian Anda\t:\n\n";
for(int z=0;z<cek;z++){
cout<<"Nomor\t\t: "<<z+1;
cout<<endl;
cout<<"Nama\t\t: "<<id[z].nama<<endl;
cout<<endl<<endl;
}
cout<<endl<<endl;
system("PAUSE");
system("cls");
}
else{
II-16
if(pil=='2'){
if(cek==0)
cout<<"MASIH
KOSONG
ASTAGHFIRULLAHH
!!!";
else{
for(int v=0;v<cek;v++){
ant[v].data=ant[v+1].data;
}
cek--;
system("cls");
cout<<"\tProses\n\n";
cout<<"Nama\t\t:
"<<id[0].nama<<endl<<endl;
cout<<"Antrian
dengan
"<<id[0].nama<<" berhasil di proses";
cout<<endl;
{
int b;
for(b=0;b<cek;b++)
id[b]=id[b+1];
b--;
}
}
cout<<endl;
system("PAUSE");
system("cls");
}
}
}
}while(pil!='3');
}
2. Tampilan Program :
Gambar 2.4 Program Antrian Bank
nama
II-17
3. Analisa Program :
Program Antrian Bank diatas merupakan contoh penerapan queue.
Setelah memilih pilihan 1, maka user akan memasukkan data nama dan
antrian akan didapatkan secara otomatis. Proses antrian yang dimaksut
adalah antrian akan di keluarkan dari antrian yang pertama diinputkan.
II.7 Kesimpulan
1. Konsep dari Stack adalah LIFO (Last In First Out) yaitu data yang terakhir
dimasukkan adalah data yang pertama keluar dan data yang pertama
dimasukkan adalah data yang terakhir keluar.
2. Konsep dari Queue adalah FIFO (First In First Out) yaitu data yang
pertama dimasukkan lah yang akan keluar pertama dan data yang terakhir
di masukkan akan di keluarkan terakhir juga.
3. Pada Stack sebutan untuk memasukkan data adalah Push dan sebutan
untuk mengeluarkan data adalah Pop. Pada Queue sebutan untuk
memasukkan data adalah Enqueue dan sebutan untuk mengeluarkan data
adalah Dequeue.
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
III-1
BAB III
SORTING
Jumlah Pertemuan
: 2 x 60 menit
Tujuan Praktikum
:
1. Praktikan dapat memahami pengertian dari Sorting
2. Praktikan mengetahui dan memahami cara kerja dari system sorting
3. Praktikan dapat mengoprasikan atau menerapkan metode sorting
Alat / bahan
:
1. Perangkat komputer
2. Perangkat lunak: Dev C++
3. Modul Struktur Data 2019
III.1 Landasan Teori
3.1 Pengertian
Sorting dalam arti bahasaa adalah pengelompokan sebuah data yang
tersusun secara acak yang kemudian di urutkan secara ascending (urutan
naik) maupun discending (urutan turun). Pengurutan data dalam struktur data
sangat penting terutama untuk data yang bertipe data numerik ataupun
karakter.
Metode sorting terdiri dari :
1. Bubble Sort
2. Exchange Sort
3. Insertion Sort
4. Selection Sort
5. Quicksort
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
III-2
3.2 Bubble Sort
Bubble adalah metode dalam sorting yang paling mudah logikanya.
Diberi nama “Bubble” karena proses pengurutannya berangsur angsur
bergerak/berpindah ke posisi yang tepat, seperti gelembung yang keluar dari
dalam gelas bersoda. Cara kerja metode ini adalah dengan cara
membandingkan elemen sekarang dengan elemen berikutnya. Metode ini
seolah – olah menggeser satu elemen dari kanan kekiri atau sebaliknya,
tergantung jenis pengurutannya.
3.3 Exchange Sort
Exchange adalah metode dalam sorting dimana dikatakan sangat
mirip dengan metode sorting Bubble Sort. Namun, Exchange Sort
membandingkan suatu elemen dengan elemen – elemen lainnya dalam array
tersebut dan melakukan pertukaran elemen jika perlu. Jadi ada elemen yang
selalu menjadi elemen pusat (pivot). Sedangkan Bubble Sort akan
membandingkan
elemen
pertama/terakhir
dengan
elemen
sebelumnya/sesudahnya, kemudian elemen tersebut itu akan menjadi pusa
(pivot) untuk dibandingkan dengan elemen sebelumnya/sesudahnya lagi,
begitu seterusnya. Disitulah dimana letak perbedaan Exchange dan Bubble
Sort terletak.
3.4 Insertion Sort
Insertion adalah metode dalam sorting dimana logikanya hampir
mirip seperti mengurutkan sebuah kartu. Dimana kartu tersebut di urutkan
selembar demi selembar. Dalam Insertion pengurutan dimulai dari elemen-2
sampai elemen terakhir, jika ditemukan yang lebih kecil, maka akan
ditempatkan pada posisi yang seharusnya.
III-3
3.5 Selection Sort
Selection adalah metode dalam sorting pengurutan dengan cara
elemen terkecil atau terbesar,
sesuai permintaan.
untuk kemudian
dibandingkan & ditukarkan dengan elemen data awal seterusnya sampai
dengan seluruh elemen,sehingga akan menghasilkan pola data yang telah di
sort.
Prinsip Kerja Selection Sort :
1. Pengecekan dimulai data ke-1 sampai dengan data ke-n (missal I &
pos)
2. Bandingkan data pos dengan data i+1 (missal j)
3. Jika data pos tidak sesuai dengan kondisi maka pos = j dan j akan
selalu bertambah (j++) sampai melewati n.
4. Lakukan langkah 2 dan 3 untuk bilangan berikutya sampai
didapatkan urutan yang optimal.
5. Mengecek apakah i != pos jika ya, maka data akan ditukar
6. Lakukan Proses 1 sampai 5 sampai di dapatkan proses ke n-1
3.6 Quick Sort
Quicksort adalah metode dalam sorting yang mana adalah pengurutan
membandingkan suatu elemen yang disebut pivot ( memilih index tengah dari
array ) dengan elemen yang lain dan menyusunnya sedemikian rupa sehingga
elemen‐elemen lainnya yang lebih kecil daripada pivot tersebut terletak
disebelah kirinya dan elemenelemen lain yang lebih besar daripada pivot
terletak disebelah kanannya. Dengan demikian telah terbentuk dua sublist,
lalu pada sublist kiri dan sublist kanan anggap sebuah list baru dan kerjakan
proses yang sama seperti sebelumnya. Demikian seterusnya sampai tidak
terdapat sublist lagi.
III-4
Algoritma Quick Sort :
1. Mengecek apakah A [ i ] < tengah
- Jika ya, i++ ; Ke langkah 1
- Jika tidak, i = i ; Ke langkah 2
2. Mengecek apak A [ j ] > tengah
- Jika ya, j-- ; Ke langkah 2
- Jika tidak, j = j ; Ke langkah 3
3. Mengecek apakah i <= j
- Jika ya, tukar A [ i ] dengan A [ j ]
i++, j-- ; Ke langkah 4
- Jika tidak, Ke langkah 4
4. Mengecek apakah i > j
- Jika ya, Ke langkah 5
- Jika tidak, Ke langkah 1
5. Mengecek apakah L < j
- Jika ya, panggil fungsi Quicksort (L , j)
- Jika tidak, Ke langkah 6
6. Mengecek apakah i < R
- Jika ya, panggil Quicksort (i , R)
- Jika tidak, selesai
III.2 Langkah-langkah Praktikum
1. Script ditulis dengan menggunakan Dev C++
2. Script dicompile dengan menggunakan Dev C++
3. Aplikasi dijalankan dengan menggunakan Dev C++
III-5
III.3 Tugas Praktikum ke-1 : Sorting menggunakan Bubble Sort
1. Listing Program :
#include <iostream>
using namespace std;
main(){
int NumList [5]={3,4,1,8,12};
int temp;
cout<<"Data sebelum diurutkan : ";
for (int d=0;d < 5;d++){
cout<<" "<<NumList[d];
}
cout<<endl<<endl;
for(int i=0;i<=3;i++){
cout<< "Proses "<< i+1<< " = ";
for(int x=0;x<=3;x++){
if(NumList[x]>=NumList[x+1]){
temp=NumList[x];
NumList[x]=NumList[x+1];
NumList[x+1]=temp;
}
}
for(int y=0;y<5;y++){
cout<<" "<<NumList[y];
}
cout<<endl;
}
cout<<endl;
cout<<"Data setelah diurutkan : ";
for (int d=0;d < 5;d++){
cout<<" "<<NumList[d];
}
}
2. Tampilan Program :
Gambar 3.1 Program Sorting menggunakan Bubble Sort
III-6
3. Analisa Program :
Program diatas adalah contoh sorting menggunakan metode
Bubble Sort. Pada proses 1, data pertama (3), lebih besar dari data ke dua
(1), maka terjadi pertukaran tempat sehingga data menjadi 1, 3. Begitupun
pada proses 2, 3 dan 4. Proses dari Bubble sort adalah banyaknya data – 1.
III.4 Tugas Praktikum ke-2 : Sorting menggunakan Exchange Sort
1. Listing Program :
#include<iostream>
using namespace std;
main(){
int data[6]={84,69,76,86,94,91};
int tanda;
cout<<"Data Awal : ";
for(int a=0;a< 6;a++){
cout<<data[a]<<" ";
}
cout<<endl<<endl;
for(int b=0;b< 5;b++){
cout<<"Proses "<< b+1 << " = ";
for(int a=b;a<5;a++){
if(data[b]<data[a+1]){
data[b]=data[b];
}
else{
tanda=data[b];
data[b]=data[a+1];
data[b+1]=tanda;
}
}
for(int a=0;a< 6 ;a++){
cout<<data[a]<<" ";
}
cout<<endl;
}
}
2. Tampilan Program :
Gambar 3.2 Program Sorting menggunakan Exchange Sort
III-7
3. Analisa Program :
Pertama – tama mendeklarasikan variabel data dengan index array
6 dan di isi dengan data 84, 69, 76, 86, 94, 91. For pertama dimaksudkan
untuk menampilkan data dari index array. For kedua adalah For bersarang,
digunakan untuk melakukan sorting data nya.
III.5 Tugas Praktikum ke-3 : Sorting menggunakan Insertion Sort
1. Listing Program :
#include <iostream>
using namespace std;
main(){
int data[5] = { 20, 34,12,5,60 }; //menampilkan data awal
cout<<"Data sebelum di sorting :";
for(int i=0;i<5;i++){
cout<<data[i]<<" ";
}
cout<<endl; //proses insertion sort
int temp,i,j;
for(i=1;i<5;i++){
temp = data[i];
for(j = i-1; j >= 0 ; j--){
if ( temp <= data[j]){
data[j+1] = data[j];
data[j] = temp;
temp = data[j];
}
}
cout<<"Proses "<< i << " = ";
for(int x=0;x<5;x++){
cout<<data[x]<<" ";
}
cout<<endl;
}
}
2. Tampilan Program :
Gambar 3.3 Program Sorting menggunakan Insertion Sort
III-8
3. Analisa Program :
Program diatas adalah program sorting menggunakan metode
Insertion Sort. Sorting seperti gabungan dari Bubble Sort dan Exchange
Sort. Proses pengurutan dimulai dari indeks ke-2 yaitu data 34 akan
ditukar dengan data 20. Pertukaran akan dilakukan jika memang perlu dan
seterusnya hingga data yang paling akhir
III.6 Tugas Praktikum ke-4 : Sorting menggunakan Selection Sort
1. Listing Program :
#include <iostream>
using namespace std;
main(){
int data[6]={32,75,69,58,21,40};
int i,pos,j,temp;
i=0;
pos=0;
j=1;
cout<<"Data Awal : ";
for(int x=0;x<=5;x++){
cout<<data[x]<<" ";
}
cout<<endl;
for(int z=0;z<=4;z++){
i=z;
pos=z;
j=z + 1;
while (j < 6){
if(data[j]<data[pos]){
pos = j;
j = j+1;
}
else{
pos = pos;
j = j+1;
}
}
if(pos!=i){
temp=data[pos];
data[pos]=data[i];
data[i]=temp;
}
cout<<"Proses "<<z+1<<" = ";
for(int x=0;x<=5;x++){
cout<<data[x]<<" ";
}
cout<<endl;
}
}
III-9
2. Tampilan Program :
Gambar 3.4 Program Sorting menggunakan Selection Sort
3. Analisa Program :
Program diatas adalah program sorting dengan menggunakan
metode Selection Sort. For pertama digunakan untuk menampilkan data
pada index array, kemudian for kedua digunakan untuk melakukan proses
sorting nya
III.7 Tugas Praktikum ke-5 : Sorting menggunakan Quick Sort
1. Listing Program :
#include <iostream>
using namespace std;
int data[5] = { 23, 13, 45, 89,50 };
void QuickSort(int L, int R){ //the best sort i've ever had :)
int i, j;
int mid;
i = L;
j = R;
mid = data[(L+R) / 2];
do{
while(data[i] < mid)
i++; //selama nilai Data[i] lebih kecil daripada
nilai Mid maka i bertambah 1
while (data[j] > mid)
j--; //selama nilai Data[j] lebih besar daripada
nilai Mid makan j berkurang 1
if (i <= j){ //jika I <= J maka data ditukar..
int t;
t = data[j];
data[j] = data[i];
data[i] = t;
i++;
III-10
j--;
cout<<"Quicksort ( "<<L<<", "<<R<<" ) = ";
for(int i=0;i<5;i++){
cout<<data[i]<<" ";
}
cout<<endl;
}
}
while (i < j); //melakukan perulangan selama I lebih kecil
daripada J
if (L < j)
QuickSort(L, j);
if (i < R)
QuickSort(i, R);
}
main(){
cout<<"
Proses Quick Sort"<<endl;
cout<<"------------------------------------- "<<endl;
cout<<"Data awal : ";
for(int i=0;i<5;i++){
cout<<data[i]<<" ";
}
cout<<endl;
QuickSort(0,4);
}
2. Tampilan Program :
Gambar 3.5 Program Sorting menggunakan Quick Sort
3. Analisa Program :
Program diatas adalah program sorting menggunakan metode
Quick Sort. Variabel data merupakan variabel array berisi data 23,
13,45,89, 50. Proses pertukaran data terjadi pada perulangan do-while
selama I < j
III-11
III.8 Tugas Rumah ke-1 : Program mengurutkan Data Aslab
1. Listing Program :
#include <iostream>
using namespace std;
int main(){
string nama[40];
int nim[20];
int banyak_aslab,tukar_nim;
string tukar_nama;
cout<<"\tLab. RPL ITN Malang"<<endl;
cout<<"Masukkan Data Aslab RPL"<<endl;
cout<<"Banyak Aslab : ";cin>>banyak_aslab;
cout<<"==============================="<<endl;
for(int a=0; a<banyak_aslab; a++){
cout<<"Data Aslab ke-"<<a+1<<endl;
cout<<"NIM\t: ";cin>>nim[a];
cout<<"NAMA\t: ";cin>>nama[a];
cout<<"---------------------"<<endl;
}
for(int x=0; x<banyak_aslab; x++){
for(int y=0; y<banyak_aslab; y++){
if(nim[y] > nim[y+1]){
tukar_nim = nim[y];
nim[y] = nim[y+1];
nim[y+1] = tukar_nim;
tukar_nama = nama[y];
nama[y] = nama[y+1];
nama[y+1] = tukar_nama;
}
else{
nim[y] = nim[y];
}
}
}
cout<<endl;
cout<<"Data setelah diurutkan :"<<endl;
for(int n=0; n<banyak_aslab; n++){
cout<<nim[n]<<" "<<nama[n]<<endl;
}
}
III-12
2. Tampilan Program :
Gambar 3.6 Program mengurutkan Data Aslab
3. Analisa Program :
Program diatas merupakan Sorting dengan menggunakan metode
Bubble Sort. Nama menggunakan variabel “nama” dengan tipe data string
dan NIM menggunakan variabel “nim” dengan tipe data integer. Dengan
menambahkan variabel “tukar_nim” dan “tukar_nama”, data dapat ditukar
dengan memanfaatkan variabel tersebut yang cara kerjanya adalah data di
simpan pada variabel tersebut kemudian di letakkan pada variabel nim dan
nama yang diininkan user
III-13
III.9 Tugas Rumah ke-2 : Program Sorting menggunakan Quick Sort
1. Listing Program :
#include <iostream>
using namespace std;
int data[6] = {53,30,82,3,20,44};
void QuickSort(int L,int R){
int x,y;
int mid;
x = L;
y = R;
mid = data[(L + R)/2];
do{
while (data[x] < mid){
x++;
}
while (data[y] > mid){
y--;
}
if(x <= y){
int z;
z = data[y];
data[y] = data[x];
data[x] = z;
x++;
y--;
cout<<"QuickSort ("<<L<<", "<<R<<") = ";
for(int x=0; x<6; x++){
cout<<data[x]<<" ";
}
cout<<endl;
}
}
while(x < y);
if(L < y){
QuickSort(L,y);
}
if(x < R){
QuickSort(x,R);
}
}
main(){
cout<<" Proses Quick Sort"<<endl;
cout<<endl<<endl;
cout<<"Data awal : ";
for(int b=0; b<6; b++){
cout<<data[b]<<" ";
}
cout<<endl;
QuickSort(0,5);
}
III-14
2. Tampilan Program :
Gambar 3.7 Program Sorting menggunakan Quick Sort
3. Analisa Program :
Program diatas adalah menggunakan metode sorting QuickSort.
QuickSort menggunakan variabel untuk index kiri (L), index kanan (R)
dan mid ((L+R)/2). Proses pengurutan / pertukaran data adalah pada
perulangan do-while nya. Tetapi hanya selama x < y do akan tetap
dijalankan
III.10 Kesimpulan
1. Sorting dalam C++ terdiri dari 5 macam sort yaitu Bubble Sort, Exchange
Sort, Insertion Sort, Selection Sort dan Quick Sort.
2. Sorting adalah pengelompokan sejumlah data yang tersusun secara acak
kemudian diurutkan secara Ascending maupun Descending
3. Selection Sort adalah metode dalam sorting pengurutan dengan cara
elemen terkecil atau terbesar, sesuai permintaan.
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
IV-1
BAB IV
SEARCHING
Jumlah Pertemuan
: 2 x 60 menit
Tujuan Praktikum
:
1. Praktikan dapat memahami pengertian dari Searching
2. Agar Praktika mengetahui dan memahami cara kerja dari system
Searching
3. Praktikan dapat mengoprasikan atau menerapkan metode
Searching
Alat / bahan
:
1. Perangkat komputer
2. Perangkat lunak: Dev C++
3. Modul Struktur Data 2019
IV.1 Landasan Teori
4.1 Pengertian
Algoritma pencarian (searching algorithm) adalah algoritma yang
menerima sebuah argumen kunci dan dengan langkah-langkah tertentu akan
mencari rekaman dengan kunci tersebut. Setelah proses pencarian
dilaksanakan, akan diperoleh salah satu dari dua kemungkinan, yaitu data
yang dicari berhasil ditemukan (successful) atau data yang kita cari tersebut
tidak berhasil ditemukan (unsuccessful).
Ada beberapa macam teknik pencarian seperti pencarian sekuensial
dan pencarian biner. Perbedaan dari dua teknik ini terletak pada keadaan data.
Pencarian sekuensial digunakan apabila data dalam keadaan acak atau tidak
terurut (contoh: sequential search). Sebaliknya, pencarian biner digunakan
pada data yang sudah dalam keadaan urut (contoh: Binary serach dan
interpolation search).
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
IV-2
4.2 Sequential Searching (Pencarian Berurutan)
Pencarian berurutan sering disebut pencarian linear merupakan
metode pencarian yang paling sederhana. Pencarian berurutan menggunakan
prinsip sebagai berikut : data yang ada akan dibandingkan satu per satu secara
berurutan dengan data yang dicari sampai data tersebut ditemukan atau tidak
ditemukan.
Pada dasarnya, pencarian ini hanya melakukan pengulangan dari 1
sampai dengan jumlah data. Pada setiap pengulangan, setiap data akan
dibandingkan dengan yang dicari. Apabila sama, berarti data telah ditemukan,
sebaliknya apabila sampai akhir pengulangan tidak ada data yang sama,
berarti data tidak ditemukan. Pada kasus yang paling buruk, apabila terdapat n
data maka harus dilakukan pencarian sebanyak n kali pula.
Algoritma pencarian Berurutan dapat dituliskan sebagai berikut :
1. i ← 0
2. Jika (data[i] = x) maka data ditemukan, melanjutkan ke langkah 3
3. Selama (i ≤ n) kerjakan langkah 4
4. i = j + 1, melanjutkan ke langkah ke 5
5. Kembali ke langkah 2
i = Posisi Data
x = Data yang dicari
n = Jumlah data yang tersedia
4.3 Binary Search
Salah satu syarat agar pencarian biner dapat dilakukan adalah data
yang tersedia sudah dalam keadaan urut. Dengan kata lain, apabila data belum
dalam keadaan urut, pencarian biner tidak dapat dilakukan. Dalam kehidupan
sehari-hari, sebenarnya kita juga sering menggunakan pencarian biner.
Misalnya saat ingin mencari suatu kata dalam kamus, Algoritma dari
pencarian biner dapat dijelaskan sebagai berikut :
IV-3
Inisialisasi awal :
Kiri = 0, Kanan = n (index terakhir dari array), flag = 0
1. Mengecek apakah (kiri <= kanan && flag 0)
- Jika ya, Ke langkah 2
- Jika tidak, Ke langkah 6
2. Menghitung nilai tengah = (kiri + kanan) / 2
3. Mengecek apakah cari == data [ tengah ]
- Jika ya, flag = 1. Ke langkah 6
- Jika tidak, Ke langkah 4
4. Mengecek apakah cari < data [ tengah ]
- Jika ya, Kanan = tengah – 1. Ke langkah 1
- Jika tidak ke langkah 5
5. Mengecek apakah cari > data [ tengah ]
- Jika ya, Kiri = tengah + 1. Ke langkah 1
- Jika tidak, Ke langkah 1
6. Mengecek apakah flag == 1
- Jika ya, data di temukan
- Jika tidak, data tidak ditemukan
4.4 Interpolation Search
Teknik ini dilakukan pada data yang sudah terurut berdasarkan kunci
tertentu. Teknik searching ini dilakukan dengan perkiraan letak data. Contoh
ilustrasi : jika kita hendak mencari suatu kata dalam buku telepon, misal yang
berawalan dengan huruf J, maka kita tidak akan mencarinya dari awal buku,
tetapi kita langsung membukanya pada 1/3 atau 1/4 dari tebal buku tersebut.
IV-4
Algoritma Interpolation Search :
1. Mengecek apakah ( cari >= data[low] && cari <= data[high])
- Jika ya, Ke langkah 2
- Jika tidak, Ke langkah 6
2. Mencari nilai posisi = cari – data[low] / data[high] – data[low] x
(high – low) + low, Pos = Pembulatan kebawah dari posisi
3. Mengecek apakah (data[pos] == cari)
- Jika ya, Flag = 1. Ke langkah 6
- Jika tidak, Ke langkah 4
4. Mengecek apakah (data[pos] > cari)
- Jika ya, High = pos – 1. Ke langkah 1
- Jika tidak, Ke langkah 5
5. Mengecek apakah (data[pos] < cari)
- Jika ya, low = pos + 1. Ke langkah 1
- Jika tidak, Ke langkah 1
6. Mengecek apakah (flag == 1)
- Jika ya, data ditemukan
- Jika tidak, data tidak ditemukan
IV.2 Langkah-langkah Praktikum
1. Script ditulis dengan menggunakan Dev C++
2. Script dicompile dengan menggunakan Dev C++
3. Aplikasi dijalankan dengan menggunakan Dev C++
IV-5
IV.3 Tugas Praktikum ke-1 : Program Implementasi Sequential Search
1. Listing Program :
#include <iostream>
using namespace std;
main(){
// Sequential Search
int data[8] = {1,5,34,56,-9,80,23,7};
int cari;
int index;
int flag = 0;
cout<<"+=================================+\n";
cout<<"\tPROGRAM SEARCHING\n";
cout<<"+=================================+\n\n";
cout<<"Data : ";
for(int a=0; a<8; a++){
cout<<data[a]<<" ";
}
cout<<endl<<endl;
cout<<"Masukkan data yang ingin dicari : ";cin>>cari;
cout<<endl;
for(int x=0; x<8; x++){
if(data[x] == cari){
flag = 1;
}
}
if(flag == 1){
cout<<"===================================\n";
cout<<"\tData Ditemukan\n";
cout<<"===================================\n";
}
else{
cout<<"===================================\n";
cout<<"\tData Tidak Ditemukan\n";
cout<<"===================================\n";
}
}
2. Tampilan Program :
Gambar 4.1 Program Implementasi Sequeantial Search
IV-6
3. Analisa Program :
Program
diatas
merupakan
program
searching
dengan
menggunakan metode Sequential Searching. Data cari akan dibandingkan
dengan data di setiap index. Pertama dibandingkan dengan data 1,
kemudian data 5 dan seterusnya hingga ke seluruh indeks.
IV.4 Tugas Praktikum ke-2 : Program Implementasi Binary Search
1. Listing Program :
#include <iostream>
using namespace std;
main(){
int data[10] = {11,24,38,46,58,64,78,88,89,95};
int cari, awal=0, akhir=9, tengah;
int flag = 0;
cout<<"+================================+ \n";
cout<<" PROGRAM SEARCHING \n";
cout<<"+================================+ \n\n";
cout<<"Data : ";
for(int a=0; a<=9;a++){
cout<<data[a]<< " ";
}
cout<<"\n\nMasukkan data yang dicari : ";
cin>>cari;
while (awal <= akhir && flag == 0){
tengah = (awal + akhir)/2;
if ( cari == data [ tengah ] ){
flag = 1;
break;
}
else if (cari < data[tengah]){
akhir= tengah - 1;
}
else if (cari > data[tengah] ){
awal = tengah + 1;
}
}
if ( flag == 1 ){
cout<<"\nData ditemukan "<<endl;
}
else{
cout<<"\nData tidak ditemukan "<<endl;
}
}
IV-7
2. Tampilan Program :
Gambar 4.2 Program Implementasi Binary Search
3. Analisa Program :
Program diatas adalah program searching menggunakan metode
Binary Search. Dapat dilakukan hanya jika data telah terirut seperti data
diatas. Data cari = 30, maka yang dilakukan Searching hanya pada data
sebelah kiri.
IV.5 Tugas Praktikum ke-3 : Program Implementasi Interpolation Search
1. Listing Program :
#include <iostream>
#include <cmath>
using namespace std;
main(){
int data[8] = {10,12,36,44,50,57,70,72};
int low, high, cari, pos, tanda = 0;
float pos1;
int N = 8;
low = 0;
high = N - 1;
cout << "Data : " << endl;
for (int x = 0; x <= 7; x++){
cout << "
" << data[x];
}
cout<<endl;
cout << "=================================" << endl;
cout << "Masukkan Data Yang Ingin Dicari : ";
cin >> cari;
do{
IV-8
pos1
=
((cari-data[low])/(data[high]data[low]))*((high - low)+low);
pos = floor(pos1); //pembulatan nilai kebawah
if (data[pos] == cari){
tanda = 1;
break;
}
if (data[pos] > cari){
high = pos - 1;
}
else if (data[pos] < cari ){
low = pos + 1;
}
}
while (cari >= data[low] && cari <= data[high]);
if (tanda == 1){
cout << ":: Data Ditemukan ::" << endl;
}
else{
cout << ":: Data Tidak Ditemukan :: " << endl;
}
}
2. Tampilan Program :
Gambar 4.3 Program Implementasi Interpolation Search
3. Analisa Program :
Program
diatas
merupakan
program
searching
dengan
menggunakan metode Interpolation Search. Variabel pos diatas digunakan
untuk pembulatan kebawah. Kemudian pos akan dibandingkan dengan
data cari (10), apabila data pos sama dengan 10. Maka tanda akan bernilai
1
IV-9
IV.6 Tugas Rumah ke-1 : Program Mencari Data Aslab
1. Listing Program :
#include <iostream>
using namespace std;
struct data{
int nim[10];
string nama[10];
int hasil_nim;
string hasil_nama;
};
data aslab;
main(){
int banyak_aslab;
int cari;
int flag = 0;
cout<<"\tLab Rpl ITN Malang"<<endl;
cout<<"Masukkan Data Aslab RPL"<<endl;
cout<<"Banyak Aslab : ";cin>>banyak_aslab;
cout<<"==================================="<<endl;
for(int a=0; a<banyak_aslab; a++){
cout<<"Data Aslab ke-"<<a+1<<endl;
cout<<"NIM\t: ";cin>>aslab.nim[a];
cout<<"NAMA\t: ";cin>>aslab.nama[a];
cout<<"----------------------\n";
}
cout<<endl;
cout<<"Masukkan NIM yang ingin dicari : ";
cin>>cari;
for(int n=0; n<banyak_aslab; n++){
if(aslab.nim[n] == cari){
flag = 1;
aslab.hasil_nim = aslab.nim[n];
aslab.hasil_nama = aslab.nama[n];
}
}
if(flag == 1){
cout<<"=============================\n";
cout<<"\tData ditemukan"<<endl;
cout<<"\t"<<aslab.hasil_nim<<"
"<<aslab.hasil_nama;
cout<<"\n=============================\n";
}
else if(flag == 0){
cout<<"=====================================\n";
cout<<"\tData tidak ditemukan"<<endl;
cout<<"=====================================\n";
}
}
IV-10
2. Tampilan Program :
Gambar 4.4 Program Mencari Data Aslab
3. Analisa Program :
Program diatas merupakan Searching, dibuat dengan menggunakan
metode Sequential Searching. Banyaknya aslab sifatnya dinamis,
tergantung pada berapa user menginputkan. Dalam Sequential Searching,
terdapat variabel flag untuk memberi tanda apakah data ditemukan atau
tidak. Data tiap indeks akan dibandingkan dengan data yang dicari.
Apabila data yang dicari ketemu, maka flag akan bernilai 1.
IV-11
IV.7 Kesimpulan
1. Searching dalam C++ terbagi menjadi 3 metode yaitu Sequential Search,
Binary Search dan Interpolation Search
2. Sequential Search adalah proses pencarian data dengan membandingkan
data yang ada satu per satu secara berurutan dengan data yang dicari
3. Binary Search dan Interpolation Search adalah metode Searching yang
bisa dilakukan hanya saat data telah diurutkan terlebih dahulu
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
V-1
BAB V
LINKED LIST
Jumlah Pertemuan
: 2 x 60 menit
Tujuan Praktikum
:
1. Praktikan dapat memahami pengertian dari linked list
2. Praktikan dapat mengetahui dan memahami cara kerja dari system
Linked List
3. Praktikan dapat mengoprasikan atau menerapkan metode Linked
List
Alat / bahan
:
1. Perangkat komputer
2. Perangkat lunak: Dev C++
3. Modul Struktur Data 2019
V.1 Landasan Teori
5.1 Pengertian
Linked list adalah sekumpulan elemen dari data yang bertipe sama
yang saling terurut dan terhubung dengan bantuan variabel pointer, yang
setiap data didalamnya disebut node ( simpul ) menempati alokasi memorat
secara dinamis dan biasanya berupa struct yang terdiri dari beberapa field.
Linked list juga merupakan suatu cara untuk menyimpan data dengan struktur
sehingga dapat secara otomatis menciptakan suatu tempat baru untuk
menyimpan data yang diperlukan
Perbandingan Array dengan Linked List
Array
Linked List
Statis
Dinamis
Penambahan / Penghapusan data Penmbahan / Penghapusan data tidak
terbatas
terbatas
Penghapusan
mungkin
Array
tidak Penghapusan Linked List mudah
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
V-2
5.2 Single Linked List
Single linked list merupakan linked list yang field pointer-nya hanya
satu buah saja dan satu arah. Serta pada akhir node, pointernya menunjuk
NULL.
5.2.1 Jenis Single Linked List
1. Single Linked list dengan head
2. Single Linked list dengan head dan tail
5.2.2 Deklarasi Single Linked List
1. Deklarasi Node
Pendeklarasian Node pada single link list menggunakan
struct dengan 2 buah field, yaitu field untuk menyimpan data
dan field yang bertipe pointer dari untuk menyimpan alamat
dari node selanjutnya. Setelah itu membuat variabel yang
bernama node yang digunakan kunci untuk mengakses struct
TNode.
Struct Node{
int data;
Node *next;
};
2. Pembuatan Node baru
Node *baru;
baru=new Node;
baru->data=databaru;
baru->next=NULL
Penjelasan :
Keyword new berguna untuk mempersiapkan sebuah node
baru beserta alokasi memorinya, kemudian node tersebut diisi
data dan pointer nextnya ditunjuk ke NULL.
V-3
5.3 Double Linked List
Double linked list adalah linked list yang filed pointernya 2 arah, ke
node sebelum dan sesudahnya. Double linked list memiliki 3 buah field dalam
1 node yaitu, 1 untuk menyimpan data dan 2 untuk pointer ( next dan prev ).
Pointer next menunjuk pada node setelahnya dan prev menunjuk pada node
sebelumnya.
5.3.1 Jenis Double Linked List
1. Double Linked List menggunakan Head
2. Double Linked List menggunakan Head dan Tail
5.3.2 Deklarasi Double Linked List
1. Deklarasi Node
struct Node{
int data;
Node *next;
Node *prev;
}
2. Pembuatan Node baru
Node *baru;
baru=new Node;
baru->data=databaru;
baru->next=NULL;
baru->prev=NULL
V.2 Langkah-langkah Praktikum
1. Script ditulis dengan menggunakan Dev C++
2. Script dicompile dengan menggunakan Dev C++
3. Aplikasi dijalankan dengan menggunakan Dev C++
V-4
V.3 Tugas Praktikum ke-1 : Single Linked List
1. Listing Program :
#include <iostream>
using namespace std;
struct Node{
int data;
Node *next;
};
Node *head;
int cek(){
if(head==NULL){
return 0;
}
else{
return 1;
}
}
void tambahdepan(int databaru){
Node *baru;
baru=new Node;
baru->data=databaru;
baru->next=NULL;
if (cek==0){
head=baru;
head->next=NULL;
}
else{
baru->next=head;
head=baru;
}
cout<<"Penambahan Data Berhasil \n"<<endl;
}
void tambahbelakang(int databaru){
Node *baru;
Node *temp;
baru=new Node;
baru->data=databaru;
baru->next=NULL;
if(cek()==0){
head=baru;
head->next=NULL;
}
else{
temp=head;
while (temp->next!=NULL){
temp=temp->next;
}
temp->next=baru;
}
cout<<"Penambahan Data Berhasil \n"<<endl;
V-5
}
void hapusDepan(){
Node *hapus;
int cap;
if (cek()==1){
if(head->next != NULL){
hapus = head;
cap = hapus->data;
head = head->next;
delete hapus;
}
else{
cap = head->data;
head = NULL;
}
cout<<"Data "<<cap<<" terhapus\n\n";
}
else cout<<"Masih kosong\n";
}
void hapusBelakang(){
Node *hapus,*temp;
int cap;
if (cek()==1){
if(head->next != NULL){
temp = head;
while(temp->next->next!=NULL){
temp = temp->next;
}
hapus = temp->next;
cap = hapus->data;
temp->next = NULL;
delete hapus;
}
else{
cap = head->data;
head = NULL;
}
cout<<"Data "<<cap<<" terhapus\n\n";
}
else cout<<"Masih kosong\n";
}
void tampil(){
Node *temp;
temp=head;
if (cek==0){
cout<<"Data Masih Kosong";
}
else if(temp==NULL){
cout<<"Data Masih Kosong"<<endl;
}
else{
while(temp!=NULL){
cout<<temp->data<<" ";
temp=temp->next;
}
}
V-6
}
main(){
int pilihan, data;
do{
cout<<"Single Linked List dengan Head"<<endl;
cout<<"1. Masukkan Data dari Depan"<<endl;
cout<<"2. Masukkan Data dari Belakang"<<endl;
cout<<"3. Hapus Data dari Depan"<<endl;
cout<<"4. Hapus Data dari Belakang"<<endl;
cout<<"5. Tampilkan Data"<<endl;
cout<<"6. Keluar"<<endl;
cout<<"Masukkan Pilihan Anda : ";
cin>>pilihan;
if (pilihan == 1 ){
cout<<"Masukkan Data = ";
cin>>data;
tambahdepan(data);
}
else if (pilihan == 2 ){
cout<<"Masukkan Data = ";
cin>>data;
tambahbelakang(data);
}
else if (pilihan == 3 ){
hapusDepan();
cout<<endl;
}
else if (pilihan == 4 ){
hapusBelakang();
cout<<endl;
}
else if (pilihan == 5 ){
tampil();
cout<<endl<<endl;
}
else if (pilihan == 6 ){
cout<<"Keluar dari program";
}
else{
cout<<"Pilihan tidak tersedia... \n\n";
}
}
while(pilihan!=6);
}
V-7
2. Tampilan Program :
Gambar 5.1 Program Single Linked List
3. Analisa Program :
Fungsi cek digunakan untuk mengecek apakah head bernilai NULL
atau tidak. Akan mereturnkan 0 jika head = NULL dan akan mereturnkan
1 jika head tidak NULL / ada isinya. Struct Node berisi elemen int data
dan *next dengan tipe data Node.
V.4 Tugas Praktikum ke-2 : Double Linked List Input Data
1. Listing Program :
#include <iostream>
using namespace std;
struct Node
{
int data;
Node *next;
Node *prev;
};
Node *head;
V-8
int cek()
{
if(head == NULL)
{
return 0;
}
else
{
return 1;
}
}
void tambahdepan(int databaru)
{
Node *baru;
baru = new Node;
baru->data = databaru;
baru->next = NULL;
baru->prev = NULL;
if(cek()==0)
{
head=baru;
head->next = NULL;
head->prev = NULL;
}
else
{
baru->next = head;
head->prev = baru;
head = baru;
}
cout<<"Data ditambahkan \n"<<endl;
}
main()
{
int pilihan, data;
do
{
cout<<"Double Linked List Dengan Head"<<endl;
cout<<"1. Masukkan Data dari Depan"<<endl;
cout<<"2. Keluar"<<endl;
cout<<"Masukkan Pilihan Anda = "; cin>>pilihan;
if (pilihan == 1)
{
cout<<"Masukkan Data = "; cin>>data;
tambahdepan(data);
}
else if(pilihan ==2)
{
cout<<"keluar dari program...";
}
else
{
cout<<"pilihan tidak tersedia... \n\n";
}
}
while(pilihan!=2);
}
V-9
2. Tampilan Program :
Gambar 5.2 Program Double Linked List Input Data
3. Analisa Program
Pertama – tama membuat sebuah fungsi cek yang digunakan untuk
mengecek apakah head berisi data atau NULL. Kemudian membuat fungsi
tambahdepan untuk memasukkan data. Pada fungsi main pilihan 1 berisi
fungsi tambahdepan yang telah dibuat sebelumnya
V.5 Tugas Rumah ke-1 : Menampilkan Hubungan Orang tua Anak
1. Listing Program :
#include <iostream>
using namespace std;
struct Node{
string data;
Node *next;
};
Node *head;
V-10
int cek(){
if(head==NULL){
return 0;
}
else{
return 1;
}
}
void tambahdepan(string databaru){
Node *baru;
baru=new Node;
baru->data=databaru;
baru->next=NULL;
if (cek==0){
head=baru;
head->next=NULL;
}
else{
baru->next=head;
head=baru;
}
cout<<"Berhasil diinput\n"<<endl;
}
void tambahbelakang(string databaru){
Node *baru;
Node *temp;
baru=new Node;
baru->data=databaru;
baru->next=NULL;
if(cek()==0){
head=baru;
head->next=NULL;
}
else{
temp=head;
while (temp->next!=NULL){
temp=temp->next;
}
temp->next=baru;
}
cout<<"Berhasil diinput\n"<<endl;
}
void hapusDepan(){
Node *hapus;
string cap;
if (cek()==1){
if(head->next != NULL){
hapus = head;
cap = hapus->data;
head = head->next;
delete hapus;
}
else{
cap = head->data;
head = NULL;
V-11
}
cout<<cap<<" terhapus\n\n";
}
else cout<<"Masih kosong\n";
}
void hapusBelakang(){
Node *hapus,*temp;
string cap;
if (cek()==1){
if(head->next != NULL){
temp = head;
while(temp->next->next!=NULL){
temp = temp->next;
}
hapus = temp->next;
cap = hapus->data;
temp->next = NULL;
delete hapus;
}
else{
cap = head->data;
head = NULL;
}
cout<<cap<<" terhapus\n\n";
}
else cout<<"Masih kosong\n";
}
void tampil(){
Node *temp;
temp=head;
if (cek==0){
cout<<"Data Masih Kosong";
}
else if(temp==NULL){
cout<<"Data Masih Kosong"<<endl;
}
else{
while(temp!=NULL){
cout<<temp->data<<"-->";
temp=temp->next;
}
}
}
main(){
int pilihan;
string data;
do{
cout<<"Program Hubungan Orang Tua Anak"<<endl;
cout<<"1. Masukkan dari Depan"<<endl;
cout<<"2. Masukkan dari Belakang"<<endl;
cout<<"3. Hapus dari Depan"<<endl;
cout<<"4. Hapus dari Belakang"<<endl;
cout<<"5. Tampilkan"<<endl;
cout<<"6. Keluar"<<endl;
cout<<"Masukkan Pilihan Anda : ";
cin>>pilihan;
V-12
if (pilihan == 1 ){
cout<<"Masukkan Nama = ";
cin>>data;
tambahdepan(data);
}
else if (pilihan == 2 ){
cout<<"Masukkan Nama = ";
cin>>data;
tambahbelakang(data);
}
else if (pilihan == 3 ){
hapusDepan();
cout<<endl;
}
else if (pilihan == 4 ){
hapusBelakang();
cout<<endl;
}
else if (pilihan == 5 ){
tampil();
cout<<endl<<endl;
}
else if (pilihan == 6 ){
cout<<"Keluar dari program";
}
else{
cout<<"Pilihan tidak tersedia... \n\n";
}
}
while(pilihan!=6);
}
2. Tampilan Program :
Gambar 5.3 Program Menampilkan Hubungan Orang tua Anak
V-13
3. Analisa Program :
Pertama tama membuat beberapa procedure dengan nama
tambahdepan, tambahbelakang, hapusdepan, hapus belakang dan tampil.
Procedure
tambahdepan
dipanggil
saat
user
menginputkan
1,
tambahbelakang dipanggil saat user menginputkan 2, hapusdepan saat
menginputkan 3, hapusbelakang saat menginputkan 4 dan tampil saat
menginputkan 5.
V.6 Tugas Rumah ke-2 : Implementasi Double Linked List
1. Listing Program :
#include <iostream>
using namespace std;
struct Node
{
int data;
Node *next;
Node *prev;
};
Node *head;
int cek()
{
if(head == NULL)
{
return 0;
}
else
{
return 1;
}
}
void tambahdepan(int databaru)
{
Node *baru;
baru = new Node;
baru->data = databaru;
baru->next = NULL;
baru->prev = NULL;
if(cek()==0)
{
head=baru;
head->next = NULL;
head->prev = NULL;
}
else
{
V-14
baru->next = head;
head->prev = baru;
head = baru;
}
cout<<"Data ditambahkan \n"<<endl;
}
void tambahbelakang (int databaru)
{
Node *baru,*temp;
baru = new Node;
baru->data = databaru;
baru->next = NULL;
baru->prev = NULL;
if(cek()==0)
{
head=baru;
head->next = NULL;
head->prev = NULL;
}
else
{
temp=head;
while(temp->next!=NULL)
{
temp=temp->next;
}
temp->next = baru;
baru->prev = temp;
}
cout<<"Data ditambahkan \n" << endl;
}
void tampil()
{
Node *temp; temp = head;
if(cek()==1)
{
while(temp!=NULL)
{
cout<<temp->data<< ends;
temp=temp->next;
}
cout<<endl<<endl;
}
else cout<<"Tidak ada data \n" << endl;
}
void hapusdepan()
{
Node *hapus;
int cap;
if (cek()==1)
{
if(head->next != NULL)
{
hapus = head;
cap = hapus->data;
head = head->next;
V-15
head->prev = NULL;
delete hapus;
}
else
{
cap = head->data;
head = NULL;
}
cout<<"Data "<<cap<<" terhapus" << endl;
}
else
{
cout<<"Tidak ada data \n" << endl;
}
}
void hapusbelakang()
{
Node *hapus;
int cap;
if (cek()==1)
{
if(head->next != NULL)
{
hapus = head;
while(hapus->next!=NULL)
{
hapus = hapus->next;
}
cap = hapus->data;
hapus->prev->next = NULL;
delete hapus;
}
else
{
cap = head->data;
head = NULL;
}
cout<<"Data "<<cap<<" terhapus\n";
}
else
{
cout<<"Tidak ada data \n";
}
}
main()
{
int pilihan, data;
do
{
cout<<"Double Linked List Dengan Head"<<endl;
cout<<"1. Masukkan Data dari Depan"<<endl;
cout<<"2. Masukkan Data dari Belakang"<<endl;
cout<<"3. Tampilkan Data"<<endl;
cout<<"4. Hapus Data dari Depan"<<endl;
cout<<"5. Hapus Data dari Belakang"<<endl;
cout<<"6. Keluar"<<endl;
cout<<"Masukkan Pilihan Anda = "; cin>>pilihan;
V-16
if (pilihan == 1)
{
cout<<"Masukkan Data = "; cin>>data;
tambahdepan(data);
}
else if(pilihan ==2)
{
cout<<"Masukkan Data = "; cin>>data;
tambahbelakang(data);
}
else if(pilihan ==3)
{
tampil();
}
else if(pilihan ==4)
{
hapusdepan();
cout<<endl;
}
else if(pilihan ==5)
{
hapusbelakang();
cout<<endl;
}
else if(pilihan ==6)
{
cout<<"keluar dari program...";
}
else
{
cout<<"pilihan tidak tersedia... \n\n";
}
}
while(pilihan!=6);
}
2. Tampilan Program :
Gambar 5.4 Program Implementasi Double Linked List
V-17
3. Analisa Program :
Program diatas merupakan Double Linked List. Dalam struct Node
terdapat elemen int data, *next dan *prev yang menggunakan tipe data
Node. Di dalam fungsi main, dibuat menu pilihan menggunakan
perulangan do-while yang setiap menunya sudah berisi procedure nya
masing – masing.
V.6 Kesimpulan
1. Linked List terbagi menjadi 2 yaitu Single Linked List, yang hanya
memiliki data dan *next pada Node dan Double Linked List, yang
memiliki *prev, data dan *next pada Node.
2. Linked List adalah sekumpulan elemen dari data yang bertipe sama yang
saling terurut dan terhubung dengan bantuan variabel pointer
3. Linked List dengan Array merupakan 2 hal yang berbeda. Contoh
perbedaannya adalah Array bersifat Statis sedangkan Linked List bersifat
dinamis
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
VI-1
BAB VI
TREE
Jumlah Pertemuan
: 2 x 60 menit
Tujuan Praktikum
:
1. Praktikan dapat memahami Pengertian dari Tree
2. Praktikan mengetahui dan memahami cara kerja dari system Tree
3. Praktikan dapat mengoprasikan atau menerapkan metode Tree
Alat / bahan
:
1. Perangkat komputer
2. Perangkat lunak: Dev C++
3. Modul Struktur Data 2019
VI.1 Landasan Teori (Tree)
6.1 Pengertian Tree
Tree merupakan salah satu bentuk struktur data tidak linear yang
menggambarkan hubungan yng bersifat hirarkis (hubungan one to many)
antara elemen – elemen. Tree bisa didefinisikan sebagai kumpulan node yang
saling terhubung satu sama lain dalam suatu kesatuan yang membentuk
layaknya struktur sebuah pohon. Struktur pohon adalah suatu cara
mempresentasikan suatu struktur hirarki (one to many) secara grafis yang
mirip sebuah pohon, walaupun pohon tersebut hanya tampak sebagai
kumpulan node – node dari atas ke bawah. Suatu struktur data yang tidak
linier yang menggambarkan hubungan yang hirarkis (one to many) dan tidak
linier antara elemen – elemennya.
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
VI-2
6.2 Istilah Dalam Tree
Istilah – istilah dalam Tree
Predecesor
Node yang berada diatas node tertentu
Successor
Node yang berada di bawah node tertentu
Ancestor
Seluruh node yang terletak sebelum node
tertentu dan terletak pada jalur yang sama
Descendant
Seluruh node yang terletak setelah node
tertentu dan terletak pada jalur yang sama
Parent
Predecessor satu level di atas suatu node
Child
Sucessor satu level di bawah suatu node
Sibling
Node – node yang memiliki parent yang sama
Subtree
Suatu node beserta descendantnya
Size
Banyaknya node dalam suatu tree
Height
Banyaknya tingkatan dama suatu tree
Root
Node khusus yang tidak memiliki predecessor
Leaf
Node – node dalam tree yang i=tidak memiliki
successor
Degree
Banyaknya child dalam suatu node
6.3 Binary Tree
Binary Tree adalah tree dengan syarat bahwa tiap node hanya boleh
memiliki maksimal dua subtree dan kedua subtree tersebut harus terpisah.
Sesuai dengan definisi tersebut tiap node dalam binary tree hanya boleh
memiliki paling banyak dua child.
VI-3
Jenis – jenis binary tree :
a) Full Binary Tree
Binary Tree yang tiap nodenya (kecuali leaf) memiliki dua
child dan tiap subtree harus mempunyai panjang path yang sama.
b) Complete Binary Tree
Mirip dengan Full Binary Tree, namun tiap subtree boleh
memiliki panjang path berbeda. Node kecuali leaf memiliki 0 atau
2 child.
c) Skewed Binary Tree
Yakni Binary Tree yang semua nodenya (kecuali leaf)
hanya memiliki satu child.
6.4 Binary Search Tree
Binary Search Tree adalah Binary Tree dengan sifat bahwa semua left
child harus lebih kecil daripada right child dan parentnya, Juga semua right
child harus lebih besar dari left child serta parentnya. Binary Search Tree
dibuat untuk mengatasi kelemahan pada binary tree biasa, yaitu kesulitan
dalam searching / pencarian node tertentu dalam binary tree.
6.5 Operasi – operasi pada Tree
a) Create
: Membentuk binary tree baru yang masih kosong
b) Clear
: Mengosongkan binary tree yang sudah ada
c) Empty
: Function untuk memeriksa apakah binary tree
masih kosong
d) Insert
: Memasukkan sebuah node ke dalam tree. Ada tiga
pilihan insert : sebagai root, left child atau right
child. Khusus insert sebagai root, tree harus dalam
keadaan kosong.
VI-4
e) Find
: Mencari root, parent, left child atau right child dari
suatu node. (Tree tak boleh kosong)
f) Update
: Mengubah isi dari node yang ditunjuk oleh pointer
current. (Tree tidak boleh kosong)
g) Retrieve
: Mengetahui isi dari node yang ditunjuk pointer
current. (Tree tidak boleh kosong).
h) DeleteSub
: Menghapus sebuah subtree (node beserta seluruh
descendantnya) yang ditunjuk current. Tree tak
boleh kosong. Setelah itu pointer current akan
berpindah ke parent dari node yang dihapus.
i) Characteristic
: Mengetahui karakteristik dari suatu tree, yakni :
size, height, serta average lenghtnya. Tree tidak
boleh kosong.
j) Traverse
: Mengunjungi seluruh node – node pada tree,
masing – masing sekali. Hasilnya adalah urutan
informasi secara linier yang tersimpan dalam tree
VI.2 Langkah-Langkah Praktikum
1. Script ditulis dengan menggunakan Dev C++
2. Script dicompile dengan menggunakan Dev C++
3. Aplikasi dijalankan dengan menggunakan Dev C++
VI.3 Tugas Praktikum ke-1 : Tree
1. Listing Program :
//header
#include
#include
#include
file
<stdio.h>
<conio.h>
<stdlib.h>
//pendeklarasian struct sebuah tree awal
struct Node{
int data;
Node *kiri;
VI-5
Node *kanan;
};
//fungsi untuk menambahkan node baru
void tambah(Node **root, int databaru)
{
//jika root masih kosong
if((*root) == NULL)
{
//pembuatan node baru
Node *baru;
//pengalokasian memori dari node yang telah
dibuat
baru = new Node;
//inisialisasi awal node yang baru dibuat
baru->data = databaru;
baru->kiri = NULL;
baru->kanan = NULL;
(*root) = baru;
(*root)->kiri = NULL;
(*root)->kanan = NULL;
printf("Data bertambah!");
}
//jika data yang akan dimasukkan lebih kecil daripada
elemen root, maka akan diletakkan di node sebelah kiri.
else if(databaru<(*root)->data)
tambah(&(*root)->kiri, databaru);
//jika data yang akan dimasukkan lebih besar daripada
elemen root, maka akan diletakkan di node sebelah kanan
else if(databaru>(*root)->data)
tambah(&(*root)->kanan, databaru);
//jika saat dicek data yang akan dimasukkan memiliki
nilai yang sama dengan data pada root
else if(databaru == (*root)->data)
printf("Data sudah ada!");
}
//fungsi yang digunakan untuk mencetak tree secara preOrder
void preOrder(Node *root)
{
if(root != NULL){
printf("%d ", root->data);
preOrder(root->kiri);
preOrder(root->kanan);
}
}
//fungsi yang digunakan untuk mencetak tree secara inOrder
void inOrder(Node *root)
{
if(root != NULL){
inOrder(root->kiri);
printf("%d ", root->data);
inOrder(root->kanan);
}
}
//fungsi yang digunakan untuk mencetak tree secara postOrder
void postOrder(Node *root)
VI-6
{
if(root != NULL){
postOrder(root->kiri);
postOrder(root->kanan);
printf("%d ", root->data);
}
}
//fungsi utama
int main()
{
//deklarasikan variabel
int pil, data;// c;
Node *pohon; //*t;
pohon = NULL; //inisialisasi node pohon
//perulangan do-while
do
{
system("cls"); //bersihkan layar
printf("\t#PROGRAM TREE C++#");
printf("\n\t==================");
printf("\nMENU");
printf("\n----\n");
printf("1. Tambah\n");
printf("2. Lihat pre-order\n");
printf("3. Lihat in-order\n");
printf("4. Lihat post-order\n");
printf("5. Exit\n");
printf("Pilihan : ");
scanf("%d", &pil);
switch(pil)
{
//jika pil bernilai 1
case 1 :
printf("\nINPUT : ");
printf("\n-------");
printf("\nData baru : ");
scanf("%d", &data);
//panggil fungsi untuk menambah node yang
berisi data pada tree
tambah(&pohon, data);
break;
//jika pil bernilai 2
case 2 :
printf("\nOUTPUT PRE ORDER : ");
printf("\n------------------\n");
if(pohon!=NULL)
//panggil fungsi untuk mencetak
secara preOrder
preOrder(pohon);
else
printf("Masih kosong!");
break;
//jika pil bernilai 3
case 3 :
printf("\nOUTPUT IN ORDER : ");
printf("\n------------------\n");
data
VI-7
if(pohon!=NULL)
//panggil fungsi
untuk
mencetak
data
secara inOrder
inOrder(pohon);
else
printf("Masih kosong!");
break;
//jika pil bernilai 4
case 4 :
printf("\nOUTPUT POST ORDER : ");
printf("\n------------------\n");
if(pohon!=NULL)
//panggil fungsi untuk mencetak data
secara postOrder
postOrder(pohon);
else
printf("Masih kosong!");
break;
}
_getch();
}while(pil != 5); //akan diulang jika input tidak
samadengan 5
return EXIT_FAILURE;
}
2. Tampilan Program :
Gambar 6.1 Program Tree
3. Analisa Program
Pada Program Tree diatas dideklarasikan beberapa fungsi yakni
fungsi tambah untuk melakukan penambahan node pada Tree. Fungsi pre
order untuk mengunjungi node secara pre-Order sekaligus mencetak isi
node yang telah dikunjungi dari kunjungan yang pertama. Fungsi inOrder
VI-8
untuk mengunjungi node secara in-Order sekaligus mencetak isi node
yang telah dikunjungi secara urut mulai dari kunjungan pertama. Fungsi
postOrder untuk mengunjungi node secara post-Order
VI.4 Tugas Rumah ke-1 : Program Implementasi Tree
1. Listing Program :
#include <iostream>
using namespace std;
class BinarySearchTree{
private:
struct tree_node{
tree_node* left;
tree_node* right;
int data;
};
tree_node* root;
public:
BinarySearchTree(){
root = NULL;
}
bool
void
void
void
};
isEmpty() const { return root==NULL; }
print_preorder();
preorder(tree_node*);
insert(int);
// Smaller elements go left
// larger elements go right
void BinarySearchTree::insert(int d){
tree_node* t = new tree_node;
tree_node* parent;
t->data = d;
t->left = NULL;
t->right = NULL;
parent = NULL;
// is this a new tree?
if(isEmpty()) root = t;
else{
//Note: ALL insertions are as leaf nodes
tree_node* curr;
curr = root;
// Find the Node's parent
while(curr){
parent = curr;
if(t->data > curr->data)
curr = curr->right;
else
curr = curr->left;
}
if(t->data < parent->data)
VI-9
parent->left = t;
else
parent->right = t;
}}
void BinarySearchTree::print_preorder(){
preorder(root);
}
void BinarySearchTree::preorder(tree_node* p){
if(p != NULL){
cout<<" "<<p->data<<" ";
if(p->left) preorder(p->left);
if(p->right) preorder(p->right);
}
else return;
}
int main(){
BinarySearchTree b;
int ch,tmp;
while(1){
cout<<endl<<endl;
cout<<" Binary Search Tree Operations "<<endl;
cout<<" ----------------------------- "<<endl;
cout<<" 1. Insertion/Creation "<<endl;
cout<<" 2. Pre-Order Traversal "<<endl;
cout<<" 3. Exit "<<endl;
cout<<" Enter your choice : ";
cin>>ch;
switch(ch){
case 1 : cout<<" Enter Number to be inserted : ";
cin>>tmp;
b.insert(tmp);
break;
case 2 : cout<<endl;
cout<<" Pre-Order Traversal "<<endl;
cout<<" -------------------"<<endl;
b.print_preorder();
break;
case 3 :
return 0;
}}}
VI-10
2. Tampilan Program :
Gambar 6.2 Program Implementasi Tree
3. Analisa Program :
Pada Program Tree diatas terdapat beberapa fungsi diantaranya
adalah fungsi insert yang digunakan untuk memasukkan / membuat node
pada Tree, dan fungsi preorder yang digunakan untuk menampilkan data –
data yang telah diinputkan oleh user tadi.
4. Notasi Kurung
( 5 ( 3 ) ( 9 ( 8 , 10 ) ) )
VI-11
5. Notasi Tingkat
5
3
9
8
10
Gambar 6.3 Notasi Tingkat Program Implementasi Tree
6. Diagram Venn
5
9
3
8
10
Gambar 6.4 Diagram Venn Program Implementasi Tree
VI-12
VI.5 Kesimpulan
1. Tree adalah Kumpulan node yang saling terhubung satu sama lain dalam
suatu kesatuan yang membentuk layaknya struktur sebuah pohon.
2. Beberapa jenis Tree antara lain Binary Tree, Full Binary Tree, Complete
Binary Tree dan Skewed Binary Tree
3. Binary Tree adalah Tree dengan syarat bahwa tiap node hanya boleh
memiliki maksimal dua sub pohon dan edua sub pohon harus terpisah
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
VII-1
BAB VII
KESIMPULAN
1. Pointer adalah sebuah variabel yang meyimpan alamat memory, untuk
mendapatkan alamat dari sebuah variabel adalah dengan menggunakan
operator &, sedangkan untuk memanggil data yang ada di alamat tersebut
adalah menggunakan operator *
2. Konsep dari Stack adalah LIFO (Last In First Out) yaitu data yang terakhir
dimasukkan adalah data yang pertama keluar dan data yang pertama
dimasukkan adalah data yang terakhir keluar
3. Sorting dalam C++ terdiri dari 5 macam sort yaitu Bubble Sort, Exchange
Sort, Insertion Sort, Selection Sort dan Quick Sort
4. Searching dalam C++ terbagi menjadi 3 metode yaitu Sequential Search,
Binary Search dan Interpolation Search
5. Linked List terbagi menjadi 2 yaitu Single Linked List, yang hanya memiliki
data dan *next pada Node dan Double Linked List, yang memiliki *prev,
data dan *next pada Node.
6. Tree adalah Kumpulan node yang saling terhubung satu sama lain dalam
suatu kesatuan yang membentuk layaknya struktur sebuah pohon
Disetujui Aslab
Muh. Fitra Rizki
Tgl:
Ttd / Paraf
VII-2
DAFTAR PUSTAKA
Modul Struktur Data, Lab. Rekayasa Perangkat Lunak. ITN Malang, 2019.
Zan 2018, Pengertian Pointer (https://www.belajarcpp.com/tutorial/cpp/pointer/),
diakses pada 30 Maret 2019
Rahmat
Subekti
2016,
Implementasi
Stack
di
C++
(https://bekti.net/blog/implementasi-stack-di-cpp/), diakses pada 15 April 2019
Matheus Rumetna 2017, Contoh Program Sederhana Sorting ‘Straight Insertion
Sort’
(https://matheusrumetna.com/2017/02/11/contoh-program-sederhana-
sorting-straight-insertion-sort/), diakses pada 30 April 2019
Admin
Sarjana
2019,
Belajar
C++
Part
6
Searching
(http://www.sarjanapedia.com/2019/02/metode-searching-dalam-cpp.html),
diakses pada 2 Mei 2019
Rachmat Santoso 2014, Tree pada C++ (http://www.nblognlife.com/2014/12/treepada-c-tree-awal.html), diakses pada 18 Mei 2019
Rachmat
Santoso
2014,
Single
Linked
List
pada
C++
(http://www.nblognlife.com/2014/12/single-linked-list-pada-c.html), diakses pada
18 Mei 2019
LABORATORIUM PEMROGRAMAN & RPL
INSTITUT TEKNOLOGI NASIONAL
Kampus II : Jl. Raya Karanglo Km. 2 Malang
LEMBAR ASISTENSI PRAKTIKUM STRUKTUR DATA
SEMESTER GENAP TAHUN AKADEMIK 2018/2019
Nama
NIM
Kelompok
FOTO
3x4
: Febryan Alfaridzi
: 1818057
: 25
(Menggunaka
n Jas
Almamater)
Asistensi
No.
Tanggal
Paraf
Instruktur
Konsep
Hasil Akhir
Pointer, Struct, Rekursif
Stack, Queue
Sorting
Searching
Linked List
Tree
Dosen
1
Program
2
Batas Akhir:
Asisten,
Malang, … Mei 2019
Dosen, Pembimbing,
(Muh. Fitra Rizki)
(Hani Zulfia Zahro’, S.Kom, M.Kom)
NIP.P. 1031500480
Related papers
GLEZER; VIEIRA. Armamentismo inconstitucional
35 anos de Constituição: uma nação em evolução, 2023
English translation of: MANIPULATION DE L'IMAGE DU TURC DANS LES CONFLITS ENTRE LA MONARCHIE ET LA NOBLESSE À L'AUBE DE L'ANCIEN RÉGIME
Le Verger-Bouquet, 2015
Idolatrías en las frágiles fronteras nororientales del virreinato de la Nueva Granada, 1746-1764 Natalia Silva Prada (Ejemplar dedicado a: Julio-Diciembre; I-III)
Autoctonía: Revista de Ciencias Sociales e Historia, ISSN-e 0719-8213, Vol. 6, 2022
Identifikasi Kesulitan Peserta Didik Dalam Belajar Matematika Dan Sains DI Sekolah Dasar
Jurnal Kependidikan, 2011
Neoliberalizm nieograniczający i ekonomia społeczna
Ekonomia Społeczna, 2012
Alpine jades in the European Neolithic
HAL (Le Centre pour la Communication Scientifique Directe), 2016
CITIES OF THE DELTA ON THE MOSAIC OF THE CHURCH OF ST STEPHEN, UMM EL-RASAS, JORDAN
The Delta Survey Workshop: Proceedings from Conferences held in Alexandria (2017) and Mansoura (2019), 2022
Call for Chapters: Edited Volume on Transpacific Cultural Exchanges
Transpacific Cultural Exchanges
Missionary Linguistic Studies from Mesoamerica to Patagonia
Missionary Linguistic Studies from Mesoamerica to Patagonia, 2020
Factors Affecting Customer Satisfaction and Loyalty in Online Food Delivery Service during the COVID-19 Pandemic: Its Relation with Open Innovation
Journal of Open Innovation: Technology, Market, and Complexity
Parameters affecting the reduction factor in pedestrian load model based on pulsating stationary force
Istrazivanja i projektovanja za privredu, 2015
PLTOOL: A knowledge engineering tool for planning and learning
The Knowledge Engineering Review, 2007
Os Professores e O Cotidiano Escolar: Múltiplos Desafios, Múltiplos Caminhos
Nuances: estudos sobre Educação, 2011
Pendampingan UKM Permata Samudra dalam Pengelolaan Usaha Pembuatan Produk Ikan Asin
Jurnal Abdimas Mahakam, 2020
Dose-response in a high density three-dimensional liver device with real-time bioenergetic and metabolic flux quantification
Toxicology in Vitro, 2017
Assessing clinical applicability of COVID-19 detection in chest radiography with deep learning
Scientific Reports, 2022
Melhoria da eficiência energética de condicionadores de ar utilizando sistemas embarcados / Improving the energy efficiency of air conditioners using embedded systems
Brazilian Journal of Development, 2021
Free radical routes for prebiotic formation of DNA nucleobases from formamide
Physical Chemistry Chemical Physics, 2013