Modul Praktikum Struktur Data 2021 Fix

SEMESTER GENAP TGL BLN THN
TA.2020 / 2021 05 03 2021
M O D U L P R A K T I K U M
STRUKTUR DATA
TIM DOSEN
DIBUAT DIPERIKSA DISAHKAN

DOSEN / INSTRUKTUR KETUA KELOMPOK KETUA JURUSAN
KEAHLIAN
Yulison Herry, C., S.T., M.T Ridwan Ilyas, S.Kom., M.T Wina Witanti, S.T., M.T.
NID. 412166863 NID. 412182990 NID. 412176273
L A B O R A T O R I U M J U R U S A N I N F O R M A T I K A
TERAKREDITASI “B” SK.DIRJEN DIKTI: 8304/SK/BAN-PT/Ak-PPJ/S/XII/2020
Jl. Terusan Jend. Sudirman, PO BOX 148 Cimahi Selatan, Kota Cimahi, Jawa Barat 40531
http://if.unjani.ac.id | e-mail: informatika@unjani.ac.id
STRUKTUR DATA
OLEH : TIM DOSEN
DAFTAR ISI
DAFTAR ISI.............................................................................................................................. 1
MODUL 1 PERKENALAN ADT ............................................................................................. 2
MODUL 2 ADT LINE............................................................................................................. 16
MODUL 3 ADT TabInt (Tabel Integer) .................................................................................. 20
MODUL 4 ADT Linear Linked List ........................................................................................ 24
MODUL 5 ADT Stack Representasi Kontigu ......................................................................... 35
MODUL 6 ADT Queue Representasi Kontigu “Non Circular” .............................................. 44
MODUL 7 ADT Queue Representasi Kontigu “Circular” ...................................................... 55
MODUL 8 ADT Double Linked List ...................................................................................... 64
MODUL 9 ADT Binary Tree (BTree) ..................................................................................... 74
MODUL 10 Persoalan Struktur Data ....................................................................................... 81
REFERENSI ............................................................................................................................ 81
Halaman
1 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
MODUL 1 PERKENALAN ADT
Lama Praktikum : 1 sesi

Tujuan : Setelah menyelesaikan modul ini, anda diharapkan dapat:
1. Memahami fungsi dan prosedur di dalam Bahasa C dan menggunakannya di
dalam konsep ADT.
2. Memahami pembuatan ADT (Pada sesi ini dipelajari ADT Jam dan Point) di
dalam bahasa C.
Dasar Teori
ADT adalah definisi TYPE dan sekumpulan PRIMITIF (operasi) terhadap TYPE tersebut.
Selain itu, dalam sebuah ADT yang lengkap, disertakan juga definisi juga definisi invarian
dari TYPE dan operasi yang berlaku bagi type tersebut. ADT merupakan definisi statik.
Definisi type dari sebuah ADT dapat mengandung sebuah definisi ADT lain.
Type diterjemahkan menjadi type terdefinisi dalam bahasa yang bersangkutan, misalnya
menjadi struct dalam bahasa C.
Primitif adalah konteks prosedural, diterjemahkan menjadi fungsi atau prosedur. Primitif
dikelompokkan menjadi:
- Kontruktor, pembentukan nilai type (biasanya namanya diawali dengan Create)
- Selector, untuk mengakses komponen dari type (biasanya namanya diwali dengan Get)
- Pengubahan nilai, untuk mengubah nilai komponen (biasanya namanya diwali dengan Set)
- Destruktor, untuk “menghancurkan” nilai objek (dealokasi memori)
- Baca/tulis, untuk interface dengan input/output device
- Operator relasional, melakukan operasi relasional (lebih besar, lebih kecil, sama dengan
dsb)
- Aritmatika terhadap type, operasi aritmatika terhadap type hanya terdefinisi untuk tipe
numerik.
- Konversi type, yaitu konversi type tersebut ke type dasar dan sebaliknya
Implementasi ADT
ADT diimplementasikan menjadi dua buah modul, yaitu:
1. Definisi/ spesifikasi type primitif.
a. Spesifikasi type sesuai dengan bahasa yang bersangkutan.
b. Spesifikasi dari primitif sesuai dengan kaidah dalam konteks prosedural, yaitu
- Fungsi: nama, domain, range dan prekondisi jika ada
Halaman
2 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
- Prosedur: Initial State, Final State 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).
Selain kedua modul diatas, dibutuhkan Main driver untuk menguji/ test terhadap ADT
melalui pemanggilan (call) terhadap setiap operasi yang ada sekaligus yang mengatur alur
utama program.
Realisasi ADT dalam bahasa C,
1. Bagian spesifikasi direalisakasi ke dalam file header dengan ekstens .h;
2. Bagian Body direalisasikan ke dalam file kode dengan ekstensi .c atau .cpp
Prosedur praktikum IF1231 Struktur Data

1. Setiap ADT harus dibuat menjadi spesifikasi, body dan driver
2. Modul spesifikasi, realisasi dan driver harus disimpan dalam sebuah direktori dengan
nama ADT. Jadi source lengkap sebuah ADT adalah sebuah direktori dan isinya adalah
minimal header file, body file dan driver.
3. Pada setiap file source (spesifikasi, body dan driver) sertakan identitas yaitu nama
program, identitas mahasiswa (NIM / Nama), Kelas, Deksripsi Program, dan Tanggal
Pembuatan Program
4. Pada praktikum gunakan spesifikasi header boolean pada setiap ADT.
Catatan : define 1 sebagai true dan define 0 sebagai false
/*
Program : boolean.h
Deskripsi: Header file boolean
*/
#ifndef boolean_H
#define boolean_H
#define true 1
#define false 0
#define boolean unsigned char
#endif
Halaman
3 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Diketahui file modul ADT dibawah ini,

ADT JAM
1. Bagian file Header Jam
Silahkan anda buat file baru dengan nama point.h sebagai header dari Struktur Data Jam
/* Program : jam.h
Author : (Nim, Nama)
Kelas :
Deskripsi: Header file dari prototype jam
Tanggal :
*/
#ifndef JAM_H
#define JAM_H
#include "boolean.h"
#define true 1
#define false 0
#define boolean unsigned char
typedef struct {
int Hour ; /* Hour [0..23] */
int Minute; /* Minute [0..59] */
int Second; /* Second [0..59] */
} JAM;
/* Prototype ADT Jam */
/** Konstruktor membentuk ADT Jam **/

void CreateJam (JAM *J, int HH, int MM, int SS);
/* Membentuk sebuah JAM dari komponen-komponennya yang valid
Pre condition : HH,MM,SS valid untuk membentuk JAM
I.S : J tidak terdefinisi, tidak diketahui nilainya
F.S : membentuk sebuah Jam dari komponen-komponennya dengan J
diinisialisasi nilainya dengan
Hour = HH, Minute = MM, Second = SS
*/
/* Selektor nilai JAM **/

int GetHour(JAM J);
// Mengirimkan komponen Hour dari J
int GetMinute(JAM J);
// Mengirimkan komponen Minute dari J
int GetSecond(JAM J);
// Mengirimkan komponen Second dari J
/* Set nilai komponen */

void SetHour(JAM *J, int newHour);
/* I.S : J terdefinisi, dengan nilainya sembarang
F.S : Mengubah nilai komponen Hour dari J dengan Hour=newHour
Halaman
4 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
*/
void SetMinute(JAM *J, int newMinute);
F.S : Mengubah nilai komponen MInute dari J dengan Minute=newMinute
*/
void SetSecond(JAM *J, int newSecond);
F.S : Mengubah nilai komponen Second dari J dengan Second=newSecond
*/
/* Destruktor/Dealokator: tidak perlu */
/** {Kelompok Baca/Tulis} **/

void ReadJam (JAM *J);
/* I.S. : J tidak terdefinisi
F.S. : J terdefinisi dan merupakan jam yang valid
Proses : proses membaca komponen H,M,S terus berlangsung sampai
membentuk J yang valid. Komponen jam dikatakan valid, Jika
0≤H≤23, 0≤M≤60 dan 0≤S≤59
*/
void PrintJam (JAM J);
/* I.S. : J diisi dengan nilai sembarang
F.S. : Menampilkan jam (J) ke layar dengan format HH:MM:SS
*/
/** { kelompok Validasi Type } **/

boolean IsJValid (int H, int M, int S);
/* fungsi pengecekan nilai komponen jam yang valid
Mengirimkan true jika H,M,S dapat membentuk J yang valid
Sebaliknya mengirimkan false jika H,M,S tidak dapat membentuk J yang
valid
*/
/** {Operator Relasional} **/

boolean JEQ(JAM J1, JAM J2);
/* Mengirimkan true jika Jl=J2, false jika tidak
Artinya mengirimkan true jika semua elemen jam bernilai bernilai sama
Contoh :
- Jika J1 = 10:20:30 dan J2 = 10:20:30, maka mengirimkan true
- Jika J1 = 10:20:30 dan J2 = 10:30:30, maka mengirimkan false
*/
boolean JLT(JAM J1, JAM J2);
/* Mengirimkan true jika J1<J2 , false jika tidak
Artinya mengirimkan true jika elemen pada J1 bernilai kurang dari J2
Contoh :
*/
boolean JGT(JAM J1, JAM J2);
/* Mengirimkan true jika Jl>J2, false jika tidak
Artinya mengirimkan true jika elemen pada J1 bernilai lebih dari J2
Contoh :
Halaman
5 / 81
STRUKTUR DATA
OLEH : TIM DOSEN

*/
/** { operator aritmatika } **/

void Reset (JAM *J);
/* I.S. : J sembarang
F.S. : J bernilai “nol”, yaitu semua komponen bernilai 0
Proses : Ubah semua nilai elemen J menjadi 0:0:0
*/
JAM NextDetik (JAM J);
/* Menambahkan nilai 1 detik pada jam, dan kirimkan nilai jam baru */
JAM NextNDetik (JAM J, int N);
/* Menambahkan nilai N detik pada jam, dan mengirimkan nilai jam baru */
long int Durasi ( JAM Jaw , JAM JAkh);
/* Menghitung selisih dari dua buah jam dalam bentuk detik
Proses : Mengirimkan JAkh —JAw dlm Detik,
Hasilnya negatif jika Jaw > JAkhir
*/
/** {Kelompok Konversi Terhadap Type} **/

long int JamToDetik (JAM J);
/* melakukan konversi jam menjadi Detik
Rumus : detik = 3600*hour+menit*60 + detik
nilai maksimum = 3600*23+59*60+59*60
*/
#endif
2. Bagian file Realisasi JAM

/* Program : jam.c
Kelas :
Deskripsi: body file dari prototype jam
Tanggal :
*/
#include "jam.h"
#include <stdio.h>
#include <conio.h>
/* Realisasi dari prototype ADT Jam */
/** Konstruktor membentuk ADT Jam **/

void CreateJam (JAM *J, int HH, int MM, int SS) {
/* Membentuk sebuah JAM dari komponen-komponennya yang valid
Pre condition : HH,MM,SS valid untuk membentuk JAM
I.S : J tidak terdefinisi, tidak diketahui nilainya
F.S : membentuk sebuah Jam dari komponen-komponennya dengan J
diinisialisasi nilainya dengan
Halaman
6 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Hour = HH, Minute = MM, Second = SS

*/
(*J).Hour = HH;
(*J).Minute = MM;
(*J).Second = SS;
}
/* Selektor nilai JAM **/

int GetHour(JAM J) {
// Mengirimkan komponen Hour dari J
return (J.Hour);
}
int GetMinute(JAM J){
// Mengirimkan komponen Minute dari J
return (J.Minute);
}
int GetSecond(JAM J) {
// Mengirimkan komponen Second dari J
(return J.Second);
}

void SetHour(JAM *J, int newHour) {
F.S : Mengubah nilai komponen Hour dari J dengan Hour=newHour
*/
(*J).Hour = newHour;
}
void SetMinute(JAM *J, int newMinute) {
F.S : Mengubah nilai komponen Minute dari J dengan Minute=newMinute
*/
(*J).Minute = newMinute;
}
void SetSecond(JAM *J, int newSecond) {
F.S : Mengubah nilai komponen Second dari J dengan Second=newSecond
*/
(*J).Second = newSecond;
}
/** {Kelompok Baca/Tulis} **/

void ReadJam (JAM *J) {
/* I.S. : J tidak terdefinisi
F.S. : J terdefinisi dan merupakan jam yang valid
Proses : proses membaca komponen H,M,S terus berlangsung sampai
membentuk J yang valid. Komponen jam dikatakan valid,
Jika : 0<=H<=23, 0<=M<=60 dan 0<=S<=59
*/
int hh, mm, ss;
do {
scanf("%d", &hh);
scanf("%d", &mm);
Halaman
7 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
scanf("%d", &ss);
}while (hh<0 || hh>23 || mm<0 || mm>59 || ss<0 || ss>59);
CreateJam(&(*J), hh, mm, ss);
}
void PrintJam (JAM J) {
/* I.S. : J diisi dengan nilai sembarang
F.S. : Menampilkan jam (J) ke layar dengan format HH:MM:SS
*/
printf("%d:%d:%d", J.Hour, J.Minute, J.Second);
}
/** { kelompok Validasi Type } **/

boolean IsJValid (int H, int M, int S) {
/* fungsi pengecekan nilai komponen jam yang valid
Mengirimkan true jika H,M,S dapat membentuk J yang valid
Sebaliknya mengirimkan false jika H,M,S tidak dapat membentuk J yang valid
*/
if (H>=0 && H<=23 && M>=0 && M<=59 && S>=0 && S<=59)
return (true);
else
return (false);
}
/** {Operator Relasional} **/
boolean JEQ(JAM J1, JAM J2) {
/* Mengirimkan true jika Jl=J2, false jika tidak
Artinya mengirimkan true jika semua elemen jam bernilai bernilai sama
Contoh :
*/
if (J1.Hour == J2.Hour && J1.Minute == J2.Minute &&
J1.Second == J2.Second)
return (true);
else
return (false);
}
boolean JLT(JAM J1, JAM J2) {
/* Mengirimkan true jika J1<J2 , false jika tidak
Artinya mengirimkan true jika elemen pada J1 bernilai kurang dari J2
Contoh :
*/
if (J1.Hour < J2.Hour || J1.Minute < J2.Minute || J1.Second < J2.Second)
return (true);
else
return (false);
}
boolean JGT(JAM J1, JAM J2) {
/* Mengirimkan true jika Jl>J2, false jika tidak
Artinya mengirimkan true jika elemen pada J1 bernilai lebih dari J2
Contoh :
Halaman
8 / 81
STRUKTUR DATA
OLEH : TIM DOSEN

*/
if (J1.Hour > J2.Hour || J1.Minute > J2.Minute || J1.Second > J2.Second)
return (true);
else
return (false);
}
/** { operator aritmatika } **/
void Reset (JAM *J) {
/* I.S. : J sembarang
F.S. : J bernilai "nol", yaitu semua komponen bernilai 0
Proses : Ubah semua nilai elemen J menjadi 0:0:0
*/
(*J).Hour = 0;
(*J).Minute = 0;
(*J).Second = 0;
}
JAM NextDetik (JAM J) {
/* Menambahkan nilai 1 detik pada jam, dan kirimkan nilai jam baru */
JAM jamBaru;
/* mencopy nilai J kepada jamBaru {bisa pakai cara ini atau yang dibawah}
jamBaru.Hour = J.Hour;
jamBaru.Minute = J.Minute;
jamBaru.Second = J.Second + 1;
*/
jamBaru = J;
jamBaru.Second = jamBaru.Second + 1;
if (jamBaru.Second > 59) {
jamBaru.Second = 0;
jamBaru.Minute = jamBaru.Minute + 1;
if (jamBaru.Minute > 59) {
jamBaru.Minute = 0;
jamBaru.Hour = jamBaru.Hour + 1;
if(jamBaru.Hour > 23){
jamBaru.Hour = 0;
}
}
}
return (jamBaru);
}
JAM NextNDetik (JAM J, int N) {

/* Menambahkan nilai N detik pada jam, dan mengirimkan nilai jam baru */
int i;
JAM jamBaru;
jamBaru = J;
if (N > 0 && N <= 86400) { // menambahkan detik hanya sampai 24 jam
for (i=1; i<=N; i++){
jamBaru = NextDetik (jamBaru);
}
Halaman
9 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
}
return (jamBaru);
}
long int Durasi ( JAM JAw , JAM JAkh) {

/* Menghitung selisih dari dua buah jam dalam bentuk detik
Proses : Mengirimkan JAkh -JAw dlm Detik, Hasilnya negatif jika Jaw >
JAkhir
Jika hasilnya negatif maka ubahlah menjadi nilai positif
*/
long int detikAwl, detikAkh, result;
detikAwl = JamToDetik(JAw);
detikAkh = JamToDetik(JAkh);
result = detikAwl - detikAkh;
if (result < 0) {
result = result * (-1);
}
return (result);
}
/** {Kelompok Konversi Terhadap Type} **/
long int JamToDetik (JAM J) {
/* melakukan konversi jam menjadi Detik
Rumus : detik = 3600*hour+menit*60 + detik
nilai maksimum = 3600*23+59*60+59*60
*/
long int detik;
detik = (J.Hour * 3600) + (J.Minute * 60) + J.Second;

return (detik);
}
3. Bagian file Main driver JAM

Dibawah ini contoh main program pada ADT JAM untuk pengecekan prosedur dan
fungsi pada body ADT JAM (file jam.c)
/* Program : mjam.c
Kelas :
Deskripsi: Contoh main driver dari ADT Jam
Tanggal :
*/
#include "jam.h"
#include <stdio.h>
#include <conio.h>
int main () {
// Kamus Data
JAM J1, J2, J3, J4;
int tambahanDetik;
// Algoritma
ReadJam(&J1);
Halaman
10 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
printf("Nilai J1 = ");
PrintJam(J1);
printf("\n");
J2 = NextDetik(J1);
printf("Nilai J2 = ");PrintJam(J2);printf("\n");
printf ("Masukan nilai N detik (0...59) : ");

scanf("%d", &tambahanDetik);
J3 = NextNDetik(J1, tambahanDetik);
J4 = J1;
printf("\nPengecekan Operator Relasional\n");

if (JEQ(J1, J2))
printf("nilai J1 sama dengan J2\n");
if(JLT(J1, J2))
printf("nilai J1 lebih kecil dari J2\n");
if(JGT(J1, J2))
printf("nilai J1 lebih besar dari J2\n");
if (JEQ(J3, J1))
if(JLT(J3, J1))
if(JGT(J3, J1))
if (JEQ(J1, J4))
if(JLT(J1, J4))
if(JGT(J1, J4))
Reset(&J4);
getch(); //{opsional, ini tertulis karena ketika running console

langsung close}
return 0;
}
TUGAS PRAKTIKUM
Latihan 1
1. Ketikan source code ADT JAM diatas yaitu header file, body file dan driver dengan
nama file jam.h, jam.c dan mjam.c. File program diletakan dalam satu folder yang sama.
2. Buat projek untuk ADT JAM pada DevC++/IDE lain dengan cara:
a. Klik “file” pada menu bar
b. Pilih New > Project. Beri judul project dengan nama ADTJam
Halaman
11 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
c. Tambahkan source code ADT JAM pada project dengan cara : Klik kanan pada
project, kemudian pilih “Add to Project”, selanjutnya pilih file boolean.h, jam.h,
jam.c dan mjam.c
3. Lakukan Compiling dan Running program

4. Kemudian Simpulkan oleh anda, apa yang anda pelajari dari Source Code diatas ?
(Simpulan ditulis dalam file word)
Latihan 2
1. Dengan cara yang sama seperti pada Latihan 1, ketikan header file untuk ADT Point
dibawah ini.
2. Buat body file dari setiap prototype (prosedur dan fungsi) pada header file ADT Point
3. Buat file drivernya: mpoint.c
Sebagai catatan: Pada main driver panggil semua modul untuk memastikan bahwa body
dari modul program adalah benar
PENGUMPULAN
1. File yang dikumpulkan adalah file dengan extensi .h, .c dan word (untuk soal no 3 pada
Latihan 1.
2. Kompres hasil Latihan 1 dan Latihan 2 dalam bentuk zip dengan penamaan :
[Prak. Struktur Data]_Kelas_Modul 1_NIM_NAMA
Contoh : [Prak. Struktur Data]_A_Modul 1_3411161001_Rahmania Aulia I.P
3. Tugas dikumpulkan maksimal satu minggu setelah praktikum
ADT POINT
Bagian file Header Point
/* Program : point.h
Kelas :
Deskripsi: Header file dari prototype point
Tanggal :
*/
#ifndef _POINT_H
#define _POINT_H
#include <stdio.h>
#include <conio.h>
#define Absis(P) (P).X
Halaman
12 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
#define Ordinat(P) (P).Y

#define PI 3.14159265
/** Definisi ABSTRACT DATA TYPE POINT **/

typedef struct {
int X; // absis
int Y; // ordinat
}POINT;
/* Prototype POINT */
/* Konstruktor membentuk POINT */

void CreatePOINT (POINT *P);
/* I.S : P terdefinisi, tidak diketahui nilainya
F.S : membentuk sebuah POINT dari komponen-komponennya dengan P
diinisialisasi nilainya dengan X=0 dan Y=0
*/
void CreatePOINT2 (POINT *P, int XBaru, int YBaru);
/* I.S : P terdefinisi, tidak diketahui nilainya
F.S : membentuk sebuah POINT dari komponen-komponennya dengan P
diinisialisasi nilainya dengan X= XBaru dan Y=YBaru
*/
/* Selektor POINT **/

int GetAbsis(POINT P);
// Mengirimkan komponen Absis dari P
int GetOrdinat (POINT P);

// Mengirimkan komponen Ordinat dari P POINT

void SetAbsis(POINT *P, int newX);
/* I.S : P terdefinisi, dengan nilainya sembarang
F.S : Mengubah nilai komponen Absis dari P dengan X=newX
*/
void SetOrdinat (POINT *P, int newY);
/* I.S : P terdefinisi, dengan nilainya sembarang
F.S : Mengubah nilai komponen Ordinat dari P dengan Y=newY
*/
/** { KELOMPOK Interaksi dengan I/O device, BACA/TULIS } **/

void BacaPOINT (POINT *P);
/* I.S : P terdefinisi, mungkin kosong
F.S : P terdefinisi, dengan membaca nilai X dan Y
*/
void CetakPOINT(POINT P);
F.S : Menampilkan nilai komponen P ke layar dg format “(X , Y)
*/
Halaman
13 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
/** Kelompok operasi relasional terhadap POINT **/

boolean EQ(POINT Pl, POINT P2);
// Mengirimkan true jika PI = P2, dan false jika sebaliknya
boolean NEQ(POINT P1, POINT P2);
// Mengirimkan true jika PI tidak sama dengan P2, dan false jika sebaliknya
boolean LT(POINT P1, POINT P2);
// Mengirimkan true jika P1 < P2, dan false jika sebaliknya
// Definisi Iebih kecil: posisi titik lebih ke kiri atau ke bawah dalam
bidang kartesian
boolean MT(POINT P1, POINT P2);
// Mengirimkan true jika PI > P2, dan false jika sebaliknya.
// Definisi lebih besar: posisi titik lebih ke kanan atau ke atas dalam
bidang kartesian
/** Kelompok menentukan di mana P berada **/
boolean IsOrigin (POINT P);
// Menghasilkan true jika P berada pada titik origin yaitu nilai X=0 dan
Y=0, dan false jika sebaliknya
boolean IsOnSbX (POINT P);
// Menghasilkan true jika P terletak Pada sumbu X yaitu nilai Y=0, dan
false jika sebaliknya
boolean IsOnSbY (POINT P);
// Menghasilkan true jika P terletak pada sumbu Y yaitu nilai X=0, dan
false jika sebaliknya
int Kuadran(POINT P);
// Menghasilkan kuadran dari P: 1,2,3, atau 4
// Precondition : P bukan Titik Origin, dan P tidak terletak di salah satu
sumbu
/** KELOMPOK OPERASI LAIN TERHADAP TYPE **/

POINT MirrorOf(POINT P, boolean SbX, boolean SbY);
// Menghasilkan salinan P yang dicerminkan tergantung nilai SbX dan SBY
// Jika SbX bernilai true, maka dicerminkan terhadap Sumbu X
// Jika SbY bernilai true, maka dicerminkan terhadap Sumbu Y
float JarakO(POINT P);

// Menghitung jarak P dari titik origin (0,0)
void GeserKeSbX (POINT *P);

F.S : P berada pada Sumbu X, jika tidak berada pada Sumbu X maka geser P
ke Sumbu X.
Contoh: Jika koordinat semula(9,9) menjadi (9,0)
*/
void GeserKeSbY(POINT *P);
F.S : P berada pada Sumbu Y, jika tidak berada pada Sumbu Y maka geser P
ke Sumbu Y.
Contoh: Jika koordinat semula(9,9) menjadi (0,9)
*/
#endif
Halaman
14 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Halaman
15 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
MODUL 2 ADT LINE

1. Memahami pembuatan ADT yang dibentuk dari ADT lain.
2. Kasus yang digunakan adalah ADT Line, yaitu sebuah obyek yang dibentuk
dari dua buah titik dengan memanfaatkan ADT Point.
Dasar Teori
Sebuah ADT tidak hanya dibentuk dari tipe data primitif saja (misalnya integer, real, char dan
boolean) tetapi juga dapat dibentuk dari ADT lain.
Persoalan :
ADT Garis adalah pembentukan sebuah garis pada bidang kartesian dwiwarta yang dibentuk
dari dua buah Point (Titik) yaitu titik awal dan titik akhir. Dari kedua titik tersebut dapat
dibentuk sebuah garis.
Implementasi ADT Garis

ADT Garis diimplementasikan menjadi dua buah modul yaitu, :
- Definisi/ spesifikasi type dan primitif
Type Line : < PAwal : Point,
Pakhir : Point>
- Body atau realisasi dari operasi primitif pada file header.

Bagian file Header Line
/* Program : line.h
Kelas :
Deskripsi: Header file dari prototype Line
Tanggal :
*/
#ifndef _LINE_H
#define _LINE_H
#include "point.h"
#include <stdio.h>
#include <conio.h>
#define FirstPoint(L) (L).PAwal

#define EndPoint(L) (L).PAkhir
Halaman
16 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
/** Definisi ABSTRACT DATA TYPE Line **/

typedef struct {
POINT PAwal; // Titik Awal
POINT PAkhir; // Titik Akhir
}Line;
/* Prototype Line */
/* Konstruktor membentuk Line */

void CreateLine (Line *L);
/* I.S : L terdefinisi, tidak diketahui nilainya
F.S : membentuk sebuah Line dari komponen-komponennya dengan L
diinisialisasi nilainya dengan PAwal = (0,0) dan PAkhir = (0,0) */
void CreateLINE2 (Line *L, POINT First, POINT End);

F.S : membentuk sebuah Line dari komponen-komponennya dengan L
diinisialisasi nilainya dengan PAwal = First dan PAkhir = End */
/* Selektor Line **/

POINT GetPAwal(Line L);
// Mengirimkan komponen Titik Awal dari L
POINT GetPAkhir (Line L);
// Mengirimkan komponen Titik Akhir dari L

void SetPAwal(Line *L, POINT newFirstP);
/* I.S : L terdefinisi, dengan nilainya sembarang
F.S : Mengubah nilai komponen Titik Awal dari L dengan PAwal=newFirstP
*/
void SetPAkhir (Line *L, POINT newEndP);
/* I.S : L terdefinisi, dengan nilainya sembarang
F.S : Mengubah nilai komponen Titik Akhir dari L dengan PAkhir=newEndP
*/

void BacaLine (Line *L);
/* I.S : L terdefinisi, mungkin kosong
F.S : Komponen L dengan nilai PAwal dan PAkhir dari yang dibaca
*/
void CetakLine(Line L);
F.S : Menampilkan nilai Komponen L ke layar dg format “(P1(X1,Y1) ,
P2(X2,Y2))
*/
/** Kelompok operasi relasional terhadap Line **/

boolean IsEQLine(Line Ll, Line L2);
// Mengirimkan true jika L1 = L2, yaitu:
// jika titik awal dari L1 sama dengan titik awal dari L2 dan
Halaman
17 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
// titik akhir L1 sama titik akhir dari L2.
boolean IsNEQLine(Line P1, Line P2);

// Mengirimkan true jika PI tidak sama dengan P2, negasi dari EQLine
/** Kelompok menentukan di mana L berada **/

boolean IsLOnSbX (Line L);
// Menghasilkan true jika L terletak pada sumbu X yaitu titik Awal dan
titik Akhir dari L berada pada sumbu X, dan false jika sebaliknya
boolean IsLOnSbY (Line L);
// Menghasilkan true jika L terletak pada sumbu Y yaitu titik Awal dan
titik Akhir dari L berada pada sumbu X, dan false jika sebaliknya
boolean IsTegakLurus(Line L1, Line L2);
// Menghasilkan true jika L1 saling tegak lurus terhadap L2, dan false jika
sebaliknya. Hint : gunakan gradien Garis.
boolean IsSejajar(Line L1, Line L2);
// Menghasilkan true jika L1 saling “sejajar” terhadap L2, dan false jika
sebaliknya. Hint : gunakan gradien Garis.

void GeserLine (Line *L, int deltaX, int deltaY);
F.S : L bergeser sebesar absisnya deltaX dan ordinatnya deltaX
*/
#endif
TUGAS PRAKTIKUM
1. Dengan cara yang sama seperti pada Modul 1, ketikan header file untuk ADT Line
diatas.
2. Buat body file dari setiap prototype (prosedur dan fungsi) pada header file ADT Line
3. Buat file drivernya: mline.c
4. Buat projek untuk ADT Line, sertakan ADT Point pada Project (header dan body) karena
operasi pada ADT Line menggunakan operasi pada ADT Point
5. Kemudian Simpulkan oleh anda, apa yang anda pelajari pada latihan modul 2 ?
PENGUMPULAN
1. File yang dikumpulkan adalah file dengan extensi .h, .c dan word (untuk soal no 5)
2. Kompres hasil Tugas Praktikum dalam bentuk zip dengan penamaan :
Halaman
18 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Halaman
19 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
MODUL 3 ADT TabInt (Tabel Integer)

1. Memahami pembuatan ADT dengan tipe data array.
2. Kasus yang digunakan adalah ADT Tabel Integer, yaitu sebuah koleksi
obyek dengan tipe data yang sama berupa integer.
Dasar Teori
Sebuah ADT Tabel integer adalah pembentukan Tabel (array) yang berisi sekumpulan data
bertipe integer. ADT tabel integer terdiri dari tempat penyimpanan obyek dalam array yang
terdefinisi dengan tipe integer, serta variable pencacah bagi obyek tersebut, sehingga proses
akses terhadap obyek dapat dilakukan dengan mudah. Variable pencacah dapat disebut juga
sebagai variable yang menyimpan jumlah data/ elemen yang ada pada tabel.
Tab
nEff = 0  karena tidak ada data/ elemen pada tabel

Tab
10 5
nEff = 2  karena jumlah data/ elemen pada tabel sebanyak 2 buah (10 dan 5)
Implementasi ADT TabInt

ADT TabInt diimplementasikan menjadi dua buah modul yaitu, :
type TabInt : < T1 : array [1..nMax] of integer,
nEff : integer>

Bagian file Header TabInt
/* Program : tabint.h
Kelas :
Deskripsi: Header file dari prototype Tab Integer
Tanggal :
*/
#ifndef _TABINT_H
#define _TABINT_H
Halaman
20 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
#include <stdio.h>
#include <conio.h>
#define nMax 10
#define IdxUndef -999
#define ElType int
/** Definisi ABSTRACT DATA TYPE Tab Integer **/

typedef struct {
ElType T1[nMax]; // koleksi bilangan bertipe integer
int nEff; // jumlah data atau elemen pada tabel
}TabInt;
/* Prototype TabInt */
/* Konstruktor membentuk TabInt */

void CreateTabInt (TabInt *T);
/* I.S : T terdefinisi, tidak diketahui nilainya
F.S : membentuk sebuah TabInt dengan nEff = 0
*/
/* Selektor TabInt **/

int GetJumElmt(TabInt T);
// Mengirimkan banyaknya elemen tabel atau mengirimkan nol jika tabel
kosong
int GetFirstIdx (TabInt T);
// Mengirimkan elemen pertama dari tabel
int GetLastIdx (TabInt T);
// Mengirimkan elemen terakhir dari tabel
int GetElmt (TabInt T, int idx);
// Mengirimkan elemen pada index ke-idx dari tabel, dengan syarat x<=nMax

void SetEl(TabInt *T,int i, int v );
/* I.S : T terdefinisi, sembarang
F.S : Elemen T yang ke i bernilai v:
Mengubah nilai elemen tabel yang ke—i sehingga bernilai v
*/
/** { KELOMPOK OPERASI Cek Elemen kosong atau penuh} **/

boolean IsEmpty(TabInt T);
// mengecek apakah jumlah data pada tabel kosong
// mengirimkan true jika tabel kosong atau mengirimkan false jika tidak
boolean IsFull(TabInt T);
// mengecek apakah jumlah data pada tabel penuh
// mengirimkan true jika tabel penuh, mengirimkan false jika tidak

void BacaElmt (TabInt *T);
/* I.S : T terdefinisi, mungkin kosong
F.S : Mengisi komponen T dengan nilai elemen tabel dari yang dibaca
Halaman
21 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
*/
void CetakTabInt(TabInt T);

F.S : menampilkan semua elemen tabel ke layar
*/
void AddElmt(TabInt *T, int X);
F.S : menambahkan nilai elemen baru pada tabel yang ditempatkan diposisi
akhir. Proses penambahan dilakukan selama jumlah elemen < nMax
*/
/** { KELOMPOK OPERASI ARITMATIKA TERHADAP TYPE } **/

TabInt KaliTab (TabInt T1, TabInt T2);
// Prekondisi T1 dan T2 harus berukuran sama dan tidak kosong,
// Mengirimkan Tabel baru baru dengan mengalikan setiap elemen T1 dan T2
pada indeks yang sama
// Contoh : Nilai T1 (5, 2, 10) dan T2 (2, 3, 6)
// nilai Tabel baru = 10, 6, 60
TabInt KaliKons (TabInt T, int c);

// Prekondisi T tidak kosong,
// Mengirimkan Tabel baru dengan setiap elemen tabel dikalikan c
// Contoh : Nilai T1 (5, 2, 10) dan C = 2
/** Kelompok operasi relasional terhadap TabInt **/

boolean IsEQTab(TabInt T1, TabInt T2);
// Prekondisi T1 dan T2 harus berukuran sama dan tidak kosong
// mengirimkan true jika ukuran T1 = T2: semua elemennya sama,
// dan jika tidak mengirimkan false

void CopyTab(TabInt Tin, TabInt *Tout);
/* I.S : Tin terdefinisi, tidak boleh kosong
F.S : Tout berisi salinan Tin, Assignment THsl <~ Tin yaitu:
Setiap elemen THsl digantikan dengan semua elemen Tin dan
nEff pada THsl = nEff pada Tin.
Sehingga elemen Tout sama dengan elemen Tin
*/
TabInt InverseTab(TabInt T);
// Menghasilkan tabel dengan urutan tempat yang terbalik, yaitu:
// elemen pertama rnenjadi terakhir,
// elemen kedua menjadi elemen sebelum terakhir, dst..
// Tabel kosong menghasilkan tabel kosong
// Contoh : Nilai T (5, 2, 10)
boolean isElemenAda(TabInt T, ElType X);

// Mengirimkan true jika nilai x berada pada T dan false jika x tidak ada
int cariElemen(TabInt T, ElType X);

// Search apakah ada elemen tabel T yang bernilai X
Halaman
22 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
// Jika ada, menghasilkan indeks i terkecil, dengan elemen ke—i=X

// Jika tidak ada atau tabel kosong, mengirimkan IdXUndef (bernilai -999)
#endif
TUGAS PRAKTIKUM
1. Dengan cara yang sama seperti pada Modul 1, ketikan header file untuk ADT TabInt
diatas.
2. Buat body file dari setiap prototype (prosedur dan fungsi) pada header file ADT TabInt
3. Buat file drivernya: mtabint.c
4. Buat projek untuk ADT TabInt
PENGUMPULAN
Halaman
23 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
MODUL 4 ADT Linear Linked List

1. Memahami konsep ADT Linear Linked List (senarai berkait) yaitu bentuk
struktur data dinamik.
2. Mampu mengimplementasikannya ke bahasa C.
3. Mampu melakukan operasi insert dan delete pada list.
Dasar Teori
List Linier
List linier adalah sekumpulan elemen bertype sama yang saling terkait dengan elemen
selanjutnya dan mempunyai keterurutan tertentu. Setiap elemen pada List Linear terdiri
dari dua bagian, yaitu: informasi mengenai nilai elemennya, dan informasi mengenai
alamat elemen suksesornya atau alamat elemen selanjutnya.
Spesifikasi untuk tipe list linear adalah:
type ElmtList : <info : InfoType, Next : address>
InfoType adalah sebuah type terdefinisi yang menyimpan informasi sebuah elemen list.
Next adalah address ("alamat") dari elemen berikutnya (suksesor).
Dengan demikian, jika didefinisikan First adalah alamat elemen pertama list, maka elemen
berikutnya dapat diakses secara berurutan dari field Next elemen tersebut.
Jika address ("alamat") berisi sebuah nilai yang menunjukkan alamat elemen list maka
disebut sebagai pengalokasian elemen. Sebaliknya jika address ("alamat") bernilai suatu
konstanta Nil, maka tidak menunjuk ke elemen list atau alamat tidak terdefinisi. Alamat ini
nantinya akan didefinisikan secara lebih konkret ketika list linier diimplementasi pada
struktur data fisik.
Jadi, sebuah list linier dikenali dengan :

- Elemen pertamanya, biasanya melalui alamat elemen pertama yang disebut : First;
- Alamat elemen berikutnya (suksesor) diakses melalui informasi next;
- Setiap elemen mempunyai alamat, yaitu tempat elemen disimpan yang dapat ditunjuk oleh
address. Agar sebuah sebuah elemen dapat ditunjuk oleh address, maka harus
mendefinisikan alamat pada elemen tersebut. Dengan menggunakan alamat tersebut,
informasi yang tersimpan pada elemen list dapat diakses;
Halaman
24 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
- Elemen terakhir adalah elemen yang berada pada paling belakang.

Beberapa Definisi :
Jika L adalah list dan P adalah address maka dapat diasumsikan bahwa:
- Alamat elemen pertama list L dapat ditunjuk dengan notasi : First(L)
- Elemen yang diacu oleh P dapat dikonsultasi informasinya dengan notasi Selektor :
Info(P), untuk menunjuk elemen info
Next(P), untuk menunjuk elemen next (elemen selanjutnya)
- List L adalah list kosong, jika First(L) = nil
- Elemen terakhir dikenali, misal jika Last adalah alamat elemen terakhir, maka
Next(Last) = nil
Operasi-operasi yang ada pada Linear List,

A. INSERT (Melakukan Penyisipan pada List)
Jika sesuatu yang disisipkan ke list berupa address (sudah dialokasi sebelumnya) maka proses
penyisipan dapat langsung disisipkan. Tetapi jika sesuatu yang disisipkan adalah sebuah nilai
maka dilakukan proses pengalokasian terlebih dahulu. Alokasi adalah pembentukan sebuah
address yang mengacu/menunjuk ke elemen list. Alokasi dilakukan dengan;
1. Buat sebuah elemen list
2. Buat address (P) untuk menunjuk ke elemen list tersebut
3. Jika alokasi tidak berhasil maka P diisi nil
4. Jika alokasi berhasil, maka isi komponen element list pada address (P) : Info = nilai dan
Next = nill
INSERT-First (diketahui alamat)
Menambahkan sebuah elemen yang diketahui alamatnya sebagai elemen pertama list.
Ada dua kemungkinan yaitu kondisi list kosong dan tidak kosong.
Insert elemen pertama pada list kosong :
Halaman
25 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Insert elemen pertama pada list tidak kosong :
INSERT-First (diketahui nilai)

Menambahkan sebuah elemen yang diketahui nilainya sebagai elemen pertama list. Ada
dua kemungkinan yaitu kondisi list kosong dan tidak kosong.
Tahap pertama :
Jika diketahui nilai yang akan diinsertkan adalah 3 sebagai elemen pertama List. Oleh karena
yang diketahui adalah nilai, maka harus dialokasikan dahulu sebuah elemen supaya nilai 3
dapat di-insert.
Jika alokasi berhasil, maka P tidak sama dengan Nil
Tahap kedua : insert

Insert elemen pertama pada list kosong :
Halaman
26 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Insert elemen pertama pada list tidak kosong :
INSERT-After :
Menyisipkan sebuah elemen beralamat P setelah suksesor dari sebuah elemen list linier
yang beralamat Prec. Jika yang disisipkan adalah sebuah nilai, maka lakukan terdahulu
alokasi untuk mendapatkan alamat elemen tersebut (proses alokasi sudah disebutkan diatas).
Halaman
27 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
INSERT-Last
Menyisipkan sebuah elemen beralamat P setelah sebagai elemen terakhir sebuah list linier.
Jika yang disisipkan adalah sebuah nilai, maka lakukan terdahulu alokasi untuk mendapatkan
alamat elemen tersebut (proses alokasi sudah disebutkan diatas).
Ada dua kemungkinan sebelum penyisipan elemen yaitu kondisi list kosong dan tidak
kosong.
Insert sebagai elemen terakhir pada list kosong :
Insert sebagai elemen terakhir pada list tidak kosong :
Halaman
28 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
B. DELETE (Melakukan Penghapusan elemen pada List)

Setelah penghapusan, elemen yang dihapus dicatat alamatnya dan kadang kala alamat elemen
yang tersebut akan didealokasi. Dealokasi adalah proses pembebasan address (P) sehingga
tidak menunjuk ke elemen list.
Sebagai catatan bahwa :
- Operasi delete yang tidak melakukan dealokasi address, dilakukan jika address tersebut
masih dibutuhkan. Misalnya elemen yang dihapus akan dijadikan anggota elemen list lain:
dalam hal ini tidak perlu melakukan dealokasi, kemudian alokasi ulang ketika
ditambahkan ke list yang baru. Beberapa list dengan elemen sejenis seringkali harus
dikelola dalam program; misalnya list mahasiswa per matakuliah.
- Operasi yang sekaligus melakukan dealokasi address, biasanya dilakukan kepada
pengguna yang tidak perlu mengetahui “keberadaan” address dan yang hanya perlu
memanipulasi informasi pada field info.
DELETE-First
Menghapus elemen pertama list linier. Untuk proses penghapusan harus dipastikan bahwa
element pada list tidak kosong.
DELETE-After
Menghapus elemen yang berada ditengah list linier. Untuk proses penghapusan harus
dipastikan bahwa element pada list tidak kosong dan jumlahnya lebih dari 1.
Penghapusan suksesor sebuah elemen :
Halaman
29 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
DELETE-Last
Menghapus elemen terakhir list dapat dilakukan jika alamat dari elemen sebelum
elemen terakhir diketahui. Untuk proses penghapusan harus dipastikan bahwa element pada
list tidak kosong. Persoalan selanjutnya menjadi persoalan DELETE AFTER, jika Last
bukan satu-satunya elemen list linier. Ada dua kemungkinan setelah proses penghapusan
yaitu kondisi list menjadi kosong atau tidak.
Kasus list menjadi kosong setelah penghapusan :
List tidak menjadi kosong (masih mengandung elemen) setelah penghapusan :
Implementasi ADT Linear Linked List

ADT linear linked list diimplementasikan menjadi dua buah modul yaitu, :
Halaman
30 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
type ElmList : < info : integer,

next : address ElmList>
type List : < first : address ElmList>

Bagian file Header Linear Linked List
/*
Program : list.h
Kelas :
Deskripsi: Header file dari prototype linear linked list
Tanggal :
*/
#ifndef _LIST_H
#define _LIST_H
#include <stdio.h>
#include <conio.h>
#define Nil NULL
#define Info(P) (P)->info
#define Next(P) (P)->next
#define First(L) (L).First
/** Definisi ABSTRACT DATA TYPE List **/

/*Definisi List :*/
/* List kosong ===> First (L) =Nil
Setiap elemen dengan address P dapat diacu info (P) dan Next (P);
Elemen terakhir list ===> Jika addressnya Last maka Next (Last) = Nil
*/
typedef struct tElmtList *address; // pointer menunjuk ke alamat tElmtList
typedef int infotype;
typedef struct tElmtList{
infotype info;
address next;
} ElmtList;
typedef struct{
address First;
} List;
/* Prototype Linear List */

/* Konstruktor membentuk List */
void CreateList (List *L);
F.S : L diinisialisasi first(L) = nil
*/
/* Destruktor/Dealokator: */
address Alokasi (infotype X);
Halaman
31 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
/*Mengirimkan address hasil alokasi sebuah elemen

Jika alokasi berhasil, maka address !=Nil,
dan misalnya menghasilkan P, maka Info(P)= x, Next(P)=Nil
Jika alokasi gagal, mengirimkan Nil
*/
void DeAlokasi (address P);
/*I.S : P terdefinisi
F.S : P dikembalikan ke sistem
Melakukan dealokasi/ pengembalian address P ke system
*/
/** { KELOMPOK OPERASI Cek Elemen kosong atau penuh} **/

boolean ListEmpty(List L);
// mengecek apakah jumlah elemen pada List kosong
// mengirimkan true jika List kosong, mengirimkan false jika tidak
/**Penambahan Elemen***/
void InsFirst (List *L, infotype X);
/*I.S : L terdefinisi, mungkin kosong
F.S : melakukan alokasi sebuah elemen dan
menambahkan elemen pertama pada List dengan nilai X jika alokasi
berhasil. Jika alokasi gagal IS = FS
*/
void InsLast (List * L, iinfotype X);
F.S : melakukan alokasi sebuah elemen dan
menambahkan elemen terakhir pada List dengan nilai X jika alokasi
berhasil. Jika alokasi gagal IS = FS
*/
void InsAfter (List * L, infotype X, infotype Y);
F.S : melakukan alokasi sebuah elemen dengan nilai x dan
menambahkan elemen list setelah y ditemukan pertama kali pada list
*/
/*Penghapusan Elemen*/
void DelFirst (List * L, infotype *X);
/*I.S : L tidak kosong
F.S : Elemen pertama List dihapus, nilai info disimpan ke X
dan alamat elemen pertama di dealokasi. Sehingga elemen pertama pada List
adalah elemen berikutnya sebelum penghapusan.
*/
void DelLast (List *L, infotype *X);
/*I.S : L tidak kosong
F.S : Elemen terakhir list dihapus: nilai info disimpan pada X
dan alamat elemen terakhir di dealokasi. Sehingga elemen terakhir pada
List adalah elemen sebelumnya sebelum penghapusan.
*/
void DelAfter (List * L, infotype *X, infotype Y);
F.S : melakukan dealokasi sebuah elemen dengan nilai x setelah nilai y
pertama ditemukan pada list.
Halaman
32 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Nilai x yang dihapus dalam list akan disimpan sebagai keluaran

dari prosedur
*/
void PrintInfo (List L);
F.S : Jika List tidak kosong, menampilkan semua info yang disimpan pada
elemen list ke layar. jika List kosong, hanya menampilkan pesan
“list kosong”
*/

int NbElmt (List L);
// Mengirimkan banyaknya elemen List atau mengirimkan 0 jika List kosong
address Search (List L, infotype X);

/* Mencari apakah ada elemen list dengan Info (P)= X
Jika ada, mengirimkan address elemen tersebut yang pertama kali
ditemukan.
jika tidak ada, mengirimkan Nil
*/
void InversList (List *L);

/* I.S : L sembarang
F.S : Mengubah Elemen list menjadi terbalik, yaitu elemen terakhir
menjadi elemen pertama, elemen kedua menjadi elemen sebelum
terakhir dst
Membalik elemen list, tanpa melakukan alokasi / dealokasi
*/
List getNewInversList (List L);

// Mengirimkan list baru, hasil invers dari L
#endif
TUGAS PRAKTIKUM
1. Dengan cara yang sama seperti pada Modul 1, ketikan header file untuk ADT List diatas.
2. Buat body file dari setiap prototype (prosedur dan fungsi) pada header file ADT List
3. Buat file drivernya: mlist.c
4. Buat projek untuk ADT List
PENGUMPULAN
Halaman
33 / 81
STRUKTUR DATA
OLEH : TIM DOSEN

Halaman
34 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
MODUL 5 ADT Stack Representasi Kontigu

1. Memahami konsep ADT Stack dengan representasi fisik
kontigu, yaitu bentuk struktur data static tumpukan
menggunakan array.
3. Mampu melakukan operasi dasar stack yaitu push (menambahkan sebuah
elemen) dan pop (menghapus elemen)
Dasar Teori
Stack
Stack merupakan tumpukan yang terdiri dari sekumpulan elemen dengan operasi
penambahan (push) pada bagian paling atas (top) dari tumpukan dan pengambilan elemen
(pop) yang selalu diambil dari yang paling atas (top). Sebuah stack dikenali dengan :
1. elemen puncaknya disebut TOP
2. aturan penyisipan dan penghapusan elemennya tertentu :
- Penyisipan selalu dilakukan "di atas" TOP
- Penghapusan selalu dilakukan pada TOP
Oleh karena aturan penyisipan dan penghapusan semacam itu, maka TOP adalah satu-satunya
alamat tempat terjadi operasi. Elemen yang ditambahkan paling akhir akan menjadi elemen
yang akan dihapus. Dengan demikian bahwa elemen Stack akan tersusun secara LIFO
(Last In First Out), artinya elemen yang terakhir masuk adalah elemen yang akan pertama
dikeluarkan dari Stack. Ilustrasinya dapat digambarkan seperti tumpukan CD atau tumpukan
sate.
Struktur data ini banyak dipakai dalam informatika, misalnya untuk merepresentasi :
- pemanggilan prosedur
- perhitungan ekspresi artimatika
- rekursifitas
- backtracking dan algoritma lanjut yang lain
Halaman
35 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Perhatikan bahwa dengan definisi semacam ini, representasi tabel sangat tepat untuk
mewakili stack, karena operasi penambahan dan pengurangan hanya dilakukan di salah
satu ujung tabel.
“Perilaku” yang diubah adalah bahwa dalam stack, operasi penambahan hanya dapat
dilakukan di salah satu ujung sedangkan pada tabel, boleh dimanapun.
Definisi Fungsional
Diberikan S adalah Stack dengan elemen ElmtS, maka definisi fungsional stack adalah :
CreateStack :  S {Membuat sebuah stack kosong}
IsEmpty : S  boolean
{Cek apakah stack kosong, true jika stack kosong dan false jika S
tidak kosong}
IsFull : S  boolean
{Cek apakah stack penuh, true jika stack penuh dan false jika S
tidak penuh}
Push : ElmtS x S  S
{Menambahkan sebuah elemen baru sebagai TOP dan nilai TOP bertambah
1}
Pop : S  ElmtS x S
{Mengambil nilai elemen TOP, sehingga TOP yang baru adalah elemen
yang datang sebelum elemen TOP, dan nilai TOP berkurang 1, sehingga
memungkinkan Stack menjadi kosong.
Definisi Selektor
Jika S adalah sebuah Stack, maka
Top(S) adalah alamat elemen TOP, tempat operasi penyisipan/penghapusan dilakukan
InfoTop(S) adalah informasi yang disimpan pada Top(S).
Definisi Stack kosong adalah Stack dengan Top(S)=Nil (tidak terdefinisi).
Implementasi Stack dengan tabel :
Halaman
36 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Stack dengan representasi sebuah Tabel yaitu : elemen Stack dari index 1 sampai dengan
index Maximum (idxMax). Sehingga TOP adalah index elemen TOP (elemen paling atas)
dari Stack. Jika Stack kosong maka TOP=0, sebaliknya jika Stack penuh maka TOP=idxMax.
Ilustrasi Stack tidak kosong dan tidak penuh, dengan 5 elemen dan index maksimumnya 10 :
Ilustrasi Stack kosong :

Pada ilustrasi ini, dikatakan Stack Kosong jika Top(S)=0
Ilustrasi Stack penuh :

Pada ilustrasi ini, dikatakan Stack Penuh jika Top(S) = IdxMax
Implementasi ADT Stack

ADT Stack diimplementasikan menjadi dua buah modul yaitu, :
type ElmStack : < TabElm : array [1 ... nMax] of infotye,
Top : address of infotype>
Algoritma operasi Push untuk implementasi dengan tabel

1. Prekondisi elemen Stack : Stack tidak penuh
2. Siapkan index sebagai tempat penampung elemen stack yang akan ditambahkan
TOP  TOP + 1
3. Masukan elemen baru ke dalam lokasi TOP yang baru
S[TOP]  elemen
Algoritma operasi Pop untuk implementasi dengan tabel
Halaman
37 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
1. Prekondisi elemen Stack : Stack tidak kosong

2. Siapkan tempat penampung elemen stack yang akan dikurangi
Elemen  S[TOP]
3. Kurangi TOP dengan 1 : TOP  TOP – 1
Ilustrasi operasi POP dan PUSH terhadap stack

Hasil
Operasi
Isi Tumpukan TOP Elemen yang dikeluarkan
CreateStack(S) :<kosong> 0 -
Push(S, ‘a’) :a 1 -
Push(S, ‘b’) :ab 2 -
Push(S, ‘c’) :abc 3 -
Pop(S, elemen) :ab 2 c
Push(S, ‘d’) :abd 3 -
Push(S, ‘e’) :abde 4 -
Pop(S, elemen) :abd 3 e
Pop(S, elemen) :ab 2 d
Pop(S, elemen) :a 1 b

Bagian file Header Stack
/* Program : stack.h
Kelas :
Deskripsi: Header file dari prototype stack
Tanggal :
*/
#ifndef _STACK_H
#define _STACK_H
#include <stdio.h>
#include <conio.h>
#define Nil 0
#define MaxEl 10
/* Nil adalah stack dengan elemen kosong
Karena indeks dalam bhs C dimulai 0 maka tabel dengan indeks 0 tdk
dipakai*/
/* Definisi akses dengan Selektor : Set dan Get */
#define Top(S) (S).TOP
#define InfoTop(S) (S).T[(S).TOP]
/** Definisi ABSTRACT DATA TYPE Stack **/

/* Definisi stack :
Halaman
38 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
/*
S kosong  S.TOP = Nil
Elemen yang dipakai menyimpan nilai Stack T[l]..T[MaxEl]
Jika S adalah Stack maka akses elemen :
S.T[(S.TOP)] untuk mengakses elemen TOP
S.TOP adalah alamat elemen TOP
*/
typedef int infotype; /*elemen stack bertipe integer*/

typedef int address; /* indeks tabel */
/* Contoh deklarasi variabel bertype stack denqan ciri TOP : */
/* Versi pembentukan stack  dengan menyimpan tabel dan alamat top secara
eksplisit */
typedef struct { infotype T[MaxEl+1]; /* tabel penyimpan elemen */

address TOP; /* alamat TOP: elemen puncak */
} Stack;
/* Prototype Stack */
/* Konstruktor membentuk Stack */

void CreateStack(Stack *S);
/* I.S : S terdefinisi tidak diketahui nilainya
F.S : S diinisialisasi dengan TOP = nil
*/
/** { Operasi terhadap komponen : selektor Get dan Set } : tidak perlu
sudah di define diatas**/
/** { KELOMPOK OPERASI pada Stack} **/

/*********** Predikat Untuk test keadaan KOLEKSI **/
boolean IsStackEmpty (Stack S);
// Mengecek apakah Stack tidak memiliki elemen
// Mengirim true jika Stack kosong: lihat definisi di atas
boolean IsStackFull(Stack S);

// Mengecek apakah Stack sudah penuh
// Mengirim true jika tabel penampung nilai elemen stack penuh
/*********** Menambahkan sebuah elemen ke Stack **********/

void Push (Stack *S, infotype X);
/* Menambahkan X sebagai elemen Stack S. */
/* I.S : S terdifinisi, mungkin kosong, dan
S penampung elemen stack tidak penuh.
F.S : X menjadi TOP yang baru,TOP bertambah 1
*/
/*********** Menqhapus sebuah elemen Stack **********/

void Pop (Stack *S, infotype *X);
// Menghapus X dari Stack S.
/* I.S : S terdifisi, S tidak kosong
Halaman
39 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
F.S : mengambil elemen pada Top sehingga X berisi nilai elemen TOP yang
lama, kemudian TOP berkurang l
*/

void PrintStackInfo (Stack S);
/* I.S : S terdefinisi, mungkin kosong
F.S : Jika Stack tidak kosong, menampilkan semua info yang disimpan pada
elemen stack ke layar.
*/

boolean isInfoKetemu(Stack S, infotype x);
/* mengirim true jika x berada pada S */
address CariElemenStack(Stack S, infotype x);

// Search apakah ada elemen tabel TabElm yang bernilai X)
// Jika x ada pada S, maka mengirimkan address pertama kali ditemukan
// Jika tidak ada atau kondisi Stack adalah kosong, maka mengirimkan
IdXUndef (bernilai -999)
#endif
TUGAS PRAKTIKUM
Latihan 1
1. Dengan cara yang sama seperti pada Modul 1, ketikan header file untuk ADT Stack
diatas.
2. Buat body file dari setiap prototype (prosedur dan fungsi) pada header file ADT Stack
3. Buat file drivernya: mstack.c untuk menyelesaikan persoalan dibawah ini
Pernyataan :
Buatlah sebuah program utama dalam Bahasa C yang membaca N (integer). N bernilai
positif, yaitu N>0. Definisikan sebuah stack (dengan memanfaatkan ADT stack yang
sudah anda buat) dan isi stack tersebut dengan nilai ganjil dari 1 s.d. N. Selanjutnya, isi
stack di-pop satu per satu sampai stack kosong. Di akhir program, tampilkan pesan
bahwa stack kosong dan jumlah elemen yang sudah di-pop dari stack.
Contoh input/output :
Input Output Keterangan
5 5 N=5
3 Bilangan yang di pop secara terurut = {5, 3, 1}
1 Elemen stack = 3
Empty stack
3
10 9 N = 10
7 Bilangan yang di pop secara terurut = {9, 7, 5, 3, 1}
5 Elemen stack = 5
Halaman
40 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
3
1
Empty stack
5
0 Masukan tidak valid N=0
-1 Masukan tidak valid N=-1
dari modul program adalah benar.
4. Buat projek untuk ADT Stack
Latihan 2
1. Buatlah kelompok dengan anggota 3 orang (tidak boleh lebih). Kemudian selesaikan
persoalan ADT Stack representasi Pointer dibawah dengan memanfaatkan konsep linear
linked list pada modul sebelumnya. Buatlah body dan main driver-nya.
File header Stack dengan representasi Pointer
/* Program : stack2.h
Author : (Nim, Nama)  tuliskan anggota kelompok
Kelas :
Tanggal :
*/
#ifndef _STACK2_H
#define _STACK2_H
#include <stdio.h>
#include <conio.h>
//Pendefinisian Pointer
#define nil NULL
#define info(P)
#define next(P)
#define TOP(S) (S).TOP
//Pendefinisian tipe Stack

typedef int infotype; /*elemen stack bertipe integer*/
typedef struct tElmStack *address;
typedef struct tElmStack{

infotype Info;
address next;
}ElmStack;
Halaman
41 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
typedef struct {
address BUTTOM;
address TOP;
}Stack;
//Prototype Stack/ primitif Stack Pointer
//Konstruktor
void CreateStack(Stack *S);
/* I.S : S terdefinisi tidak diketahui isinya
F.S : S diinisialisasi dengan TOP(S)=nil
*/
address Alokasi(infotype x);
/* mengirim sebuah elemen Stack dalam bentuk address */
//Destruktor
void DeAlokasi(address P);
/* me—release memori dari P sebuah elemen stack */
//Operasi Stack
void Push (Stack *S, infotype X);
/* Menambahkan X sebagai elemen Stack S. */
/* I.S : S terdifinisi, mungkin kosong, dan
S penampung elemen stack tidak penuh.
F.S : X menjadi TOP yang baru,TOP bertambah 1
*/
void Pop (Stack *S, infotype *X);

// Menghapus X dari Stack S.
/* I.S : S terdifisi, S tidak kosong
F.S : mengambil elemen pada Top sehingga X berisi nilai elemen TOP
yang lama, kemudian TOP berkurang l
*/
void CetakStack(Stack S);

/* I.S : S terdefinisi sembarang, tidak kosong
F.S : menampilkan semua elemen S ke layar
*/
boolean IsStackEmpty(Stack S);

// mengecek apakah Stack tidak memiliki elemen
// mengirim true jika S kosong, false sebaliknya
boolean CariElemenStack(Stack S, infotype x);

/* mengirim true jika x ditemukan pada S, false jika tidak ditemukan
Skema pencarian dengan search dengan boolean
*/
#endif
PENGUMPULAN
Halaman
42 / 81
STRUKTUR DATA
OLEH : TIM DOSEN

3. Untuk tugas kelompok dikumpulkan pada email terpisah dengan penamaan :
[Prak. Struktur Data]_Kelas_TGS Modul 5_NIM1_NIM2_NIM3
Contoh :
[Prak. Struktur Data]_A_TGS Modul 5_3411161001_3411161002_3411161003
Halaman
43 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
MODUL 6 ADT Queue Representasi Kontigu “Non Circular”

1. Memahami konsep ADT Queue dengan representasi fisik kontigu, yaitu
bentuk struktur data static antrian menggunakan array.
3. Mampu melakukan operasi dasar Queue yaitu add (menambahkan antrian)
dan delete (menghapus antrian)
Dasar Teori
Queue
Queue adalah sekumpulan obyek yang berupa antrian linear yang :
1. dikenali elemen pertama (HEAD) dan elemen terakhirnya (TAIL),
2. aturan penyisipan dan penghapusan elemennya didefinisikan sebagai berikut:
- Penyisipan selalu dilakukan setelah elemen terakhir
- Penghapusan selalu dilakukan pada elemen pertama
Karena aturan penyisipan dan penghapusan semacam itu, maka elemen Queue tersusun
secara FIFO (First In First Out), artinya elemen yang pertama masuk adalah elemen yang
akan pertama di keluarkan dari Queue. Implementasi antrian dapat ditemukan seperti pada
penjualan karcis kereta, bioskop dsb.
Struktur data ini banyak dipakai dalam informatika, misalnya untuk merepresentasi :
- antrian job yang harus ditangani oleh sistem operasi
- antrian dalam dunia nyata.
Halaman
44 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Definisi Fungsional Queue

Diberikan Q adalah QUEUE dengan elemen ElmtQ maka definisi fungsional antrian adalah:
CreateQueue :  Q {Membuat sebuah antrian kosong}
IsEmpty : Q  boolean
{Cek apakah queue kosong, true jika antrian kosong,
false jika Q tidak kosong}
IsFull : S  boolean
{Cek apakah queue penuh, true jika antrian penuh, false
jika Q tidak penuh}
NBElmt : Q  integer {mengirimkan banyaknya elemen Q}
Add : ElmtQ x Q  Q
{Menambahkan sebuah elemen pada posisi teralhir atau
setelah elemen ekor pada QUEUE}
Del : Q  Q x ElmtQ
{Menghapus Elemen pertama atau kepala Queue, sehingga
memungkinkan Queue menjadi kosong}
Definisi Selektor
Jika Q adalah sebuah Queue, maka
Head(Q) adalah alamat elemen pertama dari Queue, sebagai tempat operasi penyisipan
dilakukan.
Tail(Q) adalah alamat elemen terakhir dari Queue, sebagai tempat operasi penghapusan
dilakukan.
Info(Head(Q)) adalah informasi yang disimpan pada Head(Q)
Info(Tail(Q)) adalah informasi yang disimpan pada Tail(Q)
Definisi Queue kosong adalah Queue dengan Head(Q)=Nil dan Tail(Q)=Nil (tidak
terdefinisi).
Definisi Queue penuh adalah Queue dengan Tail(Q)=idxMax (index Tail sudah mencapai
maksimum).
Implementasi QUEUE dengan tabel Non Circular :

Memori tempat penyimpan elemen adalah sebuah tabel dengan indeks 1 sampai dengan index
Maximum (IdxMax).
Implementasi Q dengan non circular artinya laju pergerakan antrian tidak melingkar. Pada
proses penyisipan posisi Tail(Q) akan selalu naik sampai Tail(Q) mencapai index Maximum.
Sedangkan untuk proses penghapusan dapat menggunakan 2 alternatif (dijelaskan dibawah
ini).
Alternatif I :
Halaman
45 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Tabel dengan representasi TAIL sebagai indeks elemen terakhir, HEAD selalu diisi dengan 1
jika Queue tidak kosong. Sedangkan jika Queue kosong, maka HEAD=0.
Ilustrasi Queue tidak kosong, dengan 5 elemen :
Ilustrasi Queue kosong :

Pada ilustrasi ini, dikatakan Stack Kosong jika Head(Q)=0 dan Tail(Q)=0
Algoritma Penambahan
Algoritma paling sederhana untuk penambahan elemen jika masih ada tempat
adalah dengan memajukan TAIL. Kasus khusus untuk Queue kosong karena HEAD
harus diset nilainya dengan nilai 1. Pada operasi ini, pastikan dahulu bahwa Queue
tidak penuh.
Ilustrasi penambahan pada Queue kosong :
Ilustrasi penambahan pada Queue tidak kosong :

Kondisi Awal, Queue dengan 5 elemen :
Kondisi setelah penambahan :
Algoritma penghapusan
Halaman
46 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Algoritma paling sederhana dan “naif” ketika penghapusan elemen jika Queue
tidak kosong: ambil nilai elemen HEAD, geser semua elemen mulai dari HEAD+1
s/d TAIL (jika ada) ke kiri, kemudian TAIL mundur. Kasus khusus untuk Queue
dengan keadaan awal yang hanya memiliki satu elemen, yaitu menyesuaikan HEAD dan
TAIL sesuai dengan DEFINISI. Algoritma ini mencerminkan pergeseran orang yang
sedang mengantri di dunia nyata, tapi tidak efisien. Pada operasi ini, pastikan dahulu
bahwa Queue tidak kosong.
Ilustrasi penghapusan pada Queue penuh :
Kondisi Awal, Queue penuh dengan 10 elemen
Kondisi setelah penghapusan :

Bagian elemen pada Head(Q) di hapus, kemudian elemen setelah Head(Q) s.d
elemen pada Tail(Q) bergeser satu step ke alamat Head(Q).
Ilustrasi penghapusan pada Queue tidak kosong :

Alternatif II :
Tabel dengan representasi HEAD dan TAIL. jika Queue tidak kosong, HEAD selalu bergerak
ke kanan ketika sebuah elemen dihapus. Sedangkan jika Queue kosong, maka HEAD=0.
Halaman
47 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Ilustrasi Queue tidak kosong dengan 5 elemen dan HEAD sedang berada di posisi awal:
Ilustrasi Queue tidak kosong dengan 5 elemen dan HEAD tidak berada di posisi awal. Hal
ini terjadi akibat algoritma penghapusan yang dilakukan.
Ilustrasi Queue kosong:

Pada ilustrasi ini, dikatakan Queue Kosong jika
Head(Q)=0 dan Tail(Q)=0 : atau
Head(Q) = Tail(Q) + 1 :
Algoritma untuk penambahan elemen sama dengan alternatif I: jika masih ada tempat
adalah dengan “memajukan” TAIL. Kasus khusus untuk Queue kosong karena HEAD
harus diset nilainya menjadi 1. Pada operasi ini, pastikan dahulu bahwa Queue tidak penuh.
Algoritma Penghapusan
Algoritma untuk penghapusan elemen jika Queue tidak kosong: ambil nilai elemen HEAD,
kemudian HEAD “maju”. Kasus khusus untuk Queue dengan keadaan awal berelemen 1,
yaitu menyesuaikan HEAD dan TAIL sesuai dengan DEFINISI. Algoritma ini TIDAK
mencerminkan pergeseran orang yang sedang mengantri di dunia nyata, tapi efisien.
Pada operasi ini, pastikan dahulu bahwa Queue tidak kosong.
Halaman
48 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Ilustrasi penghapusan pada Queue penuh :

Kondisi Awal, Queue penuh dengan 10 elemen

Bagian elemen pada Head(Q) di hapus dengan memajukan Head(Q) satu step.
Ilustrasi penghapusan pada Queue tidak kosong :

Kemudian melakukan penghapusan lagi :
Namun suatu saat terjadi keadaan Queue penuh tetapi “semu” sebagai berikut :
Halaman
49 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Jika keadaan ini terjadi, haruslah dilakukan aksi menggeser elemen untuk menciptakan
ruangan kosong. Pergeseran hanya dilakukan jika dan hanya jika TAIL sudah mencapai
IndexMax.
Implementasi ADT Queue
ADT Queue diimplementasikan menjadi dua buah modul yaitu, :
type Queue : < TabElm : array [1 ... nMax] of infotye,
HEAD : address of infotype,
TAIL : address of infotype>
Algoritma operasi Add untuk implementasi dengan tabel

1. Prekondisi elemen Queue : Queue tidak penuh
2. Siapkan index sebagai tempat penampung elemen stack yang akan ditambahkan
TAIL  TAIL + 1
3. Masukan elemen baru ke dalam lokasi TAIL yang baru
Q[TAIL]  elemen
Algoritma operasi Del untuk implementasi dengan tabel

Dengan Algoritma Alternatif I
1. Prekondisi elemen Queue : Queue tidak kosong
2. Siapkan tempat penampung elemen queue yang akan dikurangi
Elemen  Q[HEAD]
3. Geser setiap elemen Queue setelah Head(Q) s.d Tail(Q) ke arah Head(Q)
Q[HEAD]  Q[HEAD+1]
4. Kurangi TAIL dengan 1 : TAIL  TAIL - 1
Dengan Algoritma Alternatif II
1. Prekondisi elemen Queue : Queue tidak kosong
2. Siapkan tempat penampung elemen queue yang akan dikurangi
Elemen  Q[HEAD]
3. Tambahkan HEAD dengan 1: HEAD  HEAD + 1
Ilustrasi operasi Add dan Del terhadap squeue dengan anternatif I
Operasi Hasil
Halaman
50 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Isi Antrian HEAD TAIL Elemen yang dikeluarkan

CreateQueue(Q) :<kosong> 0 -
AddQueue(Q, ‘a’) :a 1 1 -
AddQueue(Q, ‘b’) :ab 1 2 -
AddQueue(Q, ‘c’) :abc 1 3 -
DelQueue(Q, elemen) :bc 1 2 a
AddQueue (Q, ‘d’) :bcd 1 3 -
AddQueue(Q, ‘e’) :bcde 1 4 -
DelQueue(Q, elemen) :cde 1 3 b
DelQueue(Q, elemen) :de 1 2 c
DelQueue(Q, elemen) :e 1 1 d
Ilustrasi operasi Add dan Del terhadap queue dengan anternatif II

Hasil
Operasi
Isi Antrian HEAD TAIL Elemen yang dikeluarkan
CreateQueue(Q) :<kosong> 0 -
AddQueue(Q, ‘a’) :a 1 1 -
AddQueue(Q, ‘b’) :ab 1 2 -
AddQueue(Q, ‘c’) :abc 1 3 -
DelQueue(Q, elemen) :bc 2 3 a
AddQueue (Q, ‘d’) :bcd 2 4 -
AddQueue(Q, ‘e’) :bcde 2 5 -
DelQueue(Q, elemen) :cde 3 5 b
DelQueue(Q, elemen) :de 4 5 c
DelQueue(Q, elemen) :e 5 5 d

Bagian file Header Queue
/* Program : queue.h
Kelas :
Deskripsi: Header file dari prototype queue
Tanggal :
*/
#ifndef _QUEUE_H
#define _ QUEUE _H
#include <stdio.h>
#include <conio.h>
#define Nil 0
#define MaxEl 10
Halaman
51 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
/* Nil adalah queue dengan elemen kosong . */

/* Karena indeks dalam bhs C dimulai O maka tabel dg indeks O tidak */
/* dipakai */
/* Jika Q adalah Queue maka akses elemen : */
/* Q.T[(Q.HEAD)] untuk mengakses elemen pertama */
/* Q.T[(Q.TAIL)] untuk mengakses elemen terakhir */
/* Q.HEAD adalah alamat elemen pertama */
/* Q.TAIL adalah alamat elemen terakhir */
#define Head(Q) (Q).HEAD
#define Tail(Q) (Q).TAIL
#define InfoHead(Q) (Q).T[(Q).HEAD]
#define InfoTail(Q) (Q).T[(Q).TAIL]
/* Definisi Queue : */
/* Queue kosong: Head=Nil, TAIL=Nil
Atau Head = Tail + 1 untuk alternatif 2
Jika Q adalah Queue maka akses elemen
Q.T[(Q.HEAD)] untuk mengakses elemen pertama
Q.T[(Q.TAIL)] untuk mengakses elemen terakhir
Q.HEAD adalah alamat elemen pertama
Q.TAIL adalah alamat elemen terakhir
*/
typedef int infotype; /*elemen queue bertipe integer*/
/* Versi pembentukan Queue  dengan menyimpan tabel dan alamat head maupun
tail secara eksplisit */
address HEAD; /* alamat HEAD: elemen pertama */
address TAIL; /* alamat TAIL: elemen terakhir */
} Queue;
/* Prototype Queue */
/* Konstruktor membentuk Queue */
void CreateQueue(Queue *Q);
/* I.S : Q terdefinisi tidak diketahui isinya
F.S : Q diinisialisasi dengan HEAD(Q)=nil, TAIL(Q)=nil
*/
int NBElmt(Queue Q);

/* Mengirimkan banyaknya elemen queue. Mengirimkan 0 jika Q kosong */
/** { KELOMPOK OPERASI pada Queue} **/

boolean IsQueuekEmpty (Queue Q);
// Mengecek apakah Queue tidak memiliki elemen
// Mengirim true jika Queue kosong: lihat definisi di atas
Halaman
52 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
boolean IsQueuekFull(Queue Q);

// Mengecek apakah Queue tidak memiliki elemen
// Mengirim true jika tabel penampung nilai elemen queue penuh
/* Mengirimkan banyaknya elemen queue atau Mengirimkan 0 jika Q kosong */
/*********** Menambahkan sebuah elemen ke Queue **********/

void AddQueue (Queue *Q, infotype X);
/* Proses: Menambahkan X pada Q dengan aturan FIFO */
/* I.S : Q terdifinisi, mungkin kosong, dan
Q penampung elemen queue tidak penuh.
F.S : X menjadi elemen TAIL yang baru, TAIL "maju"
*/
/*********** Menqhapus sebuah elemen Queue **********/

void DelQueue (Queue *Q, infotype *X);
/* Proses: Menghapus X pada Q dengan aturan FIFO */
/* I.S : Q terdefinisi, dan Q tidak kosong
F.S : Q berkurang satu elemen didepan dan disimpan pada X
*/

void PrintQueueInfo (Queue S);
F.S : Jika Queue tidak kosong, menampilkan semua info yang disimpan pada
elemen queue ke layar.
*/

boolean isInfoKetemu(Queue S, infotype X);
// mengirim true jika x berada pada Q
address CariElemenQueue(Queue Q, int X);

// Search apakah ada elemen tabel TabElm yang bernilai X)
// Jika x ada pada Q, menghasilkan address pertama kali ditemukan
// Jika tidak ada atau kondisi Queue kosong, maka mengirimkan IdXUndef
(bernilai -999)
#endif
TUGAS PRAKTIKUM
Implementasikan ADT Queue dengan Algoritma Alternatif I dan Algoritma Alternatif II
dengan :
1. Dengan cara yang sama seperti pada Modul 1, ketikan header file untuk kedua alternatif
ADT Queue diatas dengan nama file queue1.h dan queue2.h
2. Buat body file dari setiap prototype (prosedur dan fungsi) pada header file ADT Queue
dengan nama file queue1.c dan queue2.c
3. Buat file drivernya: mqueue1.c dan mqueue2.c
Halaman
53 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
4. Buat projek untuk ADT Queue1 dan ADT Queue2
PENGUMPULAN
Halaman
54 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
MODUL 7 ADT Queue Representasi Kontigu “Circular”

1. Memahami konsep ADT Queue dengan representasi fisik kontigu yang
circular.
3. Mampu melakukan operasi dasar Queue yaitu add (menambahkan antrian)
dan delete (menghapus antrian)
Dasar Teori
Queue
Queue dengan Circular sebenarnya prinsipnya sama saja dengan queue dengan cara biasa
(non circular). Perbedaannya terletak pada proses penyisipan / penambahan dan penghapusan
pada elemennya. Untuk mempermudah penggambaran lajur linear digambarkan dalam bentuk
melingkar (lihat Gambar dibawah ini).
Implementasi QUEUE dengan tabel Circular :

Memori tempat penyimpan elemen adalah sebuah tabel dengan indeks 1 sampai dengan index
Maximum (IdxMax).
Implementasi Q dengan circular artinya laju pergerakan antrian dilakukan secara melingkar.
Pada proses penyisipan dan penghapusan elemen, posisi Tail(Q)/Head(Q) akan selalu naik
sampai Tail(Q)/Head(Q) mencapai index Maximum :
- Jika Tail(Q) = idxMax tetapi jumlah elemen Queue belum mencapai antrian, maka Tail(Q)
= 1. Kemudian penempatan elemen baru pada Tail(Q).
Halaman
55 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
- Sedangkan untuk proses penghapusan, Jika Head(Q) = indxMax dan jumlah elemen
Queue tidak kosong, maka Head(Q) = 1.
Definisi kondisi Queue pada tabel Circular
Kondisi Definisi
Kosong Head(Q) = 0 dan Tail(Q) = 0
1 elemen Head(Q) = Tail(Q) dan Head(Q) <> 0
> 1 elemen tetapi tidak penuh Head(Q) <> (Head(Q)-Tail(Q)) dan Head(Q) <> 0
Penuh (Head(Q) = 1 dan Tail(Q) = indxMax) atau
Head(Q) – Tail(Q) = 1
Dibawah ini algoritma yang dipakai untuk proses Queue dengan Circular
Alternatif Queue Circular :
Tabel dengan representasi HEAD dan TAIL yang “berputar” mengelilingi indeks tabel dari
awal sampai akhir, kemudian kembali ke awal. Jika Queue kosong, maka HEAD=0.
Representasi ini memungkinkan tidak perlu lagi ada pergeseran yang harus dilakukan
seperti pada alternatif II pada saat penambahan elemen.
Ilustrasi Queue tidak kosong, dengan 5 elemen, dengan HEAD sedang berada di
posisi awal:
Ilustrasi Queue tidak kosong, dengan 5 elemen, dengan HEAD tidak berada di
posisi awal, tetapi masih “lebih kecil” atau “sebelum” TAIL. Hal ini terjadi akibat
algoritma penghapusan/Penambahan yang dilakukan (lihat keterangan).
Halaman
56 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Ilustrasi Queue tidak kosong, dengan 5 elemen, HEAD tidak berada di posisi awal, tetapi
“lebih besar” atau “sesudah” TAIL. Hal ini terjadi akibat algoritma
penghapusan/Penambahan yang dilakukan (lihat keterangan)
Pada operasi ini, pastikan dahulu bahwa elemen pada Queue tidak penuh.
Jika TAIL belum mencapai idxMax, maka memajukan TAIL. Tetapi jika TAIL sudah
mencapai IdxMax, maka suksesor dari IdxMax adalah 1 sehingga TAIL yang baru
adalah 1.
Jika TAIL belum mencapai IdxMax, maka algoritma penambahan elemen sama dengan
alternatif II. Kasus khusus untuk Queue kosong karena HEAD dan TAIL harus diset
nilainya menjadi 1.
Algoritma Penghapusan
Pada operasi ini, pastikan dahulu bahwa elemen pada Queue tidak kosong.
Pertama, ambil nilai elemen HEAD, kemudian HEAD maju. Penentuan suatu suksesor
dari indeks yang diubah/maju dibuat seperti pada algoritma penambahan elemen:
Jika HEAD mencapai IdxMAx, maka suksesor dari HEAD adalah 1.
Kasus khusus untuk Queue dengan keadaan awal berelemen 1, yaitu menyesuaikan
HEAD dan TAIL dengan DEFINISI.
Algoritma ini efisien karena tidak perlu pergeseran, dan seringkali strategi pemakaian
tabel semacam ini disebut sebagai circular buffer, dimana tabel penyimpan elemen dianggap
sebagai buffer.
Salah satu variasi dari representasi pada alternatif III adalah : menggantikan representasi
TAIL dengan COUNT, yaitu banyaknya elemen Queue. Dengan representasi ini,
banyaknya elemen diketahui secara eksplisit, tetapi untuk melakukan penambahan
elemen harus dilakukan kalkulasi TAIL.

Bagian file Header Queue
/* Program : queuecircular.h
Kelas :
Deskripsi: Header file dari prototype queue
Tanggal :
*/
Halaman
57 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
#ifndef _QUEUECIRCULAR_H
#define _ QUEUECIRCULAR_H
#include <stdio.h>
#include <conio.h>
#define Nil 0
#define MaxEl 10
/* Nil adalah queue dengan elemen kosong . */
/* Karena indeks dalam bhs C dimulai O maka tabel dg indeks O tidak */
/* dipakai */
/* Jika Q adalah Queue maka akses elemen : */

/* Q.T[(Q.HEAD)] untuk mengakses elemen pertama */
/* Q.T[(Q.TAIL)] untuk mengakses elemen terakhir */
/* Q.HEAD adalah alamat elemen pertama */
/* Q.TAIL adalah alamat elemen terakhir */
#define Head(Q) (Q).HEAD

#define Tail(Q) (Q).TAIL
#define InfoHead(Q) (Q).T[(Q).HEAD]
#define InfoTail(Q) (Q).T[(Q).TAIL]
/** Definisi ABSTRACT DATA TYPE Tab Integer **/

/* Definisi Queue :
/* Queue kosong: Head=Nil, TAIL=Nil
Atau Head = Tail + 1 untuk alternatif 2
Jika Q adalah Queue maka akses elemen
Q.T[(Q.HEAD)] untuk mengakses elemen pertama
Q.T[(Q.TAIL)] untuk mengakses elemen terakhir
Q.HEAD adalah alamat elemen pertama
Q.TAIL adalah alamat elemen terakhir
*/
typedef int infotype; /*elemen queue bertipe integer*/

/* Versi pembentukan Queue  dengan menyimpan tabel dan alamat head maupun
tail secara eksplisit */

address HEAD; /* alamat HEAD: elemen pertama */
address TAIL; /* alamat TAIL: elemen terakhir */
} Queue;
/* Prototype Queue */
/* Konstruktor membentuk Queue */
Halaman
58 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
*/


/** { KELOMPOK OPERASI pada Queue} **/
boolean IsQueuekEmpty (Queue Q);
/* Mengirim true jika Queue kosong: lihat definisi di atas */
boolean IsQueuekFull(Queue Q);

/* Mengirim true jika tabel penampung nilai elemen stack penuh yaitu jumlah
elemen sudah mencapa MaxEl : lihat definisi diatas */

/*********** Menambahkan sebuah elemen ke Queue **********/

void AddQueue (Queue *Q, infotype X);
/* Proses: Menambahkan X pada Q dengan aturan FIFO */
/* I.S : Q terdifinisi, mungkin kosong, dan
Q penampung elemen queue tidak penuh.
F.S : F.S. X menjadi TAIL yang baru, TAIL "maju"
Jika Tail(Q)=MaxE1+1 maka Tail(Q) diset =1
*/
/*********** Menqhapus sebuah elemen Queue **********/
void DelQueue (Queue *Q, infotype *X);
/* Proses: Menghapus X pada Q dengan aturan FIFO */
/* I.S : Q terdefinisi, dan Q tidak kosong
F.S : Q berkurang satu elemen didepan disimpan pada X
Head(Q) “maju” selama Head(Q) < MaxEl,
Tetapi Jika Head(Q)=MaxE1+1 maka Tail(Q) diset =1
*/

void PrintQueueInfo (Queue S);
F.S : Jika Queue tidak kosong, semua info yang disimpan pada elemen
queue diprint.
*/

boolean isInfoKetemu(Queue S, infotype x);
/* mengirim true jika x ada pada Q */
address CariElemenQueue(Queue Q, int X);

// Search apakah ada elemen tabel T yang bernilai X)
// Jika x ada pada Q, menghasilkan address terkecil
// Jika tidak ada, mengirimkan IdXUndef)
// Menghasilkan indeks tak terdefinisi(IdxUndef) jika Queue kosong)
Halaman
59 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
// Memakai Skema search DENGAN boolean Found}
#endif
TUGAS PRAKTIKUM
Latihan 1
1. Dengan cara yang sama seperti pada Modul 1, ketikan header file untuk ADT
QueueCircular
2. Buat body file dari setiap prototype (prosedur dan fungsi) pada header file ADT
QueueCircular
3. Buat file drivernya: mqueuecircular.c untuk menyelesaikan persoalan mensimulasikan
antrian di sebuah loket di suatu bank
Pernyataan :
Elemen queue menyatakan lama waktu pengunjung loket mengantri di loket tersebut
(dalam menit). Program harus melakukan hal sebagai berikut:
- Menerima masukan ukuran queue, yaitu ukuran queue selalu > 0. Jika queue <= 0
maka tuliskan pesan “masukan tidak valid”
- Dalam satu loop, pengguna bisa memilih untuk menambah pengunjung dalam antrian
atau menghapus pengunjung (menghapus pengunjung berarti pengunjung tsb
dilayani).
Jika memilih menambah antrian, masukkan kode operasi = 1 diikuti panjang waktu
mengantri (elemen queue). Contoh: 1 5 (berarti menambah elemen queue dengan
waktu antrian = 5 menit).
Untuk menghapus elemen antrian, masukkan kode operasi = 2.
Penambahan dan penghapusan harus mengikuti ketentuan operasi Add dan Del queue
(perhatikan untuk kasus queue kosong dan queue penuh). Jika dilanggar, seharusnya
tidak terjadi apa pun pada queue.
Untuk menghentikan proses, masukkan kode operasi = 0.
- Di akhir program, ditampilkan statistik queue, yaitu panjangnya antrian (berapa
banyak orang yang sedang mengantri) dan waktu rata-rata orang mengantri (dalam
menit, tulis dengan 2 digit di belakang koma). Jika panjang antrian kosong, tuliskan
pesan “Tidak bisa dihitung”
Buatlah fungsi sebagai berikut ke dalam program utama Anda:
float AvgElmt (Queue Q);
/* Menghasilkan rata-rata elemen dalam queue yang tidak kosong */
Contoh input/output :
Halaman
60 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Input Output Keterangan

10 2 Ukuran queue = 10
15 4.00 Panjangnya antrian = 2
13 Waktu rata-rata mengantri = (5+3)/2
0
15 3.00 Panjang antrian = 1
13 Waktu rata-rata mengantri = (3/1) = 3.00
2
0
15 Tidak bisa dihitung Panjang antrian = 0
13 Waktu rata-rata mengantri = tidak bisa dihitung
2 Operasi penghapusan yang terakhir tidak
2 berpengaruh pada queue
2
0
15 5.00 Panjang antrian = 1
13 Waktu rata-rata mengantri = (5/1) = 5.00
2
2
15
0
0 Masukan tidak valid N=0
-1 Masukan tidak valid N=-1
4. Buat projek untuk ADT Queue1 dan ADT Queue2
Latihan 2
1. Buatlah kelompok dengan anggota 3 orang (tidak boleh lebih). Kemudian selesaikan
persoalan ADT Queue representasi Pointer dibawah dengan memanfaatkan konsep linear
linked list pada modul sebelumnya. Buatlah body dan main derivernya.
Sebagai catatan, tugas point 3 dikumpulkan pada pertemuan selanjutnya.
File header Queue dengan representasi Pointer
/* Program : queuecircular2.h
Author : (Nim, Nama)  tuliskan anggota kelompok
Kelas :
Tanggal :
*/
#ifndef _QUEUE2_H
#define _QUEUE2_H
Halaman
61 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
#include <stdio.h>
#include <conio.h>
//pendefinisian pointer
#define nil NULL
#define info(P) (P)->info
#define next(P) (P)—>next
#define HEAD(Q) (Q).HEAD
#define TAIL(Q) (Q).TAIL
//Pembentukan tipe Queue

typedef struct tElmQueue *address;
typedef struct tElmQueue{
int info;
address next;
}ElmQueue;
typedef struct{
address HEAD;
address TAIL;
}Queue;
//Prototype Queue/ primitif Queue dengan pointer

//Konstruktor
*/
address Alokasi(int x);
/* mengirim sebuah address jika alokasi type Queue berhasil */
/* P direlease dari memori */
//Operasi Queue
void AddQue(Queue *Q, int X);
/* I.S : Q terdefinisi sembarang mungkin kosong
F.S : Q bertambah sebuah elemen bernilai X dibelakang
proses : HEAD (Q) merupakan elemen terakhir dari Q
*/
void DelQue(Queue *Q, int *y);

/* I.S : Q terdefinisi sembarang tidak kosong
F.S : Q berkurang satu elemen didepan disimpan pada y
proses : y=info(HEAD), HEAD(Q) = next(HEAD(Q))
DeAlokasi elemen pertama
*/
//Operasi I/O terhadap Queue

void CetakQueue(Queue Q);
/* I.S : Q terdefinisi sembarang tidak kosong
F.S : elemen Queue dicetak dilayar
*/
Halaman
62 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
//Operasi boolean dan relasi terhadap Queue

boolean IsQueueEmpty(Queue Q);
/* Mengirim true jika Queue kosong HEAD(Q)=nil
false sebaliknya */
boolean CariElemenQueue(Queue Q, int X);

/* mengirim true jika elemen x ada pada Q,
dan false jika x tidak ditemukan pada Q
skema pencarian dengan boolean
*/
#endif
PENGUMPULAN
3. Untuk tugas kelompok dikumpulkan pada email terpisah dengan penamaan :
[Prak. Struktur Data]_Kelas_TGS Modul 7_NIM1_NIM2_NIM3
Contoh :
[Prak. Struktur Data]_A_TGS Modul 7_3411161001_3411161002_3411161003
Halaman
63 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
MODUL 8 ADT Double Linked List

Tujuan : Setelah menyelesaikan modul ini, anda diharapkan dapat membuat Abstract Data
Type double linked list dengan representasi fisik pointer, yaitu bentuk struktur data dinamik
list. ADT double linked list merupakan perluasan dari linked list linier, dimana setiap elemen
utama memiliki dua pointer yang menunjuk ke elemen sebelumnya dan setelahnya.
Dasar Teori
Salah satu kelemahan single linked list adalah pointer (penunjuk) hanya dapat bergerak satu
arah saja, maju/mundur, atau kanan/kiri sehingga pencarian data pada single linked list hanya
dapat bergerak dalam satu arah saja. Untuk mengatasi kelemahan tersebut, dapat
menggunakan metode double linked list. Linked list ini dikenal dengan nama Linked list
berpointer Ganda atau Double Linked List.
Double linked list adalah suatu senarai/list berkait dimana setiap node (elemen) mempunyai 2
penunjuk yaitu satu penunjuk ke node(elemen) pendahulunya (predesesor) dan satu penunjuk
ke node (elemen) penerusnya (suksesor).
Tambah di awal (addFirst)

Operasi ini berguna untuk menambahkan elemen baru di posisi pertama. Langkah pertama
untuk penambahan data adalah pembuatan elemen baru dan pengisian nilai infonya. Pointer
yang menunjuk ke data tersebut dipanggil dengan nama baru. Kondisi di setelah ada
pembuatan elemen baru tersebut adalah :
Ada 2 kondisi yang harus diperhatikan dalam penambahan data di awal yaitu :
a. Ketika linked list masih kosong
Kalau kondisi linked list masih kosong, maka elemen baru akan menjadi awal dan akhir
linked list.
Perhatikan gambar di bawah ini :
 Kondisi sebelum disisipkan
Halaman
64 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
 Kondisi setelah operasi penambahan

Operasi penambahan awal ketika linked list masih kosong adalah dengan mengisikan
alamat pointer baru ke pointer awal dan pointer akhir. Lihat gambar di bawah ini.
b. Ketika linked list sudah mempunyai data

Kondisi linked list ketika sudah mempunyai data elemen dan elemen yang baru telah
dibuat, dapat dilihat di gambar di bawah ini.
Proses penambahan data di awal linked list adalah :

 Hubungkan baru kanan agar menunjuk ke awal
 Hubungkan awal kiri agar menunjuk ke posisi pointer baru
Halaman
65 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
 Pindahkan pointer awal ke pointer baru
Tambah di akhir (AddLast)

Operasi ini berguna untuk menambahkan elemen baru di posisi akhir. Langkah pertama untuk
penambahan data adalah pembuatan elemen baru dan pengisian nilai infonya. Pointer yang
menunjuk ke data tersebut dipanggil dengan nama baru. Kondisi di setelah ada pembuatan
elemen baru tersebut adalah :
Ada 2 kondisi yang harus diperhatikan dalam penambahan data di akhir yaitu :
a. Ketika linked list masih kosong
Kalau kondisi linked list masih kosong, maka elemen baru akan menjadi awal dan akhir
linked list.
Perhatikan gambar di bawah ini :
 Kondisi sebelum penambahan
 Kondisi setelah operasi penambahan

Operasi penambahan awal ketika linked list masih kosong adalah dengan mengisikan
alamat pointer baru ke pointer awal dan pointer akhir. Lihat gambar di bawah ini.
b. Ketika linked list sudah mempunyai data

Kondisi linked list ketika sudah mempunyai data elemen dan elemen yang baru telah
dibuat, dapat dilihat di gambar di bawah ini.
Halaman
66 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Proses penambahan data di akhir linked list adalah :

 Hubungkan akhir kanan agar menunjuk ke pointer baru
 Hubungkan baru kiri agar menunjuk ke posisi pointer akhir
 Pindahkan pointer akhir ke pointer baru
Hapus data awal (DeleteFisrt)

Operasi ini berguna untuk menghapus data pada posisi pertama. Ada 3 keadaan yang
mungkin terjadi ketika akan melakukan proses hapus yaitu :
a. Kondisi linked list masih kosong
Jika kondisi ini terjadi, maka proses penghapusan data tidak bisa dilakukan karena linked
list masih kosong.
b. Kondisi linked list hanya memiliki 1 data
Langkah yang perlu dilakukan ketika ingin melakukan proses penghapusan linked list
yang memiliki hanya 1 data adalah dengan langsung menghapus data dari memori dan
kemudian pointer awal dan akhir di-NULL-kan.
Untuk lebih jelas perhatikan urutan penghapusannya di bawah ini :
 Kondisi data sebelum dihapus
Halaman
67 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
 Proses penghapusan yaitu dengan menghilangkan data dari memori dengan perintah
free(awal) atau free(akhir).
 Kemudian pointer awal dan akhir diisi dengan NULL.
c. Kondisi linked list memiliki data lebih dari 1 buah

Untuk operasi penghapusan data di posisi pertama pada double linked list yang
mempunyai data lebih dari 1 buah adalah :
 Simpan pointer yang akan dihapus (awal) ke suatu pointer lain yang diberi nama
pointer bantu.
 Pindahkan pointer awal ke data berikutnya (bantu kanan atau awal kanan).
 Field kiri dari awal yang baru (awal kiri) di-NULL-kan.
 Langkah terakhir adalah hapus elemen yang ditunjuk pointer bantu.
 Setelah data dihapus, maka kondisi linked list adalah seperti di gambar di bawah ini.
Halaman
68 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Hapus data terakhir

Operasi ini berguna untuk menghapus data pada posisi terakhir. Ada 3 keadaan yang
mungkin terjadi ketika akan melakukan proses hapus yaitu :
a. Kondisi linked list masih kosong
Jika kondisi ini terjadi, maka proses penghapusan data tidak bisa dilakukan karena linked
list masih kosong.
b. Kondisi linked list hanya memiliki 1 data
Langkah yang perlu dilakukan ketika ingin melakukan proses penghapusan linked list
yang memiliki hanya 1 data adalah dengan langsung menghapus data dari memori dan
kemudian pointer awal dan akhir di-NULL-kan. Untuk lebih jelas perhatikan urutan
penghapusannya di bawah ini :
 Kondisi data sebelum dihapus
 Proses penghapusan yaitu dengan menghilangkan data dari memori dengan perintah
free(awal) atau free(akhir).
 Kemudian pointer awal dan akhir diisi dengan NULL.
c. Kondisi linked list memiliki data lebih dari 1 buah

Untuk operasi penghapusan data di posisi terakhir pada double linked list yang
mempunyai data lebih dari 1 buah adalah :
 Simpan pointer yang akan dihapus (akhir) ke suatu pointer lain yang diberi nama
pointer bantu.
Halaman
69 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
 Pindahkan pointer akhir ke data sebelumnya (bantu kiri atau akhir kiri).
 Field kanan dari akhir baru (akhir kanan) di-NULL-kan.
 Langkah terakhir adalah hapus elemen yang ditunjuk pointer bantu.
 Setelah data dihapus, maka kondisi linked list adalah seperti di gambar di bawah ini.

Bagian file Header Multiple Linked List
/* Program : doubleLinkList.h
Kelas :
Deskripsi: Header file dari prototype double linked list
Tanggal :
*/
/* ADT double Linear Linked List

pembentukan tipe List Linier dan operasi bagi List
Representasi fisik List dengan pointer
*/
#ifndef DoubleLinkList_H
#define DoubleLinkList_H
#include <stdlib.h>
Halaman
70 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
#define Nil NULL
#define Info(P) (P)->info

#define Next(P) (P)->next
#define Prev(P) (P)->prev
#define First(L) ((L).First)
typedef int infotype;

typedef struct telmtlist *address;
typedef struct telmtlist

{
infotype info;
address next; address prev;
}ElmtList;
typedef struct
{
address First;
}List;
boolean ListEmpty(List L);

/* Mengirim TRUE jika list kosong */
void CreateList(List *L);

/* Membentuk sebuah list kosong */
address Alokasi(infotype X);

/* Menghasilkan address alokasi sebuah elemen */
void Dealokasi(address P);

/* Melakukan dealokasi/pengembalian address P */
address Search(List L, infotype X);

/* Menghasilkan address yang mengandung infotype X, jika tidak ada
menghasilkan Nil */
void AddFirst(List *L, infotype X);

/* Menambahkan elemen X pada elemen pertama List */
void AddLast(List *L, infotype X);

/* Menambahkan elemen X pada elemen terakhir List */
void DelFirst(List *L, infotype *X);

/* Menghapus elemen pertama List */
void DelLast(List *L, infotype *X);

/* Menghapus elemen terakhir List */
Halaman
71 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
#endif
TUGAS PRAKTIKUM
1. Dengan cara yang sama seperti pada Modul 1, ketikan header file untuk ADT Double
Link List diatas.
2. Buat body file dari setiap prototype (prosedur dan fungsi) pada header file ADT Double
Link List
3. Buat file drivernya: mdoublelist.c untuk persoalan proses antrian di Bank.
Persoalan :
 Jika petugas menekan tombol nomor antrian, maka antrian bertambah.
 Jika petugas menekan tombol layani antrian, maka hapus antrian dan tampilkan
antrian yang sedang dilayani.
 Setiap petugas menekan tombol manapun, maka tampilkan informasi ke laya
monitor. Informasi yang ditampilkan adalah jumlah antrian dan antrian yang sedang
dilayani.
4. Buat projek untuk ADT Double Link List
PENGUMPULAN
Halaman
72 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Halaman
73 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
MODUL 9 ADT Binary Tree (BTree)

Tujuan : Setelah menyelesaikan modul ini, anda diharapkan dapat membuat Abstract Data
Type Pohon dengan representasi fisik pointer, yaitu bentuk struktur data dinamik pohon (tree)
menggunakan pointer. ADT Tree dapat dibangun menggunakan list berkait dengan
menggunakan dua pointer, yaitu left dan right.
Dasar Teori
Struktur pohon adalah struktur yang penting dalam bidang informatika yang memungkinkan
kita untuk :
- Mengorganisasikan informasi berdasarkan suatu struktur lojik
- Memungkinkan cara akses yang khusus terhadap suatu elemen, misalnya pohon
keputusan, pohon sintaks serta pohon ekspresi matematika
Sebuah pohon adalah himpunan terbatas tidak kosong, dengan elemen yang dibedakan
sebagai berikut:
- Sebuah elemen dibedakan dari yang lainnya yang disebut sebagai Akar (root) dari
pohon
- Elemen yang lain (jika masih ada) dibagi-bagi menjadi beberapa sub himpunan yang
disjoint, dan masing-masing sub himpunan tersebut adalah pohon yang disebut
sebagai Sub Pohon dari pohon yang dimaksud.
Simpul (node) adalah elemen dari pohon yang memungkinkan akses pada sub pohon dimana
simpul tersebut berfungsi sebagai akar (root).
Daun adalah simpul terminal dari pohon, semua simpul selain daun adalah simpul non-
terminal
Path (jalan) adalah suatu urutan tertentu dari cabang. Derajat sebuah pohon adalah banyaknya
anak dari pohon tersebut. Sebuah simpul berderajat N disebut sebagai pohon N-aire
Tingkat (level) pohon adalah panjangnya jalan dari root (akar) sampai dengan simpul yang
bersangkutan
Kedalaman (depth) atau tinggi sebuah pohon adalah nilai maksimum dari tingkat simpul yang
ada pada pohon tersebut. Kedalaman adalah panjang maksimum jalan dari akar menuju ke
sebuah daun
Contoh pohon ekspresi aritmatika
Halaman
74 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
Karena adanya arti bagi sub pohon kiri dan sub pohon kanan, maka dua buah pohon biner
sebagai berikut berbeda (pohon berikut disebut pohoncondong/skewed tree)
Sub pohon ditunjukkan dengan penulisan ()

Bagian file Header Binary Tree
/*
Program : bTree.h
Kelas :
Deskripsi: Header file dari prototype binary tree
Tanggal :
*/
// preprosesor
#include<conio.h>
#include<stdlib.h>
#include<stdio.h>
/* Deklarasi Btree */
#define nil NULL
#define info(P) (P)->info
#define left(P) (P)->left
Halaman
75 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
#define right(P) (P)->right
//pembentukan tipe BTree

typedef struct tNode *address;
typedef struct tNode{
int info;
address left;
address right;
}Node;
typedef address Tree;
//prototype BinTree
//Kelompok konstruktor
void CreateTree(Tree *T, int x, Tree L, Tree R);
/* I.S : T terdefinisi sembarang
F.S : menghasilkan sebuah pohon T
menghasilkan sebuah pohon T dari x, L, R jika alokasi berhasil,
menghasilkan pohon T = nil jika alokasi gagal
*/
address Alokasi(int X);

/* mengirim sebuah address dari x berupa node */

/* merelease memori bernilai P */
//Kelompok selektor
int getRoot(Tree T);
/* mengirim nilai root pada T */
Tree getLeft(Tree T);

/* mengirim anak kiri dari T */
Tree getRight(Tree T);

/* mengirim anak kanan dari T */
int TinggiPohon(Tree T);

/* mengirim tinggi pohon, pohon kosong = O */
int Maksimum(int Kiri, int Kanan);

/* mengirim nilai terbesar dari Kiri atau Kanan */
//Operasi I/O
Tree InsSearch(Tree T, int x);
/* menghasilkan sebuah pohon dengan nilai X */
void CetakTree(Tree T);

/* I.S : T terdifinisi sembarang tidak kosong
F.S : semua simpul dari T tercetak
*/
Halaman
76 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
void PreOrder(Tree T);

F.S : semua simpul T diproses secara preorder :
akar — kiri — kanan
*/
void InOrder(Tree T);

F.S : semua simpul T diproses secara inorder :
kiri — akar — kanan
*/
void PostOrder(Tree T);

F.S : semua simpul T diproses secara postorder 2
kiri — kanan — akar
*/
Bagian file Realisasi Binary Tree

/*
Program : bTree.c
Kelas :
Deskripsi: Body file dari prototype binary tree
Tanggal :
*/
#include "bTree.h"
#include <stdio.h>
#include <conio.h>
/* Realisasi dari Prototype binary tree */

//Kelompok konstruktor
void CreateTree(Tree *T, int x, Tree L, Tree R){
F.S : menghasilkan sebuah pohon T
menghasilkan sebuah pohon T dari x, L, R jika alokasi berhasil,
menqhasilkan pohon T = nil jika alokasi gagal
*/
// kamus
// algoritma
*T = Alokasi(x);
if(*T != nil){
left(*T) = L;
right(*T) = R;
}
}
address Alokasi(int X){

/* mengirim sebuah address dari x berupa node */
Halaman
77 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
// kamus
address P;
// algoritma
P = (address) malloc(sizeof(Node));
if(P!=nil){
info(P) = X;
left(P) = nil;
right(P) = nil;
}
return(P);
}
void DeAlokasi(address P){

/* merelease memori bernilai P */
free(P);
}
//Kelompok selektor
int getRoot(Tree T);
/* mengirim nilai root pada T */
Tree getLeft(Tree T);

/* mengirim anak kiri dari T */
Tree getRight(Tree T);

/* mengirim anak kanan dari T */
int TinggiPohon(Tree T){
/* mengirim tinggi pohon, pohon kosong = O */
//kamus
int tinggi;
//algoritma
tinggi = 0
if(T!=nil){
tinggi = 1 + Maksimum(TinggiPohon(left(T)),TinggiPohon(right(T)));
}
return(tinggi);
}
int Maksimum(int Kiri, int Kanan){

/* mengirim nilai terbesar dari Kiri atau Kanan */
//kamus
//algoritma
if(Kiri > Kanan)
return(Kiri);
else
return(Kanan);
}
//Operasi I/O
Tree InsSearch(Tree T, int x){
/* menghasilkan sebuah pohon dengan nilai x */
Halaman
78 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
//kamus
//algoritma
if(T == nil)
CreateTree(&T,x,nil,nil);
else if(x < info(T))
left(T) = InsSearch(left(T), x);
else
right(T) = InsSearch(right(T), x);
return(T);
}
void CetakTree(Tree T){

/* I.S : T terdifinisi sembarang tidak kosong
F.S : semua simpul dari T tercetak
*/
//kamus
//algoritma
if(T != nil){
printf("%d", info(T));
}
}
void PreOrder(Tree T){

F.S : semua simpul T diproses secara preorder :
akar — kiri — kanan
*/
//kamus
//algoritma
if(T!=nil){
CetakTree(T);
PreOrder(left(T));
PreOrder(right(T));
}
}
void InOrder(Tree T){
F.S : semua simpul T diproses secara inorder :
kiri — akar — kanan
*/
//kamus
//algoritma
if(T!=nil){
PreOrder(left(T));
CetakTree(T);
PreOrder(right(T));
}
}
void PostOrder(Tree T){

Halaman
79 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
F.S : semua simpul T diproses secara postorder :

kiri - kanan - akar
*/
//kamus
//algoritma
if(T!=nul){
PreOrder(left(T));
PreOrder(right(T));
CetakTree(T);
}
}
1. Bagian file Main driver Binary Tree

/*
Program : mBTree.c
Kelas :
Deskripsi: Body file dari prototype
Tanggal :
*/
#include "bTree.c"
#include <stdio.h>
#include <conio.h>
int main(){
// kamus global
Tree MyPohon=nil;
int N;
// algoritma
clrscr();
printf("Masukan Bilangan :");scanf("%d",&N);
while(N!=9999){
MyPohon = InsSearch(MyPohon,N);
printf("Masukan Bilangan :");scanf("%d",&N);
}// N = 9999
PreOrder(MyPohon);
printf("\nTinggi Pohon : %d", TinggiPohon(MyPohon));
getch();
return O;
}
TUGAS PRAKTIKUM
1. Dengan cara yang sama seperti pada Modul 1, ketikan header file untuk ADT Binary
Tree diatas.
2. Lengkapilah body file dari setiap prototype (prosedur dan fungsi) pada header file ADT
Binary Tree.
Halaman
80 / 81
STRUKTUR DATA
OLEH : TIM DOSEN
3. Buat file drivernya: mbinarytree.c

4. Buat projek untuk ADT Binary Tree
PENGUMPULAN
MODUL 10 Persoalan Struktur Data

Ujian Akhir Semester untuk praktikum Struktur Data. Bahasan ujiannya persoalan sebuah
studi kasus dengan memanfaatkan materi dari semua modul.
REFERENSI
Liem, Inggriani. (2007). Diktat Algoritma dan Pemrograman Prosedural. Teknik Informatika
ITB
Marcus Zakaria, Teddy dan Prijono, Agus. (2005). Konsep dan Implementasi Struktur Data.
Bandung : Informatika
Sjukani, Moh. (2007). Algoritma (Algoritma dan Struktur Data 1) dengan C, C++, dan Java.
Jakarta : Mitra Wacana Media
Halaman
81 / 81

Modul Praktikum Struktur Data 2021 Fix

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Modul Praktikum Struktur Data 2021 Fix

Diunggah oleh

Hak Cipta:

Format Tersedia

SEMESTER GENAP TGL BLN THN

TA.2020 / 2021 05 03 2021

DIBUAT DIPERIKSA DISAHKAN

NID. 412166863 NID. 412182990 NID. 412176273

MODUL 1 PERKENALAN ADT

Lama Praktikum : 1 sesi

- Prosedur: Initial State, Final State dan Proses yang dilakukan

Prosedur praktikum IF1231 Struktur Data

Diketahui file modul ADT dibawah ini,

/* Prototype ADT Jam */

/** Konstruktor membentuk ADT Jam **/

/* Selektor nilai JAM **/

/* Set nilai komponen */

/* Destruktor/Dealokator: tidak perlu */

/** {Kelompok Baca/Tulis} **/

/** { kelompok Validasi Type } **/

/** {Operator Relasional} **/

- Jika J1 = 10:40:30 dan J2 = 10:30:30, maka mengirimkan true

/** { operator aritmatika } **/

/** {Kelompok Konversi Terhadap Type} **/

2. Bagian file Realisasi JAM

/* Realisasi dari prototype ADT Jam */

/** Konstruktor membentuk ADT Jam **/

Hour = HH, Minute = MM, Second = SS

/* Selektor nilai JAM **/

/* Set nilai komponen */

/** {Kelompok Baca/Tulis} **/

/** { kelompok Validasi Type } **/

- Jika J1 = 10:40:30 dan J2 = 10:30:30, maka mengirimkan true

JAM NextNDetik (JAM J, int N) {

long int Durasi ( JAM JAw , JAM JAkh) {

detik = (J.Hour * 3600) + (J.Minute * 60) + J.Second;

3. Bagian file Main driver JAM

printf ("Masukan nilai N detik (0...59) : ");

printf("\nPengecekan Operator Relasional\n");

getch(); //{opsional, ini tertulis karena ketika running console

3. Lakukan Compiling dan Running program

#define Ordinat(P) (P).Y

/** Definisi ABSTRACT DATA TYPE POINT **/

/* Konstruktor membentuk POINT */

/* Selektor POINT **/

int GetOrdinat (POINT P);

/* Set nilai komponen */

/* Destruktor/Dealokator: tidak perlu */

/** { KELOMPOK Interaksi dengan I/O device, BACA/TULIS } **/

/** Kelompok operasi relasional terhadap POINT **/

/** KELOMPOK OPERASI LAIN TERHADAP TYPE **/

float JarakO(POINT P);

void GeserKeSbX (POINT *P);

MODUL 2 ADT LINE

Lama Praktikum : 1 sesi

Implementasi ADT Garis

Diketahui file modul ADT dibawah ini,

#define FirstPoint(L) (L).PAwal

/** Definisi ABSTRACT DATA TYPE Line **/

/* Konstruktor membentuk Line */

void CreateLINE2 (Line *L, POINT First, POINT End);

/* Selektor Line **/

/* Set nilai komponen */

/* Destruktor/Dealokator: tidak perlu */

/** { KELOMPOK Interaksi dengan I/O device, BACA/TULIS } **/

/** Kelompok operasi relasional terhadap Line **/

// titik akhir L1 sama titik akhir dari L2.

boolean IsNEQLine(Line P1, Line P2);

/ Konstruktor membentuk ADT Jam /

/ {Kelompok Baca/Tulis} /

/ { kelompok Validasi Type } /

/ {Operator Relasional} /

/ { operator aritmatika } /

/ {Kelompok Konversi Terhadap Type} /

/ Konstruktor membentuk ADT Jam /

/ {Kelompok Baca/Tulis} /

/ { kelompok Validasi Type } /

/ Definisi ABSTRACT DATA TYPE POINT /

/ { KELOMPOK Interaksi dengan I/O device, BACA/TULIS } /

/ Kelompok operasi relasional terhadap POINT /

/ KELOMPOK OPERASI LAIN TERHADAP TYPE /

/ Definisi ABSTRACT DATA TYPE Line /

/ { KELOMPOK Interaksi dengan I/O device, BACA/TULIS } /

/ Kelompok operasi relasional terhadap Line /

/ Kelompok menentukan di mana L berada /

/ KELOMPOK OPERASI LAIN TERHADAP TYPE /

/ Definisi ABSTRACT DATA TYPE Tab Integer /

/ { KELOMPOK OPERASI Cek Elemen kosong atau penuh} /

/ { KELOMPOK Interaksi dengan I/O device, BACA/TULIS } /

/ { KELOMPOK OPERASI ARITMATIKA TERHADAP TYPE } /

/ Kelompok operasi relasional terhadap TabInt /

/ KELOMPOK OPERASI LAIN TERHADAP TYPE /

/ Definisi ABSTRACT DATA TYPE List /

/ { KELOMPOK OPERASI Cek Elemen kosong atau penuh} /

/ { KELOMPOK Interaksi dengan I/O device, BACA/TULIS } /

/ KELOMPOK OPERASI LAIN TERHADAP TYPE /

/ Definisi ABSTRACT DATA TYPE Stack /

typedef int infotype; /elemen stack bertipe integer/

/ { KELOMPOK OPERASI pada Stack} /

/* Menambahkan sebuah elemen ke Stack /

/* Menqhapus sebuah elemen Stack /

/ { KELOMPOK Interaksi dengan I/O device, BACA/TULIS } /