Bài viết nằm trong series Data Structures và Algorithms trong Python

Singly Linked List

Giới thiệu

Mỗi Singly Linked List bao gồm nhiều nodes, và mỗi node chứa hai thành phần chính:

1. Data

• Component data cho phép mỗi node trong singly linked list lưu trữ một phần tử dữ liệu. Phần tử này có thể là string, character, number, hoặc bất kỳ kiểu dữ liệu nào khác.

2. Next (con trỏ)

• Component thứ hai, là một con trỏ (pointer) trỏ từ node hiện tại đến node tiếp theo trong danh sách liên kết. Component next này giúp kết nối các node lại với nhau, tạo thành chuỗi liên kết.

Head là điểm bắt đầu của linked list. Head không phải là một node mà là một con trỏ trỏ đến node đầu tiên trong danh sách. Khi cần duyệt qua linked list hoặc truy cập một phần tử, chúng ta sẽ bắt đầu từ head và di chuyển theo hướng của các node tiếp theo bằng cách sử dụng con trỏ next.

Component cuối cùng của singly linked list là null. Trong Python là None, biểu thị rằng đây là node cuối cùng và không có node nào tiếp theo nữa.

class Node: def __init__(self, data): self.data = data # Dữ liệu mà node lưu trữ self.next = None # Con trỏ trỏ đến node tiếp theo (ban đầu là None) class SinglyLinkedList: def __init__(self): self.head = None # Khởi tạo danh sách với head là None (danh sách trống)

display()

Chúng ta sẽ bắt đầu từ con trỏ head và in ra dữ liệu của từng node, sau đó di chuyển đến node tiếp theo. Ta sẽ tiếp tục kiểm tra node tiếp theo để đảm bảo rằng nó không phải là None. Nếu không phải, ta sẽ tiếp tục di chuyển đến node kế tiếp. Quy trình này sẽ lặp lại cho đến khi chạm tới node cuối cùng, nơi con trỏ next là None.

def display(self): current_node = self.head while current_node: # Duyệt qua danh sách cho đến khi gặp None print(current_node.data, end=" -> ") current_node = current_node.next print("None")

Insertion

Append

Phương thức append sẽ chèn một phần tử vào cuối linked list.

Trường hợp Linked List rỗng

Khi triển khai phương thức append cho linked list, chúng ta cần xử lý trường hợp đặc biệt nếu linked list rỗng. Trong trường hợp list rỗng (tức là head bằng None), node mới sẽ trở thành head của danh sách. Dưới đây là cách triển khai phương thức append bao gồm xử lý cho trường hợp list rỗng:

# Phương thức append: Chèn một phần tử mới vào cuối danh sách
def append(self, data): new_node = Node(data) # Nếu danh sách rỗng, node mới sẽ là head if not self.head: self.head = new_node return

Trường hợp Linked List không rỗng

Trong trường hợp linked list không rỗng, chúng ta cần duyệt qua linked list để tìm node cuối cùng và thêm node mới vào cuối danh sách.

# Phương thức append: Chèn một phần tử mới vào cuối danh sách
def append(self, data): new_node = Node(data) # Nếu danh sách rỗng, node mới sẽ là head if not self.head: self.head = new_node return # Nếu danh sách không rỗng, tìm node cuối và gắn node mới vào cuối last_node = self.head while last_node.next: last_node = last_node.next last_node.next = new_node

Sử dụng append

# Sử dụng danh sách liên kết
sll = SinglyLinkedList() # Thêm các phần tử vào danh sách
sll.append(1)
sll.append(2)
sll.append(3) # Hiển thị danh sách
sll.display() # Output: 1 -> 2 -> 3 -> None

Prepend

Phương thức prepend sẽ chèn một phần tử vào đầu linked list. Khi thêm một node mới vào đầu danh sách, chúng ta chỉ cần thay đổi con trỏ head để trỏ đến node mới, và con trỏ của node mới sẽ trỏ đến node cũ mà head trỏ đến trước đó.

def prepend(self, data): new_node = Node(data) # Tạo node mới new_node.next = self.head # Con trỏ của node mới trỏ đến node đầu hiện tại self.head = new_node # Cập nhật head để trỏ đến node mới

Sử dụng

# Sử dụng danh sách liên kết
sll = SinglyLinkedList() # Thêm các phần tử vào danh sách
sll.prepend("C") # Danh sách: C
sll.prepend("B") # Danh sách: B -> C
sll.prepend("A") # Danh sách: A -> B -> C # Thêm phần tử D vào đầu danh sách
sll.prepend("D") # Danh sách: D -> A -> B -> C # Hiển thị danh sách
sll.display() # Output: D -> A -> B -> C -> None

Insert After Node

Phương thức insert_after_node sẽ chèn một node mới sau một node cụ thể đã có trong linked list. Để triển khai phương thức này, ta cần tìm node đích và sau đó thêm node mới ngay sau nó. Điều này yêu cầu cập nhật các con trỏ để đảm bảo rằng danh sách liên kết vẫn duy trì cấu trúc chính xác.

def insert_after_node(self, prev_node_data, data): current_node = self.head while current_node: # Duyệt qua danh sách if current_node.data == prev_node_data: # Tìm node đích new_node = Node(data) # Tạo node mới new_node.next = current_node.next # Con trỏ của node mới trỏ đến node tiếp theo của node đích current_node.next = new_node # Cập nhật con trỏ của node đích trỏ đến node mới return current_node = current_node.next print(f"Node với giá trị {prev_node_data} không tồn tại trong danh sách liên kết.")

Sử dụng:

# Sử dụng danh sách liên kết
sll = SinglyLinkedList() # Thêm các phần tử vào danh sách
sll.append("A")
sll.append("B")
sll.append("C") # Chèn phần tử sau node "B"
sll.insert_after_node("B", "D") # Hiển thị danh sách
sll.display() # Output: A -> B -> D -> C -> None # Chèn phần tử sau node "F"
sll.insert_after_node("F", "D") # Output: Node với giá trị F không tồn tại trong danh sách liên kết.

Insert a node at a specific position in a linked list

Để chèn một phần tử vào vị trí cụ thể trong singly linked list, ta cần xử lý hai trường hợp chính:

• Chèn tại vị trí 0: ta chỉ cần cập nhật con trỏ next của node mới để trỏ đến head hiện tại, sau đó cập nhật head trỏ đến node mới.
• Chèn tại vị trí bất kỳ khác: Nếu position lớn hơn 0, ta sẽ duyệt qua danh sách để tìm node trước (prev_node) vị trí cần chèn. Sau đó, ta chèn node mới giữa node trước và node tại vị trí đó.

def insert_at_position(self, position, data): new_node = Node(data) # Trường hợp vị trí là 0 (chèn vào đầu danh sách) if position == 0: new_node.next = self.head self.head = new_node return # Trường hợp chèn vào vị trí bất kỳ khác current_node = self.head count = 0 prev_node = None # Duyệt qua danh sách để tìm vị trí cần chèn while current_node and count < position: prev_node = current_node current_node = current_node.next count += 1 # Nếu vị trí vượt quá kích thước của danh sách if count != position: print(f"Vị trí {position} vượt quá kích thước của danh sách.") return # Chèn node mới vào vị trí đã tìm thấy new_node.next = current_node prev_node.next = new_node

Sử dụng

# Sử dụng danh sách liên kết
llist = SinglyLinkedList() # Thêm các phần tử vào danh sách
llist.append("A")
llist.append("B")
llist.append("C") # Hiển thị danh sách ban đầu
print("Danh sách ban đầu:")
llist.display() # Chèn node tại vị trí 0 (đầu danh sách)
llist.insert_at_position(0, "D") # Hiển thị danh sách sau khi chèn tại vị trí 0
print("\nDanh sách sau khi chèn tại vị trí 0:")
llist.display() # Chèn node tại vị trí 2
llist.insert_at_position(2, "E") # Hiển thị danh sách sau khi chèn tại vị trí 2
print("\nDanh sách sau khi chèn tại vị trí 2:")
llist.display()

Output

Danh sách ban đầu: A -> B -> C -> None Danh sách sau khi chèn tại vị trí 0:
D -> A -> B -> C -> None Danh sách sau khi chèn tại vị trí 2:
D -> A -> E -> B -> C -> None 

Deletion

Xóa bởi giá trị

Chúng ta có 2 trường hợp:

• Node cần xóa là node đầu tiên (head).
• Node cần xóa không phải là node đầu tiên (head).

Node cần xóa là node đầu tiên

Nếu node cần xóa là head, ta chỉ cần cập nhật con trỏ head để trỏ đến node tiếp theo của head. Điều này sẽ xóa đi liên kết của head hiện tại, và danh sách liên kết vẫn sẽ được duy trì.

def delete_node(self, key): # Trường hợp node cần xóa là head if self.head and self.head.data == key: self.head = self.head.next return

Node cần xóa không phải là node đầu tiên

Nếu node cần xóa không phải là head, ta sẽ duyệt qua danh sách để tìm node trước node cần xóa. Sau khi tìm thấy, ta sẽ cập nhật con trỏ next của node trước này để trỏ đến node tiếp theo của node cần xóa, và điều này sẽ xóa bỏ node cần xóa ra khỏi danh sách.

def delete_node(self, key): current_node = self.head # Trường hợp node cần xóa là head if current_node and current_node.data == key: self.head = current_node.next current_node = None return # Trường hợp node cần xóa không phải là head prev_node = None while current_node and current_node.data != key: prev_node = current_node current_node = current_node.next # Nếu node cần xóa không tồn tại trong danh sách if current_node is None: print(f"Node với giá trị {key} không tồn tại trong danh sách liên kết.") return # Cập nhật con trỏ của node trước trỏ đến node tiếp theo của node bị xóa prev_node.next = current_node.next current_node = None

Sử dụng

 # Sử dụng danh sách liên kết llist = SinglyLinkedList() # Thêm các phần tử vào danh sách llist.append("A")
llist.append("B")
llist.append("C")
llist.append("D") # Hiển thị danh sách ban đầu print("Danh sách ban đầu:")
llist.display() # Xóa node "B" (không phải head) llist.delete_node("B") # Hiển thị danh sách sau khi xóa print("\nDanh sách sau khi xóa B:")
llist.display() # Xóa node "A" (là head) llist.delete_node("A") # Hiển thị danh sách sau khi xóa print("\nDanh sách sau khi xóa A (head):")
llist.display() 

Output

Danh sách ban đầu:
A -> B -> C -> D -> None Danh sách sau khi xóa B:
A -> C -> D -> None Danh sách sau khi xóa A (head):
C -> D -> None

Xóa bởi vị trí

Để xóa một node theo vị trí cụ thể trong singly linked list (danh sách liên kết đơn), ta sẽ xử lý hai trường hợp:

• Node cần xóa ở vị trí 0 (node đầu tiên - head): Đây là trường hợp đặc biệt khi node cần xóa là head, ta chỉ cần cập nhật con trỏ head để trỏ đến node tiếp theo.

• Node cần xóa không ở vị trí 0: Trong trường hợp này, ta cần duyệt qua danh sách đến vị trí cần xóa, tìm node trước vị trí đó và cập nhật con trỏ của node trước để bỏ qua node cần xóa.

Xóa node ở vị trí 0

def delete_at_position(self, position): if self.head is None: print("Danh sách trống.") return current_node = self.head # Trường hợp node cần xóa ở vị trí 0 (node đầu tiên) if position == 0: self.head = current_node.next # Cập nhật head để trỏ đến node tiếp theo current_node = None return

Xóa node ở các vị trí khác

def delete_at_position(self, position): if self.head is None: print("Danh sách trống.") return current_node = self.head # Trường hợp node cần xóa ở vị trí 0 (node đầu tiên) if position == 0: self.head = current_node.next # Cập nhật head để trỏ đến node tiếp theo current_node = None return # Trường hợp node cần xóa không phải ở vị trí 0 prev_node = None count = 0 # Duyệt qua danh sách đến vị trí cần xóa while current_node and count != position: prev_node = current_node current_node = current_node.next count += 1 # Nếu vị trí không tồn tại trong danh sách if current_node is None: print(f"Vị trí {position} vượt quá kích thước của danh sách.") return # Cập nhật con trỏ của node trước trỏ đến node tiếp theo của node bị xóa prev_node.next = current_node.next current_node = None

Sử dụng:

# Sử dụng danh sách liên kết
llist = SinglyLinkedList() # Thêm các phần tử vào danh sách llist.append("A")
llist.append("B")
llist.append("C")
llist.append("D")
llist.append("E") # Hiển thị danh sách ban đầu print("Danh sách ban đầu:")
llist.display() # Xóa node tại vị trí 0 (head) llist.delete_at_position(0) # Hiển thị danh sách sau khi xóa node tại vị trí 0 print("\nDanh sách sau khi xóa vị trí 0 (head):")
llist.display() # Xóa node tại vị trí 2 llist.delete_at_position(2) # Hiển thị danh sách sau khi xóa node tại vị trí 2 print("\nDanh sách sau khi xóa vị trí 2:")
llist.display() 

Output

Danh sách ban đầu: A -> B -> C -> D -> E -> None Danh sách sau khi xóa vị trí 0 (head):
B -> C -> D -> E -> None Danh sách sau khi xóa vị trí 2:
B -> C -> E -> None 

File code singly-linked-list cho tới lúc này

Length

Iterative

def get_length_iterative(self): count = 0 current_node = self.head while current_node: # Duyệt qua danh sách cho đến khi gặp None count += 1 current_node = current_node.next return count

Recursive

def get_length_recursive(self, node): # Nếu node là None, tức là danh sách rỗng if not node: return 0 # Tính độ dài đệ quy cho các node tiếp theo return 1 + self.get_length_recursive(node.next)

Node Swap

Trường hợp cần xử lý khi swap 2 nodes:

• Node 1 và Node 2 không phải là head.
• Một trong hai node là head.
• Hai node cần hoán đổi là giống nhau (không cần thực hiện gì).

Các bước để thực hiện swap 2 nodes:

• Tìm vị trí của hai node cần hoán đổi.
• Nếu một trong hai node là head, cập nhật con trỏ head để trỏ đến node kia.
• Cập nhật các con trỏ của các node trước hai node cần hoán đổi để giữ liên kết giữa các node trong danh sách.

 def swap_nodes(self, key1, key2): # Nếu hai node giống nhau, không cần hoán đổi if key1 == key2: return # Tìm vị trí của key1 prev_node1 = None current_node1 = self.head while current_node1 and current_node1.data != key1: prev_node1 = current_node1 current_node1 = current_node1.next # Tìm vị trí của key2 prev_node2 = None current_node2 = self.head while current_node2 and current_node2.data != key2: prev_node2 = current_node2 current_node2 = current_node2.next # Nếu không tìm thấy một trong hai node (None), dừng lại if not current_node1 or not current_node2: print("Một hoặc cả hai node không tồn tại.") return # Nếu key1 không phải là head, cập nhật con trỏ của prev_node1 if prev_node1: prev_node1.next = current_node2 else: # Nếu key1 là head self.head = current_node2 # Nếu key2 không phải là head, cập nhật con trỏ của prev_node2 if prev_node2: prev_node2.next = current_node1 else: # Nếu key2 là head self.head = current_node1 # Hoán đổi con trỏ next của hai node current_node1.next, current_node2.next = current_node2.next, current_node1.next

Sử dụng:

llist = SinglyLinkedList() print("------------------------------") llist.append("A")
llist.append("B")
llist.append("C")
llist.append("D")
# Hiển thị danh sách ban đầu
print("Danh sách ban đầu:")
llist.display() # Hoán đổi hai node
llist.swap_nodes("A", "D") # Hiển thị danh sách sau khi hoán đổi
print("\nDanh sách sau khi hoán đổi A và D:")
llist.display()

Output

------------------------------
Danh sách ban đầu:
A -> B -> C -> D -> None Danh sách sau khi hoán đổi A và D:
D -> B -> C -> A -> None

Giải thích

1. Tìm hai node cần hoán đổi:

• Ta duyệt qua danh sách liên kết để tìm prev_node và current_node cho cả hai node cần hoán đổi (key1 và key2).

2. Cập nhật liên kết:

• Nếu một trong hai node là head, ta cập nhật head trỏ đến node kia.
• Sau đó, ta cập nhật con trỏ của node trước để nó trỏ đến node còn lại.

Ví dụ key1 là "A": head, key2 là "D" thì

• self.head sẽ trỏ đến current_node2 ("D")
• prev_node2.next ("C") sẽ trỏ đến current_node1 ("A")

3. Hoán đổi các con trỏ next:

• Cuối cùng, ta hoán đổi con trỏ next của hai node hiện tại (current_node1.next và current_node2.next) để hoàn tất việc hoán đổi các node trong danh sách liên kết. Sau A (current_node1.next) sẽ là None (current_node2.next) và sau D (current_node2.next) sẽ là B (current_node1.next)

4. Trường hợp không tìm thấy node:

• Nếu không tìm thấy một trong hai node, chương trình sẽ thông báo và dừng lại.

Minh họa

File code singly-linked-list cho tới lúc này

Reverse

Iterative

def reverse_iterative(self): prev = None current = self.head while current: next_node = current.next # Lưu trữ node tiếp theo current.next = prev # Đảo ngược liên kết prev = current # Di chuyển prev lên current = next_node # Di chuyển current lên node tiếp theo self.head = prev # Cập nhật head để trỏ đến node cuối cùng (bây giờ là node đầu tiên)

• prev bắt đầu là None vì node cuối cùng của danh sách liên kết đảo ngược sẽ trỏ đến None.
• current là head, ta se duyệt qua từng node trong danh sách liên kết. Tại mỗi bước:
  • Ta lưu trữ node tiếp theo của current trong next_node.
  • Đảo ngược liên kết của node hiện tại (current.next) để trỏ về node trước (prev).
  • Cập nhật prev thành current và current thành next_node để tiếp tục duyệt danh sách.
• Cuối cùng, head được cập nhật để trỏ đến node cuối cùng, là node đầu tiên trong danh sách đảo ngược.

Merge Two Sorted Linked Lists

Ý tưởng cơ bản là so sánh các phần tử từ hai danh sách liên kết và xây dựng một danh sách mới bằng cách liên kết các node theo thứ tự.

 def merge_sorted_lists(self, other_list): head1 = self.head # con trỏ tới đầu danh sách 1 head2 = other_list.head # con trỏ tới đầu danh sách 2 tail = None # theo dõi phần cuối của merged list # Kiểm tra nếu danh sách đầu tiên rỗng if not head1: return head2 # Kiểm tra nếu danh sách thứ hai rỗng if not head2: return head1 # Bắt đầu so sánh giá trị của hai danh sách if head1 and head2: if head1.data <= head2.data: tail = head1 head1 = tail.next else: tail = head2 head2 = tail.next new_head = tail # new_head là con trỏ tới đầu merged list # Duyệt qua hai danh sách và tiếp tục so sánh các phần tử while head1 and head2: if head1.data <= head2.data: tail.next = head1 # Kết nối node nhỏ hơn từ head1 tail = head1 head1 = tail.next else: tail.next = head2 # Kết nối node nhỏ hơn từ head2 tail = head2 head2 = tail.next # Nếu head1 hết node, nối phần còn lại của head2 if not head1: tail.next = head2 # Nếu head2 hết node, nối phần còn lại của head1 if not head2: tail.next = head1 self.head = new_head # Cập nhật lại head của merged list return self.head

1. Kiểm tra danh sách rỗng:

• Nếu một trong hai danh sách rỗng, trả về danh sách còn lại.

2. Xác định node đầu tiên của merged list

• So sánh giá trị của node đầu tiên từ cả hai danh sách, chọn node có giá trị nhỏ hơn làm new_head (node đầu tiên của merged list).

3. Merge hai danh sách:

• Duyệt qua hai danh sách bằng cách so sánh từng node. Node nào nhỏ hơn sẽ được thêm vào merged list trước.

4. Nối phần còn lại:

• Khi một trong hai danh sách hết node, nối tất cả các node còn lại của danh sách kia vào.

5. Cập nhật self.head:

• Cập nhật self.head để trỏ đến node đầu tiên của merged list và trả về nếu có cần sử dụng cho mục đích khác.

Sử dụng

# Sử dụng danh sách liên kết
llist1 = SinglyLinkedList()
llist2 = SinglyLinkedList() # Thêm các phần tử vào danh sách liên kết 1 (đã sắp xếp)
llist1.append(1)
llist1.append(3)
llist1.append(5) # Thêm các phần tử vào danh sách liên kết 2 (đã sắp xếp)
llist2.append(2)
llist2.append(4)
llist2.append(6) print("Danh sách liên kết 1:")
llist1.display() print("Danh sách liên kết 2:")
llist2.display() # Gộp hai danh sách liên kết đã sắp xếp
llist1.merge_sorted_lists(llist2) print("\nDanh sách liên kết sau khi gộp:")
llist1.display()

Output

Danh sách liên kết 1: 1 -> 3 -> 5 -> None
Danh sách liên kết 2:
2 -> 4 -> 6 -> None Danh sách liên kết sau khi gộp:
1 -> 2 -> 3 -> 4 -> 5 -> 6 -> None

Remove Duplicates

• Duyệt qua danh sách liên kết, sử dụng set để lưu các giá trị đã gặp.
• Mỗi khi gặp một giá trị mới, thêm nó vào set.
• Nếu gặp một giá trị đã tồn tại trong set, ta xóa node đó khỏi danh sách.

 # Xóa các phần tử trùng lặp trong danh sách def remove_duplicates(self): if not self.head: return current = self.head prev = None seen_data = set() # Tập hợp để lưu các giá trị đã gặp while current: if current.data in seen_data: # Nếu giá trị đã gặp prev.next = current.next # Bỏ qua node hiện tại (current) else: seen_data.add(current.data) # Thêm giá trị vào tập hợp prev = current # Cập nhật con trỏ prev current = current.next # Di chuyển đến node tiếp theo

1. Duyệt qua danh sách:

• Sử dụng con trỏ current để duyệt qua từng node của danh sách.
• Con trỏ prev để theo dõi node trước đó, giúp ta cập nhật liên kết khi xóa một node trùng lặp.

2. Kiểm tra giá trị trùng lặp:

• Sử dụng set (seen_data) để lưu trữ các giá trị đã gặp.
• Mỗi khi gặp một giá trị mới, ta thêm nó vào tập hợp.
• Nếu giá trị đã tồn tại trong tập hợp, ta xóa node hiện tại bằng cách thay đổi con trỏ next của prev.

3. Cập nhật liên kết:

• Nếu phát hiện trùng lặp, ta bỏ qua node đó bằng cách thay đổi liên kết giữa prev và current.next.

Sử dụng

# Sử dụng danh sách liên kết
llist = SinglyLinkedList() # Thêm các phần tử vào danh sách
llist.append(1)
llist.append(2)
llist.append(2)
llist.append(3)
llist.append(4)
llist.append(4)
llist.append(5) print("Danh sách ban đầu:")
llist.display() # Xóa các phần tử trùng lặp
llist.remove_duplicates() print("Danh sách sau khi xóa các phần tử trùng lặp:")
llist.display()

Output

Danh sách ban đầu:
1 -> 2 -> 2 -> 3 -> 4 -> 4 -> 5 -> None
Danh sách sau khi xóa các phần tử trùng lặp:
1 -> 2 -> 3 -> 4 -> 5 -> None

Nth-to-Last Node

• Tính độ dài của danh sách
• Xác định vị trí của node thứ N từ cuối target_index = length - N
• Duyệt qua danh sách từ đầu đến vị trí target_index.
• Trả về node tại vị trí đó nếu tìm thấy, nếu N không hợp lệ (lớn hơn độ dài của danh sách hoặc N <= 0), trả về None.

 def nth_to_last_node(self, N): length = self.get_length_iterative() # Tính độ dài của danh sách if N > length or N <= 0: # Kiểm tra xem N có hợp lệ không return None target_index = length - N # Vị trí tương đương từ đầu danh sách current = self.head count = 0 while current: if count == target_index: return current # Trả về node thứ N từ cuối count += 1 current = current.next return None

Count Occurrences

Hàm count_occurrences sẽ duyệt qua từng node của danh sách, kiểm tra giá trị của từng node và đếm số lần giá trị mà ta muốn kiểm tra xuất hiện trong danh sách.

# Phương thức đếm số lần xuất hiện của một giá trị def count_occurrences(self, value): count = 0 current = self.head while current: if current.data == value: count += 1 current = current.next return count

Is Palindrome

Để kiểm tra xem một Singly Linked List có phải là palindrome hay không, chúng ta có thể sử dụng nhiều phương pháp khác nhau.

Sử dụng List

 def is_palindrome(self): values = [] current = self.head # Lưu các giá trị của danh sách liên kết vào một list while current: values.append(current.data) current = current.next # Kiểm tra xem list có phải là palindrome không return values == values[::-1]

Kết bài

Singly Linked List là một trong những cấu trúc dữ liệu cơ bản và quan trọng trong lập trình. Nó cung cấp một cách hiệu quả để lưu trữ và quản lý dữ liệu động, với các thao tác CRUD mà không cần cấp phát lại bộ nhớ như mảng. Tuy nhiên, điểm hạn chế của Singly Linked List là khó truy cập ngẫu nhiên đến các phần tử so với cấu trúc dữ liệu như mảng, do phải duyệt tuần tự qua từng node.

Việc nắm vững các thao tác trong Singly Linked List sẽ giúp ta áp dụng chúng một cách hiệu quả trong các bài toán lập trình. Hơn nữa, hiểu rõ các thuật toán liên quan đến danh sách liên kết đơn như reverse, kiểm tra palindrome, hay merge sorted list sẽ nâng cao kỹ năng xử lý dữ liệu của ta trong những tình huống thực tế.

Dù là một cấu trúc dữ liệu đơn giản, Singly Linked List vẫn là nền tảng quan trọng để hiểu sâu hơn về các cấu trúc dữ liệu phức tạp hơn, và sẽ trở thành công cụ mạnh mẽ khi bạn giải quyết những bài toán cần sự linh hoạt trong quản lý dữ liệu.