Stack merupakan bentuk khusus dari suatu struktur data, dimana node yang ditambahkan ke dalam list dan diambil dari list hanya pada kepalanya, atau dengan prinsip pengolahannya adalah last-in first-out (LIFO). Pada struktur ini hanya ada dua fungsi utama, yaitu push (memasukkan node ke dalam stack), dan pop (mengambil node dari stack).
PENGERTIAN TUMPUKAN
Secara sederhana tumpukan bisa diartikan sebagai kumpulan data yang seolah-olah diletakkan di atas data yang lain. Dalam suatu tumpukan akan dapat dilakukan operasi penambahan (penyisipan) dan pengambilan (penghapusan) data melalui ujung yang sama, ujung ini merupakan ujung atas tumpukan.
Contoh Kasus :
Terdapat dua buah kotak yang ditumpuk, kotak yang satu akan ditumpuk diatas kotak yang lainnya. Jika kemudian tumpukan 2 kotak tadi, ditambah kotak ketiga, keempat, kelima, dan seterusnya, maka akan diperoleh sebuah tumpukan kotak yang terdiri dari N kotak.
F | ATAS |
E | |
D | |
C | |
B | |
A | BAWAH |
Dapat dilihat bahwa kotak B terletak diatas kotak A dan ada dibawah kotak C. Berdasarkan pada tumpukan tersebut dapat disimpulkan bahwa penambahan dan pengambilan sebuah kotak hanya dapat dilakukan dengan melewati satu ujung saja, yaitu bagian atas.
Kotak F adalah kotak paling atas sehingga jika ada kotak lain yang akan disisipkan maka kotak tersebut akan diletakkan pada posisi paling atas (diatas kotak F). Demikian juga pada saat pengambilan kotak, kotak F akan diambil pertama kali.
menyisipkan menghapus
F | ATAS |
E | |
D | |
C | |
B | |
A | BAWAH |
OPERASI PADA TUMPUKAN
Ada 2 operasi dasar yang bisa dilaksanakan pada sebuah tumpukan, yaitu :
· Menyisipkan data (push)
· Menghapus data (pop)
Operasi Push
Perintah push digunakan untuk memasukkan data ke dalam tumpukan.
Push (34)
34 | ||
9 | 9 | |
25 | 25 | |
3 | 3 |
Contoh :
void Push (NOD **T, char item)
{
NOD *n;
n=NodBaru (item);
n->next=*T;
*T=n;
}
Operasi Pop
Operasi pop adalah operasi untuk menghapus elemen yang terletak pada posisi paling atas dari sebuah tumpukan.
Contoh :
char Pop (NOD **T)
{
NOD *n; char item;
if (!TumpukanKosong(*T)) {
P=*T;
*T=(*T)->next;
item=P->data;
free(P);
}
return item;
}
Untuk dapat mengetahui kosong tidaknya suatu tumpukan adalah dengan suatu fungsi yang menghasilkan suatu data bertipe boolean.
Contoh :
BOOL TumpukanKosong (NOD *T)
{
return ((BOOL) (T==NULL));
}
PEMANFAATAN TUMPUKAN
Pemanfaatan tumpukan antara lain untuk menulis ungkapan dengan menggunakan notasi tertentu.
Contoh :
( A + B ) * ( C – D )
Tanda kurung selalu digunakan dalam penulisan ungkapan numeris untuk mengelompokkan bagian mana yang akan dikerjakan terlebih dahulu.
Dari contoh ( A + B ) akan dikerjakan terlebih dahulu, kemudian baru ( C – D ) dan terakhir hasilnya akan dikalikan.
A + B * C – D
B * C akan dikerjakan terlebih dahulu, hasil yang didapat akan berbeda dengan hasil notasi dengan tanda kurung.
Notasi Infix Prefix
Cara penulisan ungkapan yaitu dengan menggunakan notasi infix, yang artinya operator ditulis diantara 2 operator.
Seorang ahli matematika bernama Jan Lukasiewiccz mengembangkan suatu cara penulisan ungkapan numeris yang disebut prefix, yang artinya operator ditulis sebelum kedua operand yang akan disajikan.
Contoh :
Infix | Prefix |
A + B | + A B |
A + B – C | - + A B C |
( A + B ) * ( C – D ) | * + A B – C D |
Proses konversi dari infix ke prefix :
= ( A + B ) * ( C – D )
= [ + A B ] * [ - C D ]
= * [ + A B ] [ - C D ]
= * + A B - C D
Notasi Infix Postfix
Cara penulisan ungkapan yaitu dengan menggunakan notasi postfix, yang artinya operator ditulis sesudah operand.
Contoh :
Infix | Postfix |
16 / 2 | 16 2 / |
( 2 + 14 ) * 5 | 2 14 + 5 * |
2 + 14 * 5 | 2 14 5 * + |
( 6 – 2 ) * ( 5 + 4 ) | 6 2 – 5 4 + * |
Proses konversi dari infix ke postfix :
= ( 6 - 2 ) * ( 5 + 4 )
= [ 6 2 - ] * [ 5 4 + ]
= [ 6 2 - ] [ 5 4 + ] *
= 6 2 - 5 4 + *
Contoh :
Penggunaan notasi postfix dalam tumpukan, misal : 2 14 + 5 * = 80
push 2 | pop 14 | push 5 | pop 5 | pop 80 | ||||||
push 14 | pop 2 | pop 16 | ||||||||
push 2 + 14 | push 16 * 5 | |||||||||
14 | 5 | |||||||||
2 | 16 | 16 | 80 | |||||||
CONTOH SOAL :
Buatlah program untuk memasukkan node baru ke dalam tumpukan.
//Program : stack1.cpp
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
typedef enum { FALSE = 0, TRUE = 1} BOOL;
struct nod {
char data;
struct nod *next;
};
typedef struct nod NOD;
BOOL TumpukanKosong(NOD *T) // Uji tumpukan kosong
{
return ((BOOL)(T == NULL));
}
NOD *NodBaru (char item) //Ciptakan Node Baru
{
NOD *n;
n = (NOD*) malloc(sizeof(NOD));
if(n != NULL) {
n->data = item;
n->next = NULL;
}
return n;
}
void CiptaTumpukan (NOD **T)
{
*T = NULL; // Sediakan tumpukan Kosong
}
void Push(NOD **T, char item) // Push
{
NOD *n;
n = NodBaru(item);
n->next = *T;
*T = n;
}
char Pop(NOD **T) // Pop
{
NOD *P; char item;
if ( ! TumpukanKosong(*T)) {
P = *T;
*T = (*T)->next;
item = P->data;
free(P);
}
return item;
}
void CetakTumpukan (NOD *T)
{
NOD *p;
printf("T --> ");
for (p = T; p != NULL; p = p->next) {
printf("[%c] --> ", p->data); }
printf("NULL\n");
}
int main()
{
NOD *T;
CiptaTumpukan(&T);
Push(&T, 'I');
Push(&T, 'D');
Push(&T, 'E');
CetakTumpukan(T);
return 0;
}
Bila program tersebut dijalankan maka :
T -> [E] -> [D] -> [I] -> NULL
Soal 2
Buatlah program untuk menampilkan kode pos (zip code) dari suatu negara bagian dan kota dan semua informasi tersebut dimasukkan ke dalam sebuah tumpukan. Apabila tidak ada keterangan yang dimasukkan berarti tumpukan kosong. Tekan q jika akan keluar.
//Program:stack2.cpp
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <io.h>
#define MAX_CITY 30
#define MAX_STATE 30
#define MAX_ZIP 5
void main (void);
int is_empty (struct node *);
int push (struct node **);
int pop (struct node **);
void search (struct node **);
void free_nodes (struct node **pstack);
struct node {
char zip_code[MAX_ZIP+1];
char city[MAX_CITY];
char state[MAX_STATE];
struct node *link;
};
void main (void)
{
struct node *pstack = NULL;
int ok_so_far = 1, no_of_nodes = 0;
while (ok_so_far == 1) {
ok_so_far = push(&pstack);
if (ok_so_far == 1)
no_of_nodes ++;
else if(ok_so_far == 0) {
puts("\nAn unexpected error has occurred - terminating program");
exit(1); //Abort program
}
}
search (&pstack); //search linked list
free_nodes(&pstack); //release memory back to OS when done
}
int push(struct node **pstack)
{
struct node *new_ptr; //pointer for new struct
new_ptr = (struct node *) malloc(sizeof(struct node)); //memory for new node
if(new_ptr == (struct node *) NULL) //if malloc returns NULL
{
printf("ERROR! Unable to allocate memory - Abort\n");
free(new_ptr);
return (0); //return 0 so calling function knows an error occurred
}
else
{
printf("\n\nEnter %d digit zip code or 'q' to quit>>", MAX_ZIP);
gets(new_ptr->zip_code); //input zip code
new_ptr->zip_code[MAX_ZIP] = '\0'; //NULL to 6th char in zip_code
if (strcmp(new_ptr->zip_code, "q") != 0) {
printf("\nEnter a less than %d character state name>>\n", MAX_STATE);
gets(new_ptr->state); //input state
printf("\nEnter a less than %d character city name>>\n", MAX_CITY);
gets(new_ptr->city); //input city
new_ptr->link = *pstack;
*pstack = new_ptr;
return (1); //return 1 so calling func will continue to loop
}
else return (2); //return 2 so calling func to stop looping
}
}
void search (struct node **pstack)
{
struct node *ptemp;
int test = 0;
char ch, find[6];
ptemp = *pstack;
printf("\n\nEnter %d digit zip code to search for \nor 'e' to print entire list>>", MAX_ZIP);
gets(find); //input zip code
find[MAX_ZIP] = '\0'; //assign NULL to 6th char in find array
if (find[0] =='E' || find[0] =='e') //if user wants to view entire list
{
test = 1;
while (test != 0) //while stack is not empty print
test = pop (pstack); //info from stack and free nodes
}
else //otherwise search for zip code
{
while (test == 0 || ptemp != NULL) //while not found nor at the end of list
{
if (strcmp(ptemp->zip_code, find) == 0)
{
test = 1;
printf("Zip Code: %s\n", ptemp->zip_code);
printf("State: %s\n", ptemp->state);
printf("City: %s\n\n", ptemp->city);
}
else if (ptemp == NULL)
{
printf("The zip code %s was not found.\n", find);
test = 1;
}
ptemp = ptemp->link;
}
puts ("\nType 'y' if you would you like to see the entire list");
puts ("or any other key to continue>>");
if (ch == 'y' || ch == 'Y')
{
test = 1;
while (test != 0)
test = pop (pstack);
}
}
}
int pop (struct node **pstack)
{
struct node *temp;
if (is_empty(*pstack)== 1)
{
printf("\nStack is now empty");
return(0);
}
else
{
temp = *pstack;
printf("Zip Code: %s\n", temp->zip_code);
printf("State: %s\n", temp->state);
printf("City: %s\n\n", temp->city);
*pstack = (*pstack)->link;
free(temp);
return(1);
}
}
int is_empty (struct node *stack) //test if stack points to NULL
{
if (stack == NULL)
return(1); //if stack does point to NULL return 1 or true
return(0); //othrewise stack is not empty
}
void free_nodes (struct node **pstack)
{
struct node *temp; //temp pointer used for free()ing memory
while (*pstack != NULL)
{
temp = *pstack;
*pstack = (*pstack)->link;
free(temp); //release popped node's memory back to Operating System
}
}
Tidak ada komentar:
Posting Komentar