Laporan Program Quiz 1 Struktur Data Python dan Java

Laporan Program Quiz 1 Pratikum Struktur Data
Nama : Puti Raissa Razani

Nim : 22343065
List quiz :
phyton Java
Lists, Dictionary,Tuples, Sets Array
Linked list (skip list) Linked list (circular, skip list)
stack (Implementasi menggunakan Linked queue (Circular Queue, Priority Queue)
List)
Queue (Priority Queue)
total : 9
Phyton
• Lists, Dictionary,Tuples, Sets
Source code program :
# List Example
fruits = ['apple', 'banana', 'grape', 'orange']
print("List of Fruits:", fruits)
# Dictionary Example
student = {
"name": "Raissa",
"age": 18,
"gender": "Female"
}
print("\nStudent Information:", student)
# Tuple Example
colors = ("red", "green", "blue")
print("\nTuple of Colors:", colors)
# Set Example
numbers = {1, 2, 3, 4, 5, 5}
print("\nSet of Numbers:", numbers)
penjelasan Program:
Baris Petikan source code Penjelasan

Program
2-3 fruits = ['apple', 'banana', Kode ini menginisialisasi list bernama
'grape', 'orange'] ‘fruit’ daengan 4 elemen buah sebagai
print("List of Fruits:", fruits) pada source code lalu mencetak pesan
“list of fruit” menggunakan fungsi print.
6-11 student = { Line ini membuat dictionary bernama
"name": "Raissa", ‘student’ yang mana memiliki 3 key-
"age": 18, value yakni ‘name’, ‘age’, dan ‘gender’
"gender": "Female" lalu mencetak “student” menggunakan
} fungsi print
print("\nStudent Information:",
student)
14-15 colors = ("red", "green", Line ini menginisialisasi tuple bernama

"blue") ‘colors’ dengan 3 elemen warna. Mirip
print("\nTuple of Colors:", dengan list, namun isinya tidak bisa
colors dimodifikasi setelah dibuat.
18-19 numbers = {1, 2, 3, 4, Line ini menginisialisasi set bernama

5, 5} ‘numbers’ dengan 5 elemen yang unik,
print("\nSet of Numbers:", perhatikan nomor 5 diulang dua kali
numbers) namun set digunakan untuk menyimpan
elemen yang unik dan tidak teratur.
Sehingga pada output hanya ada 1 angka
5.
Screenshot output source code
• Linked List (Skip List)
Source code
# Python3 code for inserting element in skip list
import random
class Node(object):
'''
Class to implement node
'''
def __init__(self, key, level):
self.key = key
# list to hold references to node of different level
self.forward = [None]*(level+1)
class SkipList(object):
'''
Class for Skip list
'''
def __init__(self, max_lvl, P):
# Maximum level for this skip list
self.MAXLVL = max_lvl
# P is the fraction of the nodes with level

# i references also having level i+1 references
self.P = P
# create header node and initialize key to -1

self.header = self.createNode(self.MAXLVL, -1)
# current level of skip list

self.level = 0
# create new node

def createNode(self, lvl, key):
n = Node(key, lvl)
return n
# create random level for node

def randomLevel(self):
lvl = 0
while random.random()<self.P and \
lvl<self.MAXLVL:lvl += 1
return lvl
# insert given key in skip list

def insertElement(self, key):
# create update array and initialize it
update = [None]*(self.MAXLVL+1)
current = self.header
'''
start from highest level of skip list
move the current reference forward while key
is greater than key of node next to current
Otherwise inserted current in update and
move one level down and continue search
'''
for i in range(self.level, -1, -1):
while current.forward[i] and \
current.forward[i].key < key:
current = current.forward[i]
update[i] = current
'''
reached level 0 and forward reference to
right, which is desired position to
insert key.
'''
current = current.forward[0]
'''
if current is NULL that means we have reached
to end of the level or current's key is not equal
to key to insert that means we have to insert
node between update[0] and current node
'''
if current == None or current.key != key:
# Generate a random level for node
rlevel = self.randomLevel()
'''
If random level is greater than list's current
level (node with highest level inserted in
list so far), initialize update value with
reference
to header for further use
'''
if rlevel > self.level:
for i in range(self.level+1, rlevel+1):
update[i] = self.header
self.level = rlevel
# create new node with random level generated

n = self.createNode(rlevel, key)
# insert node by rearranging references

for i in range(rlevel+1):
n.forward[i] = update[i].forward[i]
update[i].forward[i] = n
print("Successfully inserted key {}".format(key))
# Display skip list level wise

def displayList(self):
print("\n*****Skip List******")
head = self.header
for lvl in range(self.level+1):
print("Level {}: ".format(lvl), end=" ")
node = head.forward[lvl]
while(node != None):
print(node.key, end=" ")
node = node.forward[lvl]
print("")
# Driver to test above code

def main():
lst = SkipList(3, 0.5)
lst.insertElement(3)
lst.displayList()
main()
penjelasan program :
Program
3-8 import random Mengimpor random modul python
class Node(object):
'''
Class to implement
node
'''
9-13 def __init__(self, key, level): def __init__(self, key, level)
self.key = key mwndwfinisikankostruktor dari 2
parameter – key dan level
self.forward =
[None]*(level+1) self.key = key menetapkan contoh
variabel key dari objek ke value passed
sebsgai key parameter
self.forward = [None]*(level+1)
menciptakan list forward/maju dengan
panjang level+1 dimana tiap elemen
ditetapkan none.
19-31 def __init__(self, def __init__(self, max_lvl, P)
max_lvl, P): mendefinisikan 2 parameter max_lvl dan
# Maximum P
level for this skip list
self.MAXLVL = self.MAXLVL = max_lvl menciptakan
max_lvl contoh variabel MAXLVL dan
menetapkan value max_lvl,
# P is the mempresentasikan level maximum yang
fraction of the nodes with level bisa ditamplkan pada skip list
# i references
also having level i+1 self.P = P Menciptakan contoh variabel
references P dan menetapkan value dari P.
self.P = P
self.header =
# create header self.createNode(self.MAXLVL, -1)
node and initialize key to -1 menciptakan kepala node atau skip list
self.header = menggunakan createNode.
self.createNode(self.MAXLVL,
-1) self.level = 0 menciptakancontoh
variabel level dan menetapkannya ke 0
# current level
of skip list
self.level = 0
33-49 # create new node Untuk memasukkan kunci baru,
def createNode(self, lvl, ia mencari melalui Skip List dari
key): level tertinggi ke level terendah.
n = Node(key, Pada setiap tingkat, ia
lvl) memeriksa apakah simpul
return n berikutnya di tingkat saat ini
memiliki kunci yang kurang dari
# create random level kunci target. Jika ya, ia akan
for node berpindah ke simpul tersebut dan
def randomLevel(self): mengulangi proses pada tingkat
lvl = 0 yang lebih rendah berikutnya.
while Jika tidak, ia akan menyimpan
random.random()<self.P and \ referensi ke simpul tersebut
dalam update array dan bergerak
lvl<self.MAXLVL:lvl ke tingkat yang lebih rendah
+= 1 berikutnya.
return lvl
Ketika mencapai tingkat paling
# insert given key in bawah, ia menyisipkan simpul
skip list baru dan memperbarui penunjuk
def insertElement(self, maju dari simpul-simpul yang
key): disimpan di update array untuk
# create update menunjuk ke simpul baru.
array and initialize it Karena node-node ini dijamin
update = berada di setiap tingkat di mana
[None]*(self.MAXLVL+1) node baru disisipkan atau lebih
current = tinggi, hal ini memastikan bahwa
self.header node baru terhubung dengan
benar ke node di setiap tingkat
dalam Skip List
87-100 if rlevel Kode ini merupakan bagian dari

> self.level: metode insertElement untuk
struktur data Skip List di Python.
for i in
range(self.level+1, rlevel+1): Setelah menginisialisasi update
array dan menetapkan current
update[i] = self.header menjadi simpul header dari Skip
List, metode ini menghasilkan
self.level = rlevel level acak untuk simpul baru
dengan menggunakan metode
# create randomLevel.
new node with random level
generated Blok kode if rlevel > self.level:
n= memeriksa apakah level acak
self.createNode(rlevel, key) yang dihasilkan lebih besar
daripada level saat ini dari Skip
# insert List. Jika ya, maka itu berarti
node by rearranging references node baru ini akan menjadi node
for i in tertinggi dalam Skip List. Oleh
range(rlevel+1): karena itu, metode ini
memperbarui update array untuk
n.forward[i] = setiap level antara level saat ini
update[i].forward[i] dan level baru (inklusif) untuk
menunjuk ke node header
(self.header). Metode ini juga
update[i].forward[i] = n memperbarui level saat ini dari
Skip List agar sama dengan level
yang baru.
print("Successfully
inserted key {}".format(key)) Kemudian, kode tersebut
membuat simpul baru n dengan
level acak yang dihasilkan dan
kunci yang diberikan
menggunakan metode
createNode.
Terakhir, metode ini mengatur

ulang penunjuk maju dari node-
node untuk memasukkan node
baru n ke dalam Skip List
dengan melakukan iterasi dari 0
ke rlevel+1. Untuk setiap level:
Penunjuk maju dari n untuk level

tersebut diatur agar sama dengan
forward pointer dari simpul pada
level tersebut dalam update
array.
Penunjuk maju dari simpul
dalam update array untuk level
tersebut diatur untuk menunjuk
ke n.
Hal ini menghubungkan simpul
baru ke simpul-simpul sebelum
dan sesudahnya pada setiap
tingkat di mana simpul tersebut
telah disisipkan. Metode ini
kemudian mencetak sebuah
pesan yang mengindikasikan
bahwa penyisipan berhasil.
103 - def displayList(self): Kode dimulai dengan mencetak

112 pesan yang menyatakan bahwa ia
print("\n*****Skip sedang menampilkan Skip List.
List******")
head = Kemudian menetapkan head
self.header sebagai simpul header dari Skip
for lvl in List dan mengulang setiap level
range(self.level+1): Skip List dari level 0 hingga
level maksimum (self.level+1).
print("Level {}:
".format(lvl), end=" ") Untuk setiap level, ia mencetak
node = "Level {}: " di mana {} diganti
head.forward[lvl] dengan nomor level saat ini.
Parameter end="" digunakan
while(node != None): untuk menentukan bahwa kita
ingin menggabungkan output
print(node.key, end=" ") dari string berikutnya dengan
spasi, bukan dengan karakter
node = baris baru.
node.forward[lvl]
print("") Kemudian, ia menetapkan node
menjadi node pertama pada level
saat ini (yaitu node yang berada
tepat setelah header) dan mulai
mengulang semua node pada
level tersebut. Untuk setiap
simpul, ia mencetak nilai kunci
yang diikuti dengan spasi, dan
menetapkan simpul menjadi
simpul berikutnya dalam arah
maju pada level saat ini.
Perulangan akan berakhir ketika
tidak ada lagi simpul pada level
saat ini atau ketika simpul
menjadi Tidak Ada.
Terakhir, ia mencetak sebuah

string kosong pada baris baru
untuk memisahkan level-level
Skip List secara visual.
115-129 def main(): Memasukan elemen kepada list an

lst = SkipList(3, 0.5) menampilkannya
lst.displayList()
main()
• Implementasi menggunakan Linked List

Source Code
class Node:
def __init__(self, data):
self.data = data
self.next = None
class LinkedList:
def __init__(self):
self.head = None
def printList(self):
temp = self.head
while(temp):
print(temp.data)
temp = temp.next
if __name__=='__main__':
# Membuat objek dari class LinkedList
linkedList = LinkedList()
# Menambahkan node ke dalam list

linkedList.head = Node(5)
secondNode = Node(2)
thirdNode = Node(7)
linkedList.head.next = secondNode
secondNode.next = thirdNode
# Mencetak isi dari linked list

linkedList.printList()
Penjelasan
Program
1-4 class Node: Class baru bernama node didefinisikan
def __init__(self, data): yang mana memiliki 2 variabel, data
self.data = data dan next. Variabel data menyimpan
self.next = None
value dari node dan next menyimpan
referensi node selanjutnya.
6-8 class LinkedList: Class baru bernama LinkedList
def __init__(self): didefinisikan, yang mana memiliki
self.head = None satu variabel, head yang mana
memunjuk ke node pertama pada
linked list
10-14 def printList(self): Metode printList(self) didefinisikan di
temp = self.head dalam Linked List class yang mana
while(temp): digunakan untuk trnsversi melalui
print(temp.data) linked list, dimulai dari head node,
temp = temp.next dan cetak data yang disimpan pada
tiap node
16-18 if__name__=='__main__': if__name__=='__main__': didalamnya
# Membuat objek dari objek linked list dibuat menggunakan
class LinkedList variabel linked list.
linkedList = LinkedList()
21-26 linkedList.head = Menambahkan node ke dalam list
Node(5)
secondNode = Node(2) Dan linkedList.head dijadikan
thirdNode = Node(7) secondNode dan variabel next
linkedList.head.next = secondNode adalah thirdNode
secondNode
secondNode.next = thirdNode
29 linkedList.printList() Mencetak linked list
• Priority Queue
Source code
import queue
# Membuat priority queue dengan ukuran 5

q = queue.PriorityQueue(5)
# Menambahkan elemen ke dalam priority queue

q.put(7)
q.put(3)
q.put(1)
q.put(2)
# Mengambil elemen dari priority queue

print(q.get())
print(q.get())
print(q.get())
print(q.get())
Penjelasan code
Program
4 q = queue.PriorityQueue(5) Membuat priority queue dengan
ukuran 5
7-10 q.put(7) Menambahkan beberapa elemen ke
q.put(3) dalam antrian dengan metode put()
q.put(1)
q.put(2)
12-16 print(q.get()) Mengambil elemen dari antrian
print(q.get()) menggunakan metode get()
print(q.get())
print(q.get())
Java
• Array
Source Code
public class SimpleArrayExample {
public static void main(String[] args) {
// declare and initialize the array

int[] myArray = {1, 2, 3, 4, 5};
// print the elements of the array

for (int i = 0; i < myArray.length; i++) {
System.out.println(myArray[i]);
}
}
}
Penjelasan
Program
1 public class Deklarasi public class yang
SimpleArrayExample { mengandong satu metode, main
2 public static void main(String[] Metode main didklarasikan disini
args) { yang mana berarti bisa diakses di luar
dari class dan tidak mengembalikan
value
5 int[] myArray = {1, 2, 3, 4, 5}; Dibuat integer myArray berisi 5
elemen. Dilaksanakan menggunakan
kurung kurawal untuk menutup
elemen
8-9 for (int i = 0; i < Menggunakan pengulangan untuk
myArray.length; i++) { mencetak elemen ke-i
System.out.println(myArray[i]);
• Circular List
Source Code
public class CircularLinkedList {

private Node head;
private Node tail;
private static class Node {

private int value;
private Node next;
Node(int value) {
this.value = value;
}
}
public void add(int value) {

Node newNode = new Node(value);
if (head == null) {
head = newNode;
tail = newNode;
tail.next = head;
} else {
tail.next = newNode;
tail = newNode;
tail.next = head;
}
}
public void display() {

Node current = head;
if (head == null) {
System.out.println("List is empty");
return;
}
System.out.print("Nodes of the circular linked list: ");
do {
System.out.print(current.value + " ");
current = current.next;
} while (current != head);
System.out.println();
}

CircularLinkedList cll = new CircularLinkedList();
cll.add(1);
cll.add(2);
cll.add(3);
cll.display();
}
}
Penjelasan
Program
1-3 public class Dideklarasikan class ini yang berisi 2
CircularLinkedList { variabel : head dan tail keduanya
private Node head; bertipe node
private Node tail;
5-7 private static class Node { Didefinisikan nested class node yang
private int value; punya 2 variabel : value (integer) dan
private Node next; next (refrensi ke node selanjutnya
pada list)
14-25 public void add(int value) { Implementasikan metode add() untuk

Node newNode = new menambahkan new node di akhir
Node(value); circular linked list. Bila list kosong
if (head == null) { maka head dan tail ke node baru dan
head = newNode; menetaokab tail.next untuk menunjuk
tail = newNode; head jika tidak akan menunjuk new
tail.next = head; node.
} else {
tail.next = newNode;
tail = newNode;
tail.next = head;
}
}
27-39 public void display() { Diimplementasikan metode display()
Node current = head; untuk mencetak value dari semua node
if (head == null) { pada circular linked list. Dimulai pada
System.out.println("List mengecek apabila head adalah null
is empty"); maka gunakan do-while look untuk
return; mengulangi list dimulai dari head.
} Pada loop, kita mencetak nilai node
System.out.print("Nodes of sekarang dan memindahkan next node
the circular linked list: "); hingga mencapai head lagi
do {
System.out.print(current.value +
" ");
current = current.next;
} while (current != head);
}
41-48 public static void Buat pengulangan CircularLinkedList,
main(String[] args) { tambahkan 3 node dan panggil
CircularLinkedList cll = display() untuk mencetak value semua
new CircularLinkedList(); node pada list
cll.add(1);
cll.add(2);
cll.add(3);
cll.display();
}
}
• Skip List
Source Code
// Java code for inserting element in skip list
class GFG {
// Class to implement node

static class Node {
int key;
// Array to hold pointers to node of different level

Node forward[];
Node(int key, int level)

{
this.key = key;
// Allocate memory to forward

forward = new Node[level + 1];
}
};
// Class for Skip list

static class SkipList {
// Maximum level for this skip list
int MAXLVL;
// P is the fraction of the nodes with level

// i pointers also having level i+1 pointers
float P;
// current level of skip list

int level;
// pointer to header node

Node header;
SkipList(int MAXLVL, float P)

{
this.MAXLVL = MAXLVL;
this.P = P;
level = 0;
// create header node and initialize key to -1

header = new Node(-1, MAXLVL);
}
int randomLevel()
{
float r = (float)Math.random();
int lvl = 0;
while (r < P && lvl < MAXLVL) {
lvl++;
r = (float)Math.random();
}
return lvl;
}
Node createNode(int key, int level)

{
Node n = new Node(key, level);
return n;
}
// Insert given key in skip list
void insertElement(int key)

{
Node current = header;
// create update array and initialize it

Node update[] = new Node[MAXLVL + 1];
/* start from highest level of skip list

move the current pointer forward while
key is greater than key of node next to
current Otherwise inserted current in update
and move one level down and continue search
*/
for (int i = level; i >= 0; i--) {
while (current.forward[i] != null
&& current.forward[i].key < key)
current = current.forward[i];
update[i] = current;
}
/* reached level 0 and forward pointer to

right, which is desired position to
insert key.
*/
current = current.forward[0];
/* if current is NULL that means we have reached

to end of the level or current's key is not
equal to key to insert that means we have to
insert node between update[0] and current node
*/
if (current == null || current.key != key) {
// Generate a random level for node
int rlevel = randomLevel();
// If random level is greater than list's

// current level (node with highest level
// inserted in list so far), initialize
// update value with pointer to header for
// further use
if (rlevel > level) {
for (int i = level + 1; i < rlevel + 1;
i++)
update[i] = header;
// Update the list current level

level = rlevel;
}
// create new node with random level

// generated
Node n = createNode(key, rlevel);
// insert node by rearranging pointers

for (int i = 0; i <= rlevel; i++) {
n.forward[i] = update[i].forward[i];
update[i].forward[i] = n;
}
System.out.println(
"Successfully Inserted key " + key);
}
}
// Display skip list level wise

void displayList()
{
System.out.println("\n*****Skip List*****");
for (int i = 0; i <= level; i++) {
Node node = header.forward[i];
System.out.print("Level " + i + ": ");
while (node != null) {
System.out.print(node.key + " ");
node = node.forward[i];
}
}
}
}
// Driver to test above code

public static void main(String[] args)
{
// create SkipList object with MAXLVL and P
SkipList lst = new SkipList(3, 0.5f);
lst.insertElement(3);
lst.displayList();
}
}
Penjelasan
Program
3 class GFG { Kode dimulai
dengan deklarasi
kelas GFC
6-18 static class Node { Pada kelas ini,
int key; static nested node
dideklarasi,
// Array to hold pointers to node of Merepresentasikan
different level node pada skip list
Node forward[]; dan memiliki 2
field : kunci
Node(int key, int level) integer dan array
{ bernama forward
this.key = key; yang menyimpan
pointer ke node
// Allocate memory to forward
pada level berbeda
forward = new Node[level + 1];
}
22-34 static class SkipList { Static nested class

// Maximum level for this skip list bernama SkipList
int MAXLVL; dideklarasi
merepresentasikan
// P is the fraction of the nodes struktur data skip
with level list yang memiliki
// i pointers also having level i+1 MAXLVL, P,
pointers level. Header
float P;
// current level of skip list

int level;
// pointer to header node

Node header;
36-44 SkipList(int MAXLVL, float P) Kostruktor yang

{ membuat
this.MAXLVL = MAXLVL; MAXLVL dan P
this.P = P; sebagai argumen
level = 0; dan inisialisasi
fields dari kelas
// create header node and
initialize key to -1
header = new Node(-1, MAXLVL);
}
46-55 int randomLevel() Metode

{ randomLevel yang
float r = (float)Math.random(); mengembalikan
int lvl = 0; random level
while (r < P && lvl < MAXLVL) { untuk node
lvl++;
r = (float)Math.random();
}
return lvl;
}
57-61 Node createNode(int key, int level) Metode

{ createNode untuk
Node n = new Node(key, level); membuat node
return n; baru dengan given
} key dan level
65-126 void insertElement(int key) Metode

{ insertElement yang
Node current = header; memasukan
elemen ke skip list.
// create update array and
initialize it
Node update[] = new Node[MAXLVL +
1];
/* start from highest level of

skip list
move the current pointer
forward while
key is greater than key of node
next to
current Otherwise inserted
current in update
and move one level down and
continue search
*/
for (int i = level; i >= 0; i--)
{
while (current.forward[i] !=
null
&& current.forward[i].key
< key)
current =
current.forward[i];
update[i] = current;
}
/* reached level 0 and forward

pointer to
right, which is desired position
to
insert key.
*/
current = current.forward[0];
/* if current is NULL that means

we have reached
to end of the level or current's
key is not
equal to key to insert that means
we have to
insert node between update[0] and
current node
*/
if (current == null ||
current.key != key) {
// Generate a random level
for node
int rlevel = randomLevel();
// If random level is greater

than list's
// current level (node with
highest level
// inserted in list so far),
initialize
// update value with pointer
to header for
// further use
if (rlevel > level) {
for (int i = level + 1; i
< rlevel + 1;
i++)
update[i] = header;
// Update the list

current level
level = rlevel;
}
// create new node with

random level
// generated
Node n = createNode(key,
rlevel);
// insert node by rearranging

pointers
for (int i = 0; i <= rlevel;
i++) {
n.forward[i] =
update[i].forward[i];
update[i].forward[i] = n;
}
System.out.println(
"Successfully Inserted
key " + key);
}
}
129-143 void displayList() Metode displayList

{ yang menampilkan
System.out.println("\n*****Skip elemen dari skip
List*****"); list level per level
for (int i = 0; i <= level; i++)
{
Node node =
header.forward[i];
System.out.print("Level " + i
+ ": ");
while (node != null) {
System.out.print(node.key
+ " ");
node = node.forward[i];
}
}
}
}
145-163 public static void main(String[] args) Metode main yang

{ menciptakan objek
// create SkipList object with MAXLVL SkipList dengan
and P MAXLVL dari 3
SkipList lst = new SkipList(3, 0.5f); dan P dari 0,5.
Lalu memasikan
lst.insertElement(3); beberapa elemen
lst.insertElement(6); ke skip list dan
lst.insertElement(7); menampilkan skip
lst.insertElement(9); list dengan
lst.insertElement(12); displayList.
lst.displayList();
}
}
• Circular Queue
Source Code
public class CircularQueue {

private int[] queue;
private int front;
private int rear;
private int size;
public CircularQueue(int k) {
queue = new int[k];
front = -1;
rear = -1;
size = 0;
}
public boolean enQueue(int value) {

if (isFull()) {
return false;
}
if (isEmpty()) {
front = 0;
}
rear = (rear + 1) % queue.length;
queue[rear] = value;
size++;
return true;
}
public boolean deQueue() {

if (isEmpty()) {
return false;
}
if (front == rear) {
front = -1;
rear = -1;
} else {
front = (front + 1) % queue.length;
}
size--;
return true;
}
public int Front() {

if (isEmpty()) {
return -1;
}
return queue[front];
}
public int Rear() {

if (isEmpty()) {
return -1;
}
return queue[rear];
}
public boolean isEmpty() {

return size == 0;
}
public boolean isFull() {

return size == queue.length;
}

CircularQueue queue = new CircularQueue(3);
queue.enQueue(1);
queue.enQueue(2);
queue.enQueue(3);
System.out.println(queue.enQueue(4)); // false, queue penuh
System.out.println(queue.Rear()); // 3
queue.deQueue();
System.out.println(queue.Front()); // 2
queue.deQueue();
System.out.println(queue.Front()); // 3
}
}
Penjelasan
Program
public class CircularQueue { Mendefinisikan kelas
private int[] queue; CircularQueue dengan private
private int front; fields queue, front, rear, dan size.
private int rear; Kostruktor insialisasi queue ke
private int size; array dengan ukuran k dan
menetapkan font, rear, dan size
ke -1,-1,dan 0
public CircularQueue(int k)
{
queue = new int[k];
front = -1;
rear = -1;
size = 0;
}
public boolean enQueue(int value) { Metode enQueue menambahkan
if (isFull()) { elemen ke queue. Apabila queue
return false; penuh akan kembali ke false jika
} idak maka akan mengecek
if (isEmpty()) { apakah queue kososng dan
front = 0; menetapkan front ke 0. Ini aka
} inkremasi rear dengan 1,
rear = (rear + 1) % queue.length; mengambil modulus
queue[rear] = value; queue.lenght untuk menangani
size++; aspek circular dari queue dan
return true; menetapkan elemen queue[rear]
} ke value. Akhirnya diinkremasi
size dan kembali ke true
public boolean deQueue() { Metode deQueue mengurangi
if (isEmpty()) { elemen dari queue. Apabila
return false; queue kosong akan kembali ke
} false jika front dan rear sama,
if (front == rear) { queue reset dengan pengaturan
front = -1; front dan rear kembali ke -1. Jika
rear = -1; tidak front inkremasi dengan 1,
} else { mengambik modulus
front = (front + 1) % queue.lenght .Akhirnya
queue.length; diinkremasi size dan kembali ke
} true
size--;
return true;
}
public int Front() { Metode front mengembalikan
if (isEmpty()) { value elemen di depan queue.
return -1; Apabila queue kosong, kembali -
} 1
return queue[front];
}
public int Rear() { Metode rear mengembalikan
if (isEmpty()) { elemen di akhir queue. Apabila
return -1; queue kosong, kembali ke -1
}
return queue[rear];
}
public boolean isEmpty() { Dua metode is Empty dan isFull
return size == 0; mengembalikan benar apabila
} queue kosong atau penuh
public boolean isFull() {
return size == queue.length;
}
public static void main(String[] args) { Menambahkan 3 elemen pada list
CircularQueue queue = new dan menampilkannya pada
CircularQueue(3); output.
queue.enQueue(1);
queue.enQueue(2);
queue.enQueue(3);
System.out.println(queue.enQueue(4));
// false, queue penuh
System.out.println(queue.Rear());
// 3
queue.deQueue();
System
• Priority Queue
Source Code
import java.util.PriorityQueue;
public class PriorityQueueExample {

// Membuat objek PriorityQueue dengan kapasitas awal 5
PriorityQueue<Integer> queue = new PriorityQueue<>(5);
// Menambahkan elemen ke dalam queue

queue.add(10);
queue.add(20);
queue.add(15);
queue.add(5);
queue.add(25);
// Menampilkan elemen-elemen dalam queue

System.out.println("Elemen-elemen dalam queue: " + queue);
// Menghapus elemen dengan nilai paling rendah

queue.poll();
// Menampilkan elemen-elemen dalam queue setelah penghapusan

System.out.println("Elemen-elemen dalam queue setelah penghapusan: " +
queue);
// Mengambil elemen dengan nilai paling rendah tanpa menghapusnya

int minElement = queue.peek();
System.out.println("Elemen dengan nilai paling rendah: " +
minElement);
}
}
Penjelasan
Program
import java.util.PriorityQueue; Mengimpor class dari paket java.util .
Class ini menyediakan implementasi
dari struktur data priority queue
public class Mendeklarasi public class yang berisi

PriorityQueueExample { metode main yang maa server sebagai
entry point program
PriorityQueue<Integer> queue = Mencipakan objek PriorityQueue baru

new PriorityQueue<>(5); dengan kapasitas 5. Tipe parameter
integer spesifikasi tipe elemen yang
queue bisa menyimpan
queue.add(3); queue.add(4); Menambahkan 5 elemen ke queue

queue.add(64); queue.add(23); tanpa urutan
queue.add(90);
system.out.println("Elemen- Menampilkan konten terkini dari
elemen dalam queue: " + queue); konsol queue
queue.poll(); Menghapus dan mengembalikan

elemen dengan value terkecil dari
queue
System.out.println("Elemen- Menampilkan konten dari queue
elemen dalam queue setelah setelah menghapus sebuah elemen
penghapusan: " + queue);
int minElement = queue.peek(); Mengambil namun tidak
menghilangkan elemen dengan value
terkecil dari queue dan
memerintahkannya ke minElement
variabel
System.out.println("Elemen Mencetak value dari elemen dengan

dengan nilai paling rendah: " + nilai terkecil ke konsol
minElement);

Laporan Program Quiz 1 Struktur Data Python dan Java

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Laporan Program Quiz 1 Struktur Data Python dan Java

Uploaded by

Copyright:

Available Formats

Laporan Program Quiz 1 Pratikum Struktur Data

Nama : Puti Raissa Razani

Baris Petikan source code Penjelasan

14-15 colors = ("red", "green", Line ini menginisialisasi tuple bernama

18-19 numbers = {1, 2, 3, 4, Line ini menginisialisasi set bernama

Screenshot output source code

• Linked List (Skip List)

# P is the fraction of the nodes with level

# create header node and initialize key to -1

# current level of skip list

# create new node

# create random level for node

# insert given key in skip list

# create new node with random level generated

# insert node by rearranging references

print("Successfully inserted key {}".format(key))

# Display skip list level wise

# Driver to test above code

87-100 if rlevel Kode ini merupakan bagian dari

Terakhir, metode ini mengatur

Penunjuk maju dari n untuk level

103 - def displayList(self): Kode dimulai dengan mencetak

Terakhir, ia mencetak sebuah

115-129 def main(): Memasukan elemen kepada list an

• Implementasi menggunakan Linked List

# Menambahkan node ke dalam list

# Mencetak isi dari linked list

Screenshot output source code

# Membuat priority queue dengan ukuran 5

# Menambahkan elemen ke dalam priority queue

# Mengambil elemen dari priority queue

Screenshot output source code

// declare and initialize the array

// print the elements of the array

Screenshot output source code

public class CircularLinkedList {

private static class Node {

public void add(int value) {

public void display() {

public static void main(String[] args) {

14-25 public void add(int value) { Implementasikan metode add() untuk

Screenshot output source code

// Java code for inserting element in skip list

// Class to implement node

// Array to hold pointers to node of different level

Node(int key, int level)

// Allocate memory to forward

// Class for Skip list

// P is the fraction of the nodes with level

// current level of skip list

// pointer to header node

SkipList(int MAXLVL, float P)

// create header node and initialize key to -1

Node createNode(int key, int level)

// Insert given key in skip list

void insertElement(int key)

// create update array and initialize it

/* start from highest level of skip list

/* reached level 0 and forward pointer to

/* if current is NULL that means we have reached

// If random level is greater than list's

// Update the list current level

// create new node with random level