Hướng dẫn what are linked lists in python? - danh sách được liên kết trong python là gì?

Khái niệm chính

Trước khi đi sâu hơn vào danh sách được liên kết là gì và cách bạn có thể sử dụng chúng, trước tiên bạn nên tìm hiểu cách chúng được cấu trúc. Mỗi yếu tố của một danh sách được liên kết được gọi là một nút và mỗi nút có hai trường khác nhau:node, and every node has two different fields:

1. Dữ liệu chứa giá trị được lưu trữ trong nút. contains the value to be stored in the node.
2. Tiếp theo chứa một tham chiếu đến nút tiếp theo trong danh sách. contains a reference to the next node on the list.

Ở đây, những gì một nút điển hình trông như thế nào:

Một danh sách được liên kết là một tập hợp các nút. Nút đầu tiên được gọi là

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Bây giờ bạn đã biết làm thế nào một danh sách được liên kết được cấu trúc, bạn đã sẵn sàng để xem xét một số trường hợp sử dụng thực tế cho nó.

Ứng dụng thực tế

Danh sách liên kết phục vụ một loạt các mục đích trong thế giới thực. Chúng có thể được sử dụng để thực hiện hàng đợi hoặc xếp hàng hoặc ngăn xếp cũng như đồ thị. Chúng cũng hữu ích cho các nhiệm vụ phức tạp hơn nhiều, chẳng hạn như quản lý vòng đời cho một ứng dụng hệ điều hành.

Hàng đợi hoặc ngăn xếp

Hàng đợi và ngăn xếp chỉ khác nhau trong cách truy xuất các yếu tố. Đối với hàng đợi, bạn sử dụng phương pháp đầu tiên/đầu tiên (FIFO). Điều đó có nghĩa là phần tử đầu tiên được chèn vào danh sách là phần đầu tiên được truy xuất:First-In/First-Out (FIFO) approach. That means that the first element inserted in the list is the first one to be retrieved:

Xếp hàng

Trong sơ đồ trên, bạn có thể thấy các yếu tố phía trước và phía sau của hàng đợi. Khi bạn nối các yếu tố mới vào hàng đợi, họ sẽ đi đến phía sau. Khi bạn lấy các yếu tố, chúng sẽ được lấy từ phía trước hàng đợi.front and rear elements of the queue. When you append new elements to the queue, they’ll go to the rear end. When you retrieve elements, they’ll be taken from the front of the queue.

Đối với một ngăn xếp, bạn sử dụng cách tiếp cận cuối cùng/nắm tay (LIFO), có nghĩa là phần tử cuối cùng được chèn vào danh sách là lần đầu tiên được truy xuất:Last-In/Fist-Out (LIFO) approach, meaning that the last element inserted in the list is the first to be retrieved:

Cây rơm

Trong sơ đồ trên, bạn có thể thấy rằng phần tử đầu tiên được chèn trên ngăn xếp (INDEX

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

3) ở phía dưới và phần tử cuối cùng được chèn ở trên cùng. Vì các ngăn xếp sử dụng phương pháp LIFO, phần tử cuối cùng được chèn (ở trên cùng) sẽ là phần đầu tiên được truy xuất.

Do cách bạn chèn và truy xuất các phần tử từ các cạnh của hàng đợi và ngăn xếp, danh sách được liên kết là một trong những cách thuận tiện nhất để thực hiện các cấu trúc dữ liệu này. Bạn sẽ thấy các ví dụ về các triển khai này sau trong bài viết.

Đồ thị

Đồ thị có thể được sử dụng để hiển thị mối quan hệ giữa các đối tượng hoặc để biểu thị các loại mạng khác nhau. Ví dụ: biểu diễn trực quan của biểu đồ, nói rằng biểu đồ acyclic được định hướng (DAG) trông giống như thế này:

Đồ thị acyclic định hướng

Có nhiều cách khác nhau để thực hiện các biểu đồ như trên, nhưng một trong những cách phổ biến nhất là sử dụng danh sách kề. Về bản chất, một danh sách kề kề là một danh sách các danh sách được liên kết trong đó mỗi đỉnh của biểu đồ được lưu trữ cùng với một bộ sưu tập các đỉnh được kết nối:adjacency list. An adjacency list is, in essence, a list of linked lists where each vertex of the graph is stored alongside a collection of connected vertices:

Đỉnh	Danh sách các đỉnh được liên kết
1	2 → 3 → không có
2	4 → Không có
3	Không có
4	5 → 6 → không có
5	6 → Không có
6	Không có

5 → 6 → không có

6 → Không có

>>> graph = {
...     1: [2, 3, None],
...     2: [4, None],
...     3: [None],
...     4: [5, 6, None],
...     5: [6, None],
...     6: [None]
... }

Trong bảng trên, mỗi đỉnh của biểu đồ của bạn được liệt kê trong cột bên trái. Cột bên phải chứa một loạt các danh sách được liên kết lưu trữ các đỉnh khác được kết nối với đỉnh tương ứng ở cột bên trái. Danh sách kề này cũng có thể được biểu diễn trong mã bằng cách sử dụng

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

4:

>>>adjacency matrix. That’s why linked lists are so useful for graph implementation.

So sánh hiệu suất: Danh sách VS Danh sách được liên kết

Trong hầu hết các ngôn ngữ lập trình, có sự khác biệt rõ ràng trong cách các danh sách và mảng được liên kết được lưu trữ trong bộ nhớ. Tuy nhiên, trong Python, danh sách là các mảng động. Điều đó có nghĩa là việc sử dụng bộ nhớ của cả danh sách và danh sách được liên kết là rất giống nhau.

Vì sự khác biệt trong việc sử dụng bộ nhớ giữa các danh sách và danh sách được liên kết là không đáng kể, nên nó tốt hơn nếu bạn tập trung vào sự khác biệt về hiệu suất của chúng khi nói đến độ phức tạp về thời gian.

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Cách sử dụng >>> deque(['a','b','c']) deque(['a', 'b', 'c']) >>> deque('abc') deque(['a', 'b', 'c']) >>> deque([{'data': 'a'}, {'data': 'b'}]) deque([{'data': 'a'}, {'data': 'b'}]) 9

Theo mặc định, có khá nhiều phương pháp với đối tượng

>>> from collections import deque
>>> queue = deque()
>>> queue
deque([])

>>> queue.append("Mary")
>>> queue.append("John")
>>> queue.append("Susan")
>>> queue
deque(['Mary', 'John', 'Susan'])

Đầu tiên, bạn cần tạo một danh sách được liên kết. Bạn có thể sử dụng đoạn mã sau để làm điều đó với

>>> from collections import deque
>>> queue = deque()
>>> queue
deque([])

>>> queue.append("Mary")
>>> queue.append("John")
>>> queue.append("Susan")
>>> queue
deque(['Mary', 'John', 'Susan'])

>>>

>>> from collections import deque
>>> deque()
deque([])

Mã trên sẽ tạo ra một danh sách liên kết trống. Nếu bạn muốn điền nó tại Sáng tạo, thì bạn có thể cung cấp cho nó một lần nữa như đầu vào:iterable as input:

>>>

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

Mã trên sẽ tạo ra một danh sách liên kết trống. Nếu bạn muốn điền nó tại Sáng tạo, thì bạn có thể cung cấp cho nó một lần nữa như đầu vào:

Khi khởi tạo một đối tượng

>>> from collections import deque
>>> queue = deque()
>>> queue
deque([])

>>> queue.append("Mary")
>>> queue.append("John")
>>> queue.append("Susan")
>>> queue
deque(['Mary', 'John', 'Susan'])

>>>

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Mã trên sẽ tạo ra một danh sách liên kết trống. Nếu bạn muốn điền nó tại Sáng tạo, thì bạn có thể cung cấp cho nó một lần nữa như đầu vào:

>>>

>>> llist.appendleft("z")
>>> llist
deque(['z', 'a', 'b', 'c', 'd', 'e'])

>>> llist.popleft()
'z'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Mã trên sẽ tạo ra một danh sách liên kết trống. Nếu bạn muốn điền nó tại Sáng tạo, thì bạn có thể cung cấp cho nó một lần nữa như đầu vào:

Khi khởi tạo một đối tượng >>> from collections import deque >>> queue = deque() >>> queue deque([]) >>> queue.append("Mary") >>> queue.append("John") >>> queue.append("Susan") >>> queue deque(['Mary', 'John', 'Susan']) 3, bạn có thể chuyển bất kỳ thứ nào có thể sử dụng dưới dạng đầu vào, chẳng hạn như một chuỗi (cũng có thể lặp lại) hoặc danh sách các đối tượng.

Bây giờ bạn đã biết cách tạo đối tượng

>>> from collections import deque
>>> queue = deque()
>>> queue
deque([])

>>> queue.append("Mary")
>>> queue.append("John")
>>> queue.append("Susan")
>>> queue
deque(['Mary', 'John', 'Susan'])

>>> from collections import deque
>>> queue = deque()
>>> queue
deque([])

>>> queue.append("Mary")
>>> queue.append("John")
>>> queue.append("Susan")
>>> queue
deque(['Mary', 'John', 'Susan'])

>>> from collections import deque
>>> queue = deque()
>>> queue
deque([])

>>> queue.append("Mary")
>>> queue.append("John")
>>> queue.append("Susan")
>>> queue
deque(['Mary', 'John', 'Susan'])

>>> queue.popleft()
'Mary'

>>> queue
deque(['John', 'Susan'])

>>> queue.popleft()
'John'

>>> queue
deque(['Susan'])

>>> queue.popleft()
'Mary'

>>> queue
deque(['John', 'Susan'])

>>> queue.popleft()
'John'

>>> queue
deque(['Susan'])

>>> from collections import deque
>>> queue = deque()
>>> queue
deque([])

>>> queue.append("Mary")
>>> queue.append("John")
>>> queue.append("Susan")
>>> queue
deque(['Mary', 'John', 'Susan'])

>>> queue.popleft()
'Mary'

>>> queue
deque(['John', 'Susan'])

>>> queue.popleft()
'John'

>>> queue
deque(['Susan'])

>>> queue.popleft()
'Mary'

>>> queue
deque(['John', 'Susan'])

>>> queue.popleft()
'John'

>>> queue
deque(['Susan'])

>>> from collections import deque
>>> history = deque()

>>> history.appendleft("https://realpython.com/")
>>> history.appendleft("https://realpython.com/pandas-read-write-files/")
>>> history.appendleft("https://realpython.com/python-csv/")
>>> history
deque(['https://realpython.com/python-csv/',
       'https://realpython.com/pandas-read-write-files/',
       'https://realpython.com/'])

>>> history.popleft()
'https://realpython.com/python-csv/'

>>> history.popleft()
'https://realpython.com/pandas-read-write-files/'

>>> history
deque(['https://realpython.com/'])

Nhấp vào liên kết để đọc và viết các tệp CSV bằng Python

Nếu bạn thích ánh xạ hành vi này vào một ngăn xếp, thì bạn có thể làm điều gì đó như sau:

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

Trong ví dụ này, bạn đã tạo một đối tượng

>>> queue.popleft()
'Mary'

>>> queue
deque(['John', 'Susan'])

>>> queue.popleft()
'John'

>>> queue
deque(['Susan'])

>>> queue.popleft()
'Mary'

>>> queue
deque(['John', 'Susan'])

>>> queue.popleft()
'John'

>>> queue
deque(['Susan'])

>>> from collections import deque
>>> history = deque()

>>> history.appendleft("https://realpython.com/")
>>> history.appendleft("https://realpython.com/pandas-read-write-files/")
>>> history.appendleft("https://realpython.com/python-csv/")
>>> history
deque(['https://realpython.com/python-csv/',
       'https://realpython.com/pandas-read-write-files/',
       'https://realpython.com/'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> from collections import deque
>>> deque()
deque([])

Bây giờ giả sử rằng sau khi người dùng đọc cả hai bài viết, họ muốn quay lại trang chủ Python thực sự để chọn một bài viết mới để đọc. Biết rằng bạn có một ngăn xếp và muốn loại bỏ các yếu tố bằng LIFO, bạn có thể làm như sau:

>>> from collections import deque
>>> history = deque()

>>> history.appendleft("https://realpython.com/")
>>> history.appendleft("https://realpython.com/pandas-read-write-files/")
>>> history.appendleft("https://realpython.com/python-csv/")
>>> history
deque(['https://realpython.com/python-csv/',
       'https://realpython.com/pandas-read-write-files/',
       'https://realpython.com/'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> history.popleft()
'https://realpython.com/python-csv/'

>>> history.popleft()
'https://realpython.com/pandas-read-write-files/'

>>> history
deque(['https://realpython.com/'])

>>> from collections import deque
>>> deque()
deque([])

Có bạn đi! Sử dụng

>>> queue.popleft()
'Mary'

>>> queue
deque(['John', 'Susan'])

>>> queue.popleft()
'John'

>>> queue
deque(['Susan'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>>

>>> from collections import deque
>>> deque()
deque([])

Từ các ví dụ trên, bạn có thể thấy mức độ hữu ích của việc có

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

Thực hiện danh sách được liên kết của riêng bạn

>>> from collections import deque
>>> deque()
deque([])

Bây giờ bạn đã biết cách sử dụng

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

Thực hành các kỹ năng thuật toán Python của bạn

Tìm hiểu về lý thuyết cấu trúc dữ liệutraverse it. Traversing means going through every single node, starting with the

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Chuẩn bị cho các cuộc phỏng vấn việc làm

>>> from collections import deque
>>> deque()
deque([])

Vui lòng bỏ qua phần tiếp theo này nếu bạn không quan tâm đến bất kỳ điều nào ở trên hoặc nếu bạn đã thực hiện danh sách được liên kết của riêng mình trong Python. Nếu không, đó là thời gian để thực hiện một số danh sách được liên kết!

Sau khi mang lại nút hiện tại, bạn muốn chuyển sang nút tiếp theo trong danh sách. Đó là lý do tại sao bạn thêm

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

>>>

>>> from collections import deque
>>> deque()
deque([])

Trong các bài viết khác, bạn có thể thấy việc đi qua được xác định thành một phương thức cụ thể gọi là

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

Cách chèn một nút mới

Có nhiều cách khác nhau để chèn các nút mới vào một danh sách được liên kết, mỗi nút có triển khai riêng và mức độ phức tạp. Đó là lý do tại sao bạn sẽ thấy chúng chia thành các phương pháp cụ thể để chèn vào đầu, kết thúc hoặc giữa các nút của danh sách.

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

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

>>> history.popleft()
'https://realpython.com/python-csv/'

>>> history.popleft()
'https://realpython.com/pandas-read-write-files/'

>>> history
deque(['https://realpython.com/'])

>>> from collections import deque
>>> deque()
deque([])

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

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

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

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> from collections import deque
>>> deque()
deque([])

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

>>> from collections import deque
>>> deque()
deque([])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

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

>>> history.popleft()
'https://realpython.com/python-csv/'

>>> history.popleft()
'https://realpython.com/pandas-read-write-files/'

>>> history
deque(['https://realpython.com/'])

>>> from collections import deque
>>> deque()
deque([])

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

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

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

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

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

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> from collections import deque
>>> deque()
deque([])

>>> from collections import deque
>>> deque()
deque([])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> from collections import deque
>>> deque()
deque([])

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

>>> from collections import deque
>>> deque()
deque([])

>>> from collections import deque
>>> deque()
deque([])

>>> from collections import deque
>>> deque()
deque([])

>>> from collections import deque
>>> deque()
deque([])

>>> from collections import deque
>>> deque()
deque([])

>>> from collections import deque
>>> deque()
deque([])

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Cách xóa một nút

Để xóa một nút khỏi danh sách được liên kết, trước tiên bạn cần phải đi qua danh sách cho đến khi bạn tìm thấy nút bạn muốn xóa. Khi bạn tìm thấy mục tiêu, bạn muốn liên kết các nút trước và tiếp theo của nó. Liên kết lại này là những gì loại bỏ nút đích khỏi danh sách.

Điều đó có nghĩa là bạn cần theo dõi nút trước khi bạn đi qua danh sách. Hãy xem một triển khai ví dụ:

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

Trong mã trên, trước tiên bạn kiểm tra xem danh sách của bạn không trống (dòng 2). Nếu có, thì bạn sẽ tăng một ngoại lệ. Sau đó, bạn kiểm tra xem nút sẽ được xóa có phải là

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Nếu không có điều nào ở trên xảy ra, thì bạn bắt đầu đi qua danh sách tìm kiếm nút sẽ bị xóa (dòng 10). Nếu bạn tìm thấy nó, thì bạn cần cập nhật nút trước đó của nó để trỏ đến nút tiếp theo của nó, tự động xóa nút tìm thấy khỏi danh sách. Cuối cùng, nếu bạn đi qua toàn bộ danh sách mà không tìm thấy nút sẽ bị xóa (dòng 16), thì bạn sẽ tăng một ngoại lệ.

Lưu ý cách trong mã trên bạn sử dụng

>>> from collections import deque
>>> deque()
deque([])

Ở đây, một ví dụ sử dụng danh sách:

>>>

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

Đó là nó! Bây giờ bạn đã biết cách thực hiện một danh sách được liên kết và tất cả các phương pháp chính để đi qua, chèn và xóa các nút. Nếu bạn cảm thấy thoải mái với những gì bạn đã học được và bạn khao khát nhiều hơn, thì hãy thoải mái chọn một trong những thách thức dưới đây:

1. Tạo một phương thức để lấy một phần tử từ một vị trí cụ thể:

   >>> from collections import deque
   >>> deque()
   deque([])
   

   30 hoặc thậm chí

   >>> from collections import deque
   >>> deque()
   deque([])
   

   31.
2. Tạo một phương thức để đảo ngược danh sách được liên kết:

   >>> from collections import deque
   >>> deque()
   deque([])
   

   32.
3. Tạo một đối tượng

   >>> from collections import deque
   >>> deque()
   deque([])
   

   33 kế thừa danh sách liên kết bài viết này với các phương thức

   >>> from collections import deque
   >>> deque()
   deque([])
   

   34 và

   >>> from collections import deque
   >>> deque()
   deque([])
   

   35.

Ngoài việc thực hành tuyệt vời, tự mình thực hiện một số thử thách thêm là một cách hiệu quả để đồng hóa tất cả kiến ​​thức mà bạn đã đạt được. Nếu bạn muốn bắt đầu bằng cách sử dụng lại tất cả mã nguồn từ bài viết này, thì bạn có thể tải xuống mọi thứ bạn cần tại liên kết bên dưới:

Cách sử dụng danh sách liên kết gấp đôi

Danh sách liên kết gấp đôi khác với các danh sách liên kết đơn lẻ ở chỗ chúng có hai tài liệu tham khảo:

1. Trường

   >>> from collections import deque
   >>> deque()
   deque([])
   

   36 tham chiếu nút trước đó.
2. Trường

   >>> llist = deque("abcde")
   >>> llist
   deque(['a', 'b', 'c', 'd', 'e'])
   
   >>> llist.append("f")
   >>> llist
   deque(['a', 'b', 'c', 'd', 'e', 'f'])
   
   >>> llist.pop()
   'f'
   
   >>> llist
   deque(['a', 'b', 'c', 'd', 'e'])
   

   1 tham chiếu nút tiếp theo.

Kết quả cuối cùng trông như thế này:

Nếu bạn muốn thực hiện các điều trên, thì bạn có thể thực hiện một số thay đổi đối với lớp

>>> history.popleft()
'https://realpython.com/python-csv/'

>>> history.popleft()
'https://realpython.com/pandas-read-write-files/'

>>> history
deque(['https://realpython.com/'])

>>> from collections import deque
>>> deque()
deque([])

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

Loại triển khai này sẽ cho phép bạn đi qua một danh sách theo cả hai hướng thay vì chỉ đi qua bằng cách sử dụng

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> from collections import deque
>>> deque()
deque([])

Về mặt cấu trúc, đây là cách một danh sách được liên kết gấp đôi sẽ trông như thế nào:

Bạn đã học được trước đó rằng

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

>>> from collections import deque
>>> queue = deque()
>>> queue
deque([])

>>> queue.append("Mary")
>>> queue.append("John")
>>> queue.append("Susan")
>>> queue
deque(['Mary', 'John', 'Susan'])

Cách sử dụng danh sách liên kết tròn

Danh sách liên kết tròn là một loại danh sách được liên kết trong đó nút cuối cùng chỉ trở lại

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

• Đi xung quanh mỗi người chơi, lượt quay trong một trò chơi nhiều người chơi
• Quản lý vòng đời ứng dụng của một hệ điều hành nhất định
• Thực hiện một đống fibonacci

Đây là những gì một danh sách liên kết tròn trông giống như:

Một trong những lợi thế của danh sách liên kết tròn là bạn có thể đi qua toàn bộ danh sách bắt đầu tại bất kỳ nút nào. Vì nút cuối cùng chỉ vào

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

Về mặt thực hiện, các danh sách liên kết tròn rất giống với danh sách liên kết đơn lẻ. Sự khác biệt duy nhất là bạn có thể xác định điểm bắt đầu khi bạn đi qua danh sách:

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

Đi qua danh sách bây giờ nhận được một đối số bổ sung,

>>> from collections import deque
>>> deque()
deque([])

>>> history.popleft()
'https://realpython.com/python-csv/'

>>> history.popleft()
'https://realpython.com/pandas-read-write-files/'

>>> history
deque(['https://realpython.com/'])

Để kết thúc với một ví dụ cuối cùng, hãy xem loại danh sách mới này hoạt động khi bạn cung cấp cho nó một số dữ liệu:

>>>

>>> deque(['a','b','c'])
deque(['a', 'b', 'c'])

>>> deque('abc')
deque(['a', 'b', 'c'])

>>> deque([{'data': 'a'}, {'data': 'b'}])
deque([{'data': 'a'}, {'data': 'b'}])

Ở đó bạn có nó! Bạn sẽ nhận thấy rằng bạn không còn có

>>> llist = deque("abcde")
>>> llist
deque(['a', 'b', 'c', 'd', 'e'])

>>> llist.append("f")
>>> llist
deque(['a', 'b', 'c', 'd', 'e', 'f'])

>>> llist.pop()
'f'

>>> llist
deque(['a', 'b', 'c', 'd', 'e'])