Struktur data stack, queue dan dequeue
Stack
Tumpukan (stack) merupakan struktur data yang menerapkan konsep LIFO (Last In First Out) Artinya, data yang terakhir ditambahkan ke dalam stack akan berada di posisi terkahir (atau paling atas jika kita membayangkan elemen - elemen stack tersusun secara vertikal) dan ketika proses pengambilan, data terakhir tersebut akan diambil pertama kali.



Pada kelas di atas, kita mengimplementasikan metode-metode berikut :

1. isempty(), digunakan untuk memeriksa apakah stack kosong atau tidak.
2. __len__(), metode ini perlu diimplementasikan agar objek dari kelas stack dapat dihitung
    jumlah elemennya menggunakan metode len().
3. push(), digunakan untuk menambah elemen baru ke dalam stack pada posisi terakhir.
4. peek(), digunakan untuk mendapatkan elemen yang terdapat pada posisi terkahir tanpa
    menghapus elemen tersebut.
5. pop(), digunakan untuk mengambil elemen terakhir dan menghapusnya dari dalam stack.
6. size(), mengembalikan jumlah item di dalam list. Tidak memerlukan parameter dan
    mengembalikan suatu integer.

implementasinya ke dalam Phyton :
# STACK
#=======================================================================

# Import library os untuk membersihkan layar console
import os

# Class stack
class Stack:
    def __init__(self):
        self.items = []
       
    # Memeriksa apakah stack kosong
    def isEmpty(self):
        return self.items == []
    # Menambah objek/data ke dalam stack
    def push(self, item):
        self.items.append(item)
    # Mengeluarkan data dari stack
    def pop(self):
        return self.items.pop()
    # Menampilkan objek terakhir dari stack
    def peek(self):
        return self.items[len(self.items)-1]
    # Mehitung panjang stack
    def size(self):
        return len(self.items)
   
    # Menu dari aplikasi
    def mainmenu(self):
        pilih = "y"
        while (pilih == "y"):
            os.system("clear")
            print("=========================")
            print("|  Menu aplikasi stack  |")
            print("=========================")
            print("1. Push objek")
            print("2. Pop objek")
            print("3. Cek Empty")
            print("4. Tampil objek terakhir")
            print("5. Panjang dari stack")
            print("=========================")
            pilihan=str(input(("Silakan masukan pilihan anda: ")))
            if(pilihan=="1"):
                os.system("clear")
                obj = str(input("Masukan objek yang ingin anda tambahkan: "))
                self.push(obj)
                print("Object "+obj+" telah ditambahkan")
                x = input("")
            elif(pilihan=="2"):
                os.system("clear")
                print("Objek "+self.pop()+" dihapus")
                x = input("")
            elif(pilihan=="3"):
                os.system("clear")
                print(self.isEmpty())
                x = input("")
            elif(pilihan=="4"):
                os.system("clear")
                print("Objek terakhir: "+self.peek())
                x = input("")
            elif(pilihan=="5"):
                os.system("clear")
                print("Panjang dari stack adalah: "+str(self.size()))
                x = input("")
            else:
                pilih="n"  

if __name__ == "__main__":
    s=Stack()
    s.mainmenu()



Queue


Antrian (queue) merupakan struktur data yang menerapkan konsep FIFO (First In First Out), berbanding terbalik dengan (stack) yang memiliki konsep data yang masuk paling belakang akan keluar terlebih dahulu. Data atau elemen yang pertama ditambahkan ke dalam queue akan diambil pertama kali juga seperti pada ilusrasi di atas.

Pada kelas queue di atas, kita mengimplentasikan metode - metode berikut :

1. isempty(), digunakan untuk memeriksa apakah queue kosong atau tidak.
2. enqueue(), digunakan untuk menambah elemen baru ke dalam queue pada posisi terakhir.
3. peek(), digunakan untuk mendapatkan elemen yang terdapat pada posisi terkahir tanpa
  menghapus elemen tersebut.
4. dequeue(), digunakan untuk mengambil elemen terakhir dan menghapusnya dari dalam
  queue.
5. size(), mengembalikan jumlah item di dalam list. Tidak memerlukan parameter dan
   mengembalikan suatu integer.
6. semua(), mengecek isi list Queue.
Berikut implementasinya ke dalam bahasa pemrograman Python :

from datetime import timedelta, datetime
from time import sleep

class Queue:
    def __init__(self):
        self.items=[]
    def isEmpty(self):
        return self.items == []
    def enqueue(self,item):
        self.items.insert(0,item)
    def dequeue(self):
        return self.items.pop()
    def rear(self):
        return self.items[0]
    def front(self):
        return self.items[len(self.items)-1]
    def size(self):
        return len(self.items)
    def open(self):
        return self.items

def antrian():
    endtime = datetime.now() + timedelta(seconds = 2)
    tanda='n'
    m = Queue()
    cad = Queue()
    inputan = int(input('Masukan berapa orang yang ingin antri = '))
    for i in range(inputan):
        nama = input('Masukan nama costumer ke %i = '%(i+1))
        m.enqueue(nama)
        cad.enqueue(nama)

    print("Estimasi Jam Pelayanan Customer")
    while not m.isEmpty():
        if not m.isEmpty():
            if tanda=='n':
                print(m.dequeue(),'akan dilayani pada :',datetime.now())
                tanda='y'
            else:
                print(m.dequeue(),'akan dilayani pada :',endtime)
                endtime = endtime + timedelta(seconds = 2)

    tanda='n'
    print("=======================Antrian======================")
    while not cad.isEmpty():
        if not cad.isEmpty():
            if tanda==0:
                print(cad.dequeue(),'sedang dilayani')
                tanda=1
            else:
                sleep(2)
                print(cad.dequeue(),'sedang dilayani')

    if cad.isEmpty():
            print('===============Antrian Kosong==================')
            antrian()

antrian()
           


DeQueue


DeQueue, dikenal juga sebagai antrian berujung dua (double-ended), adalah suatu koleksi item terurut serupa dengan queue. Perbedaannya? Sifat tidak terikat untuk penambahan dan penghapusan item-item dari antrian. Item baru dapat ditambahkan ke depan atau belakang. Karena itu, item yang ada dapat dihapuskan dari salah satu ujung. Struktur linier hibrida ini menyediakan semua kapabilitas stack dan antrian dalam satu struktur data.

Berikut ini adalah beberapa operasi yang dapat diberlakukan terhadap Deque :

1. deque(), membuat suatu deque baru yang kosong. Tidak perlu parameter dan
    mengembalikan suatu deque kosong.
2. addFront(item), menambahkan suatu item baru ke depan dari deque. Perlu item dan tidak
    mengembalikan apapun.
3. addRear(item), menambahkan suatu item baru ke ekor dari deque. Perlu item dan tidak
    mengembalikan sesuatu.
4. removeFront(), menghapus item depan dari deque. Tidak perlu parameter dan
    mengembalikan item. Deque termodifikasi.
5. removeRear(), menghapus item ujung (ekor) dari deque. Tidak perlu parameter dan
    mengembalikan item. Deque berubah.
6. isEmpty(), menguji apakah deque dalam kondisi kosong. Tidak perlu parameter dan
    mengembalikan suatu nilai boolean.
7. size(), mengembalikan jumlah item dalam deque. Tidak perlu parameter dan
    mengembalikan suatu integer.

Untuk lebih jelasnya, langsung saja kita implementasikan ke dalam bahasa pemrograman Python seperti berikut :