A.

Jamal/Struktur Data

Bagian 2 TDA Kompleks

TDA sederhana yang sudah dibahas di bagian 1 buku ini untuk memberikan pemahan
terhadap mekanisme antar muka TDA dan implementasistrutur data menggunakan dua Bahasa
pemrograman. Disebut sederhana karena komponen dari nilai sedikit dan sudah pasti jumlahnya
dan penamaan komponenya. Bagian ini akan bahas tipe data kompleks yang memiliki banyak
nilai komponennya dan jumlah data yang disimpan bisa berubah selama penggunaan. Karena
ituada operasi atau operator yang bisa mengakses banyak jumlah nilai data pada saat tertentu.
Kapasitas dari TDA bisa diubah bisa juga tetap dengan jumlah tertentu tergantung cara
penyimpanan. Dua cara penyimpanan strutur data yang berbeda akan dibahasa di buku ini pada
bab yang berbeda. Pada prinsipnya penyimpanan menggunakan array kapasitasnya tetap sesuai
ketika jumlah elemen yang dipesan ketika membuat array. Hanya saja dalam Bahasa Python
tidak ada array seperti halnya dalam bahsa pemrograman lain, tetapi array diganti dengan
struktur data yang mirip yaitu “list” yang akan dibahas lebih detil di buku ini pada bagian
terakhir. Struktur data list tidak ada batas kapasitas seperti halnya array di Bahasa yang lain.
Cara penyimpanan struktur data yang kedua adalah menggunakan “Linked List” atau
larik berkait. Di buku ini digunakan istilah dalam Bahasa Inggris seperti halnya Array tidak ada
istilah Bahasa Indoensianya yang tepat. Disebut linked karena list ini terdiri dari komponen yang
disebut “node” yang dikaitkan antar satu node dengan node lainnya. Berbeda dengan list
berbasiskan array, linked list pada prinsipnya meemnag tidak ada batas jumlah kapasitas, karena
penambahan data tinggal menambahakan node pada memory yang baru yang tidak perlu dipesan
sebelumnya. Berikut penggambaran model memory dua sturktur data array dengan kapasitas 15
dan linked list yang menyimpan data yang sama.
I n d o n e s i a

n n

I i null
o
e
d
s a

37
 A. Jamal/Struktur Data

Bab Tiga: TDA Kompleks berbasiskan Array

TDA Kompleks 1 {Tas}
TDA kompleks yang pertama dibahas adalah Tas atau kantong yaitu tempat penyimpanan
sederhana seperti tas belanja yang bisa membawa sekumpulan barang. Duplikasi barang
dimungkinkan seperti halnya tas belanja bisa dimasukkan dua pak roti misalnya. Posisi barang di
dalam tas tidak perlu diperhatikan urutannya.
Nama fungsi dari operasi-operasi TDA Tas dipilih istilah dalam Bahasa Inggris karena
ada kesamaan dengan kata kunci khusunya dalam Bahasa Python. Berikut interface dari TDA
Tas ini:
TDA Tas
Deskripsi TDA Tas atau kantong yaitu tempat penyimpanan sederhana yang bisa
membawa sekumpulan barang dimana duplikasi barang dimungkinkan
dan posisi barang di dalam tas tidak perlu diperhatikan urutannya.
Operasi + Tas(): Konstruktor Tas dengan konsi awalnya nihil (kosong) isinya
+ len (Tas): menghasilkan jumlah barang yang ada di dalam tas dengan
tipe data integer. Nama len dari kependekan kata “length”
+ contains ( item ): Menentukan apakah barang tipe data item ada
disimoan dalam tas menhasilkan true atau false tipe data Boolean.
Diakses gunakan operator in untuk Python.
+ add( item ): tambahkan barang tipe data item ke dalam Tas.
+ remove( item ): hapus dan kembalikan bilangan bukan negative (dalam
hal ini posisi di array) jika barang bertipe data item muncul pertama kali
di dalam tas., dan nilai -1 jika tidak ditemukana di tas.
+ traversalPrint(): memproses semua baran dan dicetak ke layar.

+ iterator (): hanya dengan Bahasa Python untuk menciptakan

mekanisme iterasi yang bisa di gunakan dengan perintah for… in ….

Implementasi TDA Tas berbasiskan array ini dengan dua Bahasa yang berbeda juga
sangat berebeda algorimanya. Hal ini disebabkan beda karakter dari array di C dengan list,
struktur data yang mirip array di Python. Kita akan Bahasa lebih dahulu implementasi dengan
Bahasa C.
Penggunaan array C harus memperhatikan bahwa array ketika didefinisikan, yaitu dibuat
di dalam memory komputer, besar array atau kapasitasnya ditetapkan jumlahnya. Karena hal ini

38
 A. Jamal/Struktur Data

ada resiko ketika operasi penambahan add(item) dilakukan kapasitas array sudah penuh, tidak
bisa ada penambahan barang. Secara alami tas jika penuh tidak bisa dimasukkan barang lagi, jadi
bisa saja dirancang demikian. Tetapi bisa juga dibuat mekanisme penambahan kapasitas dengan
cara mengadakan tas lain yang kapasitasnya lebih besar, lalu memindahkan semua isi dari tas
yang sudah penuh k etas yang lebih besar kapasitasnya. Secara imaginative hal ini bisa dilakukan
terus menerus tanpa ada batas kapasitas tas.
Implementasi penambahan kapasitas dalam hal ini penggandaan kapasitas dijelaskan
dengan model sebagai berikut dimulai dari array tas, dengan nama variable tas->barang, sudah
terisi penuh pada kapasitasnya:
Index 0 1 2 3 4 5 6 7 8 9
data 12 13 10 11 12 13 14 15 16 17

Ketika akan dimasukkan data lagi, array sudah penuh lalu dibuat array dengan ukuran
dua kalinya dengan perintah
item *doubling =(item*) malloc(tas->kapasitas*sizeof(item)*2);
Index 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
Data

Setelah terbentuk array baru, satu persatu barang dipindahkan sesuai posisinya, lalu
memory yang dipegang tas->barang dibebaskan dengan perintah free(tas->barang) lalu
variable tas->barang diarahkan ke array yang baru dengan kapasitas digandakan. Mekanisme
penambahan kapasitas seperti ini juga dilakukan secara intrinsic oleh struktur data list di Python,
dan juga penambahan dilakukan diakhir dengan method list.append(item).
Algoritma yang berbeda juga ditemukan pada operasi penghapusan barang dengan fungsi
remove(item). Jika data item ditemukan di TDA tas maka diberikan posisinya sebagai hasil.
Kemudian data sebelah kanannya mengisi data yang dihapus, lalu berikutnya data sebelah
kanannya lagi mengisi data yang sudah bergeser dan seterusnya sampai data terakhir di TDA
Tas. Berikut penghapusan data 11 dengan perintah remove(11).
Index 0 1 2 3 4 5 6 7 8 9
data 12 13 10 11 12 13 14 15 16 17

Index 0 1 2 3 4 5 6 7 8 9
data 12 13 10 12 13 14 15 16 17

39
 A. Jamal/Struktur Data

Berikut file header “tas.h” dan dua file C untuk aplikasi uji TDA Tas dan
implementasinya.

typedef int item;

struct tas {
item *barang;
int jumlah;
int kapasitas;
};
typedef struct tas Tas;
Tas createTas(item);
void addItem(Tas*, item);
item removeItem(Tas*,item);
int len(Tas);
int contains(Tas,item);
void traversalPrint(Tas );

#include <stdio.h>
#include <stdlib.h>
#include "tas.h"
int main(int argc, char *argv[]) {
Tas tas1;
int i;
tas1=createTas(12);
int kps=tas1.kapasitas;
addItem(&tas1,13);
for(i=0;i<kps;i++){
addItem(&tas1,i+10);
printf(" jumlah %d kapasitas %d\n",len(tas1),tas1.kapasitas);
}
printf(" contains %d len %d\n ",contains(tas1,17),len(tas1));
traversalPrint(tas1);
printf(" removed %d \n ",removeItem(&tas1,11));
traversalPrint(tas1);
printf(" contains %d len %d\n ",contains(tas1,15),len(tas1));
printf(" contains %d \n ",contains(tas1,11));
return 0;
}

40
A. Jamal/Struktur Data

#include "tas.h"
#include <stdlib.h>
#define kap 10
Tas createTas(item itm){
Tas tas;
tas.barang =(item*)malloc(kap*sizeof(item));
tas.barang[0]=itm;
tas.jumlah=1;
tas.kapasitas=kap;
return tas;
}
void addItem(Tas* tas, item itm){
if (tas->jumlah==tas->kapasitas){
item *doubling =(item*)malloc(tas->kapasitas*sizeof(item)*2);
int i;
for(i=0;i<tas->jumlah;i++){
doubling[i]=tas->barang[i];
}
free(tas->barang);
tas->barang=doubling;
tas->kapasitas=2*tas->kapasitas;
}
tas->barang[tas->jumlah]=itm;
(tas->jumlah)++;
}
item removeItem(Tas*tas,item itm){
int i=0;
int found=0;
item itmfound='\0';
while(i < tas->jumlah && !found){
if(tas->barang[i]==itm){
found=1;
itmfound=itm;
(tas->jumlah)--;
}
i++;
}
for(;i<= tas->jumlah;i++){
tas->barang[i-1]=tas->barang[i];
}
}

41
 A. Jamal/Struktur Data

int len(Tas tas){

return tas.jumlah;
}
int contains(Tas tas,item itm){
int i=0;
while(i < tas.jumlah ){
if(tas.barang[i]==itm){
return i;
}
i++;
}
return -1;
}
void traversalPrint(Tas tas){
int i;
for ( i=0;i<tas.jumlah;i++){
printf(" %d\n",tas.barang[i]);
}
}

TDA Tas berbasis array yang menggunakan Bahasa Python akan lebih sederhana karena
mengaplikasikan struktur data list dari Python yang lebih banyak operasinya dibandingkan TDA
Tas. Implementasi TDA Tas ini hanya menggunakan sebagian dari operasi list, yaitu
list.append(item), list.index(item) dan list.pop(index) serta fungsi len(list) dan operator in.
Metode list.append(item) untk menambah item diakhir dari list. Metode list.index(item)
mencari item lalu memberikan posisi atau index dari item yang pertama kali ditemukan. Dengan
masukan index yang diperoleh lalu metode list.pop(index) menghapus item pada index yang
diberikan.
Fungsi len(list) kependekan dari length memberikan banyaknya item dalam list,
sedangkan operator in dalam perintah “item in list” memeriksa apakah item ada (contains)
dalam list. Fungsi len( ) dan operator in akan dibuat untuk TDA tetap sebagai fungsi dan
operator dengan menggunakan nama fungsi __len__() dan __contains__() dimana penamaan
fungsi diawali dan diakhiri garis bawah ganda (double underscore) adalah menimpa atau
menggantikan fungsi dan operator built-in dalam hal ini fungsi len( ) dan operator in.
Selain TDA Tas, diperlukan sebuah TDA untuk melakukan iterasi atau traversal pada
setiap barang yang ada di koleksi dalam TDA Tas. TDA bantu ini untuk iterasi TDA Tas kita
sebut TDA _TasIterator yang mana aplikasi penggunaanya pada mekanisme for barang in
tasIterator. Iterator akan diberikan oleh method

42
 A. Jamal/Struktur Data

def __iter__( )
serta method yang memberikan data barang dalam koleksi barang di TDA Tas adalah
def __next__( )
Penggunaan struktur data List dari Python, yang akan dijelaskan lebih detil pada bagian
akhir buku ini membuat implementasi TDA Tas menjadi sangat sederhana dibandingkan dengan
implementasi dengan Bahasa C sebelum ini.
Berikut file Python implementasi dari TDA Tas dan TDA _TasIterator serta aplikasi
ujinya.
class Tas:
def __init__(self):
self._barang=list()
def __len__(self):
return len(self._barang)
def __contains__(self,item):
return item in self._barang
def add(self,item):
self._barang.append(item)
def remove(self,item):
assert item in self._barang, "Barang harus ada dalam Tas"
ndx=self._barang.index(item)
self._barang.pop(ndx)
return ndx
def traversalPrint(self):
for item in self._barang:
print(" %d\n"%(item))
class _TasIterator:
def __init__(self,tas):
self._tasbarang=tas._barang
self._curitem=0
def __iter__(self):
return(self)
def __next__(self):
if(self._curitem<len(self._tasbarang)):
item=self._tasbarang[self._curitem]
self._curitem+=1
return item
else:
raise StopIteration

43
A. Jamal/Struktur Data

from tas import Tas,_TasIterator

tas1 = Tas()
tas1.add(12)
tas1.add(13)
for x in range(10):
tas1.add(x+10)
tas1.traversalPrint()
print("item 11 ada di tas", 11 in tas1)
print(" banyaknya item di tas: ", len(tas1))
print("hapus data 11 di posisi:",tas1.remove(11))
iterTas=_TasIterator(tas1)
for x in iterTas:
print("tas.next()",x)
Luaran dari aplikasi uji ini sebagai berikut;

44