modul struktur data ti

PANDUAN PRAKTIKUM

STRUKTUR DATA - TI

Disusun Oleh :

Deborah Kurniawati, S.Kom., M.Kom.

Femi Dwi Astuti, S.Kom.

Indra Yatini B., S.Kom., M.Kom.

LN Harnaningrum, S.Si., M.T.

Nurul Azizah K., S.Kom.

STMIK AKAKOM

Yogyakarta

2014

ii

KATA PENGANTAR

Puji Syukur kepada Tuhan karena modul Algoritma dan Pemrograman ini dapat

terselesaikan. Modul ini dibuat karena tuntutan kurikulum baru atau disebut sebagai kurikulum

2014 STMIK AKAKOM yang mulai diberlakukan pada tahun akademik 2014-2015.

Modul ini membahas tentang struktur data dan implementasinya dalam bahasa C++.

Materi yang dibahas meliputi tipe data, larik, pointer, stack, queue, single link list, double link

list, binary tree, hash.

Tentu saja dengan segala keterbatasan yang ada, modul ini jauh dari sempurna. Untuk

itu masukan dan saran untuk perkembangan modul ini sangat diharapkan.

Akhirnya semoga modul ini berguna dalam membantu mahasiswa untuk mempelajari

tentang Struktur Data.

Yogyakarta, September 2014.

Penulis

iii

DAFTAR ISI

Judul ................................................................................................................................ i

Kata Pengantar ................................................................................................................ ii

Daftar Isi ........................................................................................................................ iii

Pertemuan ke 1 ............................................................................................................... 1

Pertemuan ke 2 ............................................................................................................... 4

Pertemuan ke 3 ............................................................................................................... 7

Pertemuan ke 4 ............................................................................................................. 10

Pertemuan ke 5 ............................................................................................................. 13

Pertemuan ke 6 ............................................................................................................. 16

Pertemuan ke 7 ............................................................................................................. 19

Pertemuan ke 8 ............................................................................................................. 22

Pertemuan ke 9 ............................................................................................................. 25

Pertemuan ke 10 ........................................................................................................... 30

Pertemuan ke 11 ........................................................................................................... 35

Pertemuan ke 12 ........................................................................................................... 40

Pertemuan ke 13 ........................................................................................................... 45

Pertemuan ke 14 ........................................................................................................... 48

STRUKTUR DATA - TI 1

PERTEMUAN KE 1 TIPE DATA

A. TUJUAN :

Memahami tentang penggunaan tipe data larik dan pointer

Menggunakan tipe data untuk menyelesaikan soal

B. TEORI SINGKAT

LARIK

Larik (array) menyatakan kumpulan data. Pada beberapa bahasa pemrograman, data yang

terkandung dalam suatu larik harus bertipe sama. Larik dinyatakan dengan awalan huruf kapital dan

notasi [ ] dipakai untuk menyatakan data dalam larik. Contoh :

data [12,32,43,47]

Menyatakan larik data yang berisi data 12,32,43 dan 47. Larik seperti itu dapat dinyatakan dalam

bentuk gambar seperti berikut.

0 1 2 3 indeks ke

12 32 43 47 Data

data[0] data[1] data[2] data[3] penyebutan

Larik data mempunyai 4 buah elemen. Setiap elemen dinyatakan dengan nama larik beserta

indeksnya. Indeks dimulai dari nomor 0.

Membuat variabel bertipe larik dalam C++ menggunakan format

tipeData namaLarik[jumlahElemen]

Contoh

int data[4];

Deklarasi tersebut artinya adalah membuat deklarasi tipe data larik dengan nama data dan bertipe

integer serta jumlah elemen 4.

Pointer

Pointer merupakan suatu variabel yang nilainya 0 atau dari suatu variabel atau objek. Jika nilainya 0

dikatakan sebagai null pointer, pointer menunjuk ke suatu alamat variabel atau objek yang disimpan

dimemori. Pointer yang tidak diinisialisasi dikatakan sebagai dangling pointer dan tidak dapat

diprediksi.

Suatu tipe pointer adalah pointer ke xxxx, dimana xxxx adalah tipe dari variabel atau objek yang ditunjuknya. Pengenal untuk pointer adalah xxxx*

Referensi

Suatu reference merupakan alias, yaitu sinonim untuk suatu variabel atau objek. Suatu referensi

memiliki tipe xxxx&, dimana xxxx adalah tipe dari suatu nama variabel atau objek. Seperti halnya

konstanta, referensi harus diinisialisasi.


Operator new dan delete

new. Operator new menciptakan objek saat run-time, dan tetap aktif selama program aktif. Sintak

untuk operator new adalah

xxxx* p = new xxxx();

dimana xxxx adalah kelas objek. Ekspresi new xxxx() memanggil class contructor untuk menciptakan

objek baru dan mengembalikan pointer padanya. Hasilnya adalah objek anonim, dan diakses dengan

menggunakan *p atau *q dimana q pointer lainnya yang sama dengan p.

delete. Untuk beberapa kasus, penting untuk menghentikan keberadaan objek sebelum akhir

program. Untuk maksud tersebut digunakan operator delete.

C. PRAKTIK :

1. Cobalah program berikut, jalankan dan analisis hasilnya.

#include "iostream.h" #include "conio.h" void main(){ clrscr(); int bil[5],n,i; float total,rata; coutn; total = 0; for(i=1; i


#include #include void main() { int *A,*B; int p,q; p = 100; q = 50; A = &p; B = &q; cout


PERTEMUAN KE 2 SORTING

A. TUJUAN :

Memahami tentang sorting dengan metode insertion sort dan selection sort

Menggunakan sorting tersebut dalam implementasi program

B. TEORI SINGKAT

Pengurutan (Sort)

Sort adalah proses pengurutan data yang sebelumnya disusun secara acak sehingga menjadi

tersusun secara teratur menurut suatu aturan tertentu. Sort bisa naik atau turun.

Selection Sort

Membandingkan elemen yang sekarang dengan elemen yang berikutnya sampai dengan

elemen yang terakhir. Jika ditemukan elemen lain yang lebih kecil dari elemen sekarang, maka

dicatat posisinya dan kemudian ditukar.

Insertion Sort

Pengurutan dilakukan dengan cara membandingkan data ke-i (dimana i dimulai dari data ke-

2 sampai dengan data terakhir) dengan data berikutnya. Jika ditemukan data yang lebih kecil, maka

data tersebut disisipkan ke depan sesuai dengan posisi yang seharusnya.

C. PRAKTIK :

1. Cobalah program berikut, jalankan dan analisis hasilnya.

//--------------------------------------------------------------------------- #include #include #include //--------------------------------------------------------------------------- void baca_data(int A[], int n) { int i; for (i=0;i


void insertion_sort(int A[], int n) { int k,j,temp; for (k=0;k=A[j]) A[j+1]=temp; else { A[j+1]=A[j]; A[j]=temp; } } } void main() { int data[10],n; coutn; baca_data(data,n); cetak_data(data,n); insertion_sort(data,n); cetak_data(data,n); getch(); } //---------------------------------------------------------------------------

2. Cobalah dengan beberapa kemungkinan data. 3. Coba juga program berikut dan amati hasilnya.

//---------------------------------------------------------------------------

#include

#include

#include

//---------------------------------------------------------------------------

void baca_data(int A[], int n)

{

int i;

for (i=0;i


void cetak_data(const int A[], int n)

{

int i;

for (i=0; i


PERTEMUAN KE 3 MERGE SORT

A. TUJUAN :

Memahami karakteristik algoritma merge sort

Menggunakan algoritma merge sort untuk mengurutkan data

B. TEORI SINGKAT

Algoritma pengurutan data mergesort dilakukan dengan menggunakan cara

divideandconquer yaitu dengan memecah kemudian menyelesaikan setiap bagian kemudian

menggabungkannya kembali. Pertama data dipecah menjadi 2 bagian dimana bagian pertama

merupakan setengah (jika data genap) atau setengah minus satu (jika data ganjil) dari seluruh data,

kemudian dilakukan pemecahan kembali untuk masing-masing blok sampai hanya terdiri dari satu

data tiap blok.

Setelah itu digabungkan kembali dengan membandingkan pada blok yang sama apakah data

pertama lebih besar daripada data ke-tengah+1, jika ya maka data ke-tengah+1 dipindah sebagai

data pertama, kemudian data ke-pertama sampai ke-tengah digeser menjadi data ke-dua sampai ke-

tengah+1, demikian seterusnya sampai menjadi satu blok utuh seperti awalnya. Sehingga metode

mergesort merupakan metode yang membutuhkan fungsi rekursi untuk penyelesaiannya.

Dengan hal ini deskripsi dari algoritma dirumuskan dalam 3 langkah berpola divide-and-

conquer. Berikut menjelaskan langkah kerja dari Mergesort.

1. Divide

Memilah elemen elemen dari rangkaian data menjadi dua bagian. 2. Conquer

Conquer setiap bagian dengan memanggil prosedur mergesortsecararekursif

3. Kombinasi

Mengkombinasikan dua bagian tersebut secara rekursif untuk mendapatkanrangkaian data berurutan

Proses rekursi berhenti jika mencapai elemen dasar. Hal ini terjadi bilamana bagian yang akan

diurutkan menyisakan tepat satu elemen. Sisa pengurutan satu elemen tersebut menandakan bahwa

bagian tersebut telah terurut sesuai rangkaian.

C. PRAKTIK :

Cobalah program berikut, jalankan dan analisis hasilnya.

#include #include int a[50]; void merge(int,int,int); void merge_sort(int low,int high) { int mid; if(low


} void merge(int low,int mid,int high) { int h,i,j,b[50],k; h=low; i=low; j=mid+1; while((h


cout


PERTEMUAN KE 4 REKURSIF DAN QUICK SORT

A. TUJUAN :

Memahami karakteristik algoritma quick sort

Menggunakan algoritma quick sort untuk mengurutkan data

B. TEORI SINGKAT

Rekursif adalah fungsi yang memanggil dirinya sendiri secara langsung ataupun tidak, dan proses

pemanggilannya itu disebut rekursi.

Masalah yang dapat diselesaikan secara rekursif adalah masalah yang dibagi menjadi satu atau

lebih masalah-masalah serupa yang lebih kecil.

Simple Cases adalah kondisi-kondisi yang dapat diselesaikan secara langsung tanpa perlu di-

rekursi dan biasanya digunakan sebagai tanda akhir dari sebuah rekursi.

Recursive Case adalah kondisi-kondisi yang diselesaikan dengan cara memanggil fungsi itu sendiri

dengan problem yang semakin berkurang mendekati simple case.

Quick sort merupakan Algoritma Pembagi. Pertama sekali quicksort membagi list yang besar

menjadi dua buah sub list yang lebih kecil: element kecil dan element besar. Quicksort kemudian

dapat menyortir sub list itu secara rekursif.

Langkah-Langkah pengerjaannya ialah:

1. Ambil sebuah elemen, yang disebut dengan pivot, pada sebuah daftar. 2. Urutkan kembali sebuah list sehingga elemen dengan nilai yang kecil dari pivot berada

sebelum pivot, sedangkan seluruh element yang memiliki nilai yang lebih besar dari pivot

berada setelahnya (nilai yang sama dapat berada pada pivot setelahnya). Setelah pemisahan,

pivot berada pada posisi akhirnya. Operasi ini disebut Partition.

3. Sub list kemudian disortir secara recursif dari elemen yang lebih kecil dan sub list dari elemen yang lebih besar.

Kasus dasar dari rekusrif ialah list dari besaran nol atau satu, yang tidak perlu untuk di sorting.

C. PRAKTIK :


#include #include long int faktorial (int A); void main() /*fungsi ini tidak memberikan nilai balik. fungsi ini sebagai fungsi utama*/ { int r,hasil; coutr; hasil=faktorial(r); cout


getch(); } long int faktorial(int A) /*fungsi ini memberikan nilai balik berupa hasil faktorial dari data inputan*/ { if (A==1) return(A); else return (A*faktorial(A-1)); }

#include #include #define max 20 void quick_sort(int darr[max], int lb, int ub) { int a; int up,down; int temp; if (lb>=ub) return; a=darr[lb]; up=ub; down=lb; while (down < up) { while (darr[down] a) up--; if(down


lb=0; coutn; ub=n; cout


PERTEMUAN KE 5 SEARCHING

A. TUJUAN :

Memahami karakteristik algoritma searching

Menggunakan algoritma searching untuk pencarian data

B. TEORI SINGKAT

Searching adalah metode pencarian informasi dalam suatu aplikasi, dengan suatu kunci( key ).

Pencarian diperlukan untuk mencari informasi khusus dari table pada saat lokasi yang pasti dari

informasi tersebut sebelumnya tidak diketahui. Pencarian selalu dinyatakan dengan referensi

pada adanya sekelompok data yang tersimpan secara terorganisasi, kelompok data tersebut kita

sebut table.

Pada metode searching (pencarian) ada 2 teknik yang digunakan yaitu : Pencarian sekuensial

(sequential search) dan Pencarian biner (Binary search).

1. Pencarian sekuensial (sequential search) Pencarian sekuensial (sequential search) atau sering disebut pencarian linier menggunakan

prinsip sebagai berikut : data yang ada di bandingkan satu persatu secara berurutan dengan

yang dicari.

Pada dasarnya, pencarian ini hanya melakukan pengulangan dari 1 sampai dengan jumlah

data. Pada setiap perulangan , di bandingkan data ke-i dengan yang dicari. Apabila sama ,

berarti data telah ditemukan . Sebaliknya apabila sampai akhir pengulangan , tidak ada yang

sama berarti data tidak ada.

2. Pencarian Biner (Binary Search) Salah satu syarat pencarian biner (binary search) dapat dilakukan adalah data sudah dalam

keadaan terurut. Dengan kata lain, apabila data belum dalam keadaan terurut , pencarian

biner tidak dapat dilakukan . Dalam kehidupan sehari-hari, sebenarnya kita juga serig

menggunakan pencarian biner. Misalnya saat kita ingin mencari suatu kata dalam kamus.

Langkah dalam pencarian biner adalah :

1. Mula-mula diambil dari posisi awal=1 dan posisi akhir = n 2. Kemudian kita cari posisi data tengah dengan rumus posisi tengah = (posisi awal + posisi

akhir ) div 2

3. Kemudian data yang di cari dibandingkan dengan data tengah a. Jika sama, data ditemukan, Proses selesai b. Jika lebih kecil, proses dilakukan kembali tetapi posisi akhir dianggap sama dengan

posisi tengah -1,

c. Jika lebih besar , proses dilakukan kembali tetapi posisi awal dianggap sama dengan posisi tengah +1.

4. Ulangi langkah kedua hingga data ditemukan , atau tidak ditemukan. 5. Pencarian biner ini akan berakhir jika data ditemukan posisi awal lebih besar dari pada

posisi akhir. Jika posisi awal sudah lebih besar dari posisis akhir berarti data tidak

diketemukan.

C. PRAKTIK :



#include #include void main() { int i; int cari,ketemu; int A[100] ; cout


cout


PERTEMUAN KE 6 STACK (Tumpukan)

A. TUJUAN :

Memahami konsep stack (tumpukan)

Mampu membuat program yang mengimplementasikan konsep tumpukan dengan larik dan link list

B. TEORI SINGKAT

Secara sederhana Stack (tumpukan) bisa diartikan sebagai kumpulan data yang seolah-olah

data yang satu diletakkan di atas data yang lain. Penambahan dan penghapusan data hanya dapat

dilakukan dari ujung yang sama, yang disebut sebagai ujung atas tumpukan (top of stack). Dengan

kondisi demikian maka prinsip yang digunakan pada stack (tumpukan) adalah LIFO (last in first

out).

Ada dua operasi dasar yang dapat dilakukan pada sebuah stack (tumpukan), yaitu operasi

penambahan data (PUSH) dan operasi pengurangan/pengambilan data (POP). Gambar 6.1

mengilustrasikan operasi PUSH dan POP pada stack yang diimplementasikan dengan array

berukuran 6 dari proses berurutan sebagai berikut,

P1 : penambahan 3 data, yaitu A B C D - E P2 : pengurangan 2 data

P3 : penambahan 3 data, yaitu F G - H

6 6 6

5 5 Posisi top = 5 H

Posisi top =4 E 4 4 G

3 D 3 3 F

2 C Posisi top =2 C 2 C

1 B 1 B 1 B

0 A 0 A 0 A

P1 P2 P3

Gambar 6.1 Ilustrasi operasi PUSH dan POP pada Stack

Pada kehidupan sehari-hari, implementasi stack dapat diilustrasikan seperti tumpukan

kardus atau surat. Jika ada kardus atau surat baru maka kardus atau surat tersebut akan diletakkan

ditumpukan paling atas dan jika akan mengambil satu kardus atau surat maka kardus atau surat

yang berada di posisi paling atas akan diambil terlebih dahulu.

C. PRAKTIK.

Berikut contoh stack yang diimplementasikan dengan array

#include #include typedef int Item_type; struct stack_tag { int top; Item_type entry[10]; } Stack_type; void Create() {


Stack_type.top=0; } bool Empty() { return Stack_type.top


D. LATIHAN

Diberikan oleh dosen pengampu pada saat praktikum.

E. TUGAS :

Diberikan oleh dosen pengampu pada akhir praktikum.

Dikerjakan di rumah dan dilampirkan pada laporan.


PERTEMUAN KE 7 QUEUE (Antrian)

A. TUJUAN :

Memahami konsep queue (antrian)

Mampu membuat program yang mengimplementasikan konsep antrian dengan larik dan link list

B. TEORI SINGKAT

Queue (antrian) adalah suatu kumpulan data yang penambahan elemennya hanya bisa

dilakukan pada suatu ujung (disebut dengan sisi belakang atau rear), dan penghapusan atau

pengambilan elemen dilakukan lewat ujung yang lain (disebut dengan sisi depan atau front). Pada

queue prinsip yang digunakan adalaha FIFO (first in first out).

Ada dua operasi dasar yang dapat dilakukan pada sebuah queue (antrian), yaitu operasi

penambahan data (ENQUEUE) dan operasi pengurangan/pengambilan data (DEQUEUE). Gambar

7.1 mengilustrasikan operasi ENQUEUE dan DEQUEUE pada queue yang diimplementasikan

dengan array berukuran 6 dari proses berurutan sebagai berikut,

P1 : penambahan 3 data, yaitu A B C D - E P2 : pengurangan 2 data

P3 : penambahan 3 data, yaitu F G - H

6 6 6

5 5 Posisi top = 5 H

Posisi top =4 E 4 4 G

3 D 3 3 F

2 C Posisi top =2 E 2 E

1 B 1 D 1 D

0 A 0 C 0 C

P1 P2 P3

Gambar 6.1 Ilustrasi operasi PUSH dan POP pada Stack

Pada kehidupan sehari-hari, implementasi queue dapat diilustrasikan seperti antrian pasien

pada sebuah poliklinik. Jika ada pasien baru maka pasien tersebut akan mendapat nomor antrian

yang paling besar dan akan menjadi pasien yang terakhir dilayani setelah pasien-pasien yang datang

sebelumnya

C. PRAKTIK :

Berikut contoh queue yang diimplementasikan dengan array

#include #include #define MAX 8 typedef struct{ int data[MAX]; int head; int tail; }Queue; Queue antrian; void Create(){


antrian.head=antrian.tail=-1;} int IsEmpty(){ if(antrian.tail==-1) return 1; else return 0;} int IsFull(){ if(antrian.tail==MAX-1) return 1; else return 0;} void Enqueue(int data){ if(IsEmpty()==1){ antrian.head=antrian.tail=0; antrian.data[antrian.tail]=data;} else if(IsFull()==0){ antrian.tail++; antrian.data[antrian.tail]=data;}} int Dequeue(){ int i; int e = antrian.data[antrian.head]; for(i=antrian.head;i


D. LATIHAN


E. TUGAS :




PERTEMUAN KE 8 LINK LIST

A. TUJUAN

Memahami konsep link list

Mampu membuat program untuk mengimplementasikan operasi penambahan simpul di depan dan di belakang single list

B. TEORI SINGKAT

Lingked List adalah suatu cara untuk menyimpan suatu data dengan struktur sehingga

program dapat secara otomatis menciptakan suatu tempat baru untuk menyimpan suatu data kapan

saja diperlukan.Secara rinci program dapat menuliskan struct atau definisi kelas yangberisi variabel

yang memegang informasi yang ada didalamny, dan mempunayai suatu pointer yang menunjukan

ke suatu struct sesuai dengan tipe datanya.

Struktur dinamis ini mempunyai banyak keuntungan dibanding struktur array yang bersifat

statis. Struktur ini lebih dinamis, karena banyak elemen dengan mudah ditambah atau dikurangi,

berbeda dengan array yang ukurannya bersifat tetap. Disamping itu manipulasi terhadap setiap

elemen seperti menyisipkan, menghapus, menambah dapat dilakukan dengan mudah.

Definisi link list dapat dituliskan secara sederhana dengan struktur berikut;

Struct node {

Int info;

Struct node *nextPtr;

};

Struktur ini mempunyai dua anggota, yaitu bilangan bulat info dan pointer nextPtr.Variabel

pointer nextPtr ini menunjukan ke struktur bertype struct node, yang sama dengan deklarasi

induknya.

Operasi yang dapat dilakukan pada sebuah link list adalah penambahan dan penghapusan

elemen link list. Penambahan dan penghapusan dapat dilakukan pada posisi depan,posisi belakang

atau posisi tertentu pada link list.

Gambar 8.1 merupakan ilustrasi penambahan data di belakang link list.

Gambar 8.1 Ilustrasi penambahan data di belakang link list

C. PRAKTIK :

Berikut contoh queue yang diimplementasikan dengan array

#include #include typedef char Item_type; typedef struct LinkList {


Item_type entry; struct LinkList *next; } ListNode; typedef struct list { ListNode *awal; ListNode *akhir; } List; void Create(List *q) { q->awal=q->akhir=NULL; } void Tambah_Belakang(List *q, Item_type item) { ListNode *baru= new ListNode; baru->entry=item; if (q->awal==NULL) q->awal=baru; else q->akhir->next = baru; q->akhir=baru; q->akhir->next=NULL; } void Baca_Maju(List *q) { ListNode *bantu=new ListNode; bantu=q->awal; while (bantu!=NULL) { coutnext; coutnext = q->awal;


q->awal=baru; } void main() { List *SingleList=new List; char pilih, hasil, data,cari; int tempat; bool ada; Create(SingleList); Tambah_Belakang(SingleList, 'S'); Baca_Maju(SingleList); Tambah_Belakang(SingleList, 'A'); Baca_Maju(SingleList); Tambah_Depan(SingleList, 'I'); Baca_Maju(SingleList); cout


PERTEMUAN KE 9 LINK LIST

A. TUJUAN

Memahami konsep link list

Mampu membuat program untuk mengimplementasikan penambahan simpul di tengah dan menghapus single list

B. TEORI SINGKAT

Operasi yang dapat dilakukan pada sebuah link list adalah penambahan dan penghapusan

elemen link list. Penambahan dan penghapusan dapat dilakukan pada posisi depan,posisi belakang

atau posisi tertentu pada link list.

Gambar 9.1 merupakan ilustrasi penambahan di posisi tertentu pada link list dan Gambar 9.2

merupakan ilustrasi penghapusan data pada link list.

Gambar 9.1 Ilustrasi penambahan data di posisi tertentu

Gambar 9.2 Ilustrasi penghapusan data di posisi depan

C. PRAKTIK :

Berikut contoh implementasi linklist untuk menambah data di posisi tertentu dan menghapus

data.

#include #include typedef char Item_type; typedef struct LinkList { Item_type entry; struct LinkList *next; } ListNode; typedef struct list { ListNode *awal; ListNode *akhir; } List;


void Create(List *q) { q->awal=q->akhir=NULL; } void Tambah_Belakang(List *q, Item_type item) { ListNode *baru= new ListNode; baru->entry=item; if (q->awal==NULL) q->awal=baru; else q->akhir->next = baru; q->akhir=baru; q->akhir->next=NULL; } void Baca_Maju(List *q) { ListNode *bantu=new ListNode; bantu=q->awal; while (bantu!=NULL) { coutnext; coutnext = q->awal; q->awal=baru; } void Tambah_Tengah(List *q, Item_type item, int Posisi) { ListNode *baru=new ListNode; ListNode *bantu=new ListNode; baru->entry=item; if (q->awal==NULL)


{ q->awal=baru; q->akhir=baru; q->akhir->next=NULL; } else { if (Posisi==0) { baru->next = q->awal; q->awal = baru; } else { bantu=q->awal; for (int i=1;inext!=NULL) bantu=bantu->next; baru->next=bantu->next; bantu->next=baru; } } } bool Cari_Data(Item_type cari, List *q) { ListNode *bantu=new ListNode; bantu=q->awal; while (bantu!=NULL) { if (bantu->entry==cari) return 0; else { bantu=bantu->next; if (bantu==NULL) return 1; } } } void Hapus_Simpul(List *q, Item_type hapusan) { ListNode *bantu=new ListNode; ListNode *hapus=new ListNode; if (q->awal==NULL) coutawal=hapus->next;


delete(hapus); coutentry!=hapusan) ) bantu=bantu->next; hapus=bantu->next; if (hapus==NULL) coutakhir=bantu; q->akhir->next=NULL; } delete(hapus); } else cout


D. LATIHAN


E. TUGAS :




MODUL 10

DOUBLE LINK LIST

A. TUJUAN : o Mampu membuat proram untuk mengimplementasikan operasi penambahan simpul di depan

dan di belakang pada Double Link List

B. TEORI SINGKAT Double linked list atau disebut juga Senarai Berantai Ganda hampir sama dengan Single Linked List

yang telah dibahas pada bab sebelumnya, yaitu pengalokasian memori secara dinamis yang

digunakan untuk menyimpan data. Bedanya Double Linked List lebih flexibel dibanding Single

Linked List karena pada Double Linked List semua simpul-simpulnya yang ada didalamnya

memiliki 2 buah penunjuk yang digunakan untuk mengkaitkan diri dengan simpul lain yang ada di

sebelah kanannya dan di sebelah kirinya.

Di dalam konsep Double Linked List ada 3 unsur pendukung yang penting, yaitu :

1. Penunjuk (biasa disebut pointer). Penunjuk atau pointer yang dimaksud disini alat yang digunakan untuk menunjuk sebuah

simpul, seperti pada Gambar 10.1.

Gambar 10.1 Ilustrasi Sebuah Penunjuk atau Pointer

Penunjuk dapat menunjuk ke sebuah sebuah simpul, ataupun ke sebuah tempat kosong (null).

2. Simpul Ganda (biasa disebut node). Simpul yang digunakan dalam bab ini adalah simpul ganda yang digambarkan sebagai berikut.

Gambar 10.2 Ilustrasi Sebuah Simpul dalam Double Linked List

Simpul yang demikian disebut simpul ganda karena simpul ini mempunyai dua buah pointer, yaitu kiri dan kanan. Artinya pointer kanan menunjuk ke elemen disebelah kanannya dan pointer kiri menunjuk ke elemen disebelah kirinya. Dalam gambar 10.2 ini diilustrasikan

sebuah simpul dalam Double Linked List. Sedangkan (data) adalah data yang digunakan dalam

simpul, kiri adalah pointer yang menunjuk pada simpul sebelumnya, dan kanan adalah pointer

yang menunjuk pada simpul sesudahnya. Untuk pembuatan simpul ganda dapat dideklarasikan

dengan membuat struct strSimpul yang memiliki 2 anggota bertipe strSimpul, yaitu: kanan dan

kiri yang berfungsi sebagai penunjuk. Kemudian, struct strSimpul tersebut dibuat aliasnya

dengan nama Simpul, seperti contoh dibawah ini:

typedef struct strSimpul { data masukkan; struct strSimpul *kanan; struct strSimpul *kiri; } Simpul;

3. Senarai Berantai Ganda atau Double Linked List itu sendiri. Seperti senarai berantai tunggal, Senarai berantai Ganda merupakan kumpulan simpul-simpul

yang terhubung satu dengan yang lain. Hanya bedanya pada senarai ini setiap simpulnya

mempunyai 2 penghubung, kiri dan kanan, seperti Gambar 10.3.


Gambar 10.3 Ilustrasi Sebuah Double Linked List

Untuk pembuatan Senarai Berantai Ganda dapat dideklarasikan dengan membuat struct

strSeneraiGanda yang memiliki 2 anggota bertipe Simpul, yaitu: awal dan akhir yang berfungsi

sebagai penunjuk. Kemudian, struct strSeneraiGanda tersebut dibuat aliasnya dengan nama

SeneraiGanda. Selain itu diperlukan juga fungsi untuk membuat Senarai Berantai Ganda

dengan nama buat dan parameter berupa pointer *q, yang memiliki anggota awal dan akhir

dengan nilai awal masih kosong (null), seperti contoh dibawah ini:

typedef struct strSeneraiGanda { Simpul *awal; Simpul *akhir; } SeneraiGanda; void buat(SeneraiGanda *q) { q->awal=NULL; q->akhir=NULL; }

Gambar 10.4 merupakan ilustrasi penambahan data di belakang pada double link list.

Gambar 10.4 Ilustrasi penambahan data di belakang pada double link list

awal akhir

Agung

kanan

kiri

NULL

Agung

kanan

kiri

Agung

kanan

kiri

Agung

kiri

kanan

NULL


C. PRAKTIK :

Berikut contoh implementasi Double Link List untuk menambah data didepan, dibelakang

dan membaca data maju.

//--------------------------------------------------------------------------- #pragma hdrstop #include #include #include #pragma argsused //--------------------------------------------------------------------------- typedef char data; typedef struct strSimpul { data masukkan; struct strSimpul *kanan; struct strSimpul *kiri; } Simpul; typedef struct strSeneraiGanda { Simpul *awal; Simpul *akhir; } SeneraiGanda; void buat(SeneraiGanda *q) { q->awal=NULL; q->akhir=NULL; } void Tambah_Depan(SeneraiGanda *q, data elemen) { Simpul *baru=new Simpul(); baru->masukkan=elemen; if (q->awal==NULL && q->akhir==NULL) { q->awal=baru; q->akhir=baru; baru->kanan=NULL; baru->kiri=NULL; } else { q->awal->kiri=baru; baru->kanan=q->awal; q->awal=baru; q->awal->kiri=NULL; } } void Tambah_Belakang(SeneraiGanda *q, data elemen)


{ Simpul *baru=new Simpul(); baru->masukkan=elemen; if (q->awal==NULL && q->akhir==NULL) { q->awal=baru; q->akhir=baru; baru->kanan=NULL; baru->kiri=NULL; } else { q->akhir->kanan=baru; baru->kiri=q->akhir; q->akhir=baru; q->akhir->kanan=NULL; } } void Baca_Maju(SeneraiGanda *q) { Simpul *bantu=new Simpul(); bantu=q->awal; while (bantu!=NULL) { cout


clrscr(); } break; case '2' :{ couthasil; Tambah_Belakang(SnrGd, hasil); clrscr(); } break; case '3' :{ clrscr(); Baca_Maju(SnrGd); } break; default : { cout


MODUL 11

DOUBLE LINK LIST

E. TUJUAN : o Mampu membuat program untuk mengimplementasikan penambahan simpul di tengah dan

menghapus Double Link List

F. TEORI SINGKAT Menambah simpul pada Double Link List ada tiga macam yaitu menambah di depan, belakang

(telah dibahas pada modul 10) dan tengah yang akan dibahas pada modul ini. Pada gambar 11.1 ini

ditunjukkan ilustrasi penambahan data di tengah pada Double Link List.

Gambar 11.1 Ilustrasi Penambahan Data di Tengah pada Double Link List

Operasi menghapus simpul pada Double Link List juga ada tiga macam yaitu menghapus simpul di

depan, belakang dan tengah. Tapi dengan menggunakan Double Link List proses pencarian simpul

yang akan dihapus menjadi semakin cepat. Untuk menghapus sebuah simpul diperlukan satu buah

tambahan variabel pointer yaitu variabel bantu yang berguna untuk menunjukkan simpul manakah

yang akan dihapus.

Gambar 11.2 Ilustrasi Penghapusan Data pada Double Link List

C. PRAKTIK :

Berikut contoh implementasi Double Link List seperti pada modul 10, ditambah dengan

operasi menambah data di tengah, menghapus data dan membaca data mundur.

//Tuliskan program yang sudah dibuat pada pertemuan ke-10, sampai sebelum void main()

//Kemudian lanjutkan dengan program berikut

void Tambah_Tengah(SeneraiGanda *q, data elemen, int Posisi)

{

Simpul *baru=new Simpul();


Simpul *bantu=new Simpul();

Simpul *bantu1=new Simpul();

baru->masukkan=elemen;

if (q->awal==NULL && q->akhir==NULL) //masih kosong

{

q->awal=baru;

q->awal->kiri=NULL;

q->akhir=baru;

q->akhir->kanan=NULL;

}

else

{

if (Posisi==0) //posisi pertama, tambah depan

{

q->awal->kiri=baru;

baru->kanan=q->awal;

q->awal=baru;

q->awal->kiri=NULL;

}

else

{

bantu=q->awal;

for (int i=1;ikanan!=NULL)

bantu=bantu->kanan;

if (bantu->kanan==NULL) //posisi terakhir, tambah belakang

{

q->akhir->kanan=baru;

baru->kiri=q->akhir;

q->akhir=baru;

q->akhir->kanan=NULL;}

else //posisi tengah beneran

{

bantu1=bantu->kanan;

baru->kiri=bantu;

baru->kanan=bantu1;

bantu->kanan=baru;

bantu1->kiri=baru;}

}

}

}

void Hapus_Simpul(SeneraiGanda *q, data elemen)

{

Simpul *bantu=new Simpul();

Simpul *bantu1=new Simpul();

Simpul *hapus=new Simpul();

if (q->awal==NULL && q->akhir==NULL)

coutawal=hapus->kanan;

q->awal->kiri=NULL;


delete(hapus);

coutkanan->masukkan))

bantu=bantu->kanan;

if ((bantu->kanan->kanan==NULL)&&(elemen!=bantu->kanan->masukkan))

coutkanan=hapus->kanan;

bantu1->kiri=hapus->kiri;

cout


}

void main()

{

SeneraiGanda *SnrGd=new SeneraiGanda();

buat(SnrGd);

int tempat;

data hasil, cari;

char pilih='1';

while (pilih=='1'||pilih=='2'||pilih=='3'||pilih=='4'||pilih=='5'||pilih=='6')

{

cout


clrscr();

Baca_Maju(SnrGd);

}

break;

case '6' :{

clrscr();

Baca_Mundur(SnrGd);}

break;

default : {

cout


PERTEMUAN KE 12 Binary Tree

A. TUJUAN :

Mengenal dan memahami tentang Binary Tree

Dapat membuat Binary Tree

B. TEORI SINGKAT

Binary Tree adalah tree dengan sarat adalah tiap node hanya boleh memiliki maksimal dua subtree

dan kedua subtree tersebut harus terpisah. Sesuai dengan definisi tersebut, maka tiap node dalam

binary tree hanya boleh memiliki paling banyak dua child.

Gambar 12.1. Binary Tree

Istilah-istilah umum dalam tree:

a. Predesesor node yang berada di atas node tertentu. b. Succesor node yang berada dibawah node tertentu. c. Ancestor seluruh node yang terletak sebelum node tertentu dan terletak pada jalur yang

sama.

d. Descendant seluruh node yang terletak sesudah node tertentu dan terletak pada jalur yang sama.

e. Parent predesesor satu level di atas satu node. f. Child succesor satu level di bawah suatu node. g. Sibling node-node yang memiliki parent yang sama dengan suatu node. h. Subtree bagian dari tree yang berupa suatu node beserta descedantnya dan memiliki

semua karakteristik dari tree tersebut.

i. Size banyaknya node dalam suatu tree. j. Height banyaknya tingkatan/level dalam suatu tree. k. Root satu-satunya node khusus dalam tree yang tak punya predesesor. l. Leaf Node-node dalam tree yang tak memiliki succesor. m. Degree banyaknya child yang dimiliki suatu node.

C. PRAKTIK :

1. Tuliskan program berikut ini.


//--------------------------------------------------------------------------- #pragma hdrstop #include #include #include #include #include #include //--------------------------------------------------------------------------- #pragma argsused typedef int Key_type; typedef struct item_tag { int key; int no; char *posisi; }Item_type; typedef struct node_tag { Item_type info; struct node_tag *kanan; struct node_tag *kiri; } Node_type; int nourut=0; void CreateTree(Node_type *root) { root = NULL; } bool TreeEmpty(Node_type *root) { return root==NULL; } Node_type *MakeNode(Item_type info) { Node_type *p=NULL; if ((p=new (Node_type))==NULL) coutkiri=p->kanan=NULL; return p; }


Node_type *InsertTree(Node_type *root, Node_type *newnode) { Node_type *p=root; while (p!=NULL) { if (newnode->info.key < p->info.key) //node baru lebih kecil dari p if (p->kiri) p=p->kiri; else {p->kiri = newnode; p->kiri->info.posisi=(char*)" kiri"; p->kiri->info.no=++nourut;break; } else if (newnode->info.key > p->info.key) if (p->kanan) p=p->kanan; else {p->kanan=newnode; p->kanan->info.posisi=(char*)" kanan"; p->kanan->info.no=++nourut;break; } else { coutinfo.no=++nourut; } return root; } Node_type *TreeSearch(Node_type *p, Key_type target) { if (p) if (target < p->info.key) p = TreeSearch(p->kiri,target); else if (target > p->info.key) p = TreeSearch(p->kanan, target); return p; } void main() { Node_type *root=NULL; Node_type *p=root; Item_type info;


//data ke 1 info.key=10; p=root; Node_type* q=MakeNode(info); root=InsertTree(root,q); //data ke 2 info.key=5; p=root; q=MakeNode(info); root=InsertTree(root,q); //data ke 3 info.key=15; p=root; q=MakeNode(info); root=InsertTree(root,q); p=TreeSearch(p,info.key); if (p) { cout


4. Cobalah membuat sebuah pohon biner dan implementasikan pada program

I. LATIHAN


J. TUGAS




PERTEMUAN KE 13 Binary Tree

(Sesi 2)

A. TUJUAN :

Dapat melakukan menelusuran terhadap Binary Tree

B. TEORI SINGKAT

Pohon Telusur Biner adalah pohon biner yang pada setiap node menyimpan data atau kunci

yang lebih besar dari semua node pada sub tree kirinya yang lebih kecil dari semua node pada sub

tree kanannya. Pada node tertentu, ada tiga kunjungan yang kita lakukan dengan aturan: kita

mengunjungi node itu sendiri; kita melintasi subpohon kiri; kita melintasi subpohon kanan. Jika kita

beri nama tiga kunjungan ini sebagai V, L, R, maka ada enam cara penelusuran:

V L R L V R L R V

V R L R V L R L V

Gambar 13.1. Pohon Biner yang mempunyai 2 Cabang.

Berdasarkan konvensi dasar, enam pilihan ini dikurangi menjadi tiga dengan memilih yang

melintasi kiri sebelum kanan. Tiga lainnya sama. Tiga yang kita pilih kita beri nama:

V L R L V R L R V

Preorder Inorder Postorder

Kunjungan inorder adalah kunjungan dimana node yang dikunjungi mempunyai urutan kunjungi

node di sebelah kiri, kemudian kunjungi node semula dan terakhir kunjungi node di sebelah kanan.

Kunjungan preorder adalah kunjungan dimana node yang dikunjungi mempunyai urutan kunjungi

node induk, kemudian kunjungi node di sebelah kiri dan terakhir kunjungi node di sebelah kanan.

Kunjungan postorder adalah kunjungan dimana node yang dikunjungi mempunyai urutan kunjungi

node pada sub tree kiri (L), kemudian kunjungi node di sebelah kanan (R) dan terakhir kunjungi

node itu sendiri (V).

C. PRAKTIK :

5. Tuliskan program berikut ini.

//tuliskan kembali program pada praktik pertemuan ke-12 sampai sebelum void main()

//kemudian lanjutkan dengan program berikut ini.

void Visit(Node_type *p) { cout


void Inorder(Node_type *root, char *s) { if (root) { Inorder(root->kiri," Kiri"); cout


p=TreeSearch(p,info.key); if (p) { cout


MODUL 14

HASH TABLES

M. TUJUAN : o Mengenal Hash Table dan Hashing o Mengetahui kelebihan algoritma Hash o Memilih Fungsi Hash (Hash Function) dan Metode - metode penanganan duplikasi kunci

pada data atau tabrakan (collision) pada tabel hash

o Mampu membuat program yang mengimplementasikan konsep hash

N. TEORI SINGKAT Hash Table / Tabel hash digunakan untuk mengindex sekumpulan array untuk memudahkan proses

pencarian. Misalkan NIP dalam sebuah Perusahaan menggunakan 5 digit, dengan demikian

nilainya berkisar antara 00000 - 99999. Bila menggunakan array diperlukan array yang mampu

menampung 100.000 elemen. Fakta yang ada Perusahaan hanya memiliki 100 pegawai. Tentu saja

penggunaan 100.000 elemen akan membuat banyak ruang tidak terpakai / pemborosan memori.

Lalu berapa jumlah array yang sebaiknya digunakan agar pencarian data menurut kunci bisa

dilakukan dengan cepat? tentu saja diperlukan array yang berukuran kecil tetapi bisa menampung

semua data. Lalu bagaimana cara memetakan antara NIP dengan lokasi Array ? Jawabannya dengan

fungsi Hash (hash function).

Fungsi Hash adalah fungsi yang digunakan untuk menerjemahkan suatu nilai kunci menjadi suatu

nilai yang dinamakan alamat hash. Alamat hash inilah yang menyatakan indeks lokasi dalam array.

Teknik yang memungkinkan lokasi suatu record dapat diperoleh dengan mudah dan cepat melalui

fungsi hash dinamakan hashing dengan cara seperti itu pencarian data pegawai dapat dilakukan

tanpa melakukan pembandingan terhadap kunci lain. Array yang digunakan untuk menyimpan data

dengan cara hashing dengan nama tabel hash . Table hash itulah yang sering disebut sebagai

struktur data yang digunakan untuk menyimpan data dengan dasar fungsi hash.

Memilih Fungsi Hash

Kriteria dalam memilih fungsi hash perlu dipertimbangkan pertama Komputasi harus mudah dan

cepat kedua Harus menghasilkan nilai tersebar disepanjang jangkauan indeks array. Metode yang

dipakai untuk membentuk fungsi hash yaitu : Sisa Pembagian, Pemotongan dan Pelipatan (Folding)

Sisa Pembagian Konsep dari sisa pembagian adalah membagi nilai kunci Misalnya NIP pada data pegawai dengan

suatu nilai dan sisa pembagiannyalah yang digunakan sebagai alamat hash. Secara matematika

fungsi hash ditulis menjadi :

H(k) = k mod m, m>n

dengan :

k adalah kunci

m adalah suatu bilangan pembagi

n adalah jumlah data mengingat k mod m menghasilkan bilangan antara 0 sampai m-1 maka apabila lokasi memori

(indeks array) berawal dengan 1, hasil pembagian perlu ditambah dengan angka 1. Dengan

demikian fungsi hash berupa

H(k)=(k mod m) +1

Pemotongan Metode pemotongan dilakukan dengan mengabaikan bagian - bagian tertentu dalam kunci dan

menggunakan yang tersisa sebagai indeks untuk mengakses data dalam tabel hash.

Pelipatan (Folding) Pada metode pelipatan kunci dibagi-bagi menjadi beberapa bagian misalnya per dua digit kemudian

dijumlahkan . Hasilnya dipotong sehingga masuk jangkauan indeks dalam tabel hash.


Menangani tabrakan (Collision) dalam tabel hash

Apapun metode yang digunakan bisa saja menimbulkan 2 buah kunci atau lebih diterjemahkan oleh

fungsi hash ke dalam nilai yang sama. Situasi yang membuat beberapa kunci memiliki alamat hash

yang sama atau disebut dengan tabrakan hash (hash collision). Untuk mengatasinya terdapat 3

teknik yaitu : Pengalamatan Terbuka (Open Addressing), Pembentukan rantai (Chaining) dan

Pengalamatan Buket (bucket addressing)

1. Pengalamatan Terbuka (Open Addressing) Pada pengalamatan terbuka semua elemen disimpan dalam tabel hash itu sendiri. Beberapa

pemeriksaan yang termasuk pengalamatan terbuka sbb :

Pemeriksaan linear (linear probing) Tabrakan hash ditangani dengan mencari lokasi terdekat yang masih kosong atau yang dikenal

dengan pemeriksaan linear. Adapun fungsi hash bisa menjadi :

h(k,i) =(h'(k)+i) mod m, m=0..n-1

Pemeriksaan Kuadratik yang dilakukan dengan urutan sbb : h(k,i) = (h'(k)+i

2)mod m, i=0..n-1

Contoh urutan pencarian sbb :

h, h+1, h+4, h+9 ,..., h+i2

Double hashing, pemeriksaan dilakukan dengan urutan sbb : h(k,i)=(h1(k)+ih2(k))mod m

Dengan h1 dan h2 adalah fungsi hash contoh pemeriksaan dengan double hashing:

h1, h1+h2, h1+2h2, h1+3h2 , ...,h1+i x h2

Baik pada pemeriksaan kuadratik maupun double hashing , h menyatakan alamat hash yang

diperoleh melalui fungsi hash dan i dimulai dari 0.

2. Teknik Pembentukan rantai (Chaining) data dalam tabel hash dibentuk secara dinamis dengan menggunakan senarai berantai

3. Teknik Pengalamatan Buket mirip dengan pembentukan rantai , namun tabrakan tidak ditangani dengan senarai berantai, melainkan dengan array. Buket sendiri diartikan sebagai

sebuah blok ruang memori yang cukup untuk menampung sejumlah data yang memiliki alamat

hash yang sama

O. PRAKTIK : Buatlah sebuah project yang berisi File HashLin.h, HashLin.cpp dan Main.cpp

Kode Programnya sbb :

1. HashLin.h

#ifndef HASHLINEAR_H #define HASHLINEAR_H #include #include using namespace std; class DataHash { public: int nip;


string nama; // Konstruktor DataHash(int nip, string nama); }; class HashLinear { private: vector data; // Vektor untuk tabel hash int ukuranTabel; // Ukuran data dalam vektor DataHash* ptrTerhapus; // Menunjuk ke data yang dihapus public: HashLinear(int ukuran); ~HashLinear(); int hashFunction(int nip); void insert(int nip, string nama); string find(int nip); bool remove(int nip); void display(); }; #endif // HASHLINEAR_H

2. Program HashLin.cpp

#include #include #include "HashLin.h" using namespace std; DataHash::DataHash(int nip, string nama) { DataHash::nip = nip; DataHash::nama = nama; } HashLinear::HashLinear(int ukuran) { ukuranTabel = ukuran; data.resize(ukuran); // Kosongkan tabel hash for (int i = 0; i < ukuran; i++) { HashLinear::data[i] = NULL; } // Tandai NIP dengan -1 untuk menyatakan terhapus ptrTerhapus = new DataHash(-1, ""); } HashLinear::~HashLinear() { for (int i = 0; i < ukuranTabel; i++)


{ if (data[i] != NULL) if (data[i]->nip != -1) delete data[i]; } delete ptrTerhapus; } // hasFunction (publik) Menghasilkan alamat hash berdasarkan nip int HashLinear::hashFunction(int nip) { return nip % ukuranTabel; } // insert (publik) Untuk menyisipkan data ke tabel hash void HashLinear::insert(int nip, string nama) { int alamatHash = hashFunction(nip); int i = 0; while ((data[alamatHash] != NULL) && (data[alamatHash]->nip != -1)) { if (i > ukuranTabel) break; // Keluar kalau sudah penuh // Peroleh alamat berikutnya alamatHash = (alamatHash + 1) % ukuranTabel; i++; // Untuk menghitung sampai penuh } if (i < ukuranTabel) data[alamatHash] = new DataHash(nip, nama); } // find() (publik). Mencari data. Nilai balik berupa data nama string HashLinear::find(int nip) { int alamatHash = hashFunction(nip); int i = 1; while (data[alamatHash] != NULL) { if (i > ukuranTabel) break; // Keluar kalau semua sudah dicek // Cek nilai field Nip sama dengan Nip if (data[alamatHash]->nip == nip) break; // Keluar while // Peroleh alamat berikutnya alamatHash = (alamatHash + 1) % ukuranTabel; i++; // Untuk menghitung sampai semua } if ((i


return data[alamatHash]->nama; else return ""; // Kalau tidak ditemukan } // remove (publik) false jika gagal menghapus Nip sebaliknya True bool HashLinear::remove(int nip) { int alamatHash = hashFunction(nip); int i = 1; while (data[alamatHash] != NULL) { if (i > ukuranTabel) break; // Keluar kalau semua sudah dicek // Cek nilai field Nip sama dengan Nip if (data[alamatHash]->nip == nip) { // Bebaskan memori yang digunakan untuk menyimpan data delete data[alamatHash]; // Alihkan ke pointer yang menyatakan data terhapus data[alamatHash] = ptrTerhapus; break; // Keluar while } // Peroleh alamat berikutnya alamatHash = (alamatHash + 1) % ukuranTabel; i++; // Untuk menghitung sampai semua } if ((i < ukuranTabel) && (data[alamatHash] != NULL)) return true; else return false; // gagal menghapus } // display (publik) Menampilkan isi tabel hash void HashLinear::display() { for (int i=0; i < ukuranTabel; i++) { if (data[i] == NULL) cout


Main.cpp

#include #include "HashLin.h" using namespace std; int main() { // Buat tabel hash untuk 11 data HashLinear tabel(11); // Memasukkan data ke dalam tabel hash tabel.insert(12, "Andika"); tabel.insert(13, "Ratna"); tabel.insert(16, "Dewi"); tabel.insert(17, "Ari Wardi"); tabel.insert(20, "Karmila"); cout


Referensi

1. Kristanto, A., 2003, Struktur Data dengan C++, Graha Ilmu, Yogyakarta.

2. Lafore, R., 1999, Sams Teach Yourself Data Structures and Algorithms In 24 Hours, Sams Publishing.

modul struktur data ti

Documents