Doubly Linked List trong Python

Danh sách liên kết đôi (Doubly Linked List) giống với danh sách liên kết đơn (Singly Linked List), nhưng có thêm sự khác biệt là con trỏ prev trong mỗi node.

Cấu trúc của Node trong danh sách liên kết đôi:

• Data: Chứa dữ liệu của node.
• Next: Con trỏ trỏ đến node tiếp theo trong danh sách.
• Prev: Con trỏ trỏ đến node trước đó trong danh sách.

Trong khi danh sách liên kết đơn chỉ có con trỏ next để liên kết với node kế tiếp, danh sách liên kết đôi có thêm con trỏ prev để liên kết với node trước đó, giúp cho việc duyệt ngược qua danh sách trở nên dễ dàng hơn.

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

class DoublyLinkedList:
    def __init__(self):
        self.head = None

Append và Prepend

Append

def append(self, data):
        new_node = Node(data)
        if not self.head:  # Nếu danh sách rỗng
            self.head = new_node
            return
        temp = self.head
        while temp.next:
            temp = temp.next
        temp.next = new_node
        new_node.prev = temp

• Tạo một node mới.
• Nếu danh sách rỗng (head node bằng None), thì node mới trở thành node đầu tiên (head).
• Nếu danh sách không rỗng, duyệt qua danh sách để tìm node cuối cùng, rồi liên kết con trỏ next của node cuối cùng với node mới. Con trỏ prev của node mới trỏ ngược lại node cuối cùng.

Prepend

    def prepend(self, data):
        new_node = Node(data)
        if not self.head:  # Nếu danh sách rỗng
            self.head = new_node
            return
        self.head.prev = new_node
        new_node.next = self.head
        self.head = new_node

• Tạo một node mới.
• Nếu danh sách rỗng (tức là head node bằng None), thì node mới này trở thành node đầu tiên.
• Nếu danh sách không rỗng, con trỏ next của node mới sẽ trỏ đến node đầu hiện tại, và con trỏ prev của node đầu hiện tại sẽ trỏ ngược về node mới.
• Cập nhật head node thành node mới.

Add Node Before/After

Before

# Thêm node trước một node cụ thể
    def add_before(self, target_data, data):
        temp = self.head
        while temp:
            if temp.data == target_data:
                new_node = Node(data)
                new_node.next = temp
                new_node.prev = temp.prev
                if temp.prev:
                    temp.prev.next = new_node
                else:
                    self.head = new_node
                temp.prev = new_node
                return
            temp = temp.next
        print(f"Node {target_data} không tồn tại trong danh sách")

• Xác định vị trí của node mà bạn muốn thêm node mới trước nó (node mục tiêu).
• Tạo một node mới chứa dữ liệu.
• Điều chỉnh các con trỏ để thêm node mới vào trước node mục tiêu:
  • Con trỏ next của node mới sẽ trỏ đến node mục tiêu.
  • Con trỏ prev của node mới sẽ trỏ đến node trước node mục tiêu (nếu có).
  • Nếu node mục tiêu không phải là node đầu tiên, bạn cũng phải điều chỉnh con trỏ next của node trước đó để trỏ đến node mới.
  • Nếu node mục tiêu là node đầu tiên (head), cập nhật head thành node mới.

After

# Thêm node sau một node cụ thể
    def add_after(self, target_data, data):
        temp = self.head
        while temp:
            if temp.data == target_data:
                new_node = Node(data)
                # cập nhật con trỏ next của node mới để trỏ đến node sau node mục tiêu
                new_node.next = temp.next
                # cập nhật con trỏ prev của node sau node mục tiêu để trỏ về node mới
                if temp.next:
                    temp.next.prev = new_node
                # cập nhật con trỏ next của node mục trỏ đến node mới
                temp.next = new_node
                # cập nhật con trỏ prev của node mới để trỏ về node mục tiêu
                new_node.prev = temp
                return
            temp = temp.next
        print(f"Node {target_data} không tồn tại trong danh sách")

• Xác định vị trí của node mà bạn muốn thêm node mới sau nó (node mục tiêu).
• Tạo một node mới chứa dữ liệu.
• Điều chỉnh các con trỏ để thêm node mới vào sau node mục tiêu:
  • Con trỏ prev của node mới sẽ trỏ về node mục tiêu.
  • Con trỏ next của node mới sẽ trỏ đến node sau node mục tiêu (nếu có).
  • Nếu node mục tiêu không phải là node cuối cùng, bạn cũng phải điều chỉnh con trỏ prev của node sau node mục tiêu để trỏ về node mới.
  • Nếu node mục tiêu là node cuối cùng, node mới sẽ trở thành node cuối cùng trong danh sách.

Delete Node

    # Xóa node
    def delete(self, target_data):
        temp = self.head

        # Trường hợp danh sách rỗng
        if not temp:
            print("Danh sách rỗng")
            return

        # Trường hợp chỉ có một node
        if temp.next is None and temp.data == target_data:
            self.head = None
            return

        # Trường hợp xóa node đầu
        if temp.data == target_data:
            self.head = temp.next
            self.head.prev = None
            return

        # Trường hợp xóa node ở giữa hoặc cuối
        while temp:
            if temp.data == target_data:
                if temp.next:  # Node ở giữa
                    temp.prev.next = temp.next
                    temp.next.prev = temp.prev
                else:  # Node ở cuối
                    temp.prev.next = None
                return
            temp = temp.next

        print(f"Node {target_data} không tồn tại trong danh sách")

• Nếu danh sách chỉ có một node (tức là head.next là None), việc xóa node đó sẽ làm cho danh sách trở thành rỗng (head bằng None).
• Nếu node cần xóa là node đầu tiên (head):
  • Cập nhật head để trỏ đến node tiếp theo.
  • Đặt con trỏ prev của node tiếp theo là None (nếu có node tiếp theo).
• Nếu node cần xóa nằm ở giữa:
  • Con trỏ next của node trước node cần xóa sẽ trỏ đến node tiếp theo của node cần xóa.
  • Con trỏ prev của node tiếp theo sẽ trỏ ngược lại node trước đó.
• Nếu node cần xóa là node cuối cùng:
  • Cập nhật con trỏ next của node trước đó về None, bỏ qua node cuối cùng.

Reverse

 # Đảo ngược danh sách liên kết đôi
    def reverse(self):
        temp = self.head
        if not temp:
            return

        while temp:
            temp.prev, temp.next = temp.next, temp.prev  # Đảo ngược con trỏ prev và next
            if not temp.prev:  # Sau khi đảo ngược, temp.prev sẽ là None khi ở node cuối
                self.head = temp  # Cập nhật lại head
            temp = temp.prev  # Tiếp tục đảo ngược đến node tiếp theo

• Bắt đầu từ node đầu (head), ta sẽ duyệt qua từng node trong danh sách.
• Hoán đổi các con trỏ:
  • Với mỗi node, hoán đổi giá trị của hai con trỏ prev và next.
  • Sau khi hoán đổi, con trỏ prev sẽ trỏ đến node tiếp theo, và con trỏ next sẽ trỏ đến node trước đó.
• Cập nhật head node: Sau khi hoàn tất việc hoán đổi, node cuối cùng trước đó sẽ trở thành node đầu tiên. Vì vậy, cần cập nhật lại head của danh sách.

Sử dụng

# Ví dụ sử dụng
dll = DoublyLinkedList()

# Thêm một số phần tử vào danh sách
dll.append(10)
dll.append(20)
dll.append(30)
dll.prepend(0)

# In danh sách
print("Danh sách liên kết đôi ban đầu:")
dll.print_list()

# Thêm node sau node có giá trị 20
dll.add_after(20, 25)
print("\nSau khi thêm 25 sau 20:")
dll.print_list()

# Thêm node trước node có giá trị 10
dll.add_before(10, 5)
print("\nSau khi thêm 5 trước 10:")
dll.print_list()

# Xóa node đầu tiên
dll.delete(0)
print("\nSau khi xóa node đầu (0):")
dll.print_list()

# Xóa node cuối cùng
dll.delete(30)
print("\nSau khi xóa node cuối (30):")
dll.print_list()

# Đảo ngược danh sách
dll.reverse()
print("\nSau khi đảo ngược danh sách:")
dll.print_list()

Danh sách liên kết đôi ban đầu:

0 <-> 10 <-> 20 <-> 30

Sau khi thêm 25 sau 20:
0 <-> 10 <-> 20 <-> 25 <-> 30

Sau khi thêm 5 trước 10:
0 <-> 5 <-> 10 <-> 20 <-> 25 <-> 30

Sau khi xóa node đầu (0):
5 <-> 10 <-> 20 <-> 25 <-> 30

Sau khi xóa node cuối (30):
5 <-> 10 <-> 20 <-> 25

Sau khi đảo ngược danh sách:
25 <-> 20 <-> 10 <-> 5

Ưu và nhược điểm của Singly Linked List, Circular Linked List, Doubly Linked List

Singly Linked List

• Ưu điểm:
  • Cấu trúc đơn giản, tiêu tốn ít bộ nhớ hơn vì chỉ cần một con trỏ next.
• Nhược điểm:
  • Không thể duyệt ngược từ cuối danh sách.
  • Việc chèn, xóa node ở giữa mất thời gian vì cần duyệt từ đầu danh sách.

Circular Linked List

Có thể là dạng liên kết đơn hoặc đôi, nhưng phổ biến là liên kết đơn.

• Ưu điểm:
  • Có thể duyệt vòng vô tận từ bất kỳ vị trí nào trong danh sách.
  • Thích hợp cho các trường hợp yêu cầu hoạt động tuần hoàn, như lặp danh sách nhạc hoặc vòng lặp chơi game.
• Nhược điểm:
  • Khó xác định điểm kết thúc danh sách vì không có None để chỉ định kết thúc.
  • Việc xóa node hoặc duyệt vẫn tương tự như danh sách liên kết đơn, không thể duyệt ngược nếu là liên kết đơn.

Doubly Linked List

• Ưu điểm:
  • Duyệt ngược dễ dàng từ bất kỳ vị trí nào trong danh sách.
  • Chèn và xóa node nhanh chóng ở cả đầu, cuối, hoặc giữa danh sách vì có thể truy cập trực tiếp cả hai chiều.
• Nhược điểm:
  • Tiêu tốn nhiều bộ nhớ hơn vì mỗi node có thêm con trỏ prev.
  • Quản lý phức tạp hơn do phải duy trì và cập nhật cả hai con trỏ next và prev.