STRUKTUR DATA & ALGORITMA LANJUT

(TUGAS I – Linked List)

Untuk memenuhi tugas Struktur Data & Algoritma Lanjut

di Jurusan Teknik Informatika

Disusun oleh :
(0609U094) Azis Sugianto S
Kelas C

Dosen:
Abdulah Fajar

Jurusan Teknik Informatika – Universitas Widyatama

Bandung
2010
 1. Stack menggunakan array.
 Source code:
#include "stdio.h"
#include "conio.h"
#include "stdlib.h"
#include "iostream.h"
#include "string.h"
typedef struct STACK {char data;int atas;}tumpukan;
STACK tumpuk [99];
int main()
{
int pilihan, i, x;
char baru;
x = -1;
do
{
printf("==================================================\n");
printf(" M E N U U T A M A \n");
printf("==================================================\n");
printf("Tekan [1] untuk input data (PUSH)\n");
printf("Tekan [2] untuk hapus data (POP)\n");
printf("Tekan [3] untuk lihat data (VIEW)\n");
printf("==================================================\n");
printf("Silahkan Masukan Pilihan Anda : ");scanf("%d", &pilihan);
printf("==================================================\n");
switch (pilihan)
{
case 1:
{
if(x == 6)
{
printf("Tumpukan Penuh\n");

printf("==================================================\n\n");
getch ();
}
else
{
printf("Data yang akan di Push = ");cin >> baru;

printf("\n==================================================\n\n");
x++;
tumpuk[x].data = baru;
}
system("cls");
printf("\a");
break;
}
case 2:
{
if (x == -1)
{
printf("Tumpukan Kosong\n");

printf("==================================================\n\n");
getch();
}
else
{
printf("Data yang akan di Pop = %c\n", tumpuk[x].data);

printf("==================================================\n\n");
 x--;
getch();
}
system("cls");printf("\a");
break;
}
case 3:
{
if(x == -1)
{
printf("Tumpukan Kosong\n");

printf("==================================================\n\n");
getch();
}
else
{
printf("Data yang ada ditumpukan adalah : \n");
for(i=x; i>=0;i--)
{
printf("\t\t|%c|\n", tumpuk[i].data);
}

printf("==================================================\n\n");
getch();
}
system("cls");printf("\a");
break;
}
case 4:
{
main();
}
default :
{
printf("\nTidak ada dalam pilihan");
}
}
}while(pilihan >=1 && pilihan <= 3);
getch();
}

2. Perbedaan Stack menggunakan array dan menggunakan linked list ?

Jawab :
 Stack Menggunakan array :
- Stack atau tumpukan adalah suatu stuktur data yang penting dalam
pemrograman
- Bersifat LIFO (Last In First Out)
- Benda yang terakhir masuk ke dalam stack akan menjadi benda
pertama yang dikeluarkan dari stack
 - Contohnya, karena kita menumpuk Compo di posisi terakhir, maka
Compo akan menjadi elemen teratas dalam tumpukan. Sebaliknya,
karena kita menumpuk Televisi pada saat pertama kali, maka
elemen Televisi menjadi elemen terbawah dari tumpukan. Dan jika
kita mengambil elemen dari tumpukan, maka secara otomatis akan
terambil elemen teratas, yaitu Compo juga.

Operasi-operasi/fungsi Stack

Push : digunakan untuk menambah item pada stack pada tumpukan

paling atas

Pop : digunakan untuk mengambil item pada stack pada tumpukan

paling atas

Clear : digunakan untuk mengosongkan stack

IsEmpty : fungsi yang digunakan untuk mengecek apakah stack sudah

kosong

IsFull : fungsi yang digunakan untuk mengecek apakah stack sudah

penuh

Stack with Array of Struct

- Definisikan Stack dengan menggunakan struct

- Definisikan MAX_STACK untuk maksimum isi stack
- Buatlah variabel array data sebagai implementasi stack secara
nyata
- Deklarasikan operasi-operasi/function di atas dan buat
implemetasinya

 Stack Menggunakan Linked List

Keunggulannya dibandingkan array adalah penggunaan alokasi

memori yang dinamis sehingga menghindari pemborosan memori.
 Misalnya pada stack dengan array disediakan tempat untuk stack
berisi 150 elemen, sementara ketika dipakai oleh user stack hanya diisi 50
elemen, maka telah terjadi pemborosan memori untuk sisa 100 elemen, yang
tak terpakai. Dengan penggunaan linked list maka tempat yang disediakan
akan sesuai dengan banyaknya elemen yang mengisi stack.

Dalam stack dengan linked list tidak ada istilah full, sebab biasanya
program tidak menentukan jumlah elemen stack yang mungkin ada (kecuali
jika sudah dibatasi oleh pembuatnya). Namun demikian sebenarnya stack ini
pun memiliki batas kapasitas, yakni dibatasi oleh jumlah memori yang
tersedia.

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.

Tabel bawah ini adalah perbandingan dari stack menggunakan array dan stack
menggunakan linked list.

Stack Dengan Linked List Stack Dengan Array

operasi : create()

procedure create; procedure create;

begin begin
top := nil ; top := 0;

end; end;

operasi : empty()

function empty : boolean; function empty : boolean;

begin begin

empty := false ; empty := false ;

if top = nil then empty := true ; if top = 0 then empty := true ;

end; end;

operasi : full()

tidak ada istilah full pada stack. function full : boolean;

program tidak menentukan jumlah begin

elemen stack yang mungkin ada.
kecuali dibatasi oleh pembuat full := false ;
program dan jumlah memory yang if top = max then full := true ;
tersedia. tempat akan sesuai
dengan banyaknya elemen yang end;
mengisi stack.

operasi : push()

procedure push (elemen : procedure push (elemen : typedata) ;

typedata) ;
begin
var now:point ;
if not full then
begin
begin
now(now) ;
top := top + 1 ;
now^.isi := elemen ;
stack [top] := elemen ;
if empty then
end;
now^.next := nil ;
end;
else
now^.next := top ;

top := now ;

end;

operasi : pop()

procedure pop (var elemen : procedure pop (elemen : typedata) ;

typedata) ;
begin
var now:point ;
if not empty then
begin
begin
if not empty then
elemen := stack [top] ;
begin
top := top – 1 ;
elemen := now^.isi ;
end;
now := top ;
end;
top := top^.next ;

dispose(now) ;

end;

end;

operasi : clear

procedure clear ; procedure clear ;

var trash : typedata ; begin

begin top := 0 ;

while not empty do pop(trash) ; end;

end;