Antrian (Queue)

Membentuk Antrian

5
Depa 4
n 3
2
1
Belakan
g
 Ma
s uk

Ke
lua
r
Defenisi
• Antrian adalah suatu kumpulan data yang mana
penambahan elemen hanya bisa dilakukan pada
suatu ujung (disebut dengan sisi belakang atau
rear), dan penghapusan (pengambilan elemen )
dilakukan lewat ujung lain (disebut dengan sisi
depan atau front
• maka pada antrian prinsip yang digunakan
adalah “masuk pertama keluar pertama”atau
FIFO (First in First Out). Dengan kata lain,
urutan keluar elemen akan sama dengan urutan
masuknya
• Contoh lain yang lebih relevan dalam bidang
komputer adalah pemakaian sistem komputer
berbagi waktu (time – sharing computer system)
dimana ada sejumlah pemakai yang akan
menggunakan sistem tersebut secara serempak.
Karena sistem ini biasanya menggunakan
sebuah prosesor dan sebuah pengingat utama,
maka jika prosesor sedang dipakai oleh seorang
pemakai, pemakai-pemakai lain harus antri
sampai gilirannya tiba. Antrian ini mungkin tidak
akan dilayani secara FIFO murni, tetapi
didasarkan pada suatu proritas tertentu
 Jaringan Komputer

Server

User 5
User 1

User 3

User 4
User 2
 Jaringan Komputer

Server

User 5
Tabel Proses
User 1
P1 x1 y1
P2 x2 y2
P3 x3 y3
P4 x4 y4
User 3
P5 x5 y5
User 4
User 2
 Antrian Dengan Larik

A B C D E
0 1 2 3 4 5
depan

Belakang
Deklarasi struktur data
Queue = record
isi : array[1..n] of tipe data
depan,belakang : integer
end
 Inisialisasi Queue
Posisi awal Q
Q : Queue
0 1 2 3 4 5
Q.Depan = 1
Q.Belakang = 0
B D

Operasi Pada Antrian

1. Menambah Elemen ( Add (x,q))
menambah elemen x kedalam Antrian Q
2. Menghapus Elemen ( Del(q))
Menghapus elemen dari antrian Q
 Menambah Elemen (Add(x,Q))

Q
Add(Mobil,Q)
0 1 2 3 4 5

B D
 Menambah Elemen (Add(x,Q))

Q
Add(Mobil,Q)
0 1 2 3 4 5

D B
 Menambah Elemen (Add(x,Q))
Q
Add(Mobil,Q)
0 1 2 3 4 5

D B
D
Q B

Add(Mobil,Q)
0 1 2 3 4 5

B
D
Q
Add(Mobil,Q)
0 1 2 3 4 5
 Menambah Elemen (Add(x,Q))
Penambahan Algoritma :
elemen dapat
dilakukan pada Procedure Add(x : tipe data, Q: stack)
saat Antrian belum If Q.belakang < n then
penuh, dimana Q.belakang= Q.Belakang+1
antrian belum
Q.isi[Q.belakang] = x
penuh jika posisi
belakang Else
(Q.Belakang<n) Antrian Sudah Penuh
fi
 Menghapus Elemen(Del(Q))
Sifat antrian adalah FIFO (First In First Out),
sehingga data yang dihapus duluan adalah
data yang duluan masuk
B
D
Q
Del(Q)
0 1 2 3 4 5
D
Q B

Del(Q)
0 1 2 3 4 5
 Del(q)
D
Q B

Del(Q)
0 1 2 3 4 5
D
Q B

Del(Q)
0 1 2 3 4 5
D
Q B

Del(Q)
0 1 2 3 4 5
 Del(Q)
Penghapusan elemen Procedure Del (q: Antrian)
dapat dilakukan If Q.depan<= q.belakang
terhadap antrian jika Then
komponen ada dalam Write Q.isi[q.depan]
antrian, untuk q.depan = q.depan + 1
mengetahui bahwa Else
elemen dalam antrian Antrian Kosong
adalah jika posisi fi
Depan <= belakang
(Q.depan <= Q.belakang)
 Masalah
Pada saat posisi belakang berada pada posisi
belakang dan Depan berada pada posisi n (hanya ada
satu elemen), maka ketika kita lakukan Add(x,q) maka
informasi mengatakan antrian penuh
Algoritma :
D
Q B Procedure Add(x : tipe
data, Q: stack)
If Q.belakang < n then
0 1 2 3 4 5 Q.belakang=
D Q.Belakang+1

Q B
Q.isi[Q.belakang] = x
Else
0 1 2 3 4 5 6 Antrian Sudah Penuh
fi
 Bus
Sudah
penuh

40

Loket
 Pergeseseran Elemen
Pergeseran nilai depan ketika terjadi penghapusan akan
mengakibatkan antrian yang masih kosong dinyatakan
penuh dimana jika posisi belakang berada posisi n, dan
posisi depan berada pada n+1, dimana jika belakang <
depan adalah antrian kosong ( tidak ada elemen)

Untuk menghindarinya adalah ketika terjadi penghapusan,

maka elemen yang lain akan bergerak mengisi posisi
yang dihapus, dengan demikian posisi depan akan tetap
bernilai 1, dan posisi belakang akan berkurang 1.
(q.belakang = q.belakang – 1).

Untuk menambah komponen tetap sama

 Add(x,q)
Q.Depan =1
Q.Belakang =0

Add(A,Q) A
Q.Depan =1
Q.Belakang =1

Add(B,Q) A B
Q.Depan =1
Q.Belakang =2
Add(C,Q) A B C
Q.Depan =1
Q.Belakang =3

Add(D,Q) A B C D
Q.Depan =1
Q.Belakang =4

Add(E,Q) A B C D E
Q.Depan =1
Q.Belakang =5
 Del(Q)
A B C D E
Q.Depan =1
Q.Belakang =5

Del(Q) B C D E
Q.Depan =1
Q.Belakang =4

Del(Q) C D E
Q.Depan =1
Q.Belakang =3
Del(Q)
Del(Q) D E
Q.Depan =1
Q.Belakang =2

Del(Q) E
Q.Depan =1
Q.Belakang =1

Del(Q)
Q.Depan =1
Q.Belakang =0
Latihan
Misalkan jumlah data yang boleh antri
adalah 6, lakukan langkah-langkah berikut
(dengan menggunakan konsep antrian
bergeser)
1. Add(10,Q) 2. Add(15,Q) 3.Add(20,Q)
4. Add(25,Q) 5. Del(Q) 6.Del(Q)
7. Del(Q) 8. Add(10,Q) 9.Del(Q)
10. Add(20,Q) 11.Add(10,Q) 12.Del(Q)

Buat Algoritma untuk Menghapus (Del Q)

Procedure Del(Q)
If q.belakang>0 then
write q.isi[q.depan] // q.isi[1]
//lakukan pergeseran elemen
I=1
while I < Q.belakang do
q.isi[i] = q.isi[i+1]
I=I+1
e-while
q.belakang = q.belakang -1
Else
Antrian Kosong
fi
Masalah
• Misalkan jika pada antrian terdapat 1000
data, jika penghapusan dilakukan, maka
waktu yang paling banyak digunakan
adalah untuk melakukan pergeseran
elemen yaitu menggeser 999 elemen yang
ada dalam antrian.
• Untuk menghindari masalah itu, maka
dapat digunakan antrian berputar (circular
array)
 Antrian Berputar
• Cara penghapusan dengan pergeseran elemen
kelihatannya sudah memecahkan persoalan yang kita
miliki. Tetapi jika kita tinjau lebih lanjut, maka ada
sesuatu yang harus dibayar lebih mahal, yaitu tentang
penggeseran elemen itu sendiri. Jika kita mempunyai
antrian dengan 10000 elemen, maka waktu terbanyak
yang dihabiskan sesungguhnya hanya untuk melakukan
proses penggeseran. Hali ini tentu saja sangat tidak
efisien.

• Dengan melihat gambar-gambar ilustrasi, proses

penambahan dan penghapusan elemen antrian
sebenarnya hanya mengoperasikan sebuah elemen,
sehingga tidak perlu ditambah dengan sejumlah operasi
lain yang justru menyebabkan tingkat ketidak-efesienan
bertambah.
 Antrian Berputar
• Pemecahan lain adalah dengan memperlakukan
larik yang menyimpan elemen antrian sebagai
larik yang memutar (circular), bukan lurus
(straight), yakni dengan membuat elemen
pertama larik terletak berdekatan langsung
dengan elemen terakhir larik. Dengan cara ini,
meskipun elemen terakhir telah terpakai, elemen
baru masih tetap bisa ditambahkan pada elemen
pertama, sejauh elemen pertama dalam
keadaan kosong. Gambar berikut ini
menunjukan ilustrasi antrian Q yang
diimplementasikan dengan larik yang memutar
B Antrian Berputar
D
Insialisasi struktur data
N = Jumlah elemen
Antrian = record
Isi : array [ 1..N] of tipe data
Depan,belakang : integer
Count : integer;
End
Insialisasi Antrian
Q.depan =1
Q.Belakang = 0
Q.Count = 0
Add(x,q) & Del(q)
Procedure Add ( x : Tipe data, Procedure Del(Q)
Q : Antrian) If Q.count > 0
If Q.Count < N Then
Then
If Q. belakang = N
Write Q.isi[Q.depan]
Then If Q.depan = N
Q.belakang = 1 Then
Else Q.depan = 1
Q.belakang = Q.belakang + 1 Else
Fi
Q.isi[q.belakang] = X
Q.Depan = Q.depan +1
Q.count = Q.count + 1 Fi
Else Q.count = Q.Count -1
Antrian Penuh Else
Fi Antrian Kosong
Fi
 Tugas
• Buat simulasi antrian seperti yang
digunakan oleh bank

• Waktu 1 Bulan