Struktur Data

LAPORAN PRAKTIKUM
STRUKTUR DATA
SEMESTER GENAP TAHUN AKADEMIK 2018/2019
Disusun oleh :
Nama : Febryan Alfaridzi

NIM : 1818057
Prodi : TEKNIK INFORMATIKA S1
Kelompok : 25
PROGRAM STUDI TEKNIK INFORMATIKA S-1

FAKULTAS TEKNOLOGI INDUSTRI
INSTITUT TEKNOLOGI NASIONAL MALANG
2019
LEMBAR PERSETUJUAN
PRAKTIKUM STRUKTUR DATA
Disusun Oleh
NAMA : Febryan Alfaridzi
NIM : 1818057
PRODI : TEKNIK INFORMATIKA S-1
Mengetahui, Menyetujui,
Kepala Laboratorium Dosen Pembimbing
Rekayasa Perangkat Lunak
(Ali Mahmudi,B.Eng,.PhD) (Hani Zulfia Zahro’, S.kom,M.kom)

NIP.P.1031000429 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 Ttd / Paraf
Muh. Fitra Rizki
Tgl:
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 Pointer
Berisi data/nilai 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

#include <iostream>
#include <cstdlib>
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

#include <iostream>
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
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

#include <iostream>
main(){
int x,*y,*z;
x=1;
y=&x;
z=&x;
cout<<y<<endl;
cout<<*y<<endl;
cout<<z<<endl;
cout<<*z<<endl;
}
Gambar 1.4 Program Implementasi Pointer
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

#include <iostream>
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+";
}
mhs.nilai = "B";
}
mhs.nilai = "C";
}
mhs.nilai = "D";
}
else{
mhs.nilai = "Salah input nilai";
}
cout<<"Nilai Huruf Anda\t : "<<mhs.nilai<<endl;
cout<<"=====================================================
========"<<endl<<endl;
}
II-11
Gambar 1.5 Program Implementasi Struct
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>
int hanoi(int n, char dari, char bantu, char tujuan){

if (n == 1)
cout <<"Pindahkan piring dari "<<dari<<" ke
"<<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');
}
Gambar 1.6 Program Menara Hanoi

I-13
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.
Muh. Fitra Rizki
Tgl:
II-1
BAB II
Stack dan Queue
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 :
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).
Muh. Fitra Rizki
Tgl:
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

II.3 Tugas Praktikum ke-1 : Program Implementasi Stack
#include <iostream>
#define MAXSTACK 100
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;
}
Gambar 2.1 Program Implementasi Stack

II-11
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

#include <iostream>
#define max 8

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;
}
Gambar 2.2 Program Implementasi Queue
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

#include <iostream>
#include <cstdlib>
#include <cstring>
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;
}
}
Gambar 2.3 Program Membalikkan Nama Menggunakan Stack
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

#include <iostream>
#include <windows.h>
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 nama
"<<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');
}
Gambar 2.4 Program Antrian Bank

II-17
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.
Muh. Fitra Rizki
Tgl:
III-1
BAB III
SORTING
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 :
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
Muh. Fitra Rizki
Tgl:
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
5. Mengecek apakah L < j
- Jika ya, panggil fungsi Quicksort (L , j)
6. Mengecek apakah i < R
- Jika ya, panggil Quicksort (i , R)
- Jika tidak, selesai
III.2 Langkah-langkah Praktikum

III-5
III.3 Tugas Praktikum ke-1 : Sorting menggunakan Bubble Sort

#include <iostream>
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];
}
}
Gambar 3.1 Program Sorting menggunakan Bubble Sort

III-6
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

#include<iostream>
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;
}
}
Gambar 3.2 Program Sorting menggunakan Exchange Sort

III-7
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

#include <iostream>
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;
}
}
Gambar 3.3 Program Sorting menggunakan Insertion Sort

III-8
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

#include <iostream>
main(){
int data[6]={32,75,69,58,21,40};
int i,pos,j,temp;
i=0;
pos=0;
j=1;
cout<<"Data Awal : ";
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<<" = ";
cout<<data[x]<<" ";
}
cout<<endl;
}
}
III-9
Gambar 3.4 Program Sorting menggunakan Selection Sort
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

#include <iostream>
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<<" ) = ";
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 : ";
cout<<data[i]<<" ";
}
cout<<endl;
QuickSort(0,4);
}
Gambar 3.5 Program Sorting menggunakan Quick Sort
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

#include <iostream>
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
Gambar 3.6 Program mengurutkan Data Aslab

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

#include <iostream>
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
Gambar 3.7 Program Sorting menggunakan Quick Sort

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.
Muh. Fitra Rizki
Tgl:
IV-1
BAB IV
SEARCHING
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 :
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).
Muh. Fitra Rizki
Tgl:
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)
2. Menghitung nilai tengah = (kiri + kanan) / 2
3. Mengecek apakah cari == data [ tengah ]
- Jika ya, flag = 1. Ke langkah 6
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
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])
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
4. Mengecek apakah (data[pos] > cari)
- Jika ya, High = pos – 1. Ke langkah 1
5. Mengecek apakah (data[pos] < cari)
- Jika ya, low = pos + 1. Ke langkah 1
6. Mengecek apakah (flag == 1)
- Jika ya, data ditemukan
- Jika tidak, data tidak ditemukan
IV.2 Langkah-langkah Praktikum

IV-5
IV.3 Tugas Praktikum ke-1 : Program Implementasi Sequential Search

#include <iostream>
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";
}
}
Gambar 4.1 Program Implementasi Sequeantial Search

IV-6
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

#include <iostream>
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
Gambar 4.2 Program Implementasi Binary Search
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

#include <iostream>
#include <cmath>
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;
}
}
Gambar 4.3 Program Implementasi Interpolation Search
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

#include <iostream>
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
Gambar 4.4 Program Mencari Data Aslab
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
Muh. Fitra Rizki
Tgl:
V-1
BAB V
LINKED LIST
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 :
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 Array tidak Penghapusan Linked List mudah

mungkin
Muh. Fitra Rizki
Tgl:
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->next=NULL;
baru->prev=NULL
V.2 Langkah-langkah Praktikum

V-4
V.3 Tugas Praktikum ke-1 : Single Linked List

#include <iostream>
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->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->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){
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";
}
}
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<<"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);
}
hapusDepan();
cout<<endl;
}
hapusBelakang();
cout<<endl;
}
tampil();
cout<<endl<<endl;
}
cout<<"Keluar dari program";
}
else{
cout<<"Pilihan tidak tersedia... \n\n";
}
}
while(pilihan!=6);
}
V-7
Gambar 5.1 Program Single Linked List
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

#include <iostream>
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<<"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
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

#include <iostream>
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->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->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){
hapus = head;
cap = hapus->data;
head = head->next;
delete hapus;
}
else{
cap = head->data;
head = NULL;
V-11
}
cout<<cap<<" terhapus\n\n";
}
}
void hapusBelakang(){
Node *hapus,*temp;
string cap;
if (cek()==1){
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";
}
}
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<<"Masukkan Pilihan Anda : ";
cin>>pilihan;
V-12
if (pilihan == 1 ){
cout<<"Masukkan Nama = ";
cin>>data;
tambahdepan(data);
}
cout<<"Masukkan Nama = ";
cin>>data;
}
hapusDepan();
cout<<endl;
}
hapusBelakang();
cout<<endl;
}
tampil();
cout<<endl<<endl;
}
cout<<"Keluar dari program";
}
else{
cout<<"Pilihan tidak tersedia... \n\n";
}
}
while(pilihan!=6);
}
Gambar 5.3 Program Menampilkan Hubungan Orang tua Anak

V-13
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

#include <iostream>
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->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->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<<"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<<"Masukkan Pilihan Anda = "; cin>>pilihan;
V-16
if (pilihan == 1)
{
tambahdepan(data);
}
{
}
{
tampil();
}
{
hapusdepan();
cout<<endl;
}
{
hapusbelakang();
cout<<endl;
}
{
cout<<"keluar dari program...";
}
else
{
cout<<"pilihan tidak tersedia... \n\n";
}
}
while(pilihan!=6);
}
Gambar 5.4 Program Implementasi Double Linked List

V-17
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
Muh. Fitra Rizki
Tgl:
VI-1
BAB VI
TREE
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 :
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.
Muh. Fitra Rizki
Tgl:
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

VI.3 Tugas Praktikum ke-1 : Tree

//header file
#include <stdio.h>
#include <conio.h>
#include <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->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);
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);
}
}
//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;

case 2 :
printf("\nOUTPUT PRE ORDER : ");
printf("\n------------------\n");
if(pohon!=NULL)
//panggil fungsi untuk mencetak data
secara preOrder
preOrder(pohon);
else
printf("Masih kosong!");
break;

case 3 :
printf("\nOUTPUT IN ORDER : ");
printf("\n------------------\n");
VI-7
if(pohon!=NULL)
secara inOrder
inOrder(pohon);
else
break;

case 4 :
printf("\nOUTPUT POST ORDER : ");
printf("\n------------------\n");
if(pohon!=NULL)
secara postOrder
postOrder(pohon);
else
break;
}
_getch();
}while(pil != 5); //akan diulang jika input tidak
samadengan 5
return EXIT_FAILURE;
}
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

#include <iostream>
class BinarySearchTree{
private:
struct tree_node{
tree_node* left;
tree_node* right;
int data;
};
tree_node* root;
public:
BinarySearchTree(){
root = NULL;
}
bool isEmpty() const { return root==NULL; }

void print_preorder();
void preorder(tree_node*);
void 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
Gambar 6.2 Program Implementasi Tree
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
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
Muh. Fitra Rizki
Tgl:
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
Muh. Fitra Rizki
Tgl:
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/tree-

pada-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

FOTO
Nama : Febryan Alfaridzi 3x4
(Menggunaka
NIM : 1818057 n Jas
Almamater)
Kelompok : 25
Asistensi
No. Tanggal Paraf
Konsep Program Hasil Akhir
Pointer, Struct, Rekursif

Stack, Queue
Instruktur
Sorting
1
Searching
Linked List
Tree
Dosen
Batas Akhir:
Asisten, Malang, … Mei 2019
Dosen, Pembimbing,
(Muh. Fitra Rizki) (Hani Zulfia Zahro’, S.Kom, M.Kom)

NIP.P. 1031500480

Struktur Data

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Struktur Data

Diunggah oleh

Hak Cipta:

Format Tersedia

LAPORAN PRAKTIKUM

Nama : Febryan Alfaridzi

PROGRAM STUDI TEKNIK INFORMATIKA S-1

(Ali Mahmudi,B.Eng,.PhD) (Hani Zulfia Zahro’, S.kom,M.kom)

PROGRAM STUDI TEKNIK INFORMATIKA S-1

Malang, Mei 2019

KATA PENGANTAR ........................................................................................ ii

III.8 Tugas Rumah ke-1 : Program mengurutkan Data Aslab .......................... 11

Gambar 1.1 Program Implementasi Pointer ...................................................... 6

Perbedaan pointer dengan variabel biasa .......................................................... 2

Alat dan bahan :

I.1 Landasan Teori

Pointer adalah suatu variabel penunjuk, berisi nilai yang menunjuk

Jika ingin menyimpan alamat dari variabel x, kita dapat menggunakan

Int alamat_x = &x;

Disetujui Aslab Ttd / Paraf

Muh. Fitra Rizki

1.2 Pointer tanpa tipe data

Ada cara khusus untuk membuat pointer yang dideklarasikan tersebut

Perbedaan pointer dengan variabel biasa

Variabel Biasa Pointer

Berisi data/nilai Berisi alamat memori dari suatu

Operasi yang bisa dilakukan seperti Membutuhkan operator khusus:”&”

Yang kedua : Operator “*”. Operator

Bersifat statis Bersifat dinamis

Deklarasi : int a; Deklarasi : int *a;

1.3 Aturan Pointer

Variabel pointer dapat dideklarasikan dengan tipe data apapun.

Tipe data digunakan sebagai lebar data untuk alokasi memori

Jika suatu variabel pointer dideklarasikan bertipe float, berarti variabel

1.4 Pointer Pada Array

Array adalah suatu variabel yang menyimpan sekumpulan data yang

1.5 Pengertian Struct

Struct (struktur) adalah kumpulan elemen – elemen data yang

Field – field tersebut digabungkan menjadi satu dengan tujuan untuk

1.6 Penggunaan dan Pengaksesan Elemen Terstruktur

Untuk menggunakan struct, tulis nama struct beserta dengan fieldnya

Jika x adalah pointer bertipe mahasiswa* maka field dari x dapat

- Cout << mahasiswa->nim;

1.7 Pengertian Rekursif

Rekursif adalah salah satu metode dalam dunia matematika, rekursif

1.8 Fase dalam Rekursif

1.8.1 Fase Awal

Fase awal merupakan fase dimana fungsi tersebut

Terminate merupakan fase dimana fungsi tersebut berhenti

1.8.3 Fase Balik

Fase balik merupakan fase mengunjungi kembali kondisi –

1.9 Implementasi Rekursif

Dalam matematika, factorial dari bilangan asli n adalah

Fibonacci adalah kumpulan deret angka seperti berikut ini

Jika n = 0, maka FN = 0, jika n = 1, maka Fn = 1

Implementasi dari fungsi Fibonacci dari definisi diatas

I.2 Langkah-langkah Praktikum

I.3 Tugas Praktikum ke-1 : Program Implementasi Pointer

Gambar 1.1 Program Implementasi Pointer

I.4 Tugas Praktikum ke-2 : Program implementasi Struct

Gambar 1.2 Program Implementasi Struct

I.5 Tugas Praktikum ke-3 : Program Menghitung Nilai Faktorial

int faktorial(int angka){

Gambar 1.3 Program Menghitung Nilai Faktorial

I.6 Tugas Rumah ke-1 : Program Implementasi Pointer

Gambar 1.4 Program Implementasi Pointer