Algo

LAPORAN PRAKTIKUM
ALGORITMA DAN STRUKTUR DATA
Diajukan sebagai Penilaian pada

Mata Kuliah Algoritma dan Struktur Data
Nama : SIDDIK
Nim : 4517210039
Fakultas : Teknik
Jurusan : Informatika
Nama Dosen : Dra. Sri Rezeki Candra N., M.Kom
FAKULTAS TEKNIK JURUSAN INFORMATIKA

UNIVERSITAS PANCASILA
T.A 2017/2
DAFTAR ISI
DAFTAR ISI ................................................................................................................................ i
KATA PENGANTAR ............................................................................................................. ......1
BAB I PENDAHULUAN ......................................................................................................... .....2
A. STRUKTUR
DATA ..........................................................................................................2
B. ABSTRACT DATA TYPE .................................................................................................3
1. CLASS ..................................................................................................................
5
2. KONSTUKTOR & DESTRUKTOR ...........................................................................7
3. CLASS & OBJEK ...................................................................................................7
C. REKURSIF .....................................................................................................................8
1. FIBONACCI ..........................................................................................................
9
2. TOWER OF HANOI ............................................................................................11
D. SORT ..........................................................................................................................13
1. SELECTION & INSERTION SORT ........................................................................13
2. BUBBLE & SHELL SORT .....................................................................................15
3. MERGE & QUICK SORT .....................................................................................21
E. STRUKTUR DATA LINEAR ...........................................................................................26
1. LINKED LIST ......................................................................................................26
a. SINGLE LINKED LIST ..............................................................................26
b. DOUBLE LINKED LIST ............................................................................28
c. CIRCULAR SINGLE LINKED LIST .............................................................29
d. CIRCULAR DOUBLE LINKED LIST ...........................................................31
2. STACK – TUMPUKAN ........................................................................................34
3. QUEUE – ANTRIAN ...........................................................................................35
F. STUKTUR DATA HIRARKI (TREE, GRAPH) ...................................................................39
1. TREE (POHON) ..................................................................................................39
2. GRAPH ..............................................................................................................47
G. SEARCH ......................................................................................................................48
1. SEQUENTIAL SEARCH ....................................................................................48
2. BINARY SEARCH .............................................................................................49
3. FIBONACCI SEARCH .......................................................................................50
4. INTERPOLATION SEARCH ...............................................................................52
BAB II TUGAS PERORANGAN ..................................................................................................53

1. STRUCT ......................................................................................................................53
2. ADT ............................................................................................................................56
3. SELECTION
SORT ........................................................................................................57
4. SHELL
SORT ................................................................................................................58
5. MERGE SORT .............................................................................................................59
6. QUICK SORT ...............................................................................................................61
7. LINKED
LIST ................................................................................................................63
8. STACK ........................................................................................................................65
9. QUEUE .......................................................................................................................67
10. TREE ...........................................................................................................................7
0
11. SEARCH ......................................................................................................................72
BAB III TUGAS BESAR ..............................................................................................................73

A. PROGRAM .................................................................................................................73
B. OUTPUT .....................................................................................................................78
C. PSEUDOCODE ............................................................................................................81
D. ALGORITMA ...............................................................................................................86
BAB IV TUGAS PERORANGAN & KELOMPOK (KERTAS) ..........................................................89

BAB V PENUTUP .....................................................................................................................90
A. KESIMPULAN ..............................................................................................................90
B. KOMENTAR .................................................................................................................90
DAFTAR PUSTAKA ...................................................................................................................91

LAMPIRAN ..............................................................................................................................92
KATA PENGANTAR
Puji syukur atas kehadirat Allah SWT yang telah melimpahkan rahmat dan hidayah
Nya sehingga saya bisa menyelasaikan makalah ini. Dalam makalah ini saya memapaparkan
mengenai materi algoritma dan hasil Pratikum untuk memenuhi tugas mata kuliah
Algoritma Struktur Data di semester 2 saat ini.
Laporan ini ditulis dan disusun untuk menyelesaikan tugas akhir praktikum Algoritma
Struktur Data, terdiri diantaranya Struktur, Abstrak Data Tipe(class), Rekursif(Fibonacci,
Faktorial, Perkalian, Tower of hanoi), Sorting(Selection, Insertion, Bubble ,Shell, Merge,
Quick), Struktur Data Hirarki(Tree, Graph, Hash Tables), Search (Sequential, Fibonacci,
Interpolation, Binary).
Algoritma adalah jantung ilmu komputer atau informatika. Banyak cabang ilmu
komputer yang diacu dalam terminologi Algoritma. Untuk itulah perlu bagi kita sebagai
mahasiswa untuk mempelajari dan memahami lebih dalam materi tentang algoritma.
Dalam penulisan makalah ini saya sadar tentunya masih jauh dari kata sempurna
tentunya masih banyak kesalahan dan kekurangan dalam penyusunan makalah ini, untuk
itulah saya mengharap kritik dan sarannya yang membangun dari pembaca sebagai bahan
koreksi selaku penyusun agar bisa mengerti dimana letak kekurangan dan kesalahan agar
bisa saya perbaiki.
Jakarta, Juni 2018

Siddik
BAB I
PENDAHULUAN
A. STRUKTUR DATA
Definisi Struktur
Suatu object benda biasanya mempunyai beberapa attribut yang perlu dicatat.
Contoh :
 Budi sebagai personal mempunyai attribut  nama, alamat, usia,
jenis kelamin, pekerjaan, status.
 Budi sebagai atlit mempunyai attribut  cabang olah raga, daftar
prestasi, jadual pertandingan.
 Jadi satu benda (Budi) yang sama dimungkinkan mempunyai atribut yang
berbeda-beda sesuai dengan dari sudut mana objek itu dipandang.
Definisi Struktur
 Merupakan kumpulan elemen-elemen data yang digabungkan menjadi satu
kesatuan.
 Masing-masing elemen data dinamakan field atau elemen struktur
 Struktur digunakan untuk mengelompokkan beberapa informasi yang berkaitan.
Pendeklarasian Struktur
 Pendeklarasian Struktur selalu diawali dengan kata kunci struct yang diikuti
dengan nama dari struktur.
 Field-field yang dikumpulkan dalam sebuah struktur diletakkan diantara tanda
kurung kurawal buka { dan kurung kurawal tutup } dan diakhiri dengan tanda titik
koma ;
 Bermanfaat untuk mengelompokkan sejumlah data dengan tipe yang berlainan
 Membuat tipe data baru dan disebut dengan tipe data abstrak
 Pendefinisian/pendeklarasian variabel struktur sama seperti pendefinisian
variabel biasa:
– tipe_data nama_variabel
• Contoh :
–MATAKULIAH Data_MK;
–MAHASISWA Data_MHS;
 Pendefinisian variabel bisa digabung dengan pendeklarasian struktur
Mengakses Struktur
• Syntax:
–variabel_struktur.nama_anggota
–Contoh :
• strcpy(Data_MK.NmMk,“Algo 2”);
•Data_MHS.Data_MK.sks = 3;
Menyalin Struktur
 Misal didefinisikan dua buah variabel:
– Contoh :
MATAKULIAH mk1, mk2;
 Maka penyalinan berikut yang diperbolehkan adalah:
mk2 = mk1
 Pernyataan diatas sama dengan gabungan 3 pernyataan berikut:
strcpy(mk2.NmMK, mk1.NmMK);
mk2.sks = mk1.sks;
mk2.nilai = mk1.nilai
Membandingkan Struktur
 Dua buah struktur tidak dapat secara langsung di bandingkan
 Pembandingan dilakukan dengan membandingkan masing-masing
anggotanya
Contoh:
if ((strcmp(mk1.NmMK,mk2.NmMK) == 0) &&
(mk1.sks == mk2.sks) && (mk1.nilai == mk2.nilai))
cout << “Sama”;
else
cout << “Tidak sama”;
B. Abstract Data Type (ADT)
Pengertian ADT
• ADT adalah definisi type dan sekumpulan primitif (operasi dasar) terhadap type
tersebut.
• Type diterjemahkan menjadi type terdefinisi dalam bahasa pemrograman yang
bersangkutan, misalnya menjadi Struct dalam bahasa C
• Primitif dalam konteks pemrograman prosedural, diterjemahkan menjadi fungsi dan
prosedur.
• Primitif dikelompokkan menjadi :
1. Konstruktor/Kreator, pembentuk nilai type. Biasanya namanya diawali dengan
Make.
2. Selektor, untuk mengakses komponen type. Biasanya namanya diawali dengan
Get.
3. Prosedur Pengubah nilai komponen
4. Validator komponen type, yang dipakai untuk mengetes apakah dapat
membentuk type sesuai batasan.
5. Destruktor/Dealokator, yaitu untuk menghancurkan nilai objek, sekaligus memori
penyimpannya
6. Read/write, untuk interface dengan input/output device
7. Operator Relasional terhadap type tersebut untuk mendefinisikan lebih besar,
lebih kecil, sama dengan dan sebagainya.
8. Aritmatika terhadap type tersebut, dalam pemrograman biasanya hanya
terdefinisi untuk bilangan numerik.
9. Konversi dari type tersebut ke type dasar dan sebaliknya
ADT biasanya diimplementasi menjadi dua buah modul, yaitu :
1. Definisi/spesifikasi type dan primitif

• Spesifikasi type sesuai dengan bahasa yang dipakai
• Spesifikasi dari primitif sesuai dengan kaidah dalam konteks prosedural, yaitu :
a) Fungsi : nama, domain, range, dan pre kondisi jika ada
b) Prosedur : Keadaan Awal, Keadaan Akhir dan proses yang dilakukan
2. Body/realisasi dari primitif, berupa kode program dalam bahasa yang

bersangkutan. Realisasi fungsi dan prosedur harus sedapat mungkin memanfaatkan
Selektor dan Konstruktor
• Realisasi ADT dalam beberapa bahasa pemrograman
• Setiap ADT harus dibuat menjadi spesifikasi, body dan driver

– Dalam bahasa C++, modul spesifikasi dan body dapat dibuat
dengan cara
• Include dari file header
• Encapsulate dalam class
– Driver digunakan untuk menguji ADT
1. CLASS
Pendahuluan Class
• Class merupakan struktur data dari objek
• Sebuah class (kelas) yang menyerupai struktur dapat dibuat dengan
menggantikan kata struct dengan class
• Persamaan struktur dengan kelas, pada cara mendeklarasikan, mendefinisikan
dan cara akses
• Sedangkan perbedaan struktur dengan kelas adalah kelas mempunyai access
specifier (penentu akses), sedangkan struktur tidak mempunyai access
specifier (penentu akses)
Struktur vs Kelas/Class
Persamaan :
• Cara deklarasi • Cara deklarasi
struct cthStruct class cthClass
{ {
int b; int b;
........ ........
}; };
• Cara definisi • Cara definisi
variabel/objek variabel/objek
cthStruct x; cthClass x;
• Cara akses • Cara akses
x.a = 22; x.a = 22;
Perbedaan :
struct cthStruct class cthClass
{ {
int b; public;
........ int b;
}; ........
};
Kelas/Class
• Kelas digunakan untuk mendefinisikan obyek
• Contoh : tipe data digunakan untuk mendefinisikan variabel
• Obyek melingkupi anggota data dan fungsi anggota
• Nama kelas biasanya dimulai dengan huruf besar
• Pendefinisian Kelas
• Pendefinisian obyek: NamaKelas Nama_Obyek
Penentu Akses (Access Specifier)
• Digunakan untuk menentukan anggota data atau fungsi anggota mana yang boleh
diakses dan oleh siapa
• Ada 4 macam penentu akses(access specifier)/level access modifier:
– Public
– Default
– Private
– Protected
Penentu Akses (Access Specifier) :
Public
• Bisa diakses dari luar kelas (bersifat global).
• Maka semua class yang lain dapat melihat class tersebut.
• Dapat melakukan import, instansiasi, extends, dan memanggil method yang
ada dalam class.
Default
• Maka hanya class dari package yang sama atau class turunannya yang dapat
melihat class tersebut
Private
• Hanya bisa diakses dari dalam kelas (bersifat lokal)
• Hanya dapat digunakan oleh inner class saja, sedangkan class lain tidak dapat
ditandai sebagai private
Protected
• Sama dengan Private dan bisa diakses oleh kelas-kelas turunan
• Class tidak dapat dideklarasikan sebagai protected
Penentu Akses Private
• Digunakan untuk memproteksi anggotaanggota tertentu pada kelas agar tidak
bisa diakses secara langsung dari luar kelas
• Biasanya yang menggunakan penentu akses private adalah anggota data
• Biasa digunakan pada kelas untuk memproteksi anggota-anggota tertentu pada
kelas, agar tidak dapat diakses di luar kelas secara langsung.
• Penentu akses private adalah nilai default sehingga kalau penentu akses tidak
ditentukan, maka dianggap menggunakan penentu akses private
Class VS Object
• Object adalah instansiasi dari sebuah class.
• Class itu sebagai sebuah cetakan sedangkan object itu adalah barang dari hasil
cetakan.
• Class juga dapat dikatakan sebagai kategori, sedangkan object adalah sesuatu
yang memuhi syarat-syarat yang harus dipenuhi agar masuk dalam kategori
tersebut
• Jadi satu class dapat mempunyai banyak object
• Setiap object mempunyai sifat yang sama persis seperti yang didefinisikan
dalam class tersebut
2. KONSTRUKTOR & DESTRUKTOR
Konstruktor
 Konstruktor adalah fungsi anggota yang mempunyai nama yang sama dengan
nama kelas
 Konstruktor digunakan pada saat membuat sebuah objek
 Dengan Konstruktor dapat membuat pernyataan untuk menginisialisasikan
sebuah objek
 Kegunaannya konstruktor :
1. Mengalokasikan ruang bagi suatu objek
2. Memberikan nilai awal pada anggota data suatu objek
3. Membentuk tugas-tugas umum/konstruktor
 Konstruktor dijalankan secara otomatis saat obyek diciptakan
 Sifat konstruktor:
o Nama konstruktor sama dengan nama kelas
o Konstruktor tidak mempunyai nilai balik (bahkan tanpa void)
o Konstruktor harus diletakkan pada bagian public
Destruktor
 Destruktor adalah fungsi anggota kelas yang akan dijalankan secara otomatis
pada saat obyek akan sirna
 Nama destruktor sama dengan nama konstruktor, hanya diawali dengan
sebuah karakter ~
 Destruktor akan digunakan apabila sebuah obyek tidak digunakan lagi
 Dalam destruktor dapat menuliskan pernyataan untuk diinisialisasikan ke
sebuah obyek
 Ada beberapa hal yang terkai dnegan fungsi destruktor, yaitu
• Fungsi destructor tidak mengembalikan sembarang nilai
• Tidak ada overloading
• Fungsi destructor akan dilaksanakan secara otomatis apabila obyek
daripada kelas yang dipertimbangkan selesai.
3. CLASS & OBJEK
Kelas adalah bentuk penyederhanaan dari suatu permasalahan yang

berkaitan dengan objek. Kelas juga dapat didefinisikan sebagai sesuatu yang
mempunyai data (sifat) dan funsi (kelakuan). Kelas bersifat abstrak, oleh karena
itu kita harus melakukan instansiasi dari kelas tersebut,
selanjutnya instance(contoh nyata atau perwujudan) dari kelas tersebut juga
sering dinamakan dengan objek, sebagi contoh manusia adalah suatu kelas
maka instance atau objek dari manusia adalah Irwan, Yana, Parlin dan yang
lainnya.
Obyek Terdiri dari 2, yaitu :

1. Obyek Lokal
2. Obyek Global
1. Obyek Lokal
• Merupakan suatu obyek yang didefinisikan di luar fungsi
• Konstruktor dijalankan saat obyek bersangkutan di ciptakan
• Destruktor dijalankan dengan sendirinya saat fungsi yang
mendefinisikannya berakhir
2. Obyek Global
• Merupakan suatu obyek yang didefinisikan secara global
• Konstruktor dijalankan saat awal eksekusi program, yaitu sebelum fungsi
main() di proses
• Destruktor dijalankan saat fungsi main() berakhir
• Apabila ada exit() destruktor obyek global akan dijalankan terlebih
dahulu, tetapi destruktor obyek lokal tidak akan dieksekusi
Obyek Sebagai Parameter
Ada 3 kemungkinan melewatkan obyek sebagai parameter:
1. Melewatkan obyek berdasarkan nilai (passing parameter by value)
2. Melewatkan obyek sebagai referensi (passing parameter by reference)
3. Melewatkan obyek sebagai pointer
C. REKURSIF
Rekursif berarti suatu proses yang memanggil dirinya sendiri. Rekursif terdiri dari
prosedur atau fungsi. Perbedaannya adalah bahwa rekursif bisa memanggil ke dirinya
sendiri, tetapi prosedur atau fungsi harus dipanggil lewat pemanggil prosedur atau
fungsi. Pemanggilan prosedur atau fungsi ke dirinya sendiri bisa berarti proses yang
berulang yang tidak dapat diketahui kapan akan berakhir. Dalam pemakaian sehari-hari,
rekursi merupakan teknik pemrograman yang berdaya guna untuk digunakan pada
pekerjaan pemrograman dengan mengeksperisikannya ke dalam suku-suku dari program
lain dengan menambahkan langkah-langkah sejenis.
Fungsi Rekursif
• Setara dengan proses looping/ iterasi = faktorial, perkalian
• Kadang rekursif lebih baik dari iterasi = tower of hanoi
• Terkadang sebaliknya = fibonacci
• Komponen :
– Way out if – else + return()
– Recursive call dengan value baru
Contoh 2 Perkalian
1. FIBONACCI
Deret Fibonacci adalah sebuah deret yang untuk suku pertama dan kedua

bernilai 0 dan 1, sedangkan untuk suku ketiga dan seterusnya merupakan
penjumlahan 2 suku sebelummnya, misal untuk ke-3 adalah (0+1) = 1, suku ke-4
adalah (1+1) = 2, dst.
• The Fibonacci series fn≥0 is a famous series defined by:

f0 :≡ 0, f1 :≡ 1, fn≥2 :≡ fn−1 + fn−2
• f2 = f0 + f1 = 0 + 1 = 1
• f3 = f1 + f2 = 1 + 1 = 2
• f4 = f2 + f3 = 1 + 2 = 3
• f5 = f3 + f4 = 2 + 3 = 5
Tracing Fibonacci
• fibo (2) = ?
• fibo (3) = ?
• fibo (4) = ?
2. TOWER OF HANOI
Tower of Hanoi adalah teka-teki matematika di mana kita memiliki tiga

batang dan n disk. Tujuan dari teka-teki adalah memindahkan seluruh tumpukan
ke batang lain, mematuhi aturan sederhana berikut ini :
1) Hanya satu disk yang dapat dipindahkan dalam satu waktu.

2) Setiap langkah terdiri dari mengambil disk bagian atas dari salah satu
tumpukan dan menempatkannya di atas tumpukan lain yaitu disk hanya
dapat dipindahkan jika itu adalah disk paling atas pada tumpukan.
3) Tidak ada disk yang dapat ditempatkan di atas disk yang lebih kecil.
Contoh source code nya :
D. SORT
1. SELECTION & INSERTION SORT
Sort adalah proses pengurutan data yang sebelumnya disusun secara acak
sehingga menjadi tersusun secara teratur menurut suatu aturan tertentu Pada
umumnya terdapat 2 jenis pengurutan, yaitu :
–Ascending (naik)
– Descending (turun)
SELECTION SORT adalah membandingkan elemen yang sekarang dengan

elemen yang berikutnya sampai dengan elemen yang terakhir. Jika ditemukan
elemen lain yang lebih kecil dari elemen sekarang maka dicatat posisinya dan
kemudian ditukarkan.
Selection Sort (Metode pengurutan seleksi)

Algoritmanya sebagai berikut :
1. i << 1
2. Selama (i <= N-1) kerjakan baris 3 s.d. 9
3. k << i
4. j << i + 1
5. Selama (j <= N) kerjakan baris 6 s.d. 7
6. Jika (Data[k] > Data[j]) maka k << j
7. j << j + 1
8. Tukar Data [i] dengan Data [k]
9. i << i + 1
Contoh manualnya :
Contoh source codenya :
INSERTION SORT adalah Pengurutan dilakukan dengan cara

membandingkan data ke-i (dimana i dimulai dari data ke-2 sampai dengan
data terakhir) dengan data berikutnya. Jika ditemukan data yang lebih kecil
maka data tersebut disisipkan ke depan sesuai dengan posisi yang
seharusnya.

1. i << 2
2. Selama (i <= N) kerjakan baris 3 s.d. 10
3. x << data[i]
4. Data[0] << x
5. j << i -1
6. Selama (x < data[j]) kerjakan baris 7 s.d. 8
7. data[j+1] > data[j]
8. j << j - 1
9. data [j+1] << x
10.i << i + 1
Contoh manualnya :

2. BUBBLE & SHELL SORT
BUBBLE SORT adalah membandingkan elemen yang sekarang dengan elemen

yang berikutnya, jika elemen sekarang > elemen berikutnya, maka ditukar.
Metode pengurutan gelembung (Bubble Sort) , menginginkan larik terurut
menaik, maka elemen larik yang berharga paling kecil, dipindahkan ke ujung kiri
larik melalui proses pertukaran. Proses metode ini dilakukan sebanyak N-1
langkah(pass) dengan N adalah ukuran larik. Pada akhir setiap langkah ke-I, larik
L[1..N] akan terdiri atas dua bagian yaitu bagian yang sudah terurut, yaitu L[1..I],
dan bagian yang belum terurut L[I+1..N]. Sedangkan langkah terakhir, diperoleh
larik L[1..N] yang terurut menaik.

1. i << 2
3. j << N
4. Selama (j >= i) kerjakan baris 5 s.d. 7
5. Jika (data[j-1] > data[j]) maka tukar data[j-1] dengan data[j]
6. j << j - 1
7. i << i + 1
Contoh manualnya :
Pengurutan Bubble Sort

Ascending
A: [ 23,17,14,6,13,10,1,5,7]
SHELL SORT adalah metode pertambahan menurun. Metode ini mengurutkan
data dengan cara membandingkan suatu data dengan data lain yang memiliki jarak
tertentu, kemudian dilakukan penukaran jika diperlukan.
Pada metode ini pertama-tama adalah menentukan jarak mula-mula dari data
yang akan dibandingkan, yaitu N/2. Setelah itu, dilakukan pengulangan dari 1 sampai
dengan N/2. Pada masing-masing pengulangan dilakukan pembandingan antara data
ke-j dengan data ke-(j+N/2). Apabila data ke-j lebih besar dari data ke-(j+N/2) maka
kedua data tersebut ditukar. Pengulangan dari 1 sampai dengan N/2 ini dilakukan
sampai semua data ke-j selalu lebih kecil dari data ke-(j+N/2).
Pada proses berikutnya, digunakan jarak (N/2)/2 atau N/4, Kemudian dilakukan
pengulangan dari 1 s.d. (N-N/4) atau 3N/4. Pada masing-masing pengulangan
dilakukan pembandingan antara data ke-j dengan data ke-(j+N/4) . Apabila
diperlukan, kedua data tersebut ditukar. Pengulangan dari 1 s.d. 3N/4 ini dilakukan
sampai semua data ke-j < dari pada data ke-(j+N/4). Pada proses berikutnya,
digunakan jarak (N/4)/2 atau N/8. Demikian seterusnya sampai jarak yang digunakan
adalah 1.

1. i << 2
3. j << N
4. Selama (j >= i) kerjakan baris 5 s.d. 7
5. Jika (data[j-1] > data[j]) maka tukar data[j-1] dengan
data[j]
6. j << j - 1
7. i << i + 1
Contoh manualnya :
Pengurutan Shell Sort
Ascending
A: [ 23,17,14,6,13,10,1,5,7]
Contoh source codenya menggunakan class :
#include<iostream>
#include<conio.h>
#include<string.h>
using namespace std;
class SIDDIK
{
public:
int sid1, sid2, sid3, sid4, n;
int A[1000];
Urutan();
int DIK1();
int DIK2();
};
int SIDDIK::DIK1()
{
cout<<"Masukkan Jumlah Data : ";cin>>n;
cout<<"Masukkan Data "<<endl;
for (sid1=0; sid1<n; sid1++)
{
cout<<"Nilai ke- "<<1+sid1<<" : ";cin>>A[sid1];
}
cout<<"Sebelum Pengurutan"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~"<<endl;
for (sid1=0; sid1<n; sid1++)
cout<<A[sid1]<<endl;
for(sid2=n/2; sid2>0; sid2/=2)
{
for (sid3=sid2; sid3<n; sid3++)
{
for (sid1=sid3-sid2; sid1>=0; sid1-=sid2)
{
if (A[sid1+sid2]<=A[sid1]) break;
else
{
sid4=A[sid1];
A[sid1]=A[sid1+sid2];
A[sid1+sid2]=sid4;
}
}
}
}
cout<<endl;
cout<<endl;
int SIDDIK::DIK2()
{
cout<<"Sesudah pengurutan"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~"<<endl;
for(sid1=0; sid1<n; sid1++)
cout<<A[sid1]<<endl;
}
int main ()
{
SIDDIK urut;
urut.DIK1();
urut.DIK2();
}
3. MERGE & QUICK SORT
MERGE SORT adalah metode yang sering digunakan pada pengurutan berkas.
Mula-mula diberikan dua kumpulan data yang sudah dalam keadaan terurut.
Kedua kumpulan data tersebut harus dijadikan satu tabel sehingga dalam keadaan
terurut.
Penggabungan ini digunakan pada pengurutan berkas. Syaratnya ada dua
kumpulan data yang sudah dalam keadaan urut. Kedua kumpulan data tersebut
harus dijadikan satu tabel sehingga dalam keadaan urut
Misalnya :
T1 = 65, 44, 26, 19, 2

T2 = 22, 12, 5, 3
Proses pengurutan dengan metode penggabungan :

1) Mula-mula diambil data pertama dari T1, 2, dan data pertama dari T2, yaitu 3
2) Data ini dibandingkan, kemudian yang lebih kecil diletakkan sebagai data
pertama hasil hasil pengurutan, misalnya T3
3) Jadi T3 akan memiliki satu data, yaitu 2
4) Data yang lebih besar, yaitu 3, kemudian dibandingkan dengan data kedua
dari T1, yaitu 19
5) Karena lebih kecil, maka 3 diletakkan sebagai data kedua dari T3

1) i << 1
2) j << 1
3) J3 << 1
4) Kerjakan baris 5 s.d. 7 sampai (i > J1) atau (j > J2)
5) J3 << J3 +1
6) Jika (T1[j] <T2[j]) maka T3[J3] << T1[i], i << i+1
7) Jika (T1[j] >=T2[j]) maka T3[J3] << T2[j], j << j+1
8) Jika (i > J) maka kerjakan baris 9, jika tidak dikerjakan baris 15
9) i << j
10) Selama (i <= J2) kerjakan baris 11 s.d. 13
11) J3 << J3 + 1
12) T3[J3] << T2[i]
13) i << i + 1
14) Selesai
15) j << i
16) Selama (j <= J1) kerjakan baris 17 s.d. 19
17) J3 << J3 + 1
Contoh manualnya :
QUICK SORT adalah metode membandingkan suatu elemen (disebut pivot)

dengan elemen yang lain dan menyusunnya sedemikian rupa sehingga elemen-
elemen lain yang lebih kecil daripada pivot tersebut terletak di sebelah kirinya dan
elemenelemen lain yang lebih besar daripada pivot tersebut terletak di sebelah
kanannya. Sehingga dengan demikian telah terbentuk dua sublist, yang terletak di
sebelah kiri dan kanan dari pivot. Lalu pada sublist kiri dan sublist kanan kita anggap
sebuah list baru dan kita lakukan proses yang sama seperti sebelumnya. Demikian
seterusnya sampai tidak terdapat sublist lagi. Sehingga di dalamnya telah terjadi
proses Rekursif.
Proses pengurutan dengan metode pengurutan cepat :
1) Pilih data tertentu yang dinamakan pivot, misalnya x.
2) Pivot ini harus diletakkan pada posisi ke-j sedemikian hingga data antara 1 s.d. (j-
1) lebih kecil daripada x, sedangkan data pada posisi ke (j+1) s.d. N lebih besar
dari pada x.
3) Cara pengaturannya adalah menukarkan data diantara posisi 1 s.d. (j-1) yang
lebih besar daripada x dengan data diantara posisi (j+1) s.d. N yang lebih kecil
daripada x.

1) x << Data[(L+R)/2)]
2) i << L
3) j << R
4) Selama (i <= j) kerjakan baris 5 s.d. 12
5) Selama (Data[i] < x) kerjakan i << i+1
6) Selama (Data[i] > x) kerjakan j << j-1
7) Jika (I <= j) maka kerjakan baris 8 s.d. 10; jika tidak dikerjakan baris 11
8) Tukar Data [i] dengan Data [j]
9) i << i + 1
10) j << j – 1
11) Jika (L < j) kerjakan lagi baris 1 dengan R=j
12) Jika (i < R) kerjakan lagi baris 1 dengan L=i
Contoh manualnya :
E. STRUKTUR DATA LINEAR
1. LINKED LIST
Linked list merupakan Array Dinamis. Variabel bertipe Array merupakan

suatu tipe data yang bersifat statis dimana ukuran dan urutannya sudah pasti. Selain
itu ruang memori yang dipakai olehnya tidak dapat dihapus bila variabel bertipe
array tersebut sudah tidak digunakan lagi pada saat program dijalankan.
Linked list adalah sejumlah obyek yang di link atau dihubungkan satu dengan
yang lainnya sehingga membentuk suatu list. Obyek adalah merupakan gabungan
beberapa elemen data (variabel) yang dijadikan satu kelompok atau structureatau
recordyang dibentuk dengan perintah struct. Tiap-tiap elemen dapat memiliki tipe
data tersendiri yang berbeda dengan tipe data lemen lain. Untuk menghubungkan
obyek satu dengan obyek lainnya, diperlukan paling tidak sebuah variabel yang
bertipe pointer. Variabel pointer tersebut merupakan salah satu variabel dalam
struktur obyek.
Struktur Linked List terbagi menjadi 4 macam, yaitu : Linear Single Linked List,
Linear Double Linked List, Circular Single Linked List, Circular Double Linked List.
a. Single Linked List
Merupakan linked list lurus dengan pointer tunggal. Dalam struktur simpul
hanya ada satu elemen/field/variabel yang bertipe pointer yang isinya adalah
alamat simpul berikutnya atau next node.
Prosesnya :
a) Inisialisasi, yaitu persiapan pembuatan Linked List.

b) Membuat simpul awal.
c) Membuat simpul baru.
d) Menambahkannya (Insert) kedalam linked list.

b. Double Linked List
Linear Double Linked List adalah doubly linked list lurus dengan pointer
ganda, yaitu ada dua buah pointer. Jadi dalam struktur simpul ada dua
elemen/field/variabel yang bertipe pointer. Yang pertama menunjuk atau berisi
alamat simpul sebelumnya atau perivious node, dan yang kedua menunjuk
simpul berikutnya atau next node.
Proses DLLL (Double Linked List Linear), adalah :

9. Melakukan delete tengah / hapus elemen tengah
c. Circular Single Linked List

Circular Single Linked List adalah Single List List dimana link simpul
terakhir bukan diisi dengan null, melainkan diisi dengan alamat simpul pertama
yaitu simpul yang ditunjuk oleh pointer FIRST, sehingga menciptakan efek
melingkar “sesuai arah jarum jam”.
Proses SLLC (Single Linked List Circular), adalah :

d. Circular double linked list
Circular Double Linked List adalah doubly linked list dimana pointer
RIGHT simpul paling kanan berisi alamat simpul paling kiri, dan pointer LEFT
simpul paling kiri berisi alamat simpul paling kanan, sehingga menciptakan
efek melingkar baik menurut ‘arah jarum jam’ maupun ‘arah kebalikannya’.
Pengertian Double Linked List Circular –Double: artinya field
pointernya terdiri dari dua buah dan dua arah, yaitu prev/left dan next/right
– Linked List: artinya node-node tersebut saling terhubung satu samalain.

– Circular: artinya pointer next dan prev-nya menunjuk ke dirinya sendiri.
• Node :
– Setiap node pada linked list mempunyai field yang berisi data dan pointer
ke node berikutnya dan ke node sebelumnya.
– Untuk pembentukan node baru, mulanya pointer next/right dan
prev/left akan menunjuk ke dirinya sendiri.
– Jika sudah lebih dari satu node, maka pointer prev/left akan menunjuk ke
node sebelumnya, dan pointer next/right akan menunjuk ke node
sesudahnya.
• Head :
– Dibutuhkan satu buah variabel pointer : head

– Head akan selalu menunjuk pada node pertama
Fungsi untuk mengetahui kosong tidaknya DLLC (Double Linked List Circular)
• Penamahan elemen/data didepan/diawal
– Penambahan node baru akan dikaitan di node paling depan, namun

pada saat pertama kali (data masih kosong), maka penambahan data
dilakukan pada head nya .
– Pada prinsipnya adalah mengkaitkan data baru dengan head,

kemudian head akan menunjuk pada data baru tersebut sehingga
head akan tetap selalu menjadi data terdepan. Untuk
menghubungkan node terakhir dengan node terdepan dibutuhkan
pointer bantu.
Proses DLLC (Double Linked List Circular), adalah :
1. Pembuatan sebuah simpul
2. Pembuatan simpul awal.b (simpulyang sudah dibuat, dijadikan sebagai

simpul awal)
3. Melakukan insert kanan / sisip elemen terakhir

4. Melakukan insert kiri / sisip elemen awal
4. melakukan insert kiri
5. Melakukan insert tengah / sisip elemen tengah
6. Melakukan delete kiri / hapus elemen awal
7. Melakukan delete kanan / hapus elemen akhir
8. Melakukan delete tengah / hapus elemen Tengah

2. STACK - TUMPUKAN / LIFO
LIFO/STACK adalah suatu metode pembuatan Linked List, dimana data yang
masuk paling akhir adalah data yang keluar paling awal artinya data yang terakhir
kali dimasukkan kedalam stack akan menjadi data pertama kali dapat diambil dari
stack, sedangkan data yang pertama kali dimasukkan kedalam stack akan
menjadi data yang terakhir kali bisa diambil dari stack.
Proses Tumpukan (Stack), adalah :

a) Deklarasi struktur simpul.
b) Membuat class Linked List.
c) Inisialisasi linked list.
d) Melakukan insert kiri / sisip elemen.
e) Menampilkan data berupa data string.
f) Dalam menu utama :
 Mendeklarasikan class menjadi object,
 Melakukan proses sisip kiri
 Melakukan proses cetak
3. QUEUE – ANTRIAN / FIFO
FIFO/QUEUE adalah suatu metode pembuatan Linked List, dimana data yang
masuk paling akhir adalah data yang keluar paling akhir keluar, sedangkan data
yang pertama kali dimasukkan kedalam queue akan menjadi data pertama juga
yang dapat diambil dari queue. FIFO/QUEUE/ANTRIAN adalah struktur data
dimana proses pengambilan dan penambahan elemen dilakukan pada ujung yang
berbeda.
Penambahan/insert dan pengambilan/delete elemen pada queque biasanya
menggunakan istilah Enqueue dan Dequeue. Enqueue adalah proses
penambahan elemen pada queue. Dequeue adalah proses pengambilan elemen
pada queue. Penambahan/insert dilakukan pada bagian belakang.
Pengambilan/delete dilakukan pada bagian depan.
Proses Antrian (QUEUE), adalah :

a) Deklarasi struktur dequeue dan struktur input data.
b) Membuat fungsi enqueue.
c) Membuat fungsi baca.
d) Membuat fungsi tampil/display.
e) Dalam menu utama :
- Pilih 1 : Melakukan proses ENQUEUE.
- Pilih 2 : Melakukan proses DEQUEUE.
- Pilih 3 : Melakukan proses Baca.
- Pilih 4 : Melakukan proses Hapus semua data.
- Pilih 5 : Melakukan proses queue selesai.

#include <iostream>
#include <string.h>
#define MAX 100
#define true 1
#define false 0
struct siddik
{
char data [20];
};
struct siddik sid;

struct siddik queue[MAX];
int init (void);

int full (void);
int empty (void);
struct siddik entridata (void);
int enqueue (struct siddik sid);
struct siddik dequeue (void);
int display (struct siddik sid);
int baca (void);
int awal, akhir,i;

char nocomment[10];
int main()
{
char pilih;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
cout<<" PROGRAM QUEUE (ANTRIAN)"<<endl;
cout<<"4. Hapus Semua Data"<<endl;
cout<<"5. Selesai"<<endl;
cout<<endl;
cout<<"Pilih 1 s.d 5 : ";
cin>>pilih;
switch (pilih)
{
case '1' : sid = entridata();
enqueue (sid);
break;
case '2' : cout<<"\nData yang dihapus : \n";
cout<<endl;
sid = dequeue();
display (sid);
break;
case '3' : baca();
break;
case '4' : init();
cout<<"\nData telah dikosongkan\n";
cout<<endl;
break;
case '5' : break;
default : cout<<"Pilih 1 s.d 5 !";

break;
}
cout<<endl;
}
while (pilih != '5');

return 0;
}
int init (void)

{
awal = -1;
akhir = -1;
}
int enqueue (struct siddik sid)

{
if (empty()== true)
{
awal = 0;
akhir = 0;
queue[awal] = sid;
struct siddik dequeue (void)
{
int i;
if (empty() != true)
{
sid = queue[awal];
for (i=awal; i<=akhir; i++)
queue[i] = queue [i+1];
akhir--;
return(sid);
}
else cout<<"Queue kosong ....\n";
}
int full (void)

{
if (akhir==MAX-1) return(true);
else return (false);
}
int empty (void)

{
if (akhir == -1) return (true);
else return (false);
}
int baca(void)
{
cout<< "\nIsi Queue : ";

{
for (i=awal; i<=akhir; i++)
{
display(queue[i]);
}
}
else cout<<"Data Kosong.";
cout<<endl;
}
struct siddik entridata (void)

{
struct siddik sid;
cout<<endl;
cout<<"Masukkan Data : ";cin>> sid.data;
return(sid);
}
Input & outputnya :
F. STRUKTUR DATA HIRARKI (TREE, GRAPH)
1. TREE (POHON)
Tree merupakan salah satu bentuk struktur data yang non linear/tidak linear
yang menggambarkan hubungan yang bersifat hirarki (hubungan one to many)
antara elemen-elemen. Tree dapat juga didefinisikan sebagai kumpulan simpul/node
dengan satu elemen khusus yang disebut ROOT dan node yang lainnya terbagi
menjadi himpunan-himpunan yang saling tak berhubungan satu sama lain (disebut
SUBTREE).
Istilah Umum Dalam TREE :
a. Tree (pohon) dan Graph (Graf)

b. Simpul (Vertex, Node) dan Busur (Edge, Arc)
c. Superordinat dan subordinat, father dan son, parent dan children
d. Root (akar) dan Leaf (daun)
e. Level (tingkat) dan Depth (kedalaman)
f. Degree (derajat) simpul dan degree pohon
g. M-ary tree dan binary tree
h. Link dan null-link
Tree (pohon) merupakan bagian dari graph . Dengan simbol matematik

pernyataan Tree dapat dituliskan sebagai berikut : T = € G. Pohon merupakan
kumplan dari simpul dan busur, dimana salah satu simpul merupakan akar (root) dan
simpul-simpul lain membentuk suatu sub pohon / sub tree yang dapat dituliskan sbb:
T = (V, E)
V = vertex/node/titik/simpul.
E = edge/arc/busur.
a. Simpul/Node/Titik/Vertex – Tree terdiri dari 14 buah simpul (n=14) = simpul A

s.d. N atau v0 s.d. v13 V = {v0, v1, v2....... , v13).
Busur/Edge – Tree terdiri dari 13 buah busur (m=12)  e0 s.d. e12 E = {e0, e1,
e2....... , e12).
b. Superordinat diistilahkan dengan father/bapak/parent sedangkan subordinat

diistilahkan dengan son/anak/child.
Contoh :
– Simpul B merupakan superordinat simpul E dan F
– Simpul E dan F merupakan subordinat simpul B
– Simpul B mempunyai superordinat yaitu simpul E (left child) dan F (right
child).
Parent : predecessor satu level di atas suatu node.
Child : successor satu level di bawah suatu node.
c. Root (akar) adalah simpul yang tidak mempunyai superordinat.

– Untuk pohon yang dicontohkan diatas, maka akar adalah simpul A.
– Root : Satu-satunya node khusus dalam tree yang tak punya predecessor.
Leaf/daun adalah simpul yang tidak mempunyai subordinat.
– Untuk pohon yang dicontohkan diatas, maka daun adalah simpul C, E, G, I,
J, K, L, M, N – Leaf : Node-node dalam tree yang tidak memiliki
successor.
d. Level (tingkat) akar dinyatakan berada pada level 0, setiap turunan satu
subordinat, level bertambah 1.
Depth (kedalaman) satu pohon yang mempunyai level teratas atau level tertinggi
= k, maka disebut kedalamannya = k – Untuk pohon yang dicontohkan disamping,
karena level tertinggi adalah 3 maka depth = 3.
e. Height : Banyaknya tingkatan/level dalam suatu tree.
Degree merupakan sebuah simpul yang menyatakan jumlah simpul

subordinat dari simpul tersebut. Untuk pohon diatas :
• Simpul A : degree = 3.
• Simpul B : degree = 2.
• Simpul C : degree = 0.
Ancestor : seluruh node yang terletak sebelum node tertentu dan terletak
pada jalur yang sama.
Descendant : seluruh node yang terletak sesudah node tertentu dan terletak
pada jalur yang sama.
Sibling : node-node yang memiliki parent yang sama dengan suatu node.
Size : Banyaknya node dalam suatu tree.
f. M – ARY TREE
M atau K menyatakan derajat pohon . Contoh : sebuah simpul pohon M-
ary dimana M=3 digambarkan dengan Linked List.
g. LINK, NULL-LINK, DAN BUKAN NULL-LINK
 Link adalah pointer yang digunakan untuk menunjuk simpul subordinat. Untuk
contoh pohon biner adalah setiap simpul mempunyai 2 link, sehingga jumlah
link = n*2.
 Null-Link adalah link yang bernilai Null, yaitu link yang tidak menunjuk simpul
subordinat.
 Bukan Null-Link adalah link yang menunjuk simpul subordinat atau link yang
menghubungkan dua buah simpul yang biasanya disebut dengan busur.
h. BINARY TREE
Contoh : sebuah simpul pohon Binary Tree / Pohon Biner dimana M=2
digambarkan dengan Linked-List.
Contoh Binary Tree / Pohon Biner :
COMPLETE BINARY TREE/FULL BINARY TREE/ ALMOST COMPLETE BINARY TREE
Complete Binary Tree dengan kedalaman = d, merupakan pohon biner

strictly binary treedimana semua daun hanya berada pada level d. Pada
pohon complete binary tree/full binary tree/almost complete binary tree
berlaku :
– Pada leveL k jumlah simpul n=2^k
– Untuk pohon dengan kedalaman d, maka jumlah seluruh simpul n =
2^(d+1)-1
– Untuk pohon dengan kedalaman d, maka jumlah simpul daun n = 2^d
Pohon biner seimbang
Pohon Biner Seimbang / Berimbang adalah pohon biner yang
ketinggian subpohon kiri dan subpohon kanan untuk setiap simpul
superordinat, paling banyak berselisih 1. Jadi pohon biner complete dan
almost complete adalah pohon biner berimbang.
PENOMORAN SIMPUL POHON BINER
Berdasarkan konversi dapat disepakati cara penomoran setiap

simpul dalam pohon biner, yaitu:
– Bila sebuah simpul bernomor n, maka subordinat kiri bernomor 2n
dan subordiat kanan bernomor 2n+1
– Simpul akar, diberi nomor 1
Proses Pohon Biner (Binary Tree), adalah :
1. Mendeklarasikan struktur simpul
2. Inisialisasi
3. Pembuatan sebuah simpul
4. Pembuatan simpul akar
5. Penambahan/melakukan insert simpul baru kedalam sebuah pohon
6. Pembacaan/penelusuran pohon biner
HEAP TREE
Heap adalah tree yang mempunyai persamaan sebagai berikut: R[i] < r[2i]
dan R[i] < r[2i+1]. Heap Tree disebut juga Complete Binary Tree, jika suatu node
mempunyai child, maka jumlah childnya harus selalu dua.
Operasi dalam Heap Tree :

1. Penambahan/melakukan insert simpul
2. Penghapusan/melakukan Delete simpul
Heap Sort adalah seperti metode struktur organisasi, nilai ditukarkan dari
root ke level yang paling rendah.
Contoh :
2. GRAPH
Graph adalah sekumpulan elemen yang saling berhubungan. Graph
merupakan sebuah elemen yang dapat terhubung dengan beberapa elemen lain.
Beberapa elemen dapat terhubung ke beberapa elemen yang lain. Graph terdiri
dari node/vertex/titik dan edges/arc/busur. Graph tidak memiliki root node.
Graph adalah kumpulan dari simpul dan busur yang secara matematis dapat
dinyatakan sebagai berikut:
G = (V, E)
• G = Graph
• V = Simpul/vertex/node/titik
• E = Busur/edge/arc
Graph dibedakan menjadi 2 macam: Graph tak berarah (undirect graph/non

direct graph) dan Graph berarah(direct graph/digraph).
ISTILAH-ISTILAH GRAPH :
1. Incident
2. Degree/derajat, indegree dan outdegree
3. Adjacent
4. Successor dan Predecessor
5. Path
6. Cycle
1) Incident = Apabila e merupakan busur dengan simpul-simpulnya adalah v

dan w yang ditulis e=(v,w) . Maka v dan w disebut terletak pada e, dan e
disebut incident dengan v dan w.
2) Degree sebuah simpul adalah jumlah busur yang incident dengan simpul
tersebut.
Indegree sebuah simpul pada graph berarah adalah jumlah busur yang
kepalanya (head) incident pada simpul tersebut atau dapat dikatakan
jumlah busur masuk atau menuju simpul tersebut.
Outdedegree sebuah simpul pada graph berarah adalah jumlah busur yang
buntutnya (tail) incident pada simpul tersebut atau dapat dikatakan jumlah
busur yang keluar atau berasal dari simpul tersebut.
3) Adjacent
Pada graph tak berarah, dua simpul tersebut adjacent bila ada busur
yang menghubungkan kedua simpul tersebut. Simpul v dan simpul w
disebut adjacent. Pada graph berarah, sebuah simpul v disebut adjacent
dengan simpul w apabila ada busur dari w ke v. Simpul v adjacent dgn
simpul w.
4) Successor dan Predecessor Pada graph berarah, bila simpul v adjacent

dengan simpul w. Simpul v adalah successor (pengganti/ pelanjut) simpul
w. Simpul w adalah predecessor (pendahulu) dari simpul v.
5) Path adalah serangkaian (a sequence) simpul-simpul yang berbeda, yang

adjacent secara berturut-turut dari simpul satu ke simpul berikutnya.
6) Cycle path yang terdiri dari sekurang-kurangnya 3 simpul sedemikian rupa

simpul yang terakhir adjacent dengan simpul pertama.
Agar data yang ada dalam grpah dapat diolah, maka graph harus dinyatakan
dalam suatu struktur data yang dapat mewakili graph tersebut.
Graph perlu direpresentasikan kedalam bentuk array dua dimensi yang sering
juga disebut matrix, atau direpresentasikan dalam bentuk linked list.
G. SEARCH (Sequential, Binary, Fibonacci, Interpolation)
1. Sequential Search
Sequential Search/Pencarian Sekuential adalah proses membandingkan setiap

elemen Larik satu persatu secara beruntun, dari elemen pertama sampai elemen
yang dicari ditemukan.
Data yang ada pada suatu array dibandingkan satu persatu dengan data yang
dicari.
Pencarian ini hanya melakukan pengulangan dari 1 s.d. dengan jumlah data. Pada
setiap pengulangan, dibandingkan data ke-i dengan yang dicari. Apabila sama, berarti
data telah ditemukan. Sebaliknya apabila sampai akhir pengulangan, tidak ada yang
sama, berarti data tidak ada.
Algoritma Pencarian dengan metode Sequential Search / Pencarian Sekuensial

adalah :
1. Tentukan dan simpan data dalam suatu array.
2. Tentukan fungsi pencarian sekuensial.
3. Fungsi pencarian sekuensial adalah sebagai berikut :
int flag=-1;
{
for(int count=0; count < array_size; count++)
{
flag=count; break;
}
}
4. Masukkan data yang akan dicari
5. Kerjakan langkah 3, jika data ketemu kerjakan lang-kah 6 Jika data tidak ketemu
lakukan langkah 6
6. Cetak data tersebut
7. Selesai
Contoh Source Codenya :
2. Binary Search
Salah satu syarat pencarian bagi dua (binary search) adalah data sudah dalam
keadaan terurut. Apabila data belum keadaan terurut, pencarian biner tidak dapat
dilakukan. Data yang terurut merupakan syarat mutlak penerapan pencarian
Algoritma pencarian Bagi Dua.
Prinsip dari pencarian Biner :

 Pertama diambil posisi awal = 1 dan posisi akhir = N, kemudian dicari posisi data
tengah dengan rumus (posisi awal+posisi akhir)/2 .
 Kemudian data yang dicari dibandingkan dengan data tengah.
 Jika lebih kecil, proses dilakukan kembali tetapi posisi akhir dianggap sama dgn
posisi tengah -1.
 Jika lebih besar, proses dilakukan kembali tetapi posisi awal dianggap sama dgn
posisi tengah +1.
 Demikian seterusnya sampai data tengah sama dengan yang dicari.
3. Fibonacci Search
Merupakan pencarian sebuah elemen dalam sebuah array satu dimensi

dengan menggunakan angka fibonacci sebagai titiktitik (index) elemen array yang
isinya dibandingkan dengan nilai yang dicari (misal N).
Salah satu syarat pencarian fibonacci adalah data sudah dalam keadaan
terurut. Prosesnya hanya menggunakan operasi tambah dan kurang yang
memerlukan waktu yang lebih cepat dibandingkan dengan proses pembagian yang
digunakan pada binary search.

4. Interpolation Search
Merupakan pencarian sebuah elemen dalam sebuah array satu dimensi

dengan menggunakan rumus interpolasi atau perkiraan secara interpolasi. Berlaku
rumus interpolasi adalah b/a = q/p.

BAB II
TUGAS PERORANGAN
1. STRUCT
Soal Nomor 1
A. Program
B. Pseudocode :
Algoritma Struktur
KAMUS/DEKLARASI VARIABEL FUNCTION
Struct KHS nama[20][20],matkul[20]
[20],huruf[10] = char
Sks[10],angka[10],nomor[10] = int
Struct NIM
fakultas[1],prodi[1],angkatan[2],status[2],
rk_r[1],no_urut[3]
Main
jumlah,sid,dik,reg,jsks,jmutu,Nakhir,ipk =
int
ALGORITMA/DESKRIPSI:
struct KHS{Char nama[20][20],matkul[20]
[20],huruf[10]int
sks[10],angka[10],nomor[10]}
KHS data
Struct NIM{char fakultas[1],
prodi[1],angkatan[2],status[2],rk_r[1],no_u
rut[3]
}
NIM kode
Print(Input Jumlah Mahasiswa : )
For(sid=1; sid<=jumlah; sid++)
{
Print(Nama Mahasiswa Ke <<sid<< Print(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
: ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~)
Gets(data.nama[sid]) Print(Jumlah Mata Kuliah Yang Diambil = )
print(Nomor Induk Mahasiswa <<reg
: ) Print(jumlah SKS = )
print(Kode Fakultas : ) <<jsks)
cinkode.fakultas Print(Indeks Prestasi Komulatif [IPK] = )
print(Kode Prodi : ) <<ipk
cinkode.prodi Print(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
print(Kode Angkatan : ) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~)
cinkode.angkatan }
print(Kode Status : )
cinkode.status C. Algoritma:
print(Kode RK/R : ) 1. Mendeklarasikan stuktur nama[20]
cinkode.rk_r [20],matkul[20]
print(Nomor Urut : ); [20],huruf[10],sks[10],angka[10],nomor[
cinkode.no_urut 10]
ptint(Nomor Induk Anda 2. Mendefinisikan stuktur(KHS Data)
Adalah : ) 3. Mendeklarasikan atruktur fakultas[1],
<<kode.fakultas,kode.prodi,kode.angkatan,ko prodi[1],
de.status,kode.rk_r,kode.no_urut angkatan[2],status[2],rk_r[1],no_urut[3
print(Banyak Mata Kuliah Yang ]
Diambil : ) 4. Mendefinisikan stuktur(NIM kode)
5. Mendefinisikan jumlah,sid, dik,
cinreg
reg,jsks,jmutu,Nakhir,ipk dalam bentuk
for(dik=1; dik<=reg; dik++)
integer
{
6. Menampilkan (Input Jumlah Mahasiswa)
Print(Mata Kuliah Yang Ke : <<dik<<)
7. Menginput nilai jumlah
Print(Nama Mata Kuliah : )
8. Membuat pengulangan for(sid=1;
Gets(data.matkul[dik]);
sid<=jumlah; sid++)
Print(jumlah sks : )
9. Menampilkan (Nama Mahasiswa Ke<<sid<<,
Cindata.sks[dik], sizeof(data.sks) menginput nilai data.nama[sid]
Print(nilai huruf : ) 10. Menampilkan (Nomor Induk Mahasiswa
11. Menampilkan (kode fakultas), menginput
Cindata.huruf[dik],sizeof(data.sks) kode.fakultas
Print(nilai angka :) 12. Menampilkan (kode prodi), menginput
Cindata.angka[dik],sizeof(d kode.prodi
ata.sks) Nakhir = 13. Menampilkan (kode angkatan), menginput
data.sks[dik]*data.angka[dik] kode.angkatan
Print(nilai akhir : ) 14. Menampilkan (kode status), menginput
<<Nakhir kode.status
15. Menampilkan (kode rk_r), menginput
kode.rk_r
16. Menampilkan (nomor urut), menginput
jmutu = jmutu + Nakhir kode.no_urut
jsks = jsks + data.sks[dik] 17. Menampilkan (nomor induk anda adalah),
menampilkan nilai
ipk = jmutu/jsks kode.fakultas,kode.prodi,kode.angkatan,
} kode.status,kode.rk_r.kode.no_urut
18. Menampilkan (banyak mata kuliah yang
Print(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diambil), menginput reg
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~) 19. Membuat pengulangan for(dik=1;
Print( KARTU HASIL dik<=reg; dik++)
STUDI [KHS]) 20. Menampilkan (mata kuliah yang ke :
<<dik<<)
21. Menampilkan (nama mata kuliah),
Print(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ menginput data.matkul[dik]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~) 22. Menampilkan (jumlah sks), menginput
Print(Nama Mahasiswa : ) data.sks[dik]
<<data.nama[sid] 23. Menampilkan (nilai huruf), menginput
Print(Nomor Induk Mahasiswa :) data.huruf[dik]
<<kode.fakultas,kode.prodi,kode.angkatan,ko 24. Menampilkan (nilai angka), menginput
de.status,kode.rk_r,kode.no_urut data.angka[dik]
Print(Mata Kuliah Yang Ditempuh : ) 25. Membuat rumus Nakhir =
Print(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ data.sks[dik]*data.angka[dik]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~) 26. Menampilkan (nilai akhirNakhir)
Print(No Mata Kuliah SKS 27. Membuat rumus jmutu = jmutu + Nakhir,
Nilai Huruf Nilai Angka) jsks = jsks + data.sks[dik], ipk =
Print(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ jmutu/jsks
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~) 28. Menampilkan(~~~~~~~~~~~~~~~~~~~~~~~~~~~
for(dik=1; dik<=reg; dik++) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
{ ~~~~)
Print(dik<<setw(22)<<data.matkul[dik]<<setw 29. Menampilkan
(8)<<data.sks[dik]<<setw(15)<<data.huruf[di (KARTU HASIL STUDI [KHS])
k]<<setw(19)<<data.angka[dik]) 30. Menampilkan(~~~~~~~~~~~~~~~~~~~~~~~~~~~
} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~)
31. Menampilkan(Nama Mahasiswa
: "<data.nama[sid]
32. Menampilkan Nomor Induk (Mahasiswa

:
<<kode.fakultas,kode.prodi,kode.angkata
n,kode.status,kode.rk_r,kode.no_urut)
33. Menampilkan (Mata Kuliah Yang Ditempuh
: )
34. Menampilkan
(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~)
35. Menampilkan (No Mata Kuliah
SKS Nilai Huruf Nilai
Angka)
36. Menampilkan(~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~)
37. Membuat pengulangan for(dik=1;
dik<=reg; dik++)
38. Menmapilkan nilai
dari(dik,data.matkul,data.sks,data.huru
f,data.angka)
39. Menampilkan
(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~)
40. Menampilkan( Jumlah Mata Kuliah Yang
Diambil = reg)
41. Menampilkan(Jumlah SKS
= jsks)
42. Menampilkan (Indeks Prestasi Komulatif
[IPK] = ipk)
43. Menampilkan
(~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~)
Menit minutes
JAM hours
2. ADT Input (second); output (second)
Input (minutes);output(minutes)
1. ADT jam dengan bahas algoritmik. Input(hours);output(hours)
a. Program
c. Algoritma
1. Pendefinisian type detik
2. Pendefinisian type menit
3. Pendefinisian type JAM
4. Mendefinisikan objek detik
pada type minutes
5. Mendefinisikan objek menit
pada type minutes
6. Mendefinisikan objek JAM
pada type hours
7. Memasukkan isi data objek
second
8. Mencetak/menampilkan isi
data objek second
second
minutes
data objek minutes
hours
data objek hours.
14. Selesai
b. Pseudocode
Algoritma ADT jam
Kamus /Deklarasi Variabel
Detik = int
Menit = float
JAM = float
Algoritma/Deskrpsi
Typedef detik
Typedef menit
Typedef jam
Detik second
58
3. SELECTION SORT
a. Program di notepad. b. output
b. Output
59
4. SHELL SORT
A. Program
B. Pseudocode
KAMUS/DEKLARASI VARIABEL
Sid1, sid2, sid3, sid4, n = int
A[n] = int
DESKRIPSI VARIABEL
Public : class SIDDIK (sid1, sid2,
sid3, sid4, n, fungsi Urutan, fungsi
DIK1, fungsi DIK2)
SIDDIK::DIK1
Int A[1000]
For (sid1=0; sid1<n; sid1++)
Print 1+sid1
Input A[sid1]
End for
For (sid1=0; sid1<n; sid1++)
Print A[sid1]
End for
for(sid2=n/2; sid2>0; sid2/=2)
for (sid3=sid2; sid3<n;
sid3++)
for (sid1=sid3-sid2;
sid1>=0; sid1-=sid2)
if
(A[sid1+sid2]>=A[sid1]) break
else
sid4=A[sid1]
A[sid1]=A[sid1+sid2]
A[sid1+sid2]=sid4
End if
End for
End for
End for
SIDDIK::DIK2
Int A[1000]
for(sid1=0; sid1<n; sid1++)
print A[sid1]
end for
SIDDIK urut
Urut.DIK1
60
Urut.DIK2
5. MERGE SORT
A. Program
B. Algoritma
1. Membuat class SIDDIK

2. Pendefinisian type deklarasi class
{public : int a[50], int merge
(int,int,int), int cetak()}
3. Membuat fungsi mergeSort (int low,
int up) di dalam class SIDDIK
4. Deklarasi mid dalam bentuk integer
5. Jika (low<up) kerejakan baris 6 s.d
9
6. mid=(low+up)/2
7. mergeSort(low,mid)
8. mergeSort(mid+1,up)
9. merge(low,mid,up)
10. membuat fungsi merge (int low, int
mid, int up) di dalam class
Hasil Running : SIDDIK
11. Deklarasi b[50],h,i,j,k dalam
bentuk integer
12. h = low
13. i = low
14. j = mid+1
15. selama (h<=mid)&&(j<=up) kerjakan
baris 16 s.d 22 jika tidak
kerjakan baris 19 s.d 20
16. jika a[h] > a[j] kerjakan baris 17
s.d 18
17. b[i]=a[h]
18. h++
19. b[i]=a[j]
20. j++
21. i++
22. jika (h>mid) kerjakan baris 23 s.d
27 jika tidak kerjakan baris 28 s.d
31
23. k=j
24. selama k<=up kerjakan baris 25 s.d
27
25. b[i]=a[k]
26. i++
27. k++
28. k=h
61
29. selama (k<=nid ) kerjakan baris 30
s.d 32
30. b[i]=a[k]
31. i++
32. k++
33. k=low
34. selama (k<=up) kerjakan baris 35
s.d 36
35. a[k]=b[k]
36. k++
37. membuat fungsi cetak di dalam class
SIDDIK
38. deklarasi( jumlahBil, c) dalam
bentuk integer
39. memasukkan isi variabel jumlahBil
40. c=1
41. selama( c<=jumlahBil) kerjakan
baris 42 43
42. mencetak/menampilkan a[c]
43. c++
44. mergeSort(1,jumlahBil)
45. c=1
46. selama( c<=jumlahBil) kerjakan
baris 47 s.d 48
47. mencetak/menampilkan a[c]
48. c++
49. pendefinisian objek class SIDDIK
dengan regar
50. regar.cetak()
51. selesai
62
6. QUICK SORT
1. Program
2. Psuodocode
Deklarasi Variabel
Public :
int qSort (int[], int, int)
int dik()
Deskripsi Variabel
int SIDDIK::qSort(int jumlah[], int
kiri, int kanan)
int pivot, ki_hold, ka_hold
ki_hold=kiri
ka_hold=kanan
pivot=jumlah[kiri]
while(kiri<kanan)
while((jumlah[kanan]>=pivot) &&
(kiri<kanan))
kanan--
end while
if (kiri != kanan)
jumlah[kiri]=jumlah[kanan]
kiri++
end if
while((jumlah[kiri]<=pivot) &&
(kiri<kanan))
kiri++
end if
if (kiri != kanan)
jumlah[kanan]=jumlah[kiri]
kanan--
end if
end while
jumlah[kiri] = pivot
pivot=kiri
kiri=ki_hold
kanan=ka_hold
if (kiri<pivot)
63
qSort (jumlah, kiri, pivot-1) 34) c=1
end if 35) selama c<=n kerjakan baris 35 s.d
if (kanan>pivot) 37
qSort(jumlah, pivot+1, kanan)
36) mencetak/menampilkan A[c]
end if
37) c++
int SIDDIK::dik() 38) pendefinisian objek class SIDDIK
int A[50] dengan regar
int c, n 39) memanggil fungsi regar.dik()
input (n) 40) selesai
for (c=1; c<=n; c++)
input (A[c])
end for
qSort (A, 1, n)
for (c=1; c<=n; c++)
print (A[c])
SIDDIK regar
regar.dik()
3. Algoritma
1) Membuat class SIDDIK

2) Pendefinisian type deklarasi class
SIDDIK { public : int qSort (int[],
int, int), int dik() }
3) Membuat fungsi qSort(int jumlah[],
int kiri, int kanan) dalam class
SIDDIK
4) Deklarasi pivot, ki_hold, ka_hold
dala bentuk integer
5) ki_hold=kiri
6) ka_hold=kanan
7) pivot=jumlah[kiri]
8) selama (kiri<kanan) kerjakan baris
9 s.d 18
9) selama (jumlah[kanan]>=pivot) &&
(kiri<kanan) kerjakan baris 10
10) kanan --
11) jika kiri != kanan kerjakan baris
12 s.d 13
12) jumlah[kiri]=jumlah[kanan]
13) kiri++
14) selama ((jumlah[kiri]<=pivot) &&
(kiri<kanan))
15) kiri++
16) jika (kiri != kanan) kerjakan baris
17 s.d 18
17) jumlah[kanan]=jumlah[kiri]
18) kanan--
19) jumlah[kiri] = pivot
20) pivot=kiri
21) kiri=ki_hold
22) kanan=ka_hold
23) jika (kiri<pivot) maka qSort
(jumlah, kiri, pivot-1)
24) jika (kanan>pivot) maka
qSort(jumlah, pivot+1, kanan)
25) membuat fungsi dik () dalam class
SIDDIK
26) deklarasi A[50], c, n dalam bentuk
integer
27) memasukkan isi variabel (n)
28) c=1
29) selama c<=n kerjakan baris 30 s.d
32
30) mencetak/menampilkan c
31) memasukkan isi variabel A[c]
32) c++
33) memanggil fungsi qSort (A, 1, n)
64
7. LINKED LIST
A. PROGRAM
Hasil Running :
B. ALGORITMA
1. Membuat struktur Node { int INFO,

struct Node *LEFT, struct Node
*RIGHT}
2. Mendefinisikan struktur Node dengan
nama Simpul
3. Membuat pointer yang menunjuk ke
Simpul { *P, *FIRST, *LAST, *Q}
4. Mendefinisikan integer X
5. Membuat function BUAT_SIMPUL( int
X )
65
6. Mendefinisikan function 63. Memanggil function INSERT_KANAN()
BUAT_SIMPUL( int X ) 64. Memanggil function CETAK()
7. P=(Simpul*) malloc (sizeof(Simpul)) 65. X = 99
8. Jika (P != NULL) maka P -> INFO = X 66. Memanggil function BUAT_SIMPUL(X)
jika tidak maka mencetak/menampilkan 67. Memanggil function INSERT_KIRI()
(“ kosong “) 68. Memanggil function CETAK()
9. Membuat function AWAL() 69. Memanggil function DELETE_KANAN()
10. Mendefinisikan function AWAL() 70. Memanggil function CETAK()
11. FIRST = P 71. Memanggil function DELETE_KIRI()
12. LAST = P 72. Memanggil function CETAK()
13. P -> LEFT = NULL 73. Selesai.
14. P -> RIGHT = NULL
15. Membuat function INSERT_KANAN()
16. Mendefinisikan function
INSERT_KANAN()
17. P -> LEFT = LAST
18. LAST -> RIGHT = P
19. LAST = P
20. P -> RIGHT = NULL
21. Membuat function INSERT_TENGAH()
22. Menfinisikan funtion INSERT_TENGAH()
23. P -> RIGHT = Q -> RIGHT
24. P -> LEFT = Q
25. P -> RIGHT -> LEFT = P
26. Q -> RIGHT = P
27. Membuat function DELETE_KANAN()
28. Mendefinisikan funtion
DELETE_KANAN()
29. LAST = LAST -> LEFT
30. free(LAST -> RIGHT)
31. LAST -> RIGHT = NULL
32. Membuat funtion DELETE_KANAN()
33. Mendefinisikan function
DELETE_KANAN()
34. FIRST = FIRST -> RIGHT
35. free(FIRST -> LEFT)
36. LAST -> LEFT = NULL
37. Membuat funtion CETAK()
38. Mendefinisikan funtion CETAK()
39. Mendefinisikan int X
40. Q = FIRST
41. Selama (Q != NULL) kerjakan baris
42 s.d 44
42. X = Q -> INFO
43. Mencetak/menampilkan X
44. Q = Q -> RIGHT
45. Membuat fungsi utama
46. Mendefinisikan fungsi utama
47. Menefinisikan anggota integer array
A[7] = {22, 28, 7, 11, 66, 63, 10};
48. Mendefinisikan integer I
49. FIRST = NULL
50. I = 0
51. X=A[I]
52. Memanggil function BUAT_SIMPUL(X)
53. Memanggil function AWAL()
54. I=1
55. Selama I<6 kerjakan baris 56 s.d
59
56. X=A[I]
58. Memanggil function INSERT_KANAN()
59. I++
60. Memanggil function CETAK()
61. X = 100
66
Deklarasi Variabel Function
INSERTKIRI
8. STACK Nama = char
Deskripsi Variabel Function
1. program INSERTKIRI
Node *p
P = new Node
P -> LINK = FIRST
Strcpy (p -> nama, nm)
FIRST = p
Print (1)
Deklarasi Variabel Function CETAK1
-
Deskripsi Variabel Funtion CETAK1
Node *Q
Q = FIRST
While (Q != NULL)
Print (‘Nama : ‘<< Q -> nama )
Q = Q -> LINK
End while
Deklarasi Variabel Function CETAK2
-
Deskripsi Variabel Function CETAK2
Node *Q
Q = FIRST
While (Q != NULL)
Print (‘Q -> nama << “ “)
Q = Q -> LINK
End while
Deklarasi Menu Utama
-
Deskripsi Menu Utama
SIDDIK Xx
Xx.INSERTKIRI ("Candra")
Xx.INSERTKIRI ("Cinthya")
Xx.INSERTKIRI ("Ilham")
Xx.INSERTKIRI ("Tiara")
Xx.INSERTKIRI ("Fanny")
Xx.CETAK1()
Print ("Nama : ")
Xx.CETAK2()
3. Algoritma
1) Mendeklarasikan Struct SIDDIK
{ nama [20], Node *LINK}
2) Mendeklarasikan Class SIDDIK
{( private : Node *FIRST, *LAST,
*Q), (public : SIDDIK(), void
INSERTKIRI (char *nama), void
CETAK1(), void CETAK2()}
3) Mendeklarasikan Function SIDDIK
4) Mendeskripsikan Function SIDDIK
5) FIRST = NULL
6) Mendeklarasikan Function
INSERTKIRI (char *nama)
7) Mendeskripsikan Function
2. Pseudocode INSERTKIRI
Deklarasi Variabel Stuct Node 8) Node *p
- 9) p = new Node
Deskripsi Variabel Stuct Node 10) p -> LINK = FIRST
Nama [20] = char 11) Pengisian (p -> nama,nm)
Node *LINK
12) FIRST = p
Deklarasi Variabel Class SIDDIK
- 13) Mendeklarasikan Function CETAK1
Deskripsi Variabel Class SIDDIK 14) Mendeskripsikan Function CETAK1
Private : Node *FIRST, *LAST, *Q 15) Node *Q
Public : SIDDIK(), void INSERTKIRI 16) Q = FIRST
(char *nama), void CETAK1(), void 17) Selama (Q tidak sama dengan
CETAK2(). NULL), maka kerjakan baris 18
Deklarasi Variabel Function SIDDIK
s.d 19
-
Deskripsi Variabel Function SIDDIK 18) Mencetak/Menampilkan (“Nama :
FIRST = NULL "<< Q -> nama )
67
19) Q = Q -> LINK
20) Mendeklarasikan Funtion CETAK2
21) Node *Q
22) Q = FIRST
23) Selama (Q tidak sama dengan
NULL), maka kerjakan baris 24
s.d 25
24) Mencetak/menampilkan ( Q -> nama
<< " " )
25) Q = Q -> LINK
26) Mendeskripsikan menu utama
27) Pemberian nama objek pada Class
SIDDIK dengan (Xx)
28) Pengaksesan & Pengisian Function
Xx.INSERTKIRI ("Candra")
Xx.INSERTKIRI ("Cinthya")
Xx.INSERTKIRI ("Ilham")
Xx.INSERTKIRI ("Tiara")
Xx.INSERTKIRI ("Fanny")
33) Pengaksesan Function Xx.CETAK1()
34) Mencetak/Menampilkan (“Nama : ")
35) Pengaksesan Function Xx.CETAK2()
36) Selesai
68
9. QUEUE
1. PROGRAM
2. Pseudocode
Deklarasi Variabel Struct biodata

-
Deskripsi Variabel Srtuct biodata
char = nama [20]
int = usia
Deklarasi Variabel Function init
(void)
-
Deskrpsi variabel Function init
awal = -1
akhir = -1
Deklarasi Variabel Function full
-
Deskripsi Variabel Function full
if (akhir==MAX-1) return(true)
else return (false)
end if
Deklarasi Variabel Function enqueue
Stuct biodata mhs
Deskripsi Variabel function enqueue
if (empty()== true)
awal = 0
akhir = 0
queue[awal] = mhs
end if
else if (full() != true)
akhir++
queue[akhir] = mhs
end if
else Print ("Queue Sudah Penuh ....
")
Deklarasi Variabel Function Display
Struct biodata mhs
Deskripsi Variabel function Display
Print ( “Nama : “<<mhs.nama)
69
Print (“ Usia : "<<mhs.usia)
Deklarasi Variabel Function Baca
i = int
Deskripsi Variabel Function Baca
Print( "Isi Queue : ") 3. Algoritma
for (i=awal; i<=akhir; i++) 1) Mendeklarasikan struct biodata
display(queue[i]) 2) Mendeskripsikan struct biodata {
end for char nama [20], int usia }
end if 3) Mendeskripsikan objek struct
else Print (“Data Kosong.") biodata dengan mhs dan
end if queue[MAX]
4) Mendeklarasikan function init
Deklarasi Variabel Struct biodata (void)
entridata 5) Mendeskripsikan function init
- (void)
Deklarasi Variabel Struct biodata 6) awal = -1
entridata 7) akhir = -1
struct biodata mhs 8) mendeklarasikan function full
Print (“Masukkan Nama : ") (void)
Input (mhs.nama) 9) mendeskripsikan function full
Print (“Masukkan Usia : ") (void)
Input (mhs.usia) 10) jika (akhir==MAX-1) maka
return(mhs) print(true) jika tidak maka
Deklarasi Variabel Struct biodata print (false)
dequeue 11) mendeklarasikan function empty
i = int (void)
Deskripsi Variabel Struct biodata 12) mendeskripsikan function empty
dequeue (void)
if (empty() != true) 13) jika (akhir == MAX-1) maka print
mhs = queue[awal] (true) jika tidak maka print
for (i=awal; i<=akhir; i++) (false)
queue[i] = queue [i+1]; 14) mendeklarasikan funtion enqueue
akhir--; (struct biodata mhs)
return(mhs) 15) mendeskripsikan funtion enqueue
end if (struct biodata mhs)
end for 16) jika (empty() == true) maka
else Print (“Queue kosong ....") kerjakan baris 17 s.d 19 jika
end if tidak maka kerjakan baris 23
Deklarsi Variabel Menu Utama 17) awal = 0
Awal, akhir = int 18) akhir = 0
Nocomment[10], pilih = char 19) queue[awal] = mhs
Deskripsi Variabel Menu Utama 20) jika (full() tidak sama dengan
char pilih; true) maka kerjakan baris 21 s.d
print (“ Program Entri Data 22 jika tidak maka kerjakan
Mahasiswa " baris 23
init () 21) akhir++
do 22) queue[akhir] = mhs
print ("MENU PILIHAN : ") 23) else Mencetak/Menampilkan
Print (“1. Input Data") (“Queue Sudah Penuh .... ")
Print (“2. Hapus Data") 24) mendeklarasikan function display
Print ("3. Lihat Daftar Mhs") (struct biodata mhs)
Print (“4. Hapus Semua Data") 25) mendeskripsikan function display
Print (“5. Selesai") (struct biodata mhs)
Print (“Pilih 1 s.d 5 : ") 26) Mencetak/Menampilkan (" Nama :
Input (pilih) "<<mhs.nama)
switch (pilih) 27) Mencetak/Menampilkan (“Usia :
case '1' : mhs = entridata() "<<mhs.usia)
enqueue (mhs) 28) Mendeklarasikan function baca
break (void)
case '2' : Print (“Data yang 29) Mendeskripsikan function baca
dihapus : ") (void)
mhs = dequeue() 30) Deklarasi int i
display (mhs) 31) Mencetak/menampilkan ( "Isi
break Queue : ")
case '3' : baca() 32) jika (empty() != true) maka
break kerjakan baris 33 s.d 36 jika
case '4' : init() tidak kerjakan baris 37
Print ("Data telah dikosongkan") 33) i=awal
break 34) selama (i<=akhir) maka kerjakan
case '5' : break baris 35 s.d 36
default : Print ("Pilih 1 s.d 5 !”) 35) display(queue[i])
break 36) i++
while (pilih != '5') 37) else Print ("Data Kosong.")
return 0 38) Mendeklarasika struct biodata
entridata (void)
70
39) Mendeskripsikan struct biodata
entridata (void)
40) struct biodata mhs
41) Mencetak/menampilkan (“Masukkan
Nama : ")
42) Menginput ( mhs.nama )
43) Mencetak/menampilkam (“Masukkan
Usia : ")
44) Menginput ( mhs.usia )
45) Mencetak/menampilkan (mhs)
46) Mendeklarasikan struct biodata
dequeue (void)
47) Mendeskrpsikan struct biodata
dequeue (void)
48) Deklarasi int i
49) Jika (empty() != true) maka
kerjakan baris 50 s.d 56 jika
tidak kerjakan baris 57
50) mhs = queue[awal]
51) i=awal
52) selama ( i<=akhir ) maka
kerjakan baris 53 s.d 56
53) queue[i] = queue [i+1];
54) akhir--;
55) return(mhs);
56) i++
57) else Print (“Queue kosong ....")
58) Mendeklarasikan integer awal,
akhir
59) Mendeklarasikan char
nocomment[10]
60) Mendeklarasikan menu utama
61) Mendeskripsikan menu utama
62) Deklarasi char pilih
63) Pengaksesan function init ()
64) Menginput (pilih)
65) Memilih (pilih)
66) case '1' : mhs = entridata()
67) enqueue (mhs)
68) break
69) case '2' : mhs = dequeue();
70) display (mhs)
71) break
72) case '3' : baca()
73) break
74) case '4' : init()
75) case '5' : break
76) default : break
77) selama (pilih != '5') maka
mencetak 0
78) selesai
71
kerjakan
baris 13
13. exit(1)
14. membuat
fungsi
BuatSimpulA
kar
10. TREE 15. Jika (Root
a. Pr == NULL)
ogram maka
#include <iostream> kerjakan
#include <stdio.h> baris 16
#include <stdlib.h> s.d 23
#include <conio.h> 16. Jika (P !=
NULL) maka
Using namespace std; else{ Output :
kerjakan
struct Node { Flag = 1;
baris 17
char INFO; j++;
Q[j] = NULL; s.d 20
struct Node* LEFT;
} 17. Root = P
struct Node* RIGHT;
if(Flag == 0){ 18. P->LEFT =
};
X = Input[j-1]; NULL
typedef struct Node Simpul; if(X != '0'){ 19. P->RIGHT =
Simpul *Root, *P, *Q[30], *R ,*Current; NULL;
char X; 20. Jika tidak
BuatSimpul(X);
Current->RIGHT = P; maka
int Inisialisasi(){ j++; kerjakan
Root = NULL; Q[j] = P; baris 21
P = NULL; } 21. Print
} } “Simpul
else{ belum
int BuatSimpul (char X) { Flag = 1; dibuat”
P = (Simpul*) j++; 22. Jika tidak
malloc(sizeof(Simpul)); Q[j] = NULL;
if(P != NULL) { maka
} kerjakan
P->INFO = X; i++;
P->LEFT = NULL; } baris 23
P->RIGHT} = NULL; 23. Print
} b. Algoritma “Pohon
else{ int BacaUrutNomer(){ Sudah
cout<<"PembuatanintSimpul 1. Membuat Ada !!!!”
i,j,n, Counter;
Gagal \n"; i=1;j=1;n=1;Counter=0; fungsi 24. Membuat
exit(1); int level=0; struktur fungsi
} while(Q[i] != NULL){ Node insertUrutN
} 2. Membuat
Current = Q[i]; omer
if(i == 1){ fungsi 25. Flag = 0
int BuatSimpulAkar(){ struktur
cout<<"Level 26. i = 1
if(Root == NULL)"<<level<<"\n";
{ Node Simpul
if(P != NULL) { 27. j =1
} 3. Membuat 28. Selama
Root = P; cout<<Current->INFO<<"
fungsi- "; (Flag == 0
P->LEFT = NULL; Counter++;
P->RIGHT = NULL;if(Counter == n){ Inisialisas && j < 6)
} i maka
level++;
else{ 4. Root = NULL kerjakan
cout<<"\nLevel
cout<<"Simpul 5. P = NULL baris 29
"<<level<<"";
belum dibuat \n"; } 6. Membuat s.d 51
} if(Counter == n){ fungsi 29. X =
} cout<<endl; BuatSimpul Input[j-1
else{ Counter = 0; 7. P = 30. Jika (X !=
cout<<"Pohon Sudah
n = n*2; (Simpul*) '0') maka
Ada !!!! \n"; } malloc(size kerjakan
} if(Current->LEFT != NULL){ of(Simpul)) baris 31
} j++; 8. Jika (P != s.d 36
Q[i] = Current->LEFT; NULL) maka 31. BuatSimpul(
int insertUrutNomer(char} Input[16]){ kerjakan X)
int i,j, Flag; if(Current->RIGHT != NULL){ baris 9 s.d 32. Current =
char X; j++; 11 Q[i]
Flag = 0; Q[i] = Current->LEFT;
9. P->INFO = X 33. Current-
i=1; }
j=1; if(Current->RIGHT != NULL){ 10. P->LEFT = >LEFT = P
j++; NULL 34. j++
Q[i] = Root; 11. P->RIGHT =
Q[i] = Current->RIGHT; 35. Q[j] = P
while (Flag == 0 && j < 16){ NULL
}
X = Input[j-1]; 36. Jika tidak
12. Jika tidak
if(X != i++;
'0'){ maka
} maka kerjakan
BuatSimpul(X);
}
Current = Q[i];
Current->LEFT = P;
int main(){
j++;
char =root
72
Q[j] P; = '9';
} char Daun[16] = {'7', '2', '1', '9', '9',
'1', '8', '4', '5', '1', '7', '2', '1',
'1', '1', '6'};
Inisialisasi();
BuatSimpul(root);
baris 37 65. Counter = 0 Lo, Hi,
s.d 39 66. n = n*2 Mid, Flag,
37. Flag = 1 67. jika A[1000]
38. j++ (Current- 2. Menginput/m
39. Q[j] = NULL >LEFT != engisi data
40. Jika (Flag NULL) maka pada ‘sid’
== 0) maka kerjakan 3. Dik=0
kerjakan baris 68
4. Selama
baris 41 s.d 69
dik<sid
s.d 51 68. j++
41. X = 69. Q[i] = 11. SEARCH kerjakan
Input[j-1]; Current- A. PROGRAM baris 5 s/d
42. Jika (X != >LEFT 7
'0') maka 70. Jika 5. Mencetak/me
kerjakan (Current- nampilkan
baris 43 >RIGHT != “Data ke-
s.d 46 NULL) maka “<<1+dik<<”
43. BuatSimpul( kerjakan : “
X) baris 71 6. Menginput/m
44. Current- s.d 72 engisi data
>RIGHT = P 71. j++ A[dik]
45. j++ 72. Q[i] = 7. Dik++
46. Q[j] = P Current- 8. Dik=0
47. Jika tidak >LEFT
9. Selama
maka 73. Jika
dik<sid
kerjakan (Current-
baris 48 >RIGHT != kerjakan
s.d 51 NULL) maka baris 10
48. Flag = 1 kerjakan s/d 11
49. j++ baris 74 10. Mencetak/me
50. Q[j] = NULL s.d 76 nampilkan
51. i++ 74. j++ A[dik]
52. membuat 75. Q[i] = 11. Dik++
fungsi Current- 12. Menginput/m
BacaUrutNom >RIGHT enigisi
er 76. i++ data pada
53. level = 0 77. membuat ‘N’
54. counter = 0 fungsi 13. Lo=0
55. Selama utama 14. Hi=sid-1
(Q[i] != 78. Daun [6] =
15. Flag=0
NULL) maka {7,02,00,16
16. Selama ((Lo
kerjakan ,45172106}
baris 56 79. Memanggil <= Hi &&
s.d 76 fungsi Output : Flag==0)
56. Current = Inisialisai kerjakan
Q[i] 80. Memanggil baris 17
57. Jika (i == fungsi s/d 19
1) maka BuatSimpul 17. Mid=(Lo+Hi)
kerjakan 81. Memanggil /2
baris 58 fungsi 18. Jika
s.d 60 BuatSimpulA N==A[Mid]
58. Input level kar maka Flag=1
59. Print 82. Memanggil jika tidak
“Current- fungsi kerjakan
>INFO" insertUrutN baris 19
60. Counter++ omoer
19. Jika
61. Jika 83. Memanggil
N<A[Mid]
(Counter == fungsi
n) maka BacaUrutNom maka
kerjakan er Hi=Mid-1
baris 62 84. Selesai jijka tidak
s.d 63 maka
62. level++; Lo=Mid+1
63. print 20. Jika
“level” Flag==1
64. jika kerjakan
(Counter == B. ALGORITMA baris 21
n) maka 1. Deklarasi jka tidak
kerjakan variabel kerjakan
baris 65 integer N, baris 22
s.d 66 sid, dik,
73
21. Mencetak/me
nampilkan
"Nilai
"<<N<<"
ditemukan
pada kolom
ke
"<<(Mid+1)
22. Mencetak/me
nampilkan
"Nilai
tidak
ditemukan"
23. Selesai.
74
BAB III
TUGAS BESAR
A. PROGRAM
#include<iostream>
#include<conio.h>
#include<iomanip>//setw
class SIDDIK
{
public :
int jumpel, sid,jumlah, totbar=0, reg,dik,sid1, sid2, sid3, sid4;
int input();
int sort();
int search();
int graph();
int cetak_graph(int [] [20], int);
};
struct Toko
{
int nomor[10], kode[20], harga[20], quantity[20], telp;
char nabar[20][20], napel[20], alamat[20];
};
Toko data;
int main()
{
int pilih;
char pilihlagi;
SIDDIK regar; //Pendefinisian Objek
system("cls");
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
cout<<"| Nama : Siddik |"<<endl;
cout<<"| Nim : 4517210039 |"<<endl;
cout<<"| Kelas : B |"<<endl;
cout<<"| Tugas : Program Algoritma Struktur Data |"<<endl;
cout<<"| Judul : Penjualan Toko Bagus |"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
system("pause");
cout<<endl;
awal:
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
cout<<" MENU"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;
cout<<"1. Input Data"<<endl;
cout<<"2. Shell Sort - Descending"<<endl;
cout<<"3. Interpolation Search"<<endl;
cout<<"4. Graph Tak Terarah"<<endl;
cout<<" A. Path"<<endl;
cout<<" B. Cycle"<<endl;
cout<<"5. Keluar"<<endl;
cout<<endl;
cout<<"PILIH KODE : ";cin>>pilih;
switch (pilih)
{
case 1 :
regar.input();
cout<<endl;
system("pause");
goto awal;
break;
cout<<endl;
75
case 2 :
regar.sort();
cout<<endl;
system("pause");
goto awal;
break;
cout<<endl;
case 3 :
regar.search();
cout<<endl;
system("pause");
goto awal;
break;
cout<<endl;
case 4 :
regar.graph();
system("pause");
cout<<endl;
back:
cout<<endl;
cout<<"A. Path"<<endl;
cout<<"B. Cycle"<<endl;
cout<<"C. Kembali Ke Menu Utama"<<endl;
cout<<endl;
cout<<"Pilih A/B/C : ";cin>>gar;
cout<<endl;
switch (gar)
{
case 'a' : cout<<"A. Path Dari 1 Ke 5 = 1,4,5 atau 1,2,5 atau
1,2,3,5 atau 1,4,3,5 atau 1,4,3,2,5"<<endl;
cout<<"=========================================================
======================"<<endl<<endl;
system("pause");
goto back;
break;
case 'b' : cout<<"B. Cycle Dengan Panjang 3 = 2,3,5,2 atau

3,5,4,3"<<endl;
cout<<" Cycle Dengan Panjang 4 = 1,2,3,4,1 atau
1,2,5,4,1"<<endl;
cout<<" Cycle Dengan Panjang 5 = 1,2,3,5,4,1 atau
1,2,5,3,4,1"<<endl;
cout<<"========================================================"
<<endl<<endl;
system("pause");
goto back;
break;
case 'c' : goto awal;
default : cout<<"HURUF TIDAK VALID"<<endl<<endl;

goto back;
}
goto awal;
break;
case 5 :
cout<<endl;
cout<<"ANDA YAKIN INGIN KELUAR (Y/N) ? ";
cin>>pilihlagi;
if (pilihlagi=='y'||pilihlagi=='Y')
system("cls");
else
goto awal;
cout<<endl;
break;
76
default :
cout<<endl;
cout<<"PILIHAN TIDAK ADA"<<endl;
cout<<endl;
system("pause");
goto awal;
cout<<endl;
}
}
int SIDDIK::input()
{
cout<<endl;
cout<<"Jumlah Pelanggan : ";cin>>jumpel;
cout<<endl;
for(sid=0; sid<jumpel; sid++)

{
cout<<"Pelanggan Yang Ke - "<<sid+1<<" "<<endl;
cout<<"Nama Pelanggan : ";cin>>data.napel;
cout<<"Alamat Pelanggan : ";cin>>data.alamat;
cout<<"Telephone Pelanggan : ";cin>>data.telp;
cout<<"Banyak Barang Yang Dibeli : ";cin>>reg;

cout<<endl;
for(dik=0; dik<reg; dik++)

{
cout<<"Nomor : ";cin>>data.nomor[dik], sizeof(data.nomor);
cout<<"Kode : ";cin>>data.kode[dik],sizeof(data.kode);
cout<<"Nama : ";cin>>data.nabar[dik],sizeof(data.nabar);
cout<<"Harga : ";cin>>data.harga[dik], sizeof(data.harga);
cout<<"Quantity : ";cin>>data.quantity[dik],sizeof(data.quantity);
jumlah = data.harga[dik]*data.quantity[dik];
cout<<"Jumlah : "<<jumlah;
cout<<endl;
totbar = totbar + jumlah;
cout<<endl;
}
cout<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<
<endl;
cout<<" PENJUALAN TOKO BAGUS"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<
<endl;
cout<<endl;
cout<<"Nama Pelanggan : "<<data.napel;cout<<endl;
cout<<"Alamat Pelanggan : "<<data.alamat;cout<<endl;
cout<<"Telephone Pelanggan : "<<data.telp;cout<<endl;
cout<<endl;
cout<<endl;
cout<<"Barang Yang Dibeli : "<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<
<endl;
cout<<"No Kode Nama Harga Quantity
Jumlah"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<
<endl;

{
jumlah = data.harga[dik]*data.quantity[dik];
cout<<data.nomor[dik]<<setw(12)<<data.kode[dik]<<setw(13)<<data.nabar[d
ik]<<setw(13)<<data.harga[dik]<<setw(13)<<data.quantity[dik]<<setw(17)<
<jumlah;
cout<<endl;
}
77
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<
<endl;
cout<<endl;
cout<<endl;
cout<<"Jumlah Barang Yang Dibeli = "<<reg;
cout<<endl;
cout<<"Total Bayar = "<<totbar;
cout<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<
<endl;
cout<<endl;
}
}
int SIDDIK::sort()
{
cout<<endl;
cout<<"Pengurutan Pada Harga Barang Secara Descending"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"<<endl;

{
cout<<data.harga[dik]<<endl;
}
for(sid2=reg/2; sid2>0; sid2/=2)
{
for (sid3=sid2; sid3<reg; sid3++)
{
for (dik=sid3-sid2; dik>=0; dik-=sid2)
{
if (data.harga[dik+sid2]<=data.harga[dik]) break;
else
{
sid4=data.harga[dik];
data.harga[dik]=data.harga[dik+sid2];
data.harga[dik+sid2]=sid4;
}
}
}
}
cout<<endl;
cout<<"Sesudah pengurutan"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~"<<endl;

{
cout<<data.harga[dik]<<endl;
}
}
int SIDDIK::search()
{
int N;
int i,Lo,Hi,Flag, X;
Lo=0, Hi=reg-1; Flag=0;
cout<<endl;
cout<<"Daftar Kode Barang"<<endl;

cout<<"~~~~~~~~~~~~~~~~~~"<<endl;
for(int dik1=0; dik1<reg; dik1++)

{
cout<<data.kode[dik1]<<endl;
}
cout<<endl;
cout<<"Masukkan Kode Barang Yang Dicari : ";cin>>N;

cout<<endl;
while (N>=data.kode[Lo] && N<= data.kode[Hi] && Flag==0)

{
78
X = ((N-data.kode[Lo]) * (Hi-Lo) / (data.kode[Hi] - data.kode[Lo]) + Lo);
if (data.kode[X] == N)
Flag = 1;
else
{
if (N<data.kode[X])
Hi=X-1;
else
Lo = X+1;
}
if (Flag == 1)
{
cout<<"Kode "<<N<<" ditemukan pada kolom kode barang baris ke
"<<(X+1)<<" dengan detail sbb :"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~"<<endl;
cout<<"No Kode Nama Harga Quantity
Jumlah"<<endl;
cout<<"~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
~~~~~~~~~~~~~"<<endl;
jumlah = data.harga[X]*data.quantity[X];
cout<<data.nomor[X]<<setw(12)<<data.kode[X]<<setw(13)<<data.naba
r[X]<<setw(13)<<data.harga[X]<<setw(13)<<data.quantity[X]<<setw(
17)<<jumlah;
cout<<endl;
}
else
cout<<"Nilai tidak ditemukan"<<endl;
}
}
int SIDDIK::graph()
{
int c, j, v;
cout<<endl;
cout<<"Masukkan Jumlah Simpul/Vertex: ";
cin>>v;
int matriks[20][20];
cout<<endl;
for(c = 0; c < v; c++)

{
for(j = c; j < v; j++)
{
if(c != j)
{
cout<<"Masukkan Angka 1, Jika "<<c+1<<" Adjacent/Terhubung Ke
"<<j+1<<", Jika Tidak Masukkan 0: ";
cin>>matriks[c][j];
matriks[j][c] = matriks[c][j];
}
else
matriks[c][j] = 0;
}
}
cetak_graph(matriks, v);
}
int SIDDIK::cetak_graph(int matriks[][20], int n)

{
int i, j;
cout<<"\n";
cout<<" REPRESENTASI GRAPH DALAM BENTUK MATRIKS :";
79
cout<<"\n\n"<<setw(4)<<"";
for(i = 0; i < n; i++)
cout<<setw(3)<<"("<<i+1<<")";
cout<<"\n\n";
for(i = 0; i < n; i++)

{
cout<<setw(3)<<"("<<i+1<<")";
for(j = 0; j < n; j++)
{
cout<<setw(4)<<matriks[i][j];
}
cout<<"\n\n";
}
}
B. OUTPUT
1. Tampilan Menu Awal
2. Input Data
80
3. Output Data Dalam Tabel
4. Search Data Dengan Interpolation Search Pada Kode Barang
81
5. Pengurutan Data Secara Descending Dengan Metode Shell Sort Pada Harga Barang
6. Graph Tak Berarah
82
C. PSUODOCODE
DEKLARASI CLASS SIDDIK
Jumpel, sid, jumlah, totbar=0, reg,dik,sid1, sid2, sid3, sid4 = int
DESKRIPSI CLASS SIDDIK
int jumpel, sid,jumlah, totbar=0, reg,dik,sid1, sid2, sid3, sid4

int input()
int sort()
int search()
int graph()
int cetak_graph(int [] [20], int)
DEKLARASI STRUCT TOKO
Nomor, kode, harga, quantity, telp = int

Nabar, napel, alamat = char
DESKRIPSI STRUCT TOKO
int nomor[10], kode[20], harga[20], quantity[20], telp
83
char nabar[20][20], napel[20], alamat[20]
Akses Struct = Toko data
DESKRIPSI FUCTION INPUT
Input -> jumpel

for(sid=0; sid<jumpel; sid++)
input -> data.napel
input -> data.alamat
input -> data.telp
input -> reg

input -> data.nomor[dik]
input -> data.kode[dik]
input -> data.nabar[dik]
input -> data.harga[dik]
input -> data.quantity[dik]
jumlah = data.harga[dik]*data.quantity[dik]
totbar = totbar + jumlah
end for
print -> data.napel
print -> data.alamat
print -> data.telp

jumlah = data.harga[dik]*data.quantity[dik]
print -> data.nomor[dik], data.kode[dik], data.nabar[dik], data.harga[dik],
data.quantity[dik], jumlah
end for
print -> reg
print -> totbar
end for
DESKRIPSI FUCTION SORT

print -> data.harga[dik]
end for
for(sid2=reg/2; sid2>0; sid2/=2)

for (sid3=sid2; sid3<reg; sid3++)
for (dik=sid3-sid2; dik>=0; dik-=sid2)
if (data.harga[dik+sid2]<=data.harga[dik])
break
else
sid4=data.harga[dik]
84
data.harga[dik]=data.harga[dik+sid2]
data.harga[dik+sid2]=sid4
end if
end for
end for
end for

print -> data.harga[dik]
end for
DEKLARASI VARIABEL FUCTION SEARCH
N, i, Lo, Hi, Flag, X = int
DESKRIPSI FUCTION SEARCH
Lo=0, Hi=reg-1; Flag=0

for(int dik1=0; dik1<reg; dik1++)
print -> data.kode[dik1]
end for
input -> N
while (N>=data.kode[Lo] && N<= data.kode[Hi] && Flag==0)

X = ((N-data.kode[Lo]) * (Hi-Lo) / (data.kode[Hi] - data.kode[Lo]) + Lo)
if (data.kode[X] == N)
Flag = 1
Else
if (N<data.kode[X])
Hi=X-1
else
Lo = X+1
End if
End if
if (Flag == 1)
print -> N
print -> data.nomor[X], data.kode[X], data.nabar[X], data.harga[X],
data.quantity[X], jumlah
else
print -> N
end if
end while
DEKLARASI VARIABEL FUCTION CETAK_GRAPH
cetak_graph(int matriks[][20], int n)
85
i, j = int
DESKRIPSI VARIABEL FUCTION CETAK_GRAPH
cetak_graph(int matriks[][20], int n)

for(i = 0; i < n; i++)
print -> i+1
end for
for(i = 0; i < n; i++)
print -> i+1
for(j = 0; j < n; j++)
print -> matriks[i][j]
end for
end for
DEKLARASI VARIABEL FUCTION GRAPH
c, j, v = int
DESKRIPSI FUCTION GRAPH
Input -> v
Int matriks[20][20]
for(c = 0; c < v; c++)
for(j = c; j < v; j++)
if(c != j)
input -> matriks[c][j]
matriks[j][c] = matriks[c][j]
else
matriks[c][j] = 0
end if
end for
end for
cetak_graph(matriks, v)
DEKLARASI VARIABEL MENU UTAMA
Pilih = int
Pilihlagi, gar = char
DESKRIPSI VARIABEL MENU UTAMA
Pendefinisian Objek -> SIDDIK regar
awal:
print -> MENU
print -> 1. Input Data
86
print -> 2. Shell Sort - Descending
print -> 3. Interpolation Search
print -> 4. Graph Tak Terarah
print -> A. Path
print -> B. Cycle
print -> 5. Keluar
input -> pilih
switch (pilih)
case 1 : regar.input()
goto awal
break
case 2 : regar.sort()
goto awal
break
case 3 : regar.search()
goto awal
break
case 4 : regar.graph()
back :
print -> A. Path
print -> B. Cycle
print -> C. Kembali Ke Menu Utama
input -> gar
switch (gar)
case a : print -> A. Path Dari 1 Ke 5 = 1,4,5 atau 1,2,5 atau
1,2,3,5 atau 1,4,3,5 atau 1,4,3,2,5
goto back
break
case b : print -> B. Cycle Dengan Panjang 3 = 2,3,5,2 atau
3,5,4,3
print -> Cycle Dengan Panjang 4 = 1,2,3,4,1 atau 1,2,5,4,1
print -> Cycle Dengan Panjang 5 = 1,2,3,5,4,1 atau 1,2,5,3,4,1
goto back
break
case c : goto awal
default : goto back
goto awal
break
87
case 5 : input -> pilihlagi
if (pilihlagi=='y'||pilihlagi=='Y')
system("cls")
goto awal
end if
break
default : goto awal
end case
D. ALGORITMA
1. Membuat Class SIDDIK
2. Mendeklarasikan variabel Class ( public : jumpel, sid,jumlah, totbar=0, reg,dik,sid1,
sid2, sid3, sid4 = integer )
3. Mendeklarasikan fuction dalam Class ( public : int input(), int sort, int search, int
graph, int cetak_graph(int [][20], int)
4. Membuat Struct Toko
5. Mendeklarasikan variabel Struct (nomor, kode, harga, quantity, telp = integer)
6. Mendeskripsikan variabel Struct (int = (nomor[10], kode[20], harga[20],
quantity[20], telp,) char = (nabar[20][20], napel[20], alamat[20]))
7. Membuat pendefinisian Stuct dengan Toko data
8. Mendeskripsikan fuction input yang berada dalam Class SIDDIK
9. Menginput ‘jumpel’
10. Sid=0
11. Selama sid<jumpel kerjakan baris 12 s/d 34
12. Menginput ‘data.napel’
13. Menginput ‘data.alamat’
14. Menginput ‘data.telp’
15. Menginput ‘reg’
16. Dik=0
17. Selama dik<reg kerjakan baris 18 s/d 25
18. Menginput ‘data.nomor[dik]’
19. Menginput ‘data.kode[dik]’
20. Menginput ‘data.nabar[dik]’
21. Menginput ‘data.harga[dik]’
22. Menginput ‘data.quantity[dik]’
23. jumlah = data.harga[dik]*data.quantity[dik]
24. totbar = totbar + jumlah
25. Dik++
26. Menampilkan ‘data,napel’
27. Menampilkan ‘data.alamat’
28. Dik=0
30. jumlah = data.harga[dik]*data.quantity[dik]
31. Menampilkan ‘data.nomor[dik], data.kode[dik], data.nabar[dik], data.harga[dik],
data.quantity[dik], jumlah’
32. Dik++
88
33. Menampilkan ‘reg’
34. Menampilkan ‘totbar’
35. Mendeskripsikan fuction sort yang berada dalam Class SIDDIK
36. Dik=0
38. Menampilkan ‘data.harga[dik]’
39. Dik++
40. Sid=reg/2
41. Selama sid>0 kerjakan baris 42 s/d 52
42. Sid3=sid2
43. Selama sid3<reg kerjakan baris 44 s/d 51
44. Dik=sid3-sid2
45. Selama dik>0 kerjakan baris 46 s/d 50
46. Jika ‘data.harga[dik+sid2]<=data.harga[dik]’ maka stop jika tidak kerjakan baris 47
s/d 49
47. sid4=data.harga[dik]
48. data.harga[dik]=data.harga[dik+sid2]
49. data.harga[dik+sid2]=sid4
50. dik - = sid2
51. sid3++
52. sid2/=2
53. dik=0
54. selama dik<reg maka kerjakan baris 55 s/d 56
55. menampilkan ‘data.harga[dik]’
56. dik++
57. Mendeskripsikan fuction search yang berada dalam Class SIDDIK
58. Mendeklarasikan variabel funtion search (N, i, Lo, Hi, Flag, X = integer)
59. Lo=0, Hi=reg-1, Flag=0
60. Int dik1=0
61. Selama dik1<reg kerjakan baris 62 s/d 63
62. Menampilkan data.kode[dik1]
63. Dik1++
64. Menginput ‘N’
65. Selama ‘N>=data.kode[Lo] && N<= data.kode[Hi] && Flag==0’ kerjakan baris 66 - 73
66. X = ((N-data.kode[Lo]) * (Hi-Lo) / (data.kode[Hi] - data.kode[Lo]) + Lo)
67. Jika ‘data.kode[X]==N’ maka Flag = 1 jika tidak kerjakan baris 68
68. Jika ‘N<data.kode[X]’ maka Hi=X-1 jika tidak Lo=X+1
69. Jika ‘Flag==1’ kerjakan baris 70 s/d 72 jika tidak kerjakan baris 73
70. Menampilkan ‘N’
71. jumlah = data.harga[X]*data.quantity[X]
72. menampilkan data.nomor[X], data.kode[X], data.nabar[X], data.harga[X],
data.quantity[X], jumlah
73. menampilkan ‘N’
74. mendeskripsikan function graph yang berada dalam Class SIDDIK
75. mendeklarasikan variabel funtion graph (c, j, v = integer)
76. menginput ‘v’
77. int matriks [20][20]
89
78. c=0
79. selama c<v kerjkan baris 80 s/d 85
80. j=c
81. selama j<v kerjakan baris 82 s/d 85
82. jika c != j maka kerjakan baris 83 s/d 84 jika tidak kerjakan baris 85
83. menginput ‘matriks [c][j]
84. matriks[j][c] = matriks[c][j]
85. matriks[c][j] = 0
86. cetak_graph(matriks, v)
87. Mendeskripsikan fuction cetak_graph(int matriks[][20], int n) dalam Class SIDDIK
88. Mendeklarasikan variabel funtion cetak_graph(int matriks[][20], int n)  i, j = int
89. I=0
90. Selama i<n kerjakan baris 91 s/d 92
91. Menampilkan ‘i+1’
92. I++
93. I=0
94. Selama i<n kerjakan baris 95 s/d 99
95. Menampilkan ‘i+1’
96. J=0
97. Selama j<n kerjakan baris 85 s/d 86
98. Menampilkan ‘matriks[i][j]’
99. J++
100. Mendeklarasikan function menu utama
101. Mendeskripsikan variabel menu uatam ( (pilih=integer), (pilihlagi,gar = char))
102. Mendefinisikan objek dari Class SIDDIK dengan  SIDDIK regar
103. Menginput ‘pilih’
104. switch (pilih)
105. case 1 : kerjakan baris 106 s/d 107
106. memanggil function regar.input()
107. goto awal
109. memanggil funtion regar.sort()
110. goto awal
112. memanggil function regar.search()
113. goto awal
115. memanggil function regar.graph()
116. menginput ‘gar’
117. switch(gar)
118. case a : kerjakan baris 119 s/d 120
119. print ‘A. Path Dari 1 Ke 5 = 1,4,5 atau 1,2,5 atau 1,2,3,5 atau 1,4,3,5 atau 1,4,3,2,5’
120. goto back
121. case b : kerjakan baris 122 s/125
122. print ’B. Cycle Dengan Panjang 3 = 2,3,5,2 atau 3,5,4,3’
123. print ‘Cycle Dengan Panjang 4 = 1,2,3,4,1 atau 1,2,5,4,1’
124. print ‘Cycle Dengan Panjang 5 = 1,2,3,5,4,1 atau 1,2,5,3,4,1’
90
125. goto back
126. case c : goto awal
127. default : goto back
128. goto awal
130. menginput pilihlagi
131. jika ‘pilihlagi=='y' atau pilihlagi=='Y' maka membersihkan layar jika tidak goto awal
132. default : goto awal
133. selesai
BAB IV
TUGAS PERORANGAN & KELOMPOK (KERTAS)
.... pada bab ini saya lampirkan pada bab lampiran ....
91
BAB V
PENUTUP
A. KESIMPULAN
Algoritma Struktur Data adalah materi yang bermanfaat untuk mempelajari

membuat program yang di dalamnya dapat memuat data yang terstruktur, sehingga
dapat memanipulasi data yang yang telah kita buat. Kesimpulan yang dapat saya tarik
adalah mata kuliah Algoritma Struktur Data sangat bermanfaat untuk mendalami ilmu
Algoritma Pemograman khususnya manipulasi data jadi pada mata kuliah ini harus
dipelajari dengan tekun karena akan bermanfaat bagi kedepannnya.
B. KOMENTAR
Fasilitas pada saat praktikum sangat bagus, jadi ini harus tetap dipertahankan
sehingga mahasiswa bisa belajar dengan nyaman.
92
DAFTAR PUSTAKA
http://elearning.teknik.univpancasila.ac.id/course/view.php?id=61
93

Algo

Diunggah oleh

Informasi Dokumen

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

Algo

Diunggah oleh

Hak Cipta:

Format Tersedia

LAPORAN PRAKTIKUM

ALGORITMA DAN STRUKTUR DATA

Diajukan sebagai Penilaian pada

Nama Dosen : Dra. Sri Rezeki Candra N., M.Kom

FAKULTAS TEKNIK JURUSAN INFORMATIKA

BAB II TUGAS PERORANGAN ..................................................................................................53

BAB III TUGAS BESAR ..............................................................................................................73

BAB IV TUGAS PERORANGAN & KELOMPOK (KERTAS) ..........................................................89

DAFTAR PUSTAKA ...................................................................................................................91

Jakarta, Juni 2018

B. Abstract Data Type (ADT)

ADT biasanya diimplementasi menjadi dua buah modul, yaitu :

1. Definisi/spesifikasi type dan primitif

2. Body/realisasi dari primitif, berupa kode program dalam bahasa yang

• Setiap ADT harus dibuat menjadi spesifikasi, body dan driver

2. KONSTRUKTOR & DESTRUKTOR

Kelas adalah bentuk penyederhanaan dari suatu permasalahan yang

Obyek Terdiri dari 2, yaitu :

Deret Fibonacci adalah sebuah deret yang untuk suku pertama dan kedua

• The Fibonacci series fn≥0 is a famous series defined by:

Tower of Hanoi adalah teka-teki matematika di mana kita memiliki tiga

1) Hanya satu disk yang dapat dipindahkan dalam satu waktu.

1. SELECTION & INSERTION SORT

SELECTION SORT adalah membandingkan elemen yang sekarang dengan

Selection Sort (Metode pengurutan seleksi)

INSERTION SORT adalah Pengurutan dilakukan dengan cara

Algoritmanya sebagai berikut :

Contoh source codenya :

BUBBLE SORT adalah membandingkan elemen yang sekarang dengan elemen

Algoritmanya sebagai berikut :

Pengurutan Bubble Sort

Algoritmanya sebagai berikut :

using namespace std;

3. MERGE & QUICK SORT

T1 = 65, 44, 26, 19, 2

Proses pengurutan dengan metode penggabungan :

Algoritmanya sebagai berikut :

QUICK SORT adalah metode membandingkan suatu elemen (disebut pivot)

Algoritmanya sebagai berikut :

Linked list merupakan Array Dinamis. Variabel bertipe Array merupakan

a. Single Linked List

a) Inisialisasi, yaitu persiapan pembuatan Linked List.

Contoh source codenya :

Proses DLLL (Double Linked List Linear), adalah :

c. Circular Single Linked List

Proses SLLC (Single Linked List Circular), adalah :

– Linked List: artinya node-node tersebut saling terhubung satu samalain.

– Dibutuhkan satu buah variabel pointer : head

• Penamahan elemen/data didepan/diawal

– Penambahan node baru akan dikaitan di node paling depan, namun

– Pada prinsipnya adalah mengkaitkan data baru dengan head,

Proses DLLC (Double Linked List Circular), adalah :

1. Pembuatan sebuah simpul

2. Pembuatan simpul awal.b (simpulyang sudah dibuat, dijadikan sebagai

3. Melakukan insert kanan / sisip elemen terakhir

4. melakukan insert kiri

5. Melakukan insert tengah / sisip elemen tengah

6. Melakukan delete kiri / hapus elemen awal

7. Melakukan delete kanan / hapus elemen akhir

8. Melakukan delete tengah / hapus elemen Tengah

Proses Tumpukan (Stack), adalah :

Proses Antrian (QUEUE), adalah :

Contoh source codenya :