Akhmad Fauzi R_Rangkuman dan Kesimpulan pertemuan 12

PERTEMUAN XII

STACK ( LANJUT )

TEORI DASAR 

a) Pendahuluan

Stack atau tumpukan adalah kumpulan elemen yang hanya dapat di tambah atau di hapus dari satu ujung ( gerbang ) yang sama. Hal ini menunjukan bahwa seolah olah suatu elemen di letakan di atas elemen yang lain. Yang memberi gambaran bahwa stack mempunyai sifat LIFO ( Last In Firs Out ) yang berarti bahwa yang terakhir masuk akan pertama keluar.

Representasi Stack dapat di lakukan menggunakan Array atau Linked List. Kedua representasi mempunyai keunggulan dan kelemahan masing masing. Representasi Stack dengan Array dapat di lakukan dengan asumsi bahwa elemen maksimal suatu stack tidak boleh melebihi maksimum banyak elemen atau ukuran Array.

Beberapa contoh aplikasi yang menerapkan stack, diantaranya adalah:
- Expression evaluation, baik ekspresi aritmatika, lojik maupun boolean.
- Notasi infix, prefix, dan postfix, proses perhitungannya maupun konversi antar notasi tersebut.
- Backtracking, contohnya history call pada browser (tombol back).
- Membantu penelusuran simpul pohon dengan algoritma DFS (Depth-First-Search).
- Manajemen memori dan alokasi memori, komputer modern saat ini menerapkan stack untuk memodelkan manajemen memori dari program yang sedang berjalan (running program).
- Permainan Tower of Hanoi.
- Konversi bilangan desimal ke binner.
- Sampai yang paling sederhana yaitu membalikkan urutan string.

Program STACK menggunakan Singly Linked List :

#include<stdio.h>

#include<stdlib.h>

using namespace std;

typedef int ItemType;

typedef struct simpul node;

struct simpul

{

ItemType item;

node *next;

};

struct Stack{

node *TOS;

};

node *baru;

void awal()

{

puts("===================================================");

puts("=         PROGRAM STACK DENGAN LINKED LIST        =");

puts("===================================================\n");

puts("NIM   :  181011401940");

puts("Nama   :  Akhmad Fauzi R");

puts("Fakultas  :  Teknik Informatika\n");

}

void allocate_node(ItemType x)

{

baru = (node *) malloc (sizeof(node));

if(baru==NULL)

{

printf("Alokasi Gagal\n");

exit(1);

}

else

{

baru->item=x;

baru->next=NULL;

}

}

void inisialisasi(Stack *s)

{

s->TOS = NULL;

}

int kosong(Stack *s)

{

return s->TOS==NULL;

}

void push(Stack *s)

{

baru->next = s->TOS;

s->TOS = baru;

}

ItemType pop(Stack *s)

{

node *temp;

if(kosong(s))

{

printf("Data Kosong\n");

return ' ';

}

else

{

temp = s->TOS;

s->TOS = s->TOS->next;

return temp->item;

free(temp);

temp=NULL;

}

}

void tampil(Stack *s)

{

Stack bantu;

bantu = *s;

printf("\nData Simpul ==>  ");

while(bantu.TOS!=NULL)

{

printf("%d ", bantu.TOS->item);

bantu.TOS = bantu.TOS->next;

}

printf("\n\n");

}

main()

{

int pilih, data;

char lagi='y';

Stack ujung;

inisialisasi(&ujung);

while(lagi=='y')

{

system("CLS");

awal();

//tampil(&ujung);

printf("Menu Pilihan : \n");

printf("1. Push\n");

printf("2. Pop\n");

printf("3. Tampilkan Stack\n");

printf("\nPilih No          : ");

scanf("%d", &pilih);

switch(pilih)

{

case 1:

printf("Masukkan data     : ");

scanf("%d", &data);

allocate_node(data);

push(&ujung);

break;

case 2:

pop(&ujung);

break;

case 3:

tampil(&ujung);

break;

}

fflush(stdin);

printf("Lagi (y/t) ? ");

scanf("%c", &lagi);

}

}

KESIMPULAN 

Stack atau tumpukan adalah elemen yang hanya dapat ditambangkan atau dikurangkan dari 1 buah pintu yang sama. Pada bab ini stack dilakukan menggunakan array atau single llinked list, dimana cara ini memliki kekurangan dan kelebihannya sendiri. Representasi stack dan single linked list dapat dilakukan dengan asumsi elemen stack tidak boleh lebih dari batas maksimum ukuran array.