Danh sách Python được triển khai bằng cách sử dụng một loạt các tài liệu tham khảo có thể thay thế cho các đối tượng khác. Điều này cung cấp tra cứu O [1] so với tra cứu O [N] cho việc triển khai danh sách được liên kết.
Xem danh sách được thực hiện như thế nào?
Như bạn đã đề cập, việc triển khai này đưa ra các chèn vào đầu hoặc giữa danh sách Python chậm vì mọi phần tử trong mảng ở bên phải của điểm chèn phải được thay đổi qua một yếu tố. Ngoài ra, đôi khi mảng sẽ phải được thay đổi kích thước để chứa nhiều yếu tố hơn. Để chèn vào danh sách được liên kết, bạn vẫn cần thời gian O [n] để tìm vị trí mà bạn sẽ chèn, nhưng bản thân chèn thực tế sẽ là O [1], vì bạn chỉ cần thay đổi các tham chiếu trong các nút ngay lập tức Trước và sau điểm chèn của bạn [giả sử một danh sách liên kết gấp đôi].
Vì vậy, quyết định làm cho danh sách Python sử dụng các mảng động thay vì các danh sách được liên kết không liên quan gì đến "sự trưởng thành" của việc triển khai ngôn ngữ. Chỉ đơn giản là có sự đánh đổi giữa các cấu trúc dữ liệu khác nhau và các nhà thiết kế của Python đã quyết định rằng các mảng động là lựa chọn tốt nhất tổng thể. Họ có thể đã giả định lập chỉ mục một danh sách là phổ biến hơn so với việc chèn dữ liệu vào đó, do đó làm cho các mảng động trở thành một lựa chọn tốt hơn trong trường hợp này.
Xem bảng sau trong bài viết Wikipedia mảng động để so sánh các đặc điểm hiệu suất cấu trúc dữ liệu khác nhau:
//en.wikipedia.org/wiki/Dynamic_array#Performance
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Làm việc với các danh sách được liên kết trong Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Working With Linked Lists in Python
Danh sách được liên kết giống như một người anh em họ ít được biết đến của danh sách. Họ không phổ biến hoặc tuyệt vời, và bạn thậm chí có thể không nhớ chúng từ lớp thuật toán của bạn. Nhưng trong bối cảnh đúng đắn, họ thực sự có thể tỏa sáng. are like a lesser-known cousin of lists. They’re not as popular or as cool, and you might not even remember them from your algorithms class. But in the right context, they can really shine.
Trong bài viết này, bạn sẽ học:
- Danh sách được liên kết là gì và khi nào bạn nên sử dụng chúng
- Cách sử dụng
9 để thực hiện hàng đợi và ngăn xếp>>> deque[['a','b','c']] deque[['a', 'b', 'c']] >>> deque['abc'] deque[['a', 'b', 'c']] >>> deque[[{'data': 'a'}, {'data': 'b'}]] deque[[{'data': 'a'}, {'data': 'b'}]] - Cách thực hiện các lớp danh sách và nút được liên kết của riêng bạn, cộng với các phương thức có liên quan
- Các loại danh sách được liên kết khác là gì và những gì chúng có thể được sử dụng cho
Nếu bạn muốn tìm hiểu thêm về các danh sách được liên kết, thì hãy xem bài đăng trung bình của Vaidehi Joshi, để biết giải thích trực quan hay. Nếu bạn quan tâm đến một hướng dẫn chuyên sâu hơn, thì bài viết Wikipedia khá kỹ lưỡng. Cuối cùng, nếu bạn tò mò về lý do đằng sau việc triển khai
>>> 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ó thể tải xuống mã nguồn được sử dụng trong suốt hướng dẫn này bằng cách nhấp vào liên kết sau:
Hãy thoải mái để lại bất kỳ câu hỏi hoặc ý kiến dưới đây. Happy Pythoning!
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Làm việc với các danh sách được liên kết trong Python
Danh sách được liên kết giống như một người anh em họ ít được biết đến của danh sách. Họ không phổ biến hoặc tuyệt vời, và bạn thậm chí có thể không nhớ chúng từ lớp thuật toán của bạn. Nhưng trong bối cảnh đúng đắn, họ thực sự có thể tỏa sáng.
Trong bài viết này, bạn sẽ học:node, and every node has two different fields:
- Cách sử dụng
9 cho tất cả các nhu cầu danh sách được liên kết của bạn contains the value to be stored in the node.>>> deque[['a','b','c']] deque[['a', 'b', 'c']] >>> deque['abc'] deque[['a', 'b', 'c']] >>> deque[[{'data': 'a'}, {'data': 'b'}]] deque[[{'data': 'a'}, {'data': 'b'}]] - Cách thực hiện danh sách được liên kết của riêng bạn contains a reference to the next node on the list.
Nếu bạn đang tìm cách cải thiện các kỹ năng mã hóa của mình để phỏng vấn xin việc hoặc nếu bạn muốn tìm hiểu thêm về các cấu trúc dữ liệu Python bên cạnh các từ điển và danh sách thông thường, thì bạn đã đến đúng nơi!
Hiểu danh sách liên kết
0, and it’s used as the starting point for any iteration
through the list. The last node must have its >>> 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']]
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:
Dữ liệu chứa giá trị được lưu trữ trong nút.
Tiếp theo chứa một tham chiếu đến nút tiếp theo trong danh sách.
Ở đây, những gì một nút điển hình trông như thế nào:First-In/First-Out [FIFO] approach. That means that the first element inserted in the list is the first one to be retrieved:
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']]
Danh sách liên kếtLast-In/Fist-Out [LIFO] approach, meaning that the last element inserted in the list is the first to be retrieved:
Ứng dụng thực 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:
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:
| 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']]
>>>adjacency matrix. That’s why linked lists are so useful for graph implementation.
Các khóa của từ điển này là các đỉnh nguồn và giá trị cho mỗi khóa là một danh sách. Danh sách này thường được thực hiện như một danh sách được liên kết.
Về cả hai tốc độ và bộ nhớ, việc thực hiện các biểu đồ sử dụng danh sách kề là rất hiệu quả so với, ví dụ, một ma trận kề. Đó là lý do tại sao các danh sách được liên kết rất hữu ích cho việc thực hiện đồ thị.
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.
Chèn và xóa các yếu tố
Trong Python, bạn có thể chèn các phần tử vào danh sách 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']]
>>> 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']]
Sự khác biệt chính giữa các phương pháp này là bạn 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']]
>>> 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ờ, một cái gì đó bạn cần biết về danh sách Python là việc chèn hoặc loại bỏ các yếu tố không ở cuối danh sách đòi hỏi một số yếu tố thay đổi trong nền, làm cho hoạt động phức tạp hơn về thời gian. Bạn có thể đọc bài viết được đề cập ở trên về cách các danh sách được triển khai trong Python để hiểu rõ hơn về cách thực hiện
>>> 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']]
Với tất cả điều này trong tâm trí, mặc dù việc chèn các phần tử ở cuối danh sách 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']]
Mặt khác, các danh sách được liên kết đơn giản hơn nhiều khi chèn và xóa các yếu tố ở đầu hoặc cuối danh sách, trong đó độ phức tạp về thời gian của chúng luôn luôn không đổi: O [1].
Vì lý do này, các danh sách được liên kết có lợi thế về hiệu suất so với danh sách thông thường khi thực hiện hàng đợi [FIFO], trong đó các yếu tố được chèn và xóa liên tục ở đầu danh sách. Nhưng chúng thực hiện tương tự như một danh sách khi thực hiện ngăn xếp [LIFO], trong đó các yếu tố được chèn và loại bỏ ở cuối danh sách.
Truy xuất các yếu tố
Khi nói đến Tra cứu phần tử, danh sách hoạt động tốt hơn nhiều so với danh sách được liên kết. Khi bạn biết bạn muốn truy cập yếu tố nào, danh sách có thể thực hiện thao tác này trong thời gian O [1]. Cố gắng làm điều tương tự với một danh sách được liên kết sẽ mất O [n] vì bạn cần phải đi qua toàn bộ danh sách để tìm phần tử.
Tuy nhiên, khi tìm kiếm một yếu tố cụ thể, cả danh sách và danh sách được liên kết thực hiện rất giống nhau, với độ phức tạp về thời gian của O [n]. Trong cả hai trường hợp, bạn cần lặp lại toàn bộ danh sách để tìm phần tử mà bạn đang tìm kiếm.deque [pronounced “deck”], which stands for double-ended queue.
Giới thiệ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'}]]
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
>>> deque[['a','b','c']]
deque[['a', 'b', 'c']]
>>> deque['abc']
deque[['a', 'b', 'c']]
>>> deque[[{'data': 'a'}, {'data': 'b'}]]
deque[[{'data': 'a'}, {'data': 'b'}]]
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.
>>> from collections import deque
>>> queue = deque[]
>>> queue
deque[[]]
>>> queue.append["Mary"]
>>> queue.append["John"]
>>> queue.append["Susan"]
>>> queue
deque[['Mary', 'John', 'Susan']]
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']]
Cả >>> from collections import deque
>>> queue = deque[]
>>> queue
deque[[]]
>>> queue.append["Mary"]
>>> queue.append["John"]
>>> queue.append["Susan"]
>>> queue
deque[['Mary', 'John', 'Susan']]
9 và >>> queue.popleft[]
'Mary'
>>> queue
deque[['John', 'Susan']]
>>> queue.popleft[]
'John'
>>> queue
deque[['Susan']]
0 Thêm hoặc xóa các phần tử khỏi phía bên phải của danh sách được liên kết. Tuy nhiên, bạn cũng có thể sử dụng >>> from collections import deque
>>> queue = deque[]
>>> queue
deque[[]]
>>> queue.append["Mary"]
>>> queue.append["John"]
>>> queue.append["Susan"]
>>> queue
deque[['Mary', 'John', 'Susan']]
3 để nhanh chóng thêm hoặc loại bỏ các phần tử khỏi phía bên trái hoặ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']]
0, của danh sách:
>>> 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']]
>>> 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']]
Thêm hoặc loại bỏ các phần tử khỏi cả hai đầu của danh sách là khá đơn giản bằng cách sử dụng đố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']]
>>> 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']]
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']]
>>>
>>> queue.popleft[]
'Mary'
>>> queue
deque[['John', 'Susan']]
>>> queue.popleft[]
'John'
>>> queue
deque[['Susan']]
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.
>>> from collections import deque
>>> queue = deque[]
>>> queue
deque[[]]
>>> queue.append["Mary"]
>>> queue.append["John"]
>>> queue.append["Susan"]
>>> queue
deque[['Mary', 'John', 'Susan']]
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']]
Cả
>>> 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']]
>>> 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']]
- Thêm hoặc loại bỏ các phần tử khỏi cả hai đầu của danh sách là khá đơn giản bằng cách sử dụng đối tượng
3. Bây giờ bạn đã sẵn sàng để học cách sử dụng>>> from collections import deque >>> queue = deque[] >>> queue deque[[]] >>> queue.append["Mary"] >>> queue.append["John"] >>> queue.append["Susan"] >>> queue deque[['Mary', 'John', 'Susan']]
9 để thực hiện hàng đợi hoặc một ngăn xếp.>>> deque[['a','b','c']] deque[['a', 'b', 'c']] >>> deque['abc'] deque[['a', 'b', 'c']] >>> deque[[{'data': 'a'}, {'data': 'b'}]] deque[[{'data': 'a'}, {'data': 'b'}]] - Cách thực hiện hàng đợi và ngăn xếp
- Như bạn đã học ở trên, sự khác biệt chính giữa hàng đợi và một ngăn xếp là cách bạn lấy các yếu tố từ mỗi phần. Tiếp theo, bạn sẽ tìm ra cách sử dụng
9 để triển khai cả hai cấu trúc 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'}]]
Hàng đợi
>>>
>>> from collections import deque
>>> history = deque[]
>>> history.appendleft["//realpython.com/"]
>>> history.appendleft["//realpython.com/pandas-read-write-files/"]
>>> history.appendleft["//realpython.com/python-csv/"]
>>> history
deque[['//realpython.com/python-csv/',
'//realpython.com/pandas-read-write-files/',
'//realpython.com/']]
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']]
>>>
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
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']]
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']]
3, bạn có thể tương tác với nó bằng cách thêm hoặc loại bỏ các yếu tố. Bạn có thể tạo danh sách được liên kết >>> from collections import deque
>>> queue = deque[]
>>> queue
deque[[]]
>>> queue.append["Mary"]
>>> queue.append["John"]
>>> queue.append["Susan"]
>>> queue
deque[['Mary', 'John', 'Susan']]
7 và thêm phần tử mới >>> from collections import deque
>>> queue = deque[]
>>> queue
deque[[]]
>>> queue.append["Mary"]
>>> queue.append["John"]
>>> queue.append["Susan"]
>>> queue
deque[['Mary', 'John', 'Susan']]
8 như thế này:
>>> 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']]
Cả
>>> 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']]
>>> 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']]
- Thêm hoặc loại bỏ các phần tử khỏi cả hai đầu của danh sách là khá đơn giản bằng cách sử dụng đối tượng
3. Bây giờ bạn đã sẵn sàng để học cách sử dụng>>> from collections import deque >>> queue = deque[] >>> queue deque[[]] >>> queue.append["Mary"] >>> queue.append["John"] >>> queue.append["Susan"] >>> queue deque[['Mary', 'John', 'Susan']]
9 để thực hiện hàng đợi hoặc một ngăn xếp.>>> deque[['a','b','c']] deque[['a', 'b', 'c']] >>> deque['abc'] deque[['a', 'b', 'c']] >>> deque[[{'data': 'a'}, {'data': 'b'}]] deque[[{'data': 'a'}, {'data': 'b'}]] - Cách thực hiện hàng đợi và ngăn xếp
- Như bạn đã học ở trên, sự khác biệt chính giữa hàng đợi và một ngăn xếp là cách bạn lấy các yếu tố từ mỗi phần. Tiếp theo, bạn sẽ tìm ra cách sử dụng
9 để triển khai cả hai cấu trúc 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'}]]
Hàng đợi
Với hàng đợi, bạn muốn thêm các giá trị vào danh sách [>>> queue.popleft[]
'Mary'
>>> queue
deque[['John', 'Susan']]
>>> queue.popleft[]
'John'
>>> queue
deque[['Susan']]
6] và khi thời gian đúng, bạn muốn xóa phần tử đã nằm trong danh sách dài nhất [>>> queue.popleft[]
'Mary'
>>> queue
deque[['John', 'Susan']]
>>> queue.popleft[]
'John'
>>> queue
deque[['Susan']]
7]. Ví dụ, hãy tưởng tượng một hàng đợi tại một nhà hàng hợp thời trang và được đặt đầy đủ. Nếu bạn đang cố gắng thực hiện một hệ thống công bằng cho khách, thì bạn sẽ bắt đầu bằng cách tạo một hàng đợi và thêm người khi họ đến:
>>> 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']]
Bây giờ bạn có Mary, John và Susan trong hàng đợi. Hãy nhớ rằng vì hàng đợi là FIFO, người đầu tiên tham gia hàng đợi nên là người đầu tiên ra ngoài.
class LinkedList:
def __init__[self]:
self.head = None
Bây giờ hãy tưởng tượng một thời gian trôi qua và một vài bảng trở nên có sẵn. Ở giai đoạn này, bạn muốn loại bỏ mọi người khỏi hàng đợi theo đúng thứ tự. Đây là cách bạn sẽ làm điều đó:
>>> from collections import deque
>>> deque[]
deque[[]]
Trong định nghĩa lớp trên, bạn có thể thấy hai phần tử chính của mỗi nút duy nhất:
>>> from collections import deque
>>> history = deque[]
>>> history.appendleft["//realpython.com/"]
>>> history.appendleft["//realpython.com/pandas-read-write-files/"]
>>> history.appendleft["//realpython.com/python-csv/"]
>>> history
deque[['//realpython.com/python-csv/',
'//realpython.com/pandas-read-write-files/',
'//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[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
>>> from collections import deque
>>> history = deque[]
>>> history.appendleft["//realpython.com/"]
>>> history.appendleft["//realpython.com/pandas-read-write-files/"]
>>> history.appendleft["//realpython.com/python-csv/"]
>>> history
deque[['//realpython.com/python-csv/',
'//realpython.com/pandas-read-write-files/',
'//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[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
>>> from collections import deque
>>> deque[]
deque[[]]
Hãy xem một ví dụ về việc sử dụng các lớp trên để nhanh chóng tạo một danh sách được liên kết với ba nút:
>>>
>>> from collections import deque
>>> deque[]
deque[[]]
Bằng cách xác định giá trị của nút ____ ____78 và
>>> 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[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
Ở đây, một thay đổi nhỏ đối với danh sách được liên kết
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
>>> from collections import deque
>>> deque[]
deque[[]]
Với sửa đổi ở trên, việc tạo các danh sách được liên kết để sử dụng trong các ví dụ dưới đây sẽ nhanh hơn nhiều.
Cách đi qua một danh sách được liên kết
Một trong những điều phổ biến nhất bạn sẽ làm với một danh sách được liên kết là đi qua nó. Đi qua có nghĩa là đi qua mỗi nút, bắt đầu vớ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']]
>>> 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 qua chỉ là một cách fancier để nói lặp đi lặp lại. Vì vậy, với ý nghĩ đó, hãy tạo một
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
>>> from collections import deque
>>> deque[]
deque[[]]
Phương thức trên đi qua danh sách và mang lại mỗi nút. Điều quan trọng nhất cần nhớ về
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
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
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[[]]
Bằng cách xác định giá trị của nút ____ ____78 và
>>> 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[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
Ở đây, một thay đổi nhỏ đối với danh sách được liên kết >>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
5 cho phép bạn nhanh chóng tạo danh sách được liên kết với một số dữ liệu:
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
Với sửa đổi ở trên, việc tạo các danh sách được liên kết để sử dụng trong các ví dụ dưới đây sẽ nhanh hơn nhiều.
Cách đi qua một danh sách được liên kết
Một trong những điều phổ biến nhất bạn sẽ làm với một danh sách được liên kết là đi qua nó. Đi qua có nghĩa là đi qua mỗi nút, bắt đầu vớ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']]
Đi qua chỉ là một cách fancier để nói lặp đi lặp lại. Vì vậy, với ý nghĩ đó, hãy tạo một
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
>>> from collections import deque
>>> deque[]
deque[[]]
Phương thức trên đi qua danh sách và mang lại mỗi nút. Điều quan trọng nhất cần nhớ về
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
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
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[[]]
Bằng cách xác định giá trị của nút ____ ____78 và
>>> 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[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
Ở đây, một thay đổi nhỏ đối với danh sách được liên kết >>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
5 cho phép bạn nhanh chóng tạo danh sách được liên kết với một số dữ liệu:
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
Với sửa đổi ở trên, việc tạo các danh sách được liên kết để sử dụng trong các ví dụ dưới đây sẽ nhanh hơn nhiều.
Cách đi qua một danh sách được liên kết
>>> from collections import deque
>>> deque[]
deque[[]]
Một trong những điều phổ biến nhất bạn sẽ làm với một danh sách được liên kết là đi qua nó. Đi qua có nghĩa là đi qua mỗi nút, bắt đầu vớ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']]
Đi qua chỉ là một cách fancier để nói lặp đi lặp lại. Vì vậy, với ý nghĩ đó, hãy tạo một
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
>>>
>>> from collections import deque
>>> deque[]
deque[[]]
Phương thức trên đi qua danh sách và mang lại mỗi nút. Điều quan trọng nhất cần nhớ về
>>> history.popleft[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//realpython.com/']]
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
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
4. Ở đây, một ví dụ về việc đi qua một danh sách ngẫu nhiên và in từng nút:
class LinkedList:
def __init__[self]:
self.head = None
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.
Chèn vào đầu
Chèn một nút mới ở đầu danh sách có lẽ là phần chèn đơn giản nhất vì bạn không phải đi qua toàn bộ danh sách để làm điều đó. Nó có tất cả về việc tạo ra một nút mới và sau đó trỏ
>>> 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']]
>>> 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, bạn đang đi qua danh sách được liên kết tìm kiếm nút với dữ liệu cho biết nơi bạn muốn chèn một nút mới. Khi bạn tìm thấy nút mà bạn đang tìm kiếm, bạn sẽ chèn nút mới ngay sau đó và tua lại tham chiếu
>>> 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']]
Ngoại lệ duy nhất là nếu danh sách trống, khiến không thể chèn một nút mới sau một nút hiện có hoặc nếu danh sách không chứa giá trị mà bạn đang tìm kiếm. Dưới đây là một vài ví dụ về cách
>>> 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'}]]
Cố gắng sử dụng
>>> from collections import deque
>>> deque[]
deque[[]]
Bây giờ, nếu bạn muốn thực hiện
>>> 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'}]]
Có một vài điều cần ghi nhớ trong khi thực hiện những điều trên. Đầu tiên, như với
>>> from collections import deque
>>> deque[]
deque[[]]
Thứ hai, nếu bạn đang cố gắng thêm một nút mới trước người đứng đầu danh sách [dòng 5], thì bạn có thể sử dụng lại
class LinkedList:
def __init__[self]:
self.head = None
Cuối cùng, đối với bất kỳ trường hợp nào khác [dòng 9], bạn nên theo dõi nút được kiểm tra cuối cùng bằng biến
>>> 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']]
Một lần nữa, một ví dụ đáng giá hàng nghìn từ:
>>>
>>> deque[['a','b','c']]
deque[['a', 'b', 'c']]
>>> deque['abc']
deque[['a', 'b', 'c']]
>>> deque[[{'data': 'a'}, {'data': 'b'}]]
deque[[{'data': 'a'}, {'data': 'b'}]]
Cố gắng sử dụng
>>> from collections import deque
>>> deque[]
deque[[]]
Bây giờ, nếu bạn muốn thực hiện >>> from collections import deque
>>> deque[]
deque[[]]
19, thì nó sẽ trông giống như thế này:
>>> from collections import deque
>>> deque[]
deque[[]]
Có một vài điều cần ghi nhớ trong khi thực hiện những điều trên. Đầu tiên, như với
>>> from collections import deque
>>> deque[]
deque[[]]
Thứ hai, nếu bạn đang cố gắng thêm một nút mới trước người đứng đầu danh sách [dòng 5], thì bạn có thể sử dụng lại
class LinkedList:
def __init__[self]:
self.head = None
>>> deque[['a','b','c']]
deque[['a', 'b', 'c']]
>>> deque['abc']
deque[['a', 'b', 'c']]
>>> deque[[{'data': 'a'}, {'data': 'b'}]]
deque[[{'data': 'a'}, {'data': 'b'}]]
Cuối cùng, đối với bất kỳ trường hợp nào khác [dòng 9], bạn nên theo dõi nút được kiểm tra cuối cùng bằng biến
>>> 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']]
Một lần nữa, một ví dụ đáng giá hàng nghìn từ:
Với
>>> from collections import deque
>>> deque[]
deque[[]]
Cách xóa một nút
>>>
>>> deque[['a','b','c']]
deque[['a', 'b', 'c']]
>>> deque['abc']
deque[['a', 'b', 'c']]
>>> deque[[{'data': 'a'}, {'data': 'b'}]]
deque[[{'data': 'a'}, {'data': 'b'}]]
Cố gắng sử dụng
>>> from collections import deque
>>> deque[]
deque[[]]
- Bây giờ, nếu bạn muốn thực hiện
19, thì nó sẽ trông giống như thế này:>>> from collections import deque >>> deque[] deque[[]] - Có một vài điều cần ghi nhớ trong khi thực hiện những điều trên. Đầu tiên, như với
17, bạn muốn đảm bảo tăng một ngoại lệ nếu danh sách được liên kết trống [dòng 2] hoặc nút mà bạn đang tìm kiếm không có mặt [dòng 16].>>> from collections import deque >>> deque[] deque[[]] - Thứ hai, nếu bạn đang cố gắng thêm một nút mới trước người đứng đầu danh sách [dòng 5], thì bạn có thể sử dụng lại
7 vì nút mà bạn chèn sẽ là ____30 mới của danh sách.class LinkedList: def __init__[self]: self.head = None
Cuối cùng, đối với bất kỳ trường hợp nào khác [dòng 9], bạn nên theo dõi nút được kiểm tra cuối cùng bằng biến
>>> 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']]
Một lần nữa, một ví dụ đáng giá hàng nghìn từ:
Với
>>> from collections import deque
>>> deque[]
deque[[]]
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ụ:
- 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à
0 hiện tại của danh sách [dòng 5] không. Nếu có, thì bạn muốn nút tiếp theo trong danh sách trở thành>>> 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']]
0 mớ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']]
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ệ.
>>> 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:
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
0 của danh sách thay vì trỏ đến >>> 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']]
2. Đây là những gì làm cho chúng tròn. Danh sách liên kết tròn có khá nhiều trường hợp sử dụng thú vị: are a type of linked list in which the last node points back to 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']]
- Đ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[]
'//realpython.com/python-csv/'
>>> history.popleft[]
'//realpython.com/pandas-read-write-files/'
>>> history
deque[['//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']]
Sự kết luận
Trong bài viết này, bạn đã học được khá nhiều điều! Điều quan trọng nhất là:
- Danh sách được liên kết là gì và khi nào bạn nên sử dụng chúng
- Cách sử dụng
9 để thực hiện hàng đợi và ngăn xếp>>> deque[['a','b','c']] deque[['a', 'b', 'c']] >>> deque['abc'] deque[['a', 'b', 'c']] >>> deque[[{'data': 'a'}, {'data': 'b'}]] deque[[{'data': 'a'}, {'data': 'b'}]] - Cách thực hiện các lớp danh sách và nút được liên kết của riêng bạn, cộng với các phương thức có liên quan
- Các loại danh sách được liên kết khác là gì và những gì chúng có thể được sử dụng cho
Nếu bạn muốn tìm hiểu thêm về các danh sách được liên kết, thì hãy xem bài đăng trung bình của Vaidehi Joshi, để biết giải thích trực quan hay. Nếu bạn quan tâm đến một hướng dẫn chuyên sâu hơn, thì bài viết Wikipedia khá kỹ lưỡng. Cuối cùng, nếu bạn tò mò về lý do đằng sau việc triển khai
>>> 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ó thể tải xuống mã nguồn được sử dụng trong suốt hướng dẫn này bằng cách nhấp vào liên kết sau:
Hãy thoải mái để lại bất kỳ câu hỏi hoặc ý kiến dưới đây. Happy Pythoning!
Xem bây giờ hướng dẫn này có một khóa học video liên quan được tạo bởi nhóm Python thực sự. Xem cùng với hướng dẫn bằng văn bản để hiểu sâu hơn về sự hiểu biết của bạn: Làm việc với các danh sách được liên kết trong Python This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Working With Linked Lists in Python