DSA with Python

Data Structures membahas bagaimana data dapat disimpan dalam berbagai struktur.

Algoritma membahas bagaimana memecahkan berbagai masalah, seringkali dengan menelusuri dan memanipulasi struktur data.

Memahami DSA membantu Anda menemukan kombinasi terbaik antara Struktur Data dan Algoritma untuk menciptakan kode yang lebih efisien.

Data Structures

Struktur Data adalah cara menyimpan dan mengatur data di komputer.

Python memiliki dukungan bawaan untuk beberapa struktur data, seperti daftar, kamus, dan set.

Struktur data lain dapat diimplementasikan menggunakan kelas dan objek Python, seperti daftar tertaut, tumpukan, antrean, pohon, dan grafik.

Dalam tutorial ini, kita akan berfokus pada Struktur Data berikut:

Algoritma

Algoritma adalah cara mengolah data di komputer dan memecahkan masalah seperti pengurutan, pencarian, dll.

Dalam tutorial ini, kita akan fokus pada Algoritma pencarian dan pengurutan berikut:

• Linear Search

• Binary Search

• Bubble Sort

• Selection Sort

• Insertion Sort

• Quick Sort

• Counting Sort

• Radix Sort

• Merge Sort

Mengapa Mempelajari DSA dengan Python

• Python memiliki sintaksis yang bersih dan mudah dibaca

• DSA memungkinkan Anda meningkatkan keterampilan pemecahan masalah

• DSA dan Python membantu Anda menulis kode yang lebih efisien

• DSA memberi Anda pemahaman yang lebih baik tentang penyimpanan memori

• DSA membantu Anda menangani tantangan pemrograman yang kompleks

• Python banyak digunakan dalam Ilmu Data dan Pembelajaran Mesin

Lists and Arrays

Dalam Python, lists adalah struktur data bawaan yang berfungsi sebagai array dinamis.

Lists bersifat berurutan, dapat diubah, dan dapat berisi elemen dengan tipe berbeda.

Lists

List adalah struktur data bawaan dalam Python yang digunakan untuk menyimpan banyak elemen.

List digunakan oleh banyak algoritma.

Creating Lists

List dibuat menggunakan tanda kurung siku []:

# Empty list
x = []

# List with initial values
y = [1, 2, 3, 4, 5]

# List with mixed types
z = [1, "hello", 3.14, True]

List Methods

Daftar Python dilengkapi beberapa algoritma bawaan (disebut metode), untuk melakukan operasi umum seperti penambahan, pengurutan, dan banyak lagi.

#Append one element to the list, and sort the list ascending:

x = [9, 12, 7, 4, 11]

# Add element:
x.append(8)

# Sort list ascending:
x.sort()

Create Algorithms

Terkadang kita ingin melakukan tindakan yang tidak ada di dalam Python.

Lalu kita bisa membuat algoritma kita sendiri.

Misalnya, sebuah algoritma dapat digunakan untuk menemukan nilai terendah dalam sebuah daftar, seperti pada contoh di bawah ini:

#Create an algorithm to find the lowest value in a list:

my_array = [7, 12, 9, 4, 11, 8]
minVal = my_array[0]

for i in my_array:
  if i < minVal:
    minVal = i

print('Lowest value:', minVal)

Algoritma di atas sangat sederhana dan cukup cepat untuk kumpulan data kecil, tetapi jika datanya cukup besar, algoritma apa pun akan membutuhkan waktu untuk dijalankan.

Di sinilah optimasi berperan.

Optimasi merupakan bagian penting dari pengembangan algoritma, dan tentu saja, bagian penting dari pemrograman DSA.

Time Complexity

Saat mengeksplorasi algoritma, kita sering mengamati berapa lama waktu yang dibutuhkan algoritma untuk berjalan relatif terhadap ukuran kumpulan data.

Dalam contoh di atas, waktu yang dibutuhkan algoritma untuk berjalan proporsional, atau linear, terhadap ukuran kumpulan data. Hal ini karena algoritma harus mengunjungi setiap elemen array satu kali untuk menemukan nilai terendah. Perulangan harus dijalankan 5 kali karena terdapat 5 nilai dalam array. Dan jika array memiliki 1000 nilai, perulangan harus dijalankan 1000 kali.

Coba simulasi di bawah ini untuk melihat hubungan antara jumlah operasi perbandingan yang diperlukan untuk menemukan nilai terendah, dan ukuran array.

Lihat halaman ini untuk penjelasan lebih lengkap tentang kompleksitas waktu.

Setiap algoritma dalam tutorial ini akan disajikan beserta kompleksitas waktunya.

Stacks

Stacks adalah struktur data linear yang mengikuti prinsip Last-In-First-Out (LIFO).

Stack adalah struktur data yang dapat menampung banyak elemen, dan elemen terakhir yang ditambahkan adalah elemen pertama yang dihapus.

Seperti tumpukan panekuk, panekuk ditambahkan dan dihapus dari atas. Jadi, ketika menghapus panekuk, panekuk tersebut akan selalu menjadi panekuk terakhir yang Anda tambahkan. Cara pengorganisasian elemen ini disebut LIFO: Last In First Out.

Operasi dasar yang dapat kita lakukan pada stack adalah:

• Push: Menambahkan elemen baru ke tumpukan.

• Pop: Menghapus dan mengembalikan elemen teratas dari tumpukan.

• Peek: Mengembalikan elemen teratas (terakhir) pada tumpukan.

• isEmpty: Memeriksa apakah tumpukan kosong.

• Size: Menemukan jumlah elemen dalam tumpukan.

Stacks dapat diimplementasikan dengan menggunakan array atau linked list.

Stacks dapat digunakan untuk mengimplementasikan mekanisme undo, untuk kembali ke status sebelumnya, untuk membuat algoritma pencarian depth-first dalam grafik, atau untuk backtracking.

Stacks sering disebutkan bersama dengan Antrean (Queues), yang merupakan struktur data serupa yang dijelaskan di halaman berikutnya.

Stack Implementation using Python Lists

Untuk daftar (dan array) Python, tumpukan dapat terlihat dan berperilaku seperti ini:

x = [5, 6, 2, 9, 3, 8, 4, 5, 7]

Karena daftar Python memiliki dukungan yang baik untuk fungsionalitas yang dibutuhkan untuk mengimplementasikan stacks, kita mulai dengan membuat tumpukan dan melakukan operasi tumpukan hanya dengan beberapa baris seperti ini:

#Using a Python list as a stack:

stack = []

# Push
stack.append('A')
stack.append('B')
stack.append('C')
print("Stack: ", stack)

# Peek
topElement = stack[-1]
print("Peek: ", topElement)

# Pop
poppedElement = stack.pop()
print("Pop: ", poppedElement)

# Stack after Pop
print("Stack after Pop: ", stack)

# isEmpty
isEmpty = not bool(stack)
print("isEmpty: ", isEmpty)

# Size
print("Size: ",len(stack))

#result:
# Stack: ['A', 'B', 'C']
# Peek: C
# Pop: C
# Stack after Pop: ['A', 'B']
# isEmpty: False
# Size: 2

Meskipun daftar Python dapat digunakan sebagai stacks, membuat kelas Stack khusus menyediakan enkapsulasi yang lebih baik dan fungsionalitas tambahan:

#Creating a stack using class:

class Stack:
  def __init__(self):
    self.stack = []

  def push(self, element):
    self.stack.append(element)

  def pop(self):
    if self.isEmpty():
      return "Stack is empty"
    return self.stack.pop()

  def peek(self):
    if self.isEmpty():
      return "Stack is empty"
    return self.stack[-1]

  def isEmpty(self):
    return len(self.stack) == 0

  def size(self):
    return len(self.stack)

# Create a stack
myStack = Stack()

myStack.push('A')
myStack.push('B')
myStack.push('C')

print("Stack: ", myStack.stack)
print("Pop: ", myStack.pop())
print("Stack after Pop: ", myStack.stack)
print("Peek: ", myStack.peek())
print("isEmpty: ", myStack.isEmpty())
print("Size: ", myStack.size())

Alasan untuk mengimplementasikan stacks menggunakan lists/arrays:

• Efisien Memori: Elemen array tidak menyimpan alamat elemen berikutnya seperti yang dilakukan node linked list.

• Lebih mudah diimplementasikan dan dipahami: Menggunakan array untuk mengimplementasikan tumpukan membutuhkan lebih sedikit kode daripada menggunakan linked list, dan karena alasan ini biasanya juga lebih mudah dipahami.

Alasan untuk tidak menggunakan array untuk mengimplementasikan tumpukan:

• Ukuran tetap: Sebuah array menempati bagian memori yang tetap. Ini berarti array dapat menggunakan lebih banyak memori daripada yang dibutuhkan, atau jika array penuh, array tidak dapat menampung lebih banyak elemen.

Stack Implementation using Linked Lists

Linked lists terdiri dari simpul-simpul dengan suatu jenis data, dan sebuah penunjuk ke simpul berikutnya.

Keuntungan besar menggunakan linked lists adalah simpul-simpul disimpan di mana pun terdapat ruang kosong di memori, simpul-simpul tersebut tidak harus disimpan secara berurutan tepat setelah satu sama lain seperti elemen yang disimpan dalam larik. Keuntungan lain dari daftar tertaut adalah ketika menambahkan atau menghapus simpul, simpul-simpul lainnya dalam daftar tidak perlu digeser.

Untuk lebih memahami manfaat menggunakan larik atau daftar tertaut untuk mengimplementasikan tumpukan, Anda harus memeriksa halaman ini yang menjelaskan bagaimana larik dan daftar tertaut disimpan dalam memori.

Beginilah cara tumpukan dapat diimplementasikan menggunakan daftar tertaut.

#Creating a Stack using a Linked List:

class Node:
  def __init__(self, value):
    self.value = value
    self.next = None

class Stack:
  def __init__(self):
    self.head = None
    self.size = 0

  def push(self, value):
    new_node = Node(value)
    if self.head:
      new_node.next = self.head
    self.head = new_node
    self.size += 1

  def pop(self):
    if self.isEmpty():
      return "Stack is empty"
    popped_node = self.head
    self.head = self.head.next
    self.size -= 1
    return popped_node.value

  def peek(self):
    if self.isEmpty():
      return "Stack is empty"
    return self.head.value

  def isEmpty(self):
    return self.size == 0

  def stackSize(self):
    return self.size

  def traverseAndPrint(self):
    currentNode = self.head
    while currentNode:
      print(currentNode.value, end=" -> ")
      currentNode = currentNode.next
    print()

myStack = Stack()
myStack.push('A')
myStack.push('B')
myStack.push('C')

print("LinkedList: ", end="")
myStack.traverseAndPrint()
print("Peek: ", myStack.peek())
print("Pop: ", myStack.pop())
print("LinkedList after Pop: ", end="")
myStack.traverseAndPrint()
print("isEmpty: ", myStack.isEmpty())
print("Size: ", myStack.stackSize())

#result:
   LinkedList: C -> B -> A ->
   Peek: C
   Pop: C
   LinkedList after Pop: B -> A ->
   isEmpty: False
   Size: 2

Alasan penggunaan linked list untuk mengimplementasikan stack:

• Ukuran dinamis: Stack dapat bertambah dan menyusut secara dinamis, tidak seperti array.

Alasan tidak menggunakan linked list untuk mengimplementasikan stack:

• Memori tambahan: Setiap elemen stack harus berisi alamat ke elemen berikutnya (simpul linked list berikutnya).

• Keterbacaan: Kode mungkin lebih sulit dibaca dan ditulis bagi sebagian orang karena lebih panjang dan lebih kompleks.

Common Stack Applications

Tumpukan digunakan dalam banyak skenario dunia nyata:

• Operasi Batalkan/Ulangi di editor teks

• Riwayat peramban (mundur/maju)

• Tumpukan pemanggilan fungsi dalam pemrograman

• Evaluasi ekspresi

Queues

Antrean adalah struktur data linier yang mengikuti prinsip First-In-First-Out (FIFO).

Bayangkan antrean seperti orang-orang yang mengantre di supermarket.

Orang pertama yang mengantre juga merupakan orang pertama yang membayar dan meninggalkan supermarket.

Operasi dasar yang dapat kita lakukan pada antrean adalah:

• Enqueue: Menambahkan elemen baru ke antrean.

• Dequeue: Menghapus dan mengembalikan elemen pertama (depan) dari antrean.

• Peek: Mengembalikan elemen pertama dalam antrean.

• isEmpty: Memeriksa apakah antrean kosong.

• Size: Menemukan jumlah elemen dalam antrean.

Antrean dapat diimplementasikan menggunakan array atau linked list.

Antrean dapat digunakan untuk mengimplementasikan penjadwalan pekerjaan untuk printer kantor, pemrosesan pesanan untuk e-tiket, atau untuk membuat algoritma pencarian breadth-first dalam grafik.

Antrean sering disebutkan bersama dengan Stack, yang merupakan struktur data serupa yang dijelaskan di halaman sebelumnya.

Queue Implementation using Python Lists

Untuk daftar (dan array) Python, Antrean dapat terlihat dan berperilaku seperti ini:

x = [5, 6, 2, 9, 3, 8, 4, 2]

Karena lists Python memiliki dukungan yang baik untuk fungsionalitas yang dibutuhkan untuk mengimplementasikan antrean, kita mulai dengan membuat antrean dan melakukan operasi antrean hanya dengan beberapa baris:

#Using a Python list as a queue:

queue = []

# Enqueue
queue.append('A')
queue.append('B')
queue.append('C')
print("Queue: ", queue)

# Peek
frontElement = queue[0]
print("Peek: ", frontElement)

# Dequeue
poppedElement = queue.pop(0)
print("Dequeue: ", poppedElement)

print("Queue after Dequeue: ", queue)

# isEmpty
isEmpty = not bool(queue)
print("isEmpty: ", isEmpty)

# Size
print("Size: ", len(queue))

Catatan

Meskipun penggunaan list itu mudah, menghapus elemen dari awal (operasi dequeue) memerlukan pemindahan semua elemen yang tersisa, sehingga kurang efisien untuk antrean besar.

Implementing a Queue Class

Berikut implementasi lengkap kelas Queue:

#Using a Python class as a queue:

class Queue:
  def __init__(self):
    self.queue = []

  def enqueue(self, element):
    self.queue.append(element)

  def dequeue(self):
    if self.isEmpty():
      return "Queue is empty"
    return self.queue.pop(0)

  def peek(self):
    if self.isEmpty():
      return "Queue is empty"
    return self.queue[0]

  def isEmpty(self):
    return len(self.queue) == 0

  def size(self):
    return len(self.queue)

# Create a queue
myQueue = Queue()

myQueue.enqueue('A')
myQueue.enqueue('B')
myQueue.enqueue('C')

print("Queue: ", myQueue.queue)
print("Peek: ", myQueue.peek())
print("Dequeue: ", myQueue.dequeue())
print("Queue after Dequeue: ", myQueue.queue)
print("isEmpty: ", myQueue.isEmpty())
print("Size: ", myQueue.size())

Queue Implementation using Linked Lists

Linked list terdiri dari simpul-simpul dengan suatu jenis data, dan sebuah penunjuk ke simpul berikutnya.

Keuntungan besar menggunakan linked lists adalah simpul-simpul disimpan di mana pun terdapat ruang kosong di memori, simpul-simpul tersebut tidak harus disimpan secara berurutan satu demi satu seperti elemen yang disimpan dalam larik. Keuntungan lain dari daftar tertaut adalah ketika menambahkan atau menghapus simpul, simpul-simpul lainnya dalam daftar tidak perlu digeser.

Untuk lebih memahami manfaat menggunakan larik atau daftar tertaut untuk mengimplementasikan antrean, Anda sebaiknya melihat halaman ini yang menjelaskan bagaimana larik dan daftar tertaut disimpan dalam memori.

Beginilah cara antrean dapat diimplementasikan menggunakan linked list.

#Creating a Queue using a Linked List:

class Node:
  def __init__(self, data):
    self.data = data
    self.next = None

class Queue:
  def __init__(self):
    self.front = None
    self.rear = None
    self.length = 0

  def enqueue(self, element):
    new_node = Node(element)
    if self.rear is None:
      self.front = self.rear = new_node
      self.length += 1
      return
    self.rear.next = new_node
    self.rear = new_node
    self.length += 1

  def dequeue(self):
    if self.isEmpty():
      return "Queue is empty"
    temp = self.front
    self.front = temp.next
    self.length -= 1
    if self.front is None:
      self.rear = None
    return temp.data

  def peek(self):
    if self.isEmpty():
      return "Queue is empty"
    return self.front.data

  def isEmpty(self):
    return self.length == 0

  def size(self):
    return self.length

  def printQueue(self):
    temp = self.front
    while temp:
      print(temp.data, end=" -> ")
      temp = temp.next
    print()

# Create a queue
myQueue = Queue()

myQueue.enqueue('A')
myQueue.enqueue('B')
myQueue.enqueue('C')

print("Queue: ", end="")
myQueue.printQueue()
print("Peek: ", myQueue.peek())
print("Dequeue: ", myQueue.dequeue())
print("Queue after Dequeue: ", end="")
myQueue.printQueue()
print("isEmpty: ", myQueue.isEmpty())
print("Size: ", myQueue.size())

Alasan penggunaan linked list untuk mengimplementasikan antrean:

• Ukuran dinamis: Antrean dapat bertambah dan menyusut secara dinamis, tidak seperti array.

• Tanpa pergeseran: Elemen terdepan antrean dapat dihapus (enqueue) tanpa harus menggeser elemen lain di dalam memori.

Alasan tidak menggunakan linked list untuk mengimplementasikan antrean:

• Memori tambahan: Setiap elemen antrean harus berisi alamat ke elemen berikutnya (simpul linked list berikutnya).

• Keterbacaan: Kode mungkin lebih sulit dibaca dan ditulis bagi sebagian orang karena lebih panjang dan lebih kompleks.

Common Queue Applications

Antrean digunakan dalam banyak skenario dunia nyata:

• Penjadwalan tugas dalam sistem operasi

• Pencarian breadth-first dalam grafik

• Antrean pesan dalam sistem terdistribusi

Linked Lists

Catatan

Linked List, sesuai namanya, adalah daftar tempat simpul-simpul terhubung. Setiap simpul berisi data dan sebuah pointer. Cara mereka terhubung adalah dengan setiap simpul menunjuk ke lokasi di dalam memori tempat simpul berikutnya berada.

Daftar tertaut terdiri atas simpul-simpul dengan beberapa jenis data, dan sebuah penunjuk, atau tautan, ke simpul berikutnya.

Linked Lists vs Arrays

Cara termudah untuk memahami linked list mungkin dengan membandingkan linked list dengan array.

Linked list terdiri dari node, dan merupakan struktur data linear yang kita buat sendiri, tidak seperti array yang merupakan struktur data yang sudah ada dalam bahasa pemrograman yang dapat kita gunakan.

Node dalam linked list menyimpan tautan ke node lain, tetapi elemen array tidak perlu menyimpan tautan ke elemen lain.

Catatan

Bagaimana linked list dan array disimpan dalam memori dijelaskan secara rinci di halaman Linked List dalam Memori.

Tabel di bawah ini membandingkan linked list dengan array untuk memberikan pemahaman yang lebih baik tentang apa itu linked list.

	Arrays	Linked Lists
An existing data structure in the programming language	Yes	No
Fixed size in memory	Yes	No
Elements, or nodes, are stored right after each other in memory (contiguously)	Yes	No
Memory usage is low (each node only contains data, no links to other nodes)	Yes	No
Elements, or nodes, can be accessed directly (random access)	Yes	No
Elements, or nodes, can be inserted or deleted in constant time, no shifting operations in memory needed.	No	Yes

.	Arrays	Linked Lists
An existing data structure in the programming language	Yes	No
Fixed size in memory	Yes	No
Elements, or nodes, are stored right after each other in memory (contiguously)	Yes	No
Memory usage is low (each node only contains data, no links to other nodes)	Yes	No
Elements, or nodes, can be accessed directly (random access)	Yes	No
Elements, or nodes, can be inserted or deleted in constant time, no shifting operations in memory needed.	No	Yes

Berikut beberapa properti utama linked list, dibandingkan dengan array:

• Linked list tidak dialokasikan ke ukuran tetap di memori seperti array, sehingga linked list tidak perlu memindahkan seluruh list ke ruang memori yang lebih besar ketika ruang memori tetap tersebut penuh, seperti yang harus dilakukan array.

• Node linked list tidak ditata satu per satu di memori (berkelanjutan), sehingga node linked list tidak perlu digeser ke atas atau ke bawah di memori ketika node disisipkan atau dihapus.

• Node linked list membutuhkan lebih banyak memori untuk menyimpan satu atau lebih tautan ke node lain. Elemen array tidak membutuhkan banyak memori, karena elemen array tidak berisi tautan ke elemen lain.

• Operasi linked list biasanya lebih sulit diprogram dan membutuhkan lebih banyak baris daripada operasi array serupa, karena bahasa pemrograman memiliki dukungan bawaan yang lebih baik untuk array.

• Kita harus menelusuri linked list untuk menemukan node pada posisi tertentu, tetapi dengan array kita dapat mengakses elemen secara langsung dengan menulis myArray[5].

Types of Linked Lists

Ada tiga bentuk dasar linked lists:

• Singly linked lists

• Doubly linked lists

• Circular linked lists

Singly linked lists adalah jenis daftar tertaut yang paling sederhana. Daftar ini membutuhkan lebih sedikit ruang memori karena setiap simpul hanya memiliki satu alamat ke simpul berikutnya, seperti pada gambar di bawah ini.

Doubly linked lists memiliki simpul dengan alamat ke simpul sebelumnya dan berikutnya, seperti pada gambar di bawah, sehingga membutuhkan lebih banyak memori. Namun, daftar tertaut ganda bagus jika Anda ingin dapat berpindah ke atas dan ke bawah dalam daftar.

Circular linked lists mirip dengan daftar tertaut tunggal atau ganda, dengan simpul pertama, "kepala", dan simpul terakhir, "ekor", terhubung.

Dalam daftar tertaut tunggal atau ganda, kita dapat menemukan awal dan akhir daftar hanya dengan memeriksa apakah tautannya null. Namun, untuk daftar tertaut melingkar, kode yang lebih kompleks diperlukan untuk memeriksa simpul awal dan akhir secara eksplisit dalam aplikasi tertentu.

Daftar tertaut melingkar cocok untuk daftar yang perlu Anda telusuri secara terus-menerus.

Gambar di bawah ini adalah contoh daftar tertaut melingkar tunggal:

Gambar di bawah adalah contoh daftar tertaut melingkar ganda:

Catatan

Jenis daftar tertaut yang Anda perlukan bergantung pada masalah yang ingin Anda pecahkan.

Linked List Operations

Hal-hal dasar yang dapat kita lakukan dengan linked list adalah:

• Traversal

• Remove node

• Insert a node

• Sort

Untuk menyederhanakan, linked list tunggal akan digunakan untuk menjelaskan operasi-operasi ini di bawah ini.

Traversal of a Linked List

Menelusuri (traversing) linked list berarti menelusuri linked list dengan mengikuti tautan dari satu simpul ke simpul berikutnya.

Menelusuri linked list biasanya dilakukan untuk mencari simpul tertentu, membaca atau mengubah konten simpul, menghapus simpul, atau menyisipkan simpul tepat sebelum atau sesudah simpul tersebut.

Untuk menelusuri linked list tunggal, kita mulai dengan simpul pertama dalam list, yaitu simpul kepala, dan mengikuti tautan berikutnya dari simpul tersebut, lalu tautan berikutnya dari simpul berikutnya, dan seterusnya, hingga alamat berikutnya bernilai null.

Kode di bawah ini mencetak nilai simpul saat menelusuri linked list, dengan cara yang sama seperti animasi di atas.

#Traversal of a singly linked list in Python:

class Node:
  def __init__(self, data):
    self.data = data
    self.next = None

def traverseAndPrint(head):
  currentNode = head
  while currentNode:
    print(currentNode.data, end=" -> ")
    currentNode = currentNode.next
  print("null")

node1 = Node(7)
node2 = Node(11)
node3 = Node(3)
node4 = Node(2)
node5 = Node(9)

node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5

traverseAndPrint(node1)

Find The Lowest Value in a Linked List

Mari kita cari nilai terendah dalam daftar tertaut tunggal dengan menelusurinya dan memeriksa setiap nilai.

Mencari nilai terendah dalam daftar tertaut sangat mirip dengan cara kita mencari nilai terendah dalam larik, hanya saja kita perlu mengikuti tautan berikutnya untuk menuju ke simpul berikutnya.

Untuk menemukan nilai terendah, kita perlu menelusuri daftar seperti pada kode sebelumnya. Namun, selain menelusuri daftar, kita juga harus memperbarui nilai terendah saat ini ketika kita menemukan simpul dengan nilai yang lebih rendah.

Pada kode di bawah ini, algoritma untuk menemukan nilai terendah dipindahkan ke fungsi yang disebut findLowestValue.

#Finding the lowest value in a singly linked list in Python:

class Node:
  def __init__(self, data):
    self.data = data
    self.next = None

def findLowestValue(head):
  minValue = head.data
  currentNode = head.next
  while currentNode:
    if currentNode.data < minValue:
      minValue = currentNode.data
    currentNode = currentNode.next
  return minValue

node1 = Node(7)
node2 = Node(11)
node3 = Node(3)
node4 = Node(2)
node5 = Node(9)

node1.next = node2
node2.next = node3
node3.next = node4
node4.next = node5

print("The lowest value in the linked list is:", findLowestValue(node1))

Delete a Node in a Linked List

Jika Anda ingin menghapus sebuah simpul dalam linked list, penting untuk menghubungkan simpul-simpul di setiap sisi simpul sebelum menghapusnya, agar linked list tidak rusak.

Jadi, sebelum menghapus simpul, kita perlu mendapatkan penunjuk berikutnya dari simpul sebelumnya, dan menghubungkan simpul sebelumnya ke simpul berikutnya yang baru sebelum menghapus simpul di antaranya.

Selain itu, sebaiknya hubungkan terlebih dahulu penunjuk berikutnya ke simpul setelah simpul yang ingin dihapus, sebelum kita menghapusnya. Hal ini untuk menghindari penunjuk yang 'menggantung', penunjuk yang tidak menunjuk ke mana pun, meskipun hanya sesaat.

Simulasi di bawah ini menunjukkan simpul yang ingin dihapus, dan bagaimana list harus dilintasi terlebih dahulu untuk menghubungkan list dengan benar sebelum menghapus simpul tanpa merusak linked list.

Dalam kode di bawah, algoritma untuk menghapus node dipindahkan ke fungsi yang disebut deleteSpecificNode.