im. karo karo's blog · 2019. 5. 17. · created date: 5/12/2019 7:23:09 pm

STACK AND QUEUE

Required Reading

• Baca:– Textbook A Chapter 6, 7, 13, 14– Textbook B Chapter 4.3 - 4.4, 11

Stack

• Stack: list yang spesial– list memperbolehkan user unt memanipulasi

(retrieve, insert, remove) item pada semua posisi

dalam urutan itemdalam urutan item

– pada kasus tertentu, ingin membatasi posisi• misal posisi awal atau akhir

• Stack:– hanya manipulasi posisi akhir yang diperbolehkan

Stack

• Contoh sehari-hari:– stack buku, stack piring– buku/piring lebih mudah ditambah/diambil dari atas

• Stack = LIFO (Last In First Out)• Stack = LIFO (Last In First Out)– item terakhir masuk, item yg pertama keluar

• Operasi pada stack:– Push: menambah item pada atas stack– Pop: mengambil item dari atas stack– Top: melihat item di atas stack (tanpa mengambil)

Operasi Pada Stack

Top dari stack

dapat diakses

Bottom dari

stack tidak

dapat diakses

Operasi Pada Stack

Top dari stack

dapat diakses

Bottom dari

stack tidak

dapat diakses

Push buku baru

pada top

Operasi Pada Stack

Top dari stack

dapat diakses

Bottom dari

stack tidak

dapat diakses

Push buku baru

pada top

Pop sebuah

buku dari top

Spesifikasi ADT Stacktemplate

class Stack {

public:

Stack();

bool isEmpty() const;

int size() const;int size() const;

void push(const T& newItem);

void pop();

void pop(T& stackTop);

void top(T& stackTop) const;

private:

};

Implementasi ADT Stack

• Ada beberapa cara implementasi ADT Stack, akan dibahas:

– Implementasi Array– Implementasi Linked List– Implementasi Linked List– Implementasi STL Vector– STL Stack

• Pelajari pro dan cons setiap implementasi

Implementasi ADT Stack dgn Array

[0] [1] [2] [m-1][3] [4]

• Push / Pop dari depan array atau belakang array?

...

Implementasi ADT Stack dgn Array

• Push / Pop dari depan array atau belakangarray?

[0] [1] [2] [m-1][3] [4]

...

a1

[0] [1] [2] [m-1]

a2

x

...a3 a4

[3] [4] [5]

xa2

xpush(x) pop(x)

Implementasi ADT Stack dgn Linked List

• Karakteristik singly linked list:– manipulasi efisien pada node pertama

• ada pointer head langsung menunjuk padanya• tidak perlu menjelajahi list

– manipulasi lokasi lain dimungkinkannamun harus jelajahi list dahulu, kurang efisien

manipulasi lokasi lain dimungkinkan• namun harus jelajahi list dahulu, kurang efisien

• Dengan demikian, cara terbaik dlm menggunakanlinked list:– jadikan node pertama sebagai top dari stack

• Bagaimana dengan variasi linked list lain?

Push

• Masukkan node baru pada head linked list

...

Top

_head

Push

• Masukkan node baru pada head linked list

_head

item baru

Top

...

arah pertumbuhan stack

Pop

• Keluarkan node pada head linked list

_head

Top

...

Pop

• Keluarkan node pada head linked list

_head

...

Top

arah penyusutan stack

template class Stack {public:

Stack();~Stack();bool isEmpty() const;int size() const;void push(const T& newItem);void pop();

Spesifikasi ADT Stack dgn Linked List StackLL.h

void pop();void pop(T& stackTop);void top(T& stackTop) const;

private:struct StackNode {

T item;StackNode* next;

};StackNode* _head;int _size;

};

template Stack::Stack(): _size(0), _head(NULL) { }

template Stack::~Stack(){

while(!isEmpty())pop();

}

Implementasi ADT Stack dgn Linked List StackLL.cpp (1)

destructor: pop

hingga kosong}

template bool Stack::isEmpty() const{

return _size == 0;}

template int Stack::size() const{

return _size;}

template

void Stack::push(const T& newItem)

{

StackNode* newNode = new StackNode;

newNode->item = newItem;

newNode->next = _head;

_head = newNode;

}


hanya insert pada head,

tidak perlu kasus lain

}

template

void Stack::top(T& stackTop) const

{

if(isEmpty())

throw string("stack kosong, top gagal");

else

stackTop = _head->item;

}

template

void Stack::pop(T& stackTop)

{

StackNode* delNode;

if(isEmpty())

throw string("stack kosong, pop gagal");

else

{


code unt pop tanpa

parameter mirip dgn ini

{

stackTop = _head->item;

delNode = _head;

_head = _head->next;

delNode->next = NULL;

delete delNode;

delNode = NULL;

}

}

hanya remove pada head,

tidak perlu kasus lain

ADT Stack dgn STL Vector

• STL Vector memiliki operasi:– menambah/menghapus item terakhir push_back() danpop_back() yang sangat efisien

– menggunakan iterator untuk menambah/menghapus item pada lokasi manapun, namun kurang efisienpada lokasi manapun, namun kurang efisien

• ADT Stack perlu menambah/menghapus item dari top, bukan lokasi lain

– berarti, gunakan akhir vector sebagai top dari stack

STL Stacktemplate

class stack {

public:

bool empty() const;

size_t size() const;

T& top();

void push(const T& t); void push(const T& t);

void pop();

};

• Sangat mirip dgn implementasi kita !– lihat contoh berikut untuk melihat perbedaan

pada fungsi top

Akses Elemen STL Stack

• Akses semua elemen stack dengan iterasi ?

stack s;

...

for (int i = 0; i < s.size(); i++) {

cout

#include

#include

using namespace std;

int main()

{

stack s;

s.push(5);

Contoh STL Stack

Output:s.push(5);

int &j = s.top();

s.push(3);

j++;

cout

Aplikasi Stack

• Aplikasi stack antara lain:– Bracket Matching– Tower of Hanoi– Maze Exploration– Base-N Number Conversion– Postfix Evaluation– Infix to Postfix Conversion

• Kita akan bahas tiga yang pertama, akan bahaslagi setelah kuliah minggu depan: Recursion

Bracket Matching

• Ekspresi matematis dapat menjadi cukup rumit– misal: {[x+2(i-4!)]*e^[4π/5*(φ-0.5n) ...

• Diinginkan suatu tes apakah semua tanda kurungpada ekspresi matematis berpasangan denganbenarbenar

– ( dengan )– [ dengan ]– { dengan }

• Bracket matching juga berguna bagi compiler untuk mengecek code programming

1. for setiap karakter pada input string

i. karakter bukan tanda kurung,

abaikan

ii. karakter kurung buka ( , [ , atau {

push ke dalam stack

iii. karakter kurung tutup ) , ] , atau }

Pseudocode Algoritma Bracket Matching

a. pop stack, cek hasilnya

b. if hasilnya kurung buka yang tidak sesuai dgn kurung

tutup, input bukan ekspresi yang benar, selesai

c. else lanjutkan baca karakter

2. if stack tidak kosong setelah baca seluruh input string

input bukan ekspresi yang benar, selesai

3. else stack kosong, input ekspresi benar, selesai

bool cekTandaKurung(string input){

stack s;char c;bool ok = true;for(unsigned int pos = 0;

ok && pos < input.size(); pos++){

c = input[pos];

Implementasi Bracket Matching (1)

c = input[pos];switch(c) {

case '{':s.push('}');break;

case '[':s.push(']');break;

case '(':s.push(')');break;

mengapa kita push

tanda kurung tutup

ke dalam stack ??

case '}':case ']':case ')':

if(s.empty())ok = false;

else {if(s.top() == c)

s.pop();else

kurung buka kurang

Implementasi Bracket Matching (2)

tanda kurung cocok

tanda kurung else

ok = false;}break;

}}if (s.empty() && ok)

return true;else

return false;}

tanda kurung

tidak cocok

semua tanda

kurung cocok

tanda kurung kurang

Tower of Hanoi

• Bagaimana memindahkan keping dari tiang A ke tiang B, dengan hanya menggunakan tiang C?

– hanya 1 keping setiap kali– keping harus berada di atas keping yang lebih besar

state awal

state akhir

Tower of Hanoi

• Kita belum menulis program untuk memecahkanproblem ini

– minggu depan, saat membahas recursion

• Saat ini, program unt user memainkan puzzle ini:– menyimpan informasi keberadaan setiap keping– menyimpan informasi keberadaan setiap keping– mengecek perpindahan– menampilkan state setiap waktu– operasi lainnya...

• Hanya dapat memindah keping paling atas, danmenaruhnya di atas keping lain

– sangat jelas bahwa tiap tiang adalah stack

Tower of Hanoi ToH.h

#include

using namespace std;

class ToH

{

public:

ToH(unsigned int keping = 10); ToH(unsigned int keping = 10);

bool move(int dari, int ke);

void display();

private:

stack _tiang[3];

unsigned int _keping;

};

Tower of Hanoi ToH.cpp (1)

ToH::ToH(unsigned int keping)

{

_keping = keping;

for (int i = _keping; i > 0; i--)

_tiang[0].push(i);

}}

ToH::display()

{

// coba code sendiri!

}

Tower of Hanoi ToH.cpp (2)

bool ToH::move(int dari, int ke)

{

if (dari == ke)

return false;

if (dari < 0 || dari > 2 || ke < 0 || ke > 2)

return false;

if (_tiang[dari].empty())if (_tiang[dari].empty())

return false;

if ((!_tiang[ke].empty()) &&

(_tiang[dari].top() > _tiang[ke].top()))

return false;

_tiang[ke].push(_tiang[dari].top());

_tiang[dari].pop();

return true;

}

Contoh Tower of Hanoi PlayToH.cpp

int main() {

ToH t(3);

int dari, ke;

t.display();

do {

cout > dari;

cout > ke;

if (dari != -1 && ke != -1) {if (dari != -1 && ke != -1) {

if (t.move(dari, ke)) {

cout

Penjelajahan Labirin (Maze)

• Ingin algoritma unt mencari path dari S ke E yang selalu mendapati path tsb jika ada

– apa yang harus dilakukan jika menemui jalan buntu?

Ide Algoritma Penjelajahan Labirin (Maze)

• Saat menemui jalan buntu:– ulang dari S?

jalan

buntu


• Saat menemui jalan buntu:– ulang dari S? bukan ide yang baik– mundur ke langkah sebelumnya hingga percabangan,

coba path yang belum pernah dilalui

jalan

buntupercabangan

dgn path baru


• Saat menemui jalan buntu:– ulang dari S? bukan ide yang baik– mundur ke langkah sebelumnya hingga percabangan,

coba path yang belum pernah dilalui

– lalu lanjutkan penjelajahan– lalu lanjutkan penjelajahan

jalan

buntupercabangan

dgn path barulanjutkan penje-

lajahan path baru

Desain Algoritma Penjelajahan Labirin (Maze)

• Labirin direpresentasikan dgn array 2d: N x N– setiap kotak ada koordinat (baris, kolom) unik

• Arah gerakan dikodekan sbg enumerasi:– enum Arah {ATAS, KIRI, BAWAH, KANAN, TDKADA}

• Setiap kotak menyimpan informasi:• Setiap kotak menyimpan informasi:– arah mana yang belum dijelajahi– fungsi getArah() unt mendapatkannya

• Saat sebuah kotak punya banyak arah yang belum dijelajahi– jelajahi sesuai urutan enum di atas

• Path yang sudah dijelajahi disimpan sebagai stack koordin

1. path = kosong

2. selesai = false

3. path.push(koordinat S)

4. while (path tidak kosong && belum selesai)

i. kotak = path.top()

ii. arah = kotak.getArah()

Pseudocode Algoritma Penjelajahan Labirin (Maze)

ii. arah = kotak.getArah()

iii. if (arah == TDKADA)

path.pop()

iv. else

kotakBaru = kotak.gerak(arah)

path.push(koordinat kotakBaru)

if (kotakBaru == E)

selesai = true


• Mulai dari S, koordinat (2, 0) masuk ke dalam stack path

(2, 0)

(3, 2)

(3, 3)


(2, 0)

(2, 1)

(3, 1)

• Bertemu kotak koordinat (3, 3) yang ada banyak arah– sesuai enumerasi, pilih ATAS

(3, 2)

(3, 3)

(2, 3)

(1, 3)


(2, 0)

(2, 1)

(3, 1)

(3, 2)

• Bertemu kotak koordinat (1, 3) yang bbrp arah– sesuai enumerasi, tidak ada ATAS, pilih KIRI

(2, 3)

(1, 3)

(1, 2)

(0, 2)


(2, 0)

. . .

(2, 3)

• Jalan buntu pada (0, 2)– mundur, pop hingga ketemu kotak yg ada arah blm dikunjungi

(2, 3)

(1, 3)


(2, 0)

• Setelah bbrp pop, kembali ke (1, 3)– sudah/tidak ada ATAS, KIRI, BAWAH, pilih KANAN

. . .

(2, 3)

. . .

(5, 7)


(2, 0)

. . .

• Demikian seterusnya, hingga menjelajahi seluruh labirin!– adakah saran perbaikan algoritma agar lebih baik?

Queue

• Contoh sehari-hari:– queue antrean tiket film, queue giliran bank– masuk ke belakang antrean, giliran dari terakhir

• Queue = FIFO (First In First Out)• Queue = FIFO (First In First Out)– item yg pertama masuk, item yg pertama keluar

• Operasi pada queue:– Enqueue: menambah item pada akhir queue– Dequeue: mengambil item dari depan queue– Front: melihat item pertama di depan queue

Operasi pada Queue

Queue 3 orang

Front orang

terdepan

Operasi pada Queue

Queue 3 orang

Front orang

terdepan

Enqueue orang baru

dari back queue

Operasi pada Queue

Queue 3 orang

Front orang

terdepan

Enqueue orang baru

dari back queue

Dequeue satu orang

dari front queue

Spesifikasi ADT Queue

template

class Queue {

public:

Queue();

bool isEmpty() const;

int size() const;int size() const;

void enqueue(const T& newItem);

void dequeue();

void dequeue(T& queueFront);

void front(T& queueFront) const;

private:

};

tergantung implementasi!

Desain ADT Queue

• Implementasi dgn Array– menambah item dari belakang efisien– menghapus item dari depan tidak efisien

• Implementasi dgn Singly Linked List• Implementasi dgn Singly Linked List– menambah item dari belakang tidak efisien– menghapus item dari depan efisien

• Apakah mungkin mendapatkan keduanyaefisien?

Implementasi dgn Linked List

• Singly linked list buruk untuk enqueue– harus menjelajahi seluruh node hingga node terakhir– semakin lama seiring bertumbuhnya queue

• Bagaimana menghindari penjelajahan ke node • Bagaimana menghindari penjelajahan ke node akhir?

– simpan informasi node terakhir setiap waktu

• Solusi:1. pointer tambahan ke node terakhir: pointer tail

2. atau, buat circular linked linked dgn pointer tail

1. Linked List dgn Head dan Tail

_head _tail

queue

front

queue

back

_tailqueue

front

2. Circular Linked List dgn Tail

• Digunakan dalam kuliah ini

queue

back

Enqueue ke Queue Tdk Kosong

newNode_tail

• Bagaimana cara enqueue agar node baru diletakkansetelah _tail?


newNode_tail

1. newNode->next = _tail->next;


newNode_tail


2. _tail->next = newNode;


newNode_tail


2. _tail->next = newNode;

3. _tail = newNode;

Enqueue ke Queue Kosong

newNode_tail

• Bagaimana cara enqueue agar node baru menjadi _taildan linked list menjadi circular?


newNode_tail

1. newNode->next = newNode;


newNode_tail

1. newNode->next = newNode;

2. _tail = newNode;

Dequeue dari Queue size > 1

• Bagaimana cara dequeue agar front queue dihapus?


_taildelNode

1. QueueNode* delNode = _tail->next;


_taildelNode


2. _tail->next = delNode->next;


delNode


2. _tail->next = delNode->next;

3. // hapus delNode

Dequeue dari Queue size == 1

_tail

• Bagaimana cara enqueue agar node baru menjadi _taildan linked list menjadi kosong?


delNode _tail



delNode _tail


2. _tail = NULL;


delNode _tail


2. _tail = NULL;

3. // hapus delNode

template class Queue {public:

Queue();~Queue();bool isEmpty() const;int size() const;void enqueue(const T& newItem);void dequeue();

Spesifikasi ADT Queue dgn Circular Linked List QueueCLL.h

void dequeue();void dequeue(T& queueFront);void front(T& queueFront) const;

private:struct QueueNode {

T item;QueueNode* next;

};QueueNode* _tail;int _size;

};

seperti pada ADT List

#include "QueueCLL.h"

template

Queue::Queue() : _size(0), _tail(NULL) {}

template

Queue:: ~Queue() {

while (!isEmpty())

dequeue();

}

Implementasi ADT Queue dgn Circular LL QueueCLL.cpp (1)

destructor: dequeue

hingga kosong

}

template

bool Queue::isEmpty() const {

return _size == 0;

}

template

int Queue::size() const {

return _size;

}

template

void Queue::enqueue(const T& newItem) {

QueueNode* newNode = new QueueNode;

newNode->item = newItem;

if (_size > 0) {

newNode->next = _tail->next;

_tail->next = newNode;


Queue tidak kosong

_tail->next = newNode;

_tail = newNode;

} else {

newNode->next = newNode;

_tail = newNode;

}

++_size;

}

Queue kosong

template

void Queue::dequeue(T& queueFront) {

if (isEmpty())

throw string("Queue kosong, dequeue gagal");

else {

QueueNode* delNode = _tail->next;

queueFront = delNode->item;

if (_size > 1)


if (_size > 1)

_tail->next = delNode->next;

else

_tail = NULL;

delNode->next = NULL;

delete delNode;

delNode = NULL;

--_size;

}

}

_size == 1

template

void Queue::front(T& queueFront) const {

if (isEmpty())

throw string("Queue kosong, front gagal");

else

queueFront = _tail->next->item;


}

Implementasi dgn Array

• Menghapus item dari front tidak efisien– saat index 0 dianggap sbg front, semua item harus

digeser untuk mengisinya

• Solusi:• Solusi:– jangan geser item, tapi geser index front!

• Simpan dua index:– front: index front dari queue– back: index back dari queue

Permasalahan Baru

• Index front akan bergeser ke kanan– bagian depan array terbuang sia-sia

[0] [1] [2] [49][3]

a1 a2 a3 ...a4

Permasalahan Baru

• Index front akan bergeser ke kanan– bagian depan array terbuang sia-sia

[0] [1] [2] [49][3]

a1

[0] [1] [2] [49]

a2 a3 ...a4

a3

[3]

[49]

... a2a1

[48][47]

setelah bbrp operasi, front = 47, back = 49, dianggap penuh!

Circular Array

• Unt menggunakan kembali bagian depan array,– index bisa kembali ke depan, visualisasikan array circular

[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]

front

back

Circular Array

• front = (front + 1) % MAX_QUEUE• back = (back + 1) % MAX_QUEUE

[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]

front

back

[0]

[1]

[2]

[3]

[4][5][6]

[7]

[8]

[9] front

back

back

#include using namespace std;const int MAX_QUEUE = 50;template class Queue {

public:Queue();bool isEmpty() const;

Spesifikasi ADT Queue dgn Array QueueA.h

bool isEmpty() const;int size() const;void enqueue(const T& newItem);void dequeue();void dequeue(T& queueFront);void front(T& queueFront) const;

private:T _items[MAX_QUEUE];int _front, _back, _size;

};

#include "QueueA.h"

template

Queue::Queue() {

_front = 0;

_back = MAX_QUEUE - 1;

_size = 0;

}

Implementasi ADT Queue dgn Array QueueA.cpp (1)

template

bool Queue::isEmpty() const {

return _size == 0;

}

template

int Queue::size() const {

return _size;

}

template

void Queue::enqueue(const T& newItem)

{

if (_size == MAX_QUEUE)

throw string("Queue penuh");

else

{


{

_back = (_back + 1) % MAX_QUEUE;

_items[_back] = newItem;

++_size;

}

}

template

void Queue::dequeue(T& queueFront)

{

if (isEmpty())

throw string("Queue kosong");

else

{


{

queueFront = _items[_front];

_front = (_front + 1) % MAX_QUEUE;

--_size;

}

}

template

void Queue::front(T& queueFront) const

{

if (isEmpty())




else

queueFront = _items[_front];

}

STL Queuetemplate

class queue {

public:

bool empty() const;

size_t size() const;

T& front(); T& front();

T& back();

void push(const T& t);

void pop();

};

enqueue()

dequeue()

Aplikasi Queue

• Contoh aplikasi queue:– Pengecekan Palindrome

• Palindrome adalah string yang sama dibaca dari kiri-kanandan kanan-kiri (abaikan tanda baca)

– contoh: A Man, A Plan, A Canal - Panama! Eva, Can I Stab Bats In A Cave?Eva, Can I Stab Bats In A Cave?

• Solusi:– banyak solusi yang efisien– kita ingin gunakan LIFO dan FIFO– gunakan stack untuk membalik input– gunakan queue untuk menyimpan input asli– keduanya sama jika palindrome

Pengecekan Palindrome#include #include using namespace std;bool palindrome(string input) {

stack s;queue q;for (int j=0; j < input.size(); j++) {

s.push(input[j]);q.push(input[j]);

}while (!s.empty()) {

if (s.top() != q.front())return false;

s.pop();q.pop();

}return true;

}

Quiz

• Tulis sebuah fungsi balikQueue yang menerimasebuah queue string q, lalu membalik seluruhelemen queue tersebut.

• Misal, q = front [ a b c ] back. • Misal, q = front [ a b c ] back. • Hasilnya, q = front [ a b c c b a ] back.

• Petunjuk: Gunakan sebuah stack s dalam fungsi. Berikan comment tujuan tiap loop.

Quizvoid balikQueue(queue& q) {

stack s;string str;int n = q.size();

for (int i = 0; i < n; i++) { // isi stack dgnstr = q.front(); // elemen queueq.pop(); // dan isi keq.pop(); // dan isi kes.push(str); // queue kembaliq.push(str);

}while (!s.empty()) { // isi queue dgn elemen

q.push(s.top()); // stack yang terbaliks.pop();

}}

Minggu Depan

Bahan minggu depan: Recursion

• Bagaimana rekursi bekerja• Iterasi vs rekursi• Contoh rekursi

– Print Linked List, Print Reverse Linked List– Print Linked List, Print Reverse Linked List– Kombinasi, Tower of Hanoi, Fibonacci

Baca :

• Textbook A Chapter 2, 5• Textbook B Chapter 5, 6, 7

Reference

• Purwanto, E., 2014, Slide kuliah Struktur Data, Yogyakarta : UKDW

• Kadir, A.,2003, Pemrograman C++, Yogyakarta : Andi: Andi

im. karo karo's blog · 2019. 5. 17. · created date: 5/12/2019 7:23:09 pm

Documents