PRAKTIKUM STRUKTUR DATA

Tugas SP 3

Disusun Oleh :

Nama : Jupriyanto

NIM : 07.01.53.0118

FAKULTAS TEKNOLOGI INFORMASI

UNISBANK SEMARANG
2010/2011
LINKED LIST
Operasi-Operasi yang ada pada Linked List
Insert
Istilah Insert berarti menambahkan sebuah simpul baru ke dalam suatu linked list.
IsEmpty
Fungsi ini menentukan apakah linked list kosong atau tidak.
Find First
Fungsi ini mencari elemen pertama dari linked list
Find Next
Fungsi ini mencari elemen sesudah elemen yang ditunjuk now
Retrieve
Fungsi ini mengambil elemen yang ditunjuk oleh now. Elemen tersebut lalu dikembalikan
oleh fungsi.
Update
Fungsi ini mengubah elemen yang ditunjuk oleh now dengan isi dari sesuatu
Delete Now
Fungsi ini menghapus elemen yang ditunjuk oleh now. Jika yang dihapus adalah elemen
pertama dari linked list (head), head akan berpindah ke elemen berikut.
Delete Head
Fungsi ini menghapus elemen yang ditunjuk head. Head berpindah ke elemen sesudahnya.
Clear
Fungsi ini menghapus linked list yang sudah ada. Fungsi ini wajib dilakukan bila anda ingin
mengakhiri program yang menggunakan linked list. Jika anda melakukannya, data-data yang
dialokasikan ke memori pada program sebelumnya akan tetap tertinggal di dalam memori.

Operasi-operasi untuk Stack dengan Linked List

IsEmpty
Fungsi memeriksa apakah stack yang adamasih kosong.
Push
Fungsi memasukkan elemen baru ke dalam stack. Push di sini mirip dengan insert dalam
single linked list biasa.
Pop
Fungsi ini mengeluarkan elemen teratas dari stack.
Clear
Fungsi ini akan menghapus stack yang ada.

Operasi-operasi Queue dengan Double Linked List

IsEmpty
Fungsi IsEmpty berguna untuk mengecek apakah queue masih kosong atau sudah berisi data.
Hal ini dilakukan dengan mengecek apakah head masih menunjukkan pada Null atau tidak.
Jika benar berarti queue masih kosong.
IsFull
Fungsi IsFull berguna untuk mengecek apakah queue sudah penuh atau masih bisa
menampung data dengan cara mengecek apakah Jumlah Queue sudah sama dengan
MAX_QUEUE atau belum. Jika benar maka queue sudah penuh.
EnQueue
Fungsi EnQueue berguna untuk memasukkan sebuah elemen ke dalam queue (head dan tail
mula-mula meunjukkan ke NULL).
DeQueue
Procedure DeQueue berguna untuk mengambil sebuah elemen dari queue. Hal ini dilakukan
dengan cara menghapus satu simpul yang terletak paling depan (head).

Single Linked List Circular

Single Linked List Circular (SLLC) adalah Single Linked List yang pointer nextnya
menunjuk pada dirinya sendiri. Jika Single Linked List tersebut terdiri dari beberapa node,
maka pointer next pada node terakhir akan menunjuk ke node terdepannya.

Pengertian:
Node : rangkaian beberapa simpul
Single : artinya field pointer-nya hanya satu buah saja dan satu arah.
Linked List : artinya node-node tersebut saling terhubung satu sama lain.
Circular : artinya pointer next-nya akan menunjuk pada dirinya sendiri sehingga berputar

Ilustrasi SLLC
Setiap node pada linked list mempunyai field yang berisi pointer ke node berikutnya, dan
juga memiliki field yang berisi data. Pada akhir linked list, node terakhir akan menunjuk ke
node terdepan sehingga linked list tersebut berputar.

Deklarasi:
Deklarasi node dibuat dari struct berikut ini:
typedef struct TNode{
int data;
TNode *next;
};
Pembentukan node baru
Digunakan keyword new yang berarti mempersiapkan sebuah node baru
berserta alokasi memorinya.

TNode *baru;
baru = new TNode;
baru->data = databaru;
baru->next = baru;

Dibutuhkan satu buah variabel pointer: head

Head akan selalu menunjuk pada node pertama

Penambahan data di depan

Penambahan node baru akan dikaitan di node paling depan, namun pada saat pertama kali
(data masih kosong), maka penambahan data dilakukan pada head nya.
Pada prinsipnya adalah mengkaitkan data baru dengan head, kemudian head akan menunjuk
pada data baru tersebut sehingga head akan tetap selalu menjadi data terdepan. Untuk
menghubungkan node terakhir dengan node terdepan dibutuhkan pointer bantu.

HEAD Single Linked List Circular

Penambahan data di depan

Penambahan data di depan

void insertDepan(int databaru){

TNode *baru,*bantu;
baru = new TNode;
baru->data = databaru;
baru->next = baru;
if(isEmpty()==1){
head=baru;
head->next=head;
}
else {
bantu = head;
while(bantu->next!=head){
bantu=bantu->next;
}
baru->next = head;
head = baru;
bantu->next = head;
}
printf(”Data masuk\n“);
}
Penambahan data di belakang
Penambahan data dilakukan di belakang, namun pada saat pertama kali data langsung
ditunjuk pada head-nya.
Penambahan di belakang lebih sulit karena kita membutuhkan pointer bantu untuk
mengetahui data terbelakang, kemudian dikaitkan dengan data baru. Untuk mengetahui data
terbelakang perlu digunakan perulangan.
Penambahan data di belakang

void insertBelakang (int databaru){

TNode *baru,*bantu;
baru = new TNode;
baru->data = databaru;
baru->next = baru;
if(isEmpty()==1){
head=baru;
head->next=head;
}
else {
bantu = head;
while(bantu->next != head){
bantu=bantu->next;
}
bantu->next = baru;
baru->next = head;
}
printf(”Data masuk\n“);
}

Operasi Penghapusan

Penghapusan node dilakukan dengan memutus rantai node kemudian menghapus node. Jika
node berada di tengah rangkaian, rangkaian yang terputus perlu disambung kembali. Untuk
memudahkan penghapusan simpul dibutuhkan dua cursor sebagai simpul bantu. Selain cursor
juga dibutuhkan simpul head sebagai acuan awal simpul dalam rangkaian.

Berikut langkah langkah untuk menghapus simpul dalam rangkaian:

• Buat cursor bantu yang menunjuk ke awal node(simpul).

• Pindahkan cursor ke node berikutnya
• Putus sambungan awal node dengan node berikutnya.
• Hapus rangkaian
• Jika berada di akhir rangkaian, putuskan dari rangkaian sebelumnya
• Jika di tengah rangkaian, pindahkan penunjukan node berikutnya, atau di akhir, atau
setelah node yang akan dihapus

Ilustrasi Hapus Depan

Ilustrasi Hapus Depan

void hapusDepan (){

TNode *hapus,*bantu;
if (isEmpty()==0){
int d;
hapus = head;
d = head->data;
if(head->next != head){
bantu = head;
while(bantu->next!=head){
bantu=bantu->next;
}
head = head->next;
delete hapus;
bantu->next = head;
}else{
head=NULL;
}
printf(“%d terhapus\n“,d);
} else printf(”Masih kosong\n“);
}

Ilustrasi Hapus Belakang

Ilustrasi Hapus Belakang

void hapusBelakang(){
TNode *hapus,*bantu;
if (isEmpty()==0){
int d;
hapus = head;
if(head->next == head){
head = NULL;
}else{
bantu = head;
while(bantu->next->next != head){
bantu = bantu->next;
}
hapus = bantu->next;
d = bantu->data;
bantu->next = head;
delete hapus;
}
printf(“%d terhapus\n“,d);
} else printf(”Masih kosong\n“);
}

Contoh Coding Stack Dengan Linked List

#include
#include

/* membuat linked list */

typedef struct myLinkedList {
char nim[10];
char nama[35];
int nilai;

myLinkedList *next;
};
myLinkedList *head;

/* keadaan awal */
void init() {
head = NULL;
}

/* fungsi untuk mengecek linked list

* apakah kosong atau tidak
* jika kosong maka bernilai 1
* jika tidak kosong maka bernilai 0
*/
int paKosong() {
if (head == NULL) return 1;
else return 0;
}

/**
* fungsi untuk menambahkan data dari depan node
*/
void tambahDepan() {

myLinkedList *baru;
baru = new myLinkedList;

cout << “Masukkan Data lengkap di bawah ini : ” <<>> baru->nim;

cout << “Nama : “; cin >> baru->nama;
cout << “Nilai : “; cin >> baru->nilai;

baru->next = NULL;

if (paKosong() == 1) {
head = baru;
head->next = NULL;
} else {
baru->next = head;
head = baru;
}
}
/**
* fungsu untuk menambahkan data dari depan node
*/

void tambahBelakang() {

myLinkedList *baru, *bantu;

baru = new myLinkedList;
cout << “Masukkan Data lengkap di bawah ini : ” <<>> baru->nim;
cout << “Nama : “; cin >> baru->nama;
cout << “Nilai : “; cin >> baru->nilai;

baru->next = NULL;

if (paKosong() == 1) {
head = baru;
head->next = NULL;
} else {
bantu = head;
while (bantu->next != NULL) {
bantu = bantu->next;

}
bantu->next = baru;
}
}

/**
* fungsi untuk menghapus dari depan node
*/
void hapusDepan() {
myLinkedList *hapus;
char *data;
if (paKosong() == 0) {
if (head->next != NULL) {
hapus = head;
data = hapus->nim;
head = head->next;
delete hapus;
} else {
data = head->nim;
head = NULL;
}

cout <<>

/**
* fungsi untuk menghapus dari belakang node
*/
void hapusBelakang() {
myLinkedList *hapus, *bantu;
char *data;
if (paKosong() == 0) {
if (head->next != NULL) {
bantu = head;
while(bantu->next->next != NULL) {
bantu = bantu->next;
}
hapus = bantu->next;
data = hapus->nim;
bantu->next = NULL;
delete hapus;
} else {
data = head->nim;
head = NULL;
}
cout <<>

cout << “Tekan Enter untuk kembali ke Menu!”; getch(); }

/**
* fungsi untuk menampilkan data linked list
*/

void tampilData() {
int no = 1;

myLinkedList *bantu;
bantu = head;
if (paKosong() == 0) {
while (bantu != NULL) {
cout << “No. : ” <<>nim <<>nama <<>nilai <<>

no++;
bantu = bantu->next;
}
cout <<>

} else {
cout << “Data masih kosong ” <<>

/**
* fungsi Menu, Untuk menentukan linked list mana
* yang dipilih
*/
int menu() {
int pilihan;

cout << “+———————-+\n”; cout << “| MENU PILIHAN |\n”; cout << “+
———————-+\n”; cout << “| 1. Tambah Depan |\n”; cout << “| 2. Tambah Belakang
|\n”; cout << “| 3. Hapus Depan |\n”; cout << “| 4. Hapus Belakang |\n”; cout << “| 5. Tambah
Tengah |\n”; cout << “| 6. Hapus Tengah |\n”; cout << “| 7. TampilData |\n”; cout << “| 8.
Keluar |\n”; cout << “+———————-+\n”; cout << “| PILIHAN ANDA ? [ ] |\n”; cout <<
“+———————-+\n”;

cin >> pilihan;

return pilihan;
}
/**
* fungsi operasi data
*/
void operasiData() {
int pilih;

do {
pilih = menu();

switch (pilih) {
case 1 :
tambahDepan();
break;
case 2 :
tambahBelakang();
break;
case 3 :
hapusDepan();
break;

case 4 :
hapusBelakang();
break;
case 5 :
tampilData();
break;
case 6:

cout << “Terima kasih coy!!!”; break; } } while (pilih != 6); }

/**
* PROGRAM UTAMA
*/
void main() {
init();
operasiData();
}

Setelah diCompile, maka akan menghasilkan tampilan:

___________________________________________________________________________

#include <iostream.h>
#include <conio.h>
int data[100],data2[100];
int n;

void tukar(int a,int b)

{
int t;
t = data[b];
data[b] = data[a];
data[a] = t;
}

void bubble_sort()
{
for(int i=1;i<n;i++)
{
for(int j=n-1;j>=i;j–)
{
if(data[j]<data[j-1]) tukar(j,j-1);
}
}
cout<<”bubble sort selesai!”<<endl;
}

void exchange_sort()
{
for (int i=0; i<n-1; i++)
{
for(int j = (i+1); j<n; j++)
{
if (data [i] > data[j]) tukar(i,j);
}
}
cout<<”exchange sort selesai!”<<endl;
}

void selection_sort()
{
int pos,i,j;
for(i=0;i<n-1;i++)
{
pos = i;
for(j = i+1;j<n;j++)
{
if(data[j] < data[pos]) pos = j;
}
if(pos != i) tukar(pos,i);
}
cout<<”selection sort selesai!”<<endl;
}
void insertion_sort()
{
int temp,i,j;
for(i=1;i<n;i++)
{
temp = data[i];
j = i -1;
while(data[j]>temp && j>=0)
{
data[j+1] = data[j];
j–;
}
data[j+1] = temp;
}
cout<<”insertion sort selesai!”<<endl;
}

void QuickSort(int L, int R) //the best sort i’ve ever had

{
int i, j;
int mid;

i = L;
j = R;
mid = data[(L+R) / 2];

do
{
while (data[i] < mid) i++;
while (data[j] > mid) j–;

if (i <= j)
{
tukar(i,j);
i++;
j–;
};
} while (i < j);

if (L < j) QuickSort(L, j);

if (i < R) QuickSort(i, R);
}

void Input()
{
cout<<”Masukkan jumlah data = “; cin>>n;
for(int i=0;i<n;i++)
{
cout<<”Masukkan data ke-”<<(i+1)<<” = “; cin>>data[i];
data2[i] = data[i];
}
}

void Tampil()
{
cout<<”Data : “<<endl;
for(int i=0;i<n;i++)
{
cout<<data[i]<<” “;
}
cout<<endl;
}

void AcakLagi()
{
for(int i=0;i<n;i++)
{
data[i] = data2[i];
}
cout<<”Data sudah teracak!”<<endl;
}

void main()
{
int pil;
clrscr();
do
{
clrscr();
cout<<”Program Sorting Komplit!!!”<<endl;
cout<<”*********************************************”<<endl;
cout<<” 1. Input Data”<<endl;
cout<<” 2. Bubble Sort”<<endl;
cout<<” 3. Exchange Sort”<<endl;
cout<<” 4. Selection Sort”<<endl;
cout<<” 5. Insertion Sort”<<endl;
cout<<” 6. Quick Sort”<<endl;
cout<<” 7. Tampilkan Data”<<endl;
cout<<” 8. Acak Data”<<endl;
cout<<” 9. Exit”<<endl;
cout<<” Pilihan Anda = “; cin>>pil;
switch(pil)
{
case 1:Input(); break;
case 2:bubble_sort(); break;
case 3:exchange_sort(); break;
case 4:selection_sort(); break;
case 5:insertion_sort(); break;
case 6:QuickSort(0,n-1);
cout<<”quick sort selesai!”<<endl;
break;
case 7:Tampil(); break;
case 8:AcakLagi(); break;
}
getch();
}while(pil!=9);
}

contoh program searching (binary) pada c++ :

#include<iostream.h>
#include<conio.h>

int data[10] = {1,3,4,7,12,25,40,65,78,90}; //variabel global

int binary_search(int cari)

{
int l,r,m;
int n = 10;
l = 0;
r = n-1;
int ketemu = 0;
while(l<=r && ketemu==0)
{
m = (l+r)/2;
if( data[m] == cari )
ketemu = 1;
else
if (cari < data[m])
r = m-1;
else l = m+1;
}
if(ketemu == 1) return 1; else return 0;
}

void main()
{
clrscr();
int cari,hasil;
cout<<”masukkan data yang ingin dicari = “;
cin>>cari;
hasil = binary_search(cari);
if(hasil == 1)
{
cout<<”Data ada!”<<endl;
}
else
if(hasil == 0)
cout<<”Data Tidak ada!”<<endl;
getch();
}

contoh program searching (sequential) pada c++ :

#include <iostream.h>
#include <conio.h>
void main()
{
clrscr();
int data[8] = {8,10,6,-2,10,7,1,100};
int cari,index;
int ketemu=0;
cout<<”masukkan data yang ingin dicari = “;
cin>>cari;
for(int i=0;i<8;i++)
{
if(data[i] == cari)
{
ketemu=1;
index = i;
break;
}
}
if(ketemu == 1)
{
cout<<”Data ada!”<<endl;
cout<<”Data terletak di index ke – “<<index;
}
else cout<<”Data Tidak ada!”<<endl;
getch();
}