Hướng dẫn convert list to tree python - chuyển đổi danh sách thành python cây

Tôi và bạn của tôi đang làm việc trong một dự án Python đơn giản. Trên thực tế, chúng tôi đang thực hiện thuật toán tổng song song tiền tố theo cách riêng của chúng tôi.

Chúng tôi đang tạo và xử lý một cây nhị phân với một định dạng thực sự kỳ lạ. Chúng tôi muốn chuyển đổi định dạng này thành một được chấp nhận bởi các thư viện/phần mềm in cây như ETE2.

Vì vậy, mọi cấp độ của cây đều được đẩy vào một danh sách theo cách đó

[ [level0], [level1], ... [level i-1], [root] ]

Trong định dạng của chúng tôi, mọi danh sách nội bộ [cấp độ cây] đều có số lượng nút hoặc lá.

Chẳng hạn, giả sử chúng ta có đầu vào này: [1, 2, 3, 4, 5]. Điều này sẽ tạo ra danh sách đầu ra sau: [[1, 2, 3, 4], [3, 7], [10, 5], [15]]

Vấn đề với ví dụ đầu ra ở trên là đôi khi các lá không ở cấp độ cuối cùng, nhưng chúng được đưa vào danh sách cấp trên. Điều này làm cho khó xử lý danh sách các danh sách và phân biệt các nút với lá và cũng sắp xếp chúng ở đúng vị trí.

Chúng tôi muốn hình dung điều này như sau:

//i.imgur.com/BKrqNZi.png

trong đó các con số bao gồm trong ngoặc đơn là các nút và các số khác.

Để tạo ra cây đầu ra này, chúng tôi muốn sử dụng một thư viện vẽ một cây. Hầu hết trong số họ mong đợi loại định dạng này: [root, [left], [right]]

Vì vậy, trong ví dụ của chúng tôi định dạng của chúng tôi phải là một cái gì đó như thế này:

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

Bởi vì chúng tôi không ở một vị trí tại thời điểm này để viết lại toàn bộ logic của mã của chúng tôi, chúng tôi đang tìm kiếm một cách thông minh chuyển đổi định dạng kỳ lạ của chúng tôi thành hình thức đó.

Bất kỳ ý tưởng được chào đón. Cảm ơn bạn rất nhiều trước.

Làm cách nào để biến một danh sách thành một bảng trong Python?

Examples:

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

Làm thế nào để dễ dàng tạo bảng trong Python.
Method #1 : Naive Method
This is a Naive approach in which we use two for loops to traverse the list of lists. We initialize the empty dictionary ‘tree’ to currTree and each time we check if the key [list of list’s item] is included in the currTree or not. If not, include it in the currTree, otherwise do nothing. Finally, assign the currTree[key] to currTree.

Cài đặt bảng. Trước tiên chúng tôi cài đặt thư viện Tabulation bằng cách cài đặt PIP trong dòng lệnh: PIP Cài đặt Tabulation ..

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

{'A': {'B': {}, 'C': {'D': {}}}}

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

{'A': {'B': {}, 'C': {'D': {}}}}

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

6 currTree[key]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

4[1, 2, 3, 4, 5]1

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

[1, 2, 3, 4, 5]3

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

6 [1, 2, 3, 4, 5]55____56[1, 2, 3, 4, 5]7[1, 2, 3, 4, 5]8[1, 2, 3, 4, 5]9[1, 2, 3, 4, 5]6[1, 2, 3, 4, 5]7__62

[root, [left], [right]]2[root, [left], [right]]3

Output:

{'A': {'B': {}, 'C': {'D': {}}}}

& nbsp; Phương pháp #2: Sử dụng hàm [root, [left], [right]]4the [root, [left], [right]]4 được sử dụng để áp dụng một hàm cụ thể được truyền trong đối số của nó cho tất cả các yếu tố danh sách được đề cập trong chuỗi được truyền. Chúng tôi sẽ sử dụng [root, [left], [right]]4 để vượt qua từ điển và tái sử dụng [root, [left], [right]]7 để tìm vị trí để lưu trữ giá trị cho [root, [left], [right]]8. Tất cả trừ phần tử cuối cùng trong MapList là cần thiết để tìm từ điển ‘cha mẹ để thêm giá trị vào, sau đó sử dụng phần tử cuối cùng để đặt giá trị thành phím bên phải.
Method #2 : Using [root, [left], [right]]4
The [root, [left], [right]]4 function is used to apply a particular function passed in its argument to all of the list elements mentioned in the sequence passed along. We will use [root, [left], [right]]4 to traverse the dictionary and reuse [root, [left], [right]]7 to find the location to store the value for [root, [left], [right]]8. All but the last element in mapList is needed to find the ‘parent’ dictionary to add the value to, then use the last element to set the value to the right key.

[root, [left], [right]]9 currTree[key]0currTree[key]1 currTree[key]2

[root, [left], [right]]9 currTree[key]4currTree[key]1 currTree[key]6

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

0 currTree[key]8

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

4[1, 2, 3, 4, 5]1 currTree[key]22____92

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

0 currTree4

Các

[1, 2, 3, 4, 5]3

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

6 [1, 2, 3, 4, 5]55____56[1, 2, 3, 4, 5]7[1, 2, 3, 4, 5]8[1, 2, 3, 4, 5]9[1, 2, 3, 4, 5]6[1, 2, 3, 4, 5]7__62

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

Input : [[1], [2, 1], [3, 1], [4, 2, 1], [5, 2, 1], [6, 3, 1], [7, 3, 1]]
Output : {1: {2: {4: {}, 5: {}}, 3: {6: {}, 7: {}}}}

Input : [['A'], ['B', 'A'], ['C', 'A'], ['D', 'C', 'A']]
Output : {'A': {'C': {'D': {}}, 'B': {}}}

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

{'A': {'B': {}, 'C': {'D': {}}}}

{'A': {'B': {}, 'C': {'D': {}}}}

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

[root, [left], [right]]2

[15, [10, [3, [1], [2]], [7, [3], [4]] ], [5] ]

Output:

{'A': {'B': {}, 'C': {'D': {}}}}

Làm thế nào để bạn chuyển đổi một danh sách thành một cây trong Python?

Trong bài viết này, chúng ta sẽ thấy hai cách tiếp cận để chuyển đổi một danh sách lồng nhau thành để thêm từ điển có các phần tử đại diện cho một cây giống như cấu trúc dữ liệu ...

Sử dụng cắt lát. Chúng tôi đảo ngược các mục trong danh sách cắt giảm ABY và sau đó kiểm tra xem mục này có trong danh sách không. ....

Thí dụ. ....

Đầu ra. ....

Sử dụng giảm và getitem. ....

Thí dụ. ....

Output..

Đầu ra. ....

Thay vì sử dụng phương thức nút nhiều lần, chúng ta có thể sử dụng phương thức build [] để chuyển đổi danh sách các giá trị thành cây nhị phân.Ở đây, một danh sách đã cho chứa các nút của cây sao cho phần tử tại chỉ mục i có con trái của nó tại INDEX 2*I+1, đứa con bên phải tại INDEX 2*I+2 và cha mẹ tại [i - 1] // 2.use build[] method to convert a list of values into a binary tree. Here, a given list contains the nodes of tree such that the element at index i has its left child at index 2*i+1, the right child at index 2*i+2 and parent at [i – 1]//2.

Làm cách nào để biến một danh sách thành một bảng trong Python?

Làm thế nào để dễ dàng tạo bảng trong Python..

Cài đặt bảng.Trước tiên chúng tôi cài đặt thư viện Tabulation bằng cách cài đặt PIP trong dòng lệnh: PIP Cài đặt Tabulation ..

Nhập chức năng bảng.....

Danh sách danh sách.....

Từ điển của Iterables.....

giá trị bị mất..

Bạn có thể biến một danh sách thành một chuỗi không?

Để chuyển đổi danh sách thành một chuỗi, hãy sử dụng khả năng hiểu danh sách Python và hàm tham gia [].Sự hiểu biết danh sách sẽ đi qua từng phần tử một và phương thức tham gia [] sẽ kết hợp các phần tử của danh sách thành một chuỗi mới và trả về nó làm đầu ra.use Python List Comprehension and the join[] function. The list comprehension will traverse the elements one by one, and the join[] method will concatenate the list's elements into a new string and return it as output.

Làm thế nào để bạn chuyển đổi một danh sách thành một cây trong Python?

Đầu ra. ....

Làm cách nào để biến một danh sách thành một bảng trong Python?

Bạn có thể biến một danh sách thành một chuỗi không?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề