Cây để tuple python

Gói đi theo hướng của gói AnyTree nhưng với một chút tiêu điểm khác nhau. Hiệu suất trên nhiều cây [> 100000 mặt hàng] tốt hơn nhiều và nó liên quan đến các trình duyệt để có cơ chế hiệu quả lọc

>>>from itertree import *
>>>root=iTree['root']

>>># add some children:
>>>root.append[iTree['Africa',data={'surface':30200000,'inhabitants':1257000000}]]
>>>root.append[iTree['Asia', data={'surface': 44600000, 'inhabitants': 4000000000}]]
>>>root.append[iTree['America', data={'surface': 42549000, 'inhabitants': 1009000000}]]
>>>root.append[iTree['Australia&Oceania', data={'surface': 8600000, 'inhabitants': 36000000}]]
>>>root.append[iTree['Europe', data={'surface': 10523000 , 'inhabitants': 746000000}]]
>>># you might use __iadd__ operator for adding too:
>>>root+=iTree['Antarktika', data={'surface': 14000000, 'inhabitants': 1100}]

>>># for building next level we select per index:
>>>root[0]+=iTree['Ghana',data={'surface':238537,'inhabitants':30950000}]
>>>root[0]+=iTree['Niger', data={'surface': 1267000, 'inhabitants': 23300000}]
>>>root[1]+=iTree['China', data={'surface': 9596961, 'inhabitants': 1411780000}]
>>>root[1]+=iTree['India', data={'surface': 3287263, 'inhabitants': 1380004000}]
>>>root[2]+=iTree['Canada', data={'type': 'country', 'surface': 9984670, 'inhabitants': 38008005}]    
>>>root[2]+=iTree['Mexico', data={'surface': 1972550, 'inhabitants': 127600000 }]
>>># extend multiple items:
>>>root[3].extend[[iTree['Australia', data={'surface': 7688287, 'inhabitants': 25700000 }], iTree['New Zealand', data={'surface': 269652, 'inhabitants': 4900000 }]]]
>>>root[4]+=iTree['France', data={'surface': 632733, 'inhabitants': 67400000 }]]
>>># select parent per TagIdx - remember in itertree you might put items with same tag multiple times:
>>>root[TagIdx['Europe'0]]+=iTree['Finland', data={'surface': 338465, 'inhabitants': 5536146 }]

Cây được tạo ra có thể được xuất ra

>>>root.render[]
iTree['root']
     └──iTree['Africa', data=iTData[{'surface': 30200000, 'inhabitants': 1257000000}]]
         └──iTree['Ghana', data=iTData[{'surface': 238537, 'inhabitants': 30950000}]]
         └──iTree['Niger', data=iTData[{'surface': 1267000, 'inhabitants': 23300000}]]
     └──iTree['Asia', data=iTData[{'surface': 44600000, 'inhabitants': 4000000000}]]
         └──iTree['China', data=iTData[{'surface': 9596961,  'inhabitants': 1411780000}]]
         └──iTree['India', data=iTData[{'surface': 3287263, 'inhabitants': 1380004000}]]
     └──iTree['America', data=iTData[{'surface': 42549000, 'inhabitants': 1009000000}]]
         └──iTree['Canada', data=iTData[{'surface': 9984670, 'inhabitants': 38008005}]]
         └──iTree['Mexico', data=iTData[{'surface': 1972550, 'inhabitants': 127600000}]]
     └──iTree['Australia&Oceania', data=iTData[{'surface': 8600000, 'inhabitants': 36000000}]]
         └──iTree['Australia', data=iTData[{'surface': 7688287, 'inhabitants': 25700000}]]
         └──iTree['New Zealand', data=iTData[{'surface': 269652, 'inhabitants': 4900000}]]
     └──iTree['Europe', data=iTData[{'surface': 10523000, 'inhabitants': 746000000}]]
         └──iTree['France', data=iTData[{'surface': 632733, 'inhabitants': 67400000}]]
         └──iTree['Finland', data=iTData[{'surface': 338465, 'inhabitants': 5536146}]]
     └──iTree['Antarktika', data=iTData[{'surface': 14000000, 'inhabitants': 1100}]]

Ví dụ. Bộ lọc có thể được thực hiện như thế này

>>>item_filter = Filter.iTFilterData[data_key='inhabitants', data_value=iTInterval[0, 20000000]]
>>>iterator=root.iter_all[item_filter=item_filter]
>>>for i in iterator:
>>>    print[i]
iTree["'New Zealand'", data=iTData[{'surface': 269652, 'inhabitants': 4900000}], subtree=[]]
iTree["'Finland'", data=iTData[{'surface': 338465, 'inhabitants': 5536146}], subtree=[]]
iTree["'Antarktika'", data=iTData[{'surface': 14000000, 'inhabitants': 1100}], subtree=[]]

Tìm hiểu về cây và cách thực hiện chúng

Lại

Một cây như một cấu trúc dữ liệu có thể nhanh chóng trở thành một toán học phức tạp [kiểm tra wiki], chúng ta được bao quanh bởi những thứ thực tế và ảo [thực tế dữ liệu] có thể được mô hình hóa và

Python là một ngôn ngữ rất phong phú về các tính năng và cấu trúc dữ liệu. Nó có rất nhiều cấu trúc từ điển dữ liệu có sẵn như từ Python, danh sách, tuple, set, freezeset, v. v. Ngoài ra, chúng ta cũng có thể tạo tùy chỉnh cấu trúc dữ liệu cấu trúc của riêng mình bằng các lớp. Trong bài viết này, chúng tôi sẽ tìm hiểu về cấu trúc dữ liệu cây nhị phân trong Python và sẽ cố gắng thực hiện nó bằng một ví dụ

Cây là một cấu trúc dữ liệu trong đó các mục dữ liệu được kết nối bằng các tham chiếu theo cách phân cấp. Mỗi cây bao gồm một nút gốc mà từ đó chúng ta có thể truy cập từng phần tử của cây. Bắt đầu từ nút gốc, mỗi nút chứa 0 hoặc nhiều nút được kết nối với nó khi nó còn nhỏ. Một cây nhị phân đơn giản có thể được mô tả như đã thấy trong hình sau

Constructor data tree

Các bộ phận của cấu trúc dữ liệu cây

Một cây bao gồm một nút gốc, nút lá và nút bên trong. Mỗi nút được kết nối với chile của nó thông qua một tham chiếu, được gọi là gần.  

Nút gốc. Nút gốc là nút trên cùng của cây. Nó luôn luôn là nút đầu tiên được tạo ra trong khi tạo cây và chúng ta có thể truy cập từng phần tử của cây bắt đầu từ nút gốc. Trong ví dụ trên, nút chứa phần tử 50 là nút gốc. Nút gốc là nút trên cùng của cây. Nó luôn là nút đầu tiên được tạo trong khi tạo cây và chúng ta có thể truy cập từng phần tử của cây bắt đầu từ nút gốc. Trong ví dụ trên, nút chứa phần tử 50 là nút gốc

nút cha. Cha mẹ của bất kỳ nút nào là nút tham chiếu nút hiện tại. Trong ví dụ trên, 50 là cha của tuổi 20 và 45, 20 là mẹ của tuổi 11, 46 và 15. Tương tự 45 là cha mẹ của 30 và 78. Nút cha của bất kỳ nút nào là nút tham chiếu đến nút hiện tại. Trong ví dụ trên, 50 là cha của 20 và 45, 20 là cha của 11, 46 và 15. Tương tự 45 là cha của 30 và 78

nút con. Các nút con của nút cha là các nút mà tại đó nút cha đang trỏ chuột bằng các tham chiếu. Trong ví dụ trên, 20 và 45 là con của 50. Các nút 11, 46 và 15 là con của 20 và 30 và 78 là con 45. Các nút con của nút cha là các nút mà nút cha đang trỏ tới bằng cách sử dụng các tham chiếu. Trong ví dụ trên, 20 và 45 là con của 50. Các nút 11, 46 và 15 là con của 20 và 30 và 78 là con của 45

Cạnh tranh. Tham chiếu thông qua nút cha được kết nối với nút con được gọi là cạnh. Trong ví dụ trên, mỗi mũi tên kết nối bất kỳ hai nút nào là một cạnh. Tham chiếu qua đó nút cha được kết nối với nút con được gọi là cạnh. Trong ví dụ trên, mỗi mũi tên nối hai nút bất kỳ là một cạnh

nút lá. Đây là những nút trong cây không có con.   . Đây là những nút trong cây không có con. Trong ví dụ trên, 11, 46, 15, 30 và 78 là các nút lá

Các nút bên trong. Các nút bên trong là các nút có ít nhất một đứa trẻ. Trong ví dụ trên, 50, 20 và 45 là các nút bên trong. Các nút bên trong là các nút có ít nhất một nút con. Trong ví dụ trên, 50, 20 và 45 là các nút bên trong

nhị phân cây là gì?

Một cây nhị phân là cấu trúc cây dữ liệu trong đó mỗi nút có thể có tối đa 2 trẻ em.   . Mỗi nút trong một cây nhị phân chứa dữ liệu và tham chiếu đến con cái của nó. Cả hai trẻ em được đặt tên là trẻ em bên trái và trẻ em phải theo vị trí của chúng. Cấu trúc của một nút trong một phân tích cây nhị phân được hiển thị trong hình sau

Nút của một cây nhị phân

Chúng ta có thể xác định một nút của cấu trúc được hiển thị ở trên trong Python bằng cách sử dụng các lớp như sau

class BinaryTreeNode:
  def __init__[self, data]:
    self.data = data
    self.leftChild = None
    self.rightChild=None

Ở đây, hàm tạo nút lấy giá trị dữ liệu bắt đầu vào, tạo đối tượng của loại binytreenode và khởi tạo trường dữ liệu bằng với đầu vào đã cho và khởi tạo các tham chiếu đến trẻ em không thành công. Em bé chỉ có thể được xác định vào các nút sau này. Một ví dụ về cây nhị phân được hiển thị trong hình dưới đây

Cấu hình cây nhị phân cấu trúc dữ liệu

Chúng ta có thể thực hiện nhị phân cây ở trên trong Python như sau

class BinaryTreeNode:
    def __init__[self, data]:
        self.data = data
        self.leftChild = None
        self.rightChild = None


node1 = BinaryTreeNode[50]
node2 = BinaryTreeNode[20]
node3 = BinaryTreeNode[45]
node4 = BinaryTreeNode[11]
node5 = BinaryTreeNode[15]
node6 = BinaryTreeNode[30]
node7 = BinaryTreeNode[78]

node1.leftChild = node2
node1.rightChild = node3
node2.leftChild = node4
node2.rightChild = node5
node3.leftChild = node6
node3.rightChild = node7

print["Root Node is:"]
print[node1.data]

print["left child of the node is:"]
print[node1.leftChild.data]

print["right child of the node is:"]
print[node1.rightChild.data]

print["Node is:"]
print[node2.data]

print["left child of the node is:"]
print[node2.leftChild.data]

print["right child of the node is:"]
print[node2.rightChild.data]

print["Node is:"]
print[node3.data]

print["left child of the node is:"]
print[node3.leftChild.data]

print["right child of the node is:"]
print[node3.rightChild.data]

print["Node is:"]
print[node4.data]

print["left child of the node is:"]
print[node4.leftChild]

print["right child of the node is:"]
print[node4.rightChild]

print["Node is:"]
print[node5.data]

print["left child of the node is:"]
print[node5.leftChild]

print["right child of the node is:"]
print[node5.rightChild]

print["Node is:"]
print[node6.data]

print["left child of the node is:"]
print[node6.leftChild]

print["right child of the node is:"]
print[node6.rightChild]

print["Node is:"]
print[node7.data]

print["left child of the node is:"]
print[node7.leftChild]

print["right child of the node is:"]
print[node7.rightChild]

đầu ra

Root Node is:
50
left child of the node is:
20
right child of the node is:
45
Node is:
20
left child of the node is:
11
right child of the node is:
15
Node is:
45
left child of the node is:
30
right child of the node is:
78
Node is:
11
left child of the node is:
None
right child of the node is:
None
Node is:
15
left child of the node is:
None
right child of the node is:
None
Node is:
30
left child of the node is:
None
right child of the node is:
None
Node is:
78
left child of the node is:
None
right child of the node is:
None

Kết luận

Trong bài viết này, chúng tôi đã thảo luận về cấu trúc dữ liệu cây và cấu trúc dữ liệu cây nhị phân trong Python. Để tìm hiểu thêm về cấu trúc dữ liệu cấu trúc trong Python, bạn có thể đọc bài viết này trên danh sách được liên kết trong Python

Khuyến nghị đào tạo Python

Key hoc. Python 3 cho người mới bắt đầu

Hơn 15 giờ nội dung video có hướng dẫn hướng dẫn cho người mới bắt đầu. Tìm hiểu cách làm nào để tạo các ứng dụng trong thế giới thực và làm chủ những điều cơ bản

Python có cấu trúc cây dữ liệu không?

Không có bất kỳ cấu trúc dữ liệu phân tích cấu trúc nào cho các cây chung trong Python, nhưng nó dễ dàng được triển khai với các lớp

Chủ Đề