Hướng dẫn what does listnode mean in python? - listnode nghĩa là gì trong python?

Dưới đây là định nghĩa của lớp

result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
0 trong
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
1:

class ListNode(object):
    def __init__(self, x):
        self.val = x
        self.next = None

Đối với mã:

result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None

Các giá trị trong bình luận là từ tôi đoán. Tôi không thể hiểu bước

result_tail = result_tail.next

result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
2 được truyền qua tham chiếu, vì vậy khi
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
3 trở thành
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
4,
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
5 cũng sẽ trở thành
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
4. Tại sao
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
5 vẫn giữ
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
8? Và khi
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
3 trở thành
result_tail = result_tail.next
0, tại sao
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
5 mở rộng đuôi của nó thành
result_tail = result_tail.next
2?

result_tail = result_tail.next

là một cái gì đó giống như

result_tail = result.next.next    

Bất cứ ai có thể cho tôi biết logic ở đây?

Đã hỏi ngày 9 tháng 6 năm 2019 lúc 15:39Jun 9, 2019 at 15:39

Hướng dẫn what does listnode mean in python? - listnode nghĩa là gì trong python?

user6703592user6703592user6703592

8741 Huy hiệu vàng11 Huy hiệu bạc23 Huy hiệu đồng1 gold badge11 silver badges23 bronze badges

Câu trả lời ngắn gọn cho điều này là, Python là ngôn ngữ tham khảo theo từng đối tượng, không được tham khảo theo từng câu hỏi. Nó có nghĩa là:

  1. result = ListNode(0)
    #result = 0 -> None
    result_tail = result
    #result_tail = 0 -> None
    result_tail.next = ListNode(1)
    #result_tail = 0 -> 1 -> None
    #result = 0 -> 1 -> None
    result_tail = result_tail.next
    #result_tail = 1 -> None
    #result = 0 -> 1 -> None
    result_tail.next = ListNode(2)
    #result_tail = 1 -> 2 -> None
    #result = 0 -> 1 -> 2 -> None
    result_tail = result_tail.next
    #result_tail = 2 -> None
    #result = 0 -> 1 -> 2 -> None
    
    5 và
    result = ListNode(0)
    #result = 0 -> None
    result_tail = result
    #result_tail = 0 -> None
    result_tail.next = ListNode(1)
    #result_tail = 0 -> 1 -> None
    #result = 0 -> 1 -> None
    result_tail = result_tail.next
    #result_tail = 1 -> None
    #result = 0 -> 1 -> None
    result_tail.next = ListNode(2)
    #result_tail = 1 -> 2 -> None
    #result = 0 -> 1 -> 2 -> None
    result_tail = result_tail.next
    #result_tail = 2 -> None
    #result = 0 -> 1 -> 2 -> None
    
    3 là hai biến xảy ra ở cùng một giá trị
  2. Đột biến / thay đổi giá trị cơ bản (
    result_tail = result_tail.next
    
    5) sẽ ảnh hưởng đến giá trị được hiển thị bởi
    result = ListNode(0)
    #result = 0 -> None
    result_tail = result
    #result_tail = 0 -> None
    result_tail.next = ListNode(1)
    #result_tail = 0 -> 1 -> None
    #result = 0 -> 1 -> None
    result_tail = result_tail.next
    #result_tail = 1 -> None
    #result = 0 -> 1 -> None
    result_tail.next = ListNode(2)
    #result_tail = 1 -> 2 -> None
    #result = 0 -> 1 -> 2 -> None
    result_tail = result_tail.next
    #result_tail = 2 -> None
    #result = 0 -> 1 -> 2 -> None
    
    5
  3. Tuy nhiên, việc gán / trỏ biến
    result = ListNode(0)
    #result = 0 -> None
    result_tail = result
    #result_tail = 0 -> None
    result_tail.next = ListNode(1)
    #result_tail = 0 -> 1 -> None
    #result = 0 -> 1 -> None
    result_tail = result_tail.next
    #result_tail = 1 -> None
    #result = 0 -> 1 -> None
    result_tail.next = ListNode(2)
    #result_tail = 1 -> 2 -> None
    #result = 0 -> 1 -> 2 -> None
    result_tail = result_tail.next
    #result_tail = 2 -> None
    #result = 0 -> 1 -> 2 -> None
    
    3 cho một giá trị khác sẽ không ảnh hưởng đến giá trị của
    result = ListNode(0)
    #result = 0 -> None
    result_tail = result
    #result_tail = 0 -> None
    result_tail.next = ListNode(1)
    #result_tail = 0 -> 1 -> None
    #result = 0 -> 1 -> None
    result_tail = result_tail.next
    #result_tail = 1 -> None
    #result = 0 -> 1 -> None
    result_tail.next = ListNode(2)
    #result_tail = 1 -> 2 -> None
    #result = 0 -> 1 -> 2 -> None
    result_tail = result_tail.next
    #result_tail = 2 -> None
    #result = 0 -> 1 -> 2 -> None
    
    5
  4. result_tail = result_tail.next
    
    9 đang gán nút tiếp theo của nút hiện đang được gán bởi biến

Sau đây là trực quan hóa các giá trị được gán cho các biến (

result_tail = result_tail.next
0 =
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
5,
result_tail = result_tail.next
2 =
result = ListNode(0)
#result = 0 -> None
result_tail = result
#result_tail = 0 -> None
result_tail.next = ListNode(1)
#result_tail = 0 -> 1 -> None
#result = 0 -> 1 -> None
result_tail = result_tail.next
#result_tail = 1 -> None
#result = 0 -> 1 -> None
result_tail.next = ListNode(2)
#result_tail = 1 -> 2 -> None
#result = 0 -> 1 -> 2 -> None
result_tail = result_tail.next
#result_tail = 2 -> None
#result = 0 -> 1 -> 2 -> None
3):

result = ListNode(0)
#r
#0 -> None

result_tail = result
#r
#0 -> None
#rt

result_tail.next = ListNode(1)
#r
#0 -> 1 -> None
#rt

result_tail = result_tail.next
#r
#0 -> 1 -> None
#     rt

result_tail.next = ListNode(2)
#r
#0 -> 1 -> 2 -> None
#     rt

result_tail = result_tail.next
#r
#0 -> 1 -> 2 -> None
#          rt

Tài liệu tham khảo để đọc thêm:

  • Một bài báo giải thích phong cách tham khảo Python Pass-by-Enject trong chi tiết https://robertheaton.com/2014/02/09/pythons-pass-by-object-reference-s-explained-by-philip-kick/
  • Một câu trả lời giải thích phong cách tham khảo Pass-by-Ogject của Python https://stackoverflow.com/a/33066581/12295149
  • Câu hỏi hỏi về phong cách tham chiếu đối tượng của Python Hiểu phong cách gọi theo từng đối số của Python

Đã trả lời ngày 26 tháng 12 năm 2019 lúc 9:21Dec 26, 2019 at 9:21

Hướng dẫn what does listnode mean in python? - listnode nghĩa là gì trong python?

JosephjosephJoseph

4374 Huy hiệu bạc15 Huy hiệu Đồng4 silver badges15 bronze badges

Đối với những người đọc điều này trong tương lai: Tôi muốn gỡ lỗi các vấn đề danh sách được liên kết về môi trường địa phương, vì vậy đây là những gì tôi đã làm.

  1. Đã sửa đổi mã LeetCode cho ListNode bằng cách bao gồm phương thức "repr" Dunder. Điều này là cho khi bạn muốn in một mã listnode để xem giá trị của nó và nút tiếp theo của nó là gì.repr" method. This is for when you want to print a ListNode to see what its value and next node(s).
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

    def __repr__(self):
        return "ListNode(val=" + str(self.val) + ", next={" + str(self.next) + "})"
  1. Tiếp theo, tôi đã thực hiện một chức năng đệ quy tạo ra một danh sách lồng nhau khi bạn chuyển trong danh sách. Điều này là để bạn có thể kiểm tra các phương thức của mình bằng cách truyền trong danh sách (thay vì phải tự tạo ra một danh sách tìm kiếm khó hiểu.
def list_to_LL(arr):
    if len(arr) < 1:
        return None

    if len(arr) == 1:
        return ListNode(arr[0])
    return ListNode(arr[0], next=list_to_LL(arr[1:]))
  1. Dưới đây là một ví dụ kiểm tra câu trả lời của tôi cho vấn đề "đảo ngược":
________số 8

Đã trả lời ngày 8 tháng 5 năm 2021 lúc 23:43May 8, 2021 at 23:43

NEETGLUGNEEGLUGNeeglug

Huy hiệu Bạc 1311 Huy hiệu Đồng1 silver badge2 bronze badges

Đầu tiên, cảm ơn bạn rất nhiều vì đã đăng câu hỏi này. Tôi đã làm việc với cùng một vấn đề và thấy đoạn mã này và cũng bị bối rối. Sau đó, tôi đã làm theo một số ý kiến ​​từ Leetcode và đến đây.

Tôi nhận ra rằng vấn đề của tôi là tôi không có bút và giấy trước đó. Sau khi tôi vẽ danh sách được liên kết trên giấy bằng cách theo vòng lặp, hóa ra nó khá rõ ràng.

Nếu bạn vẫn chưa rõ về điều này, vui lòng cố gắng vẽ danh sách được liên kết bằng cách làm theo logic. Không chắc chắn nếu tôi có thuật ngữ đúng ở đây nhưng dưới đây là sự hiểu biết của tôi.

Thành thật mà nói, tôi không nghĩ rằng điều này có liên quan đến việc vượt qua bởi tham chiếu hoặc giá trị. Đối với tôi, đây chỉ là về hai biến được gán với cùng một giá trị (vị trí bộ nhớ) ở đầu. Hãy nghĩ về các biến như lưu trữ địa chỉ. Địa chỉ là vị trí bộ nhớ thực là sự khởi đầu của một số giá trị. Sau đó, một biến (result_tail) tiếp tục được chỉ định lại đến một vị trí khác và một (kết quả) vẫn giữ nguyên.

Kết quả và result_tail đều chỉ vào vị trí của 0 | Không có trước khi vòng lặp.

result_tail = result_tail.next
4 đã phát triển thành
result_tail = result_tail.next
5, sau đó
result_tail = result_tail.next
6 và cuối cùng
result_tail = result_tail.next
7 bởi result_tail.next được gán mỗi lần. Result_tail được chỉ định lại giá trị đã thay đổi trong mỗi vòng lặp, nhưng kết quả chỉ vào cùng một vị trí là
result_tail = result_tail.next
8 do đó kết quả.
result_tail = result_tail.next
4 grew into
result_tail = result_tail.next
5, then
result_tail = result_tail.next
6 and at last
result_tail = result_tail.next
7 by result_tail.next being assigned every time. Result_tail gets reassigned so value changed during each loop, but result points to the same location which is the
result_tail = result_tail.next
8 Thus the result.

Hướng dẫn what does listnode mean in python? - listnode nghĩa là gì trong python?

Đã trả lời ngày 2 tháng 8 năm 2020 lúc 2:07Aug 2, 2020 at 2:07

1

Tất cả các câu trả lời trên có vẻ tốt. Tôi chỉ thêm một ví dụ cho sự hiểu biết của người đọc.

Đầu vào đã cho:

result_tail = result_tail.next
9

Mô tả đối tượng ListNode:

[ListNode{val: 1, next: ListNode{val: 4, next: ListNode{val: 5, next: None}}}, ListNode{val: 1, next: ListNode{val: 3, next: ListNode{val: 4, next: None}}}, ListNode{val: 2, next: ListNode{val: 6, next: None}}]

Hy vọng bạn có mấu chốt!

Hướng dẫn what does listnode mean in python? - listnode nghĩa là gì trong python?

Blazej

8704 Huy hiệu vàng10 Huy hiệu bạc20 Huy hiệu đồng4 gold badges10 silver badges20 bronze badges

Đã trả lời ngày 21 tháng 6 năm 2021 lúc 14:06Jun 21, 2021 at 14:06

Hướng dẫn what does listnode mean in python? - listnode nghĩa là gì trong python?

ListNode là gì?

Đây là một nút cho một danh sách liên kết đơn, có khả năng giữ một loại đối tượng.Một mã danh sách bao gồm hai thành viên dữ liệu: dữ liệu chúng tôi đang theo dõi tại nút này (đối tượng) mã danh sách tiếp theo trong chuỗi.a node for a singly-linked list, which is capable of holding an type of Object. A ListNode consists of two data members: The data we are keeping track of at this node (Object) The next ListNode in the chain.

ListNode tùy chọn có nghĩa là gì trong Python?

Đó là cho phép các giá trị có thể không có.Ví dụ: đây là tất cả các danh sách: (3 -> 1 -> Không) Ví dụ: # Sử dụng tùy chọn [] cho các giá trị không thể là x: tùy chọn [str] = some_function ()to allow for values that can be None. For example: These are all listnodes: (3 -> 1 -> None) Example: # Use Optional[] for values that could be None x: Optional[str] = some_function()

Danh sách được liên kết được sử dụng cho trong Python?

Danh sách được liên kết là một cấu trúc dữ liệu lưu trữ dữ liệu dưới dạng chuỗi.Cấu trúc của một danh sách được liên kết sao cho mỗi phần dữ liệu có kết nối với dữ liệu tiếp theo (và đôi khi cũng là dữ liệu trước đó).Mỗi phần tử trong một danh sách được liên kết được gọi là một nút.store data in the form of a chain. The structure of a linked list is such that each piece of data has a connection to the next one (and sometimes the previous data as well). Each element in a linked list is called a node.

Đầu tự ở Python là gì?

Head "Đơn giản chỉ cần đề cập đến nơi bạn đang đi qua danh sách, vì vậy sự khác biệt giữa nói:" Tự.Đầu là nút hiện tại, vì vậy tự.cái đầu.Tiếp theo là nút tiếp theo "và" n = self.cái đầu.the current node, so self. head. next is the next node" and "n = self. head.