Đệ quy cây nhị phân Python

Trong lập trình, đó là một chức năng đề cập đến chính nó. Hai chức năng có thể gọi lẫn nhau, điều này được gọi là đệ quy lẫn nhau. Hãy sử dụng một ví dụ từ thế giới toán học. giai thừa. Giai thừa của một số tự nhiên n là tích của các số nguyên dương hoàn toàn nhỏ hơn hoặc bằng n. Ghi chú n! và được tính toán như sau. ________số 8

Chạy thuật toán này trong đầu, bạn sẽ thấy rằng nó không bao giờ dừng lại và nó chạy vô tận. Thật vậy, nếu chúng ta thực thi hàm với n = 3 thì

#Create the instance
left = DecisionNode('Decision', {0:0,1:1}, 0.5)
right = DecisionNode('Age',{0:0.5, 1:0.5},62,
                     DecisionNode('Decision', {0:0.2, 1:0.8},0.5),
                     DecisionNode('Tachycardia',{0:0.4,1:0.6},0.5,
                         DecisionNode('Decision',{0:0.1, 1:0.9},0.5),
                         DecisionNode('Decision',{0:0.9, 1:0.1},0.5)) )
DecisionNd = DecisionNode('Blood Pressure', {0:0.3,1:0.7},91, left, right)>>> print(DecisionNd)IF Blood Pressure >= 91  THEN Decision = {0: 0, 1: 1}
IF Blood Pressure < 91 AND Age >= 62  THEN Decision = {0: 0.2, 1: 0.8}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia >= 0.5  THEN Decision = {0: 0.1, 1: 0.9}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia < 0.5  THEN Decision = {0: 0.9, 1: 0.1}

0 sẽ được gọi với n = 3, sau đó là

#Create the instance
left = DecisionNode('Decision', {0:0,1:1}, 0.5)
right = DecisionNode('Age',{0:0.5, 1:0.5},62,
                     DecisionNode('Decision', {0:0.2, 1:0.8},0.5),
                     DecisionNode('Tachycardia',{0:0.4,1:0.6},0.5,
                         DecisionNode('Decision',{0:0.1, 1:0.9},0.5),
                         DecisionNode('Decision',{0:0.9, 1:0.1},0.5)) )
DecisionNd = DecisionNode('Blood Pressure', {0:0.3,1:0.7},91, left, right)>>> print(DecisionNd)IF Blood Pressure >= 91  THEN Decision = {0: 0, 1: 1}
IF Blood Pressure < 91 AND Age >= 62  THEN Decision = {0: 0.2, 1: 0.8}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia >= 0.5  THEN Decision = {0: 0.1, 1: 0.9}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia < 0.5  THEN Decision = {0: 0.9, 1: 0.1}

2, sau đó là

#Create the instance
left = DecisionNode('Decision', {0:0,1:1}, 0.5)
right = DecisionNode('Age',{0:0.5, 1:0.5},62,
                     DecisionNode('Decision', {0:0.2, 1:0.8},0.5),
                     DecisionNode('Tachycardia',{0:0.4,1:0.6},0.5,
                         DecisionNode('Decision',{0:0.1, 1:0.9},0.5),
                         DecisionNode('Decision',{0:0.9, 1:0.1},0.5)) )
DecisionNd = DecisionNode('Blood Pressure', {0:0.3,1:0.7},91, left, right)>>> print(DecisionNd)IF Blood Pressure >= 91  THEN Decision = {0: 0, 1: 1}
IF Blood Pressure < 91 AND Age >= 62  THEN Decision = {0: 0.2, 1: 0.8}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia >= 0.5  THEN Decision = {0: 0.1, 1: 0.9}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia < 0.5  THEN Decision = {0: 0.9, 1: 0.1}

0, sau đó là

#Create the instance
left = DecisionNode('Decision', {0:0,1:1}, 0.5)
right = DecisionNode('Age',{0:0.5, 1:0.5},62,
                     DecisionNode('Decision', {0:0.2, 1:0.8},0.5),
                     DecisionNode('Tachycardia',{0:0.4,1:0.6},0.5,
                         DecisionNode('Decision',{0:0.1, 1:0.9},0.5),
                         DecisionNode('Decision',{0:0.9, 1:0.1},0.5)) )
DecisionNd = DecisionNode('Blood Pressure', {0:0.3,1:0.7},91, left, right)>>> print(DecisionNd)IF Blood Pressure >= 91  THEN Decision = {0: 0, 1: 1}
IF Blood Pressure < 91 AND Age >= 62  THEN Decision = {0: 0.2, 1: 0.8}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia >= 0.5  THEN Decision = {0: 0.1, 1: 0.9}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia < 0.5  THEN Decision = {0: 0.9, 1: 0.1}

1, sau đó là

#Create the instance
left = DecisionNode('Decision', {0:0,1:1}, 0.5)
right = DecisionNode('Age',{0:0.5, 1:0.5},62,
                     DecisionNode('Decision', {0:0.2, 1:0.8},0.5),
                     DecisionNode('Tachycardia',{0:0.4,1:0.6},0.5,
                         DecisionNode('Decision',{0:0.1, 1:0.9},0.5),
                         DecisionNode('Decision',{0:0.9, 1:0.1},0.5)) )
DecisionNd = DecisionNode('Blood Pressure', {0:0.3,1:0.7},91, left, right)>>> print(DecisionNd)IF Blood Pressure >= 91  THEN Decision = {0: 0, 1: 1}
IF Blood Pressure < 91 AND Age >= 62  THEN Decision = {0: 0.2, 1: 0.8}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia >= 0.5  THEN Decision = {0: 0.1, 1: 0.9}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia < 0.5  THEN Decision = {0: 0.9, 1: 0.1}

2, v.v.

Một thuật toán không bao giờ dừng lại là một vấn đề, bạn có thể tưởng tượng

Do đó, giải pháp là chỉ định một điều kiện dừng, điều này sẽ luôn phụ thuộc vào vấn đề của chúng tôi. Trong trường hợp của chúng tôi

#Create the instance
left = DecisionNode('Decision', {0:0,1:1}, 0.5)
right = DecisionNode('Age',{0:0.5, 1:0.5},62,
                     DecisionNode('Decision', {0:0.2, 1:0.8},0.5),
                     DecisionNode('Tachycardia',{0:0.4,1:0.6},0.5,
                         DecisionNode('Decision',{0:0.1, 1:0.9},0.5),
                         DecisionNode('Decision',{0:0.9, 1:0.1},0.5)) )
DecisionNd = DecisionNode('Blood Pressure', {0:0.3,1:0.7},91, left, right)>>> print(DecisionNd)IF Blood Pressure >= 91  THEN Decision = {0: 0, 1: 1}
IF Blood Pressure < 91 AND Age >= 62  THEN Decision = {0: 0.2, 1: 0.8}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia >= 0.5  THEN Decision = {0: 0.1, 1: 0.9}
IF Blood Pressure < 91 AND Age < 62 AND Tachycardia < 0.5  THEN Decision = {0: 0.9, 1: 0.1}

3. Bạn nhận thấy rằng các thừa số khác nhau (3, 2 và 1) không bao giờ âm hay thậm chí bằng 0. Chính điều kiện này sẽ phục vụ chúng ta như một điều kiện dừng. “thừa số không bao giờ được nhỏ hơn hoặc bằng 0”. Vì vậy, chúng tôi thêm một tuyên bố có điều kiện

Gọi một hàm bên trong chính nó được đặt tên là một cuộc gọi đệ quy

Một cuộc gọi đệ quy phải trong một câu lệnh có điều kiện

Ghi chú. Mọi đệ quy có thể được chuyển đổi thành phép lặp

Ví dụ từ thế giới Khoa học dữ liệu

1. Biểu diễn cấu trúc cây nhị phân

Cây nhị phân là một cấu trúc dữ liệu được hình thành bởi một hệ thống phân cấp các phần tử được gọi là các nút. Một nút được đặc trưng bởi hai loại thông tin

• Thông tin cụ thể về nút
• Thông tin mô tả các liên kết với các nút con của nó

Cây nhị phân luôn được chỉ định bởi một nút. nút ban đầu của nó được gọi là gốc.
Mỗi nút có nhiều nhất hai nút con.

• Nếu nút có đúng hai nút con thì chúng được gọi là nút con trái và nút con phải
• Nếu nút chỉ có một nút con, thì đây là nút con bên trái hoặc nút con bên phải
• Nếu nút không có con, nó được gọi là lá

Cành cây là đường đi từ gốc cây đến lá

Vì vậy, cây nhị phân là một cấu trúc đệ quy vì con trái và con phải là các nút (lần lượt đại diện cho các cây)

Hình cây nhị phân. Nguồn tác giả

Hình này biểu thị một cây nhị phân có nút A là gốc với B là con trái và C là con phải. Nút C chỉ có một con F (con phải). D, E và F là các nút lá.
[A, B, D], [A, B, E] và [A, C, F] là các nhánh của cây.

Hãy tạo lớp Node

Thuộc tính

• nhãn. một chuỗi đại diện cho quan sát
• bên trái. một thể hiện của lớp đại diện cho con trái
• đúng. một thể hiện của lớp đại diện cho con bên phải

phương pháp

• __trong đó__. nhà xây dựng
• __str__. trả về chuỗi đại diện cho cây theo ví dụ sau
• tuyến tính hóa. phương thức đệ quy trả về danh sách các nhánh cây

NodeFigure = Nd = Node('A',Node('B', Node('D'), Node('E')), Node('C',None,Node('F')))>>> print(NodeFigure)
Node(A,Node(B,Node(D),Node(E)),Node(C,None,Node(F)))

2. Đại diện của Mô hình Quyết định

Một lát của Bảng dữ liệu

Các luật quyết định có thể được biểu diễn bằng cây nhị phân, được gọi là cây quyết định nhị phân. Ví dụ, đối với tập dữ liệu trong bảng sau, có thể xây dựng cây quyết định nhị phân được minh họa bởi hình dưới đây

Trong phần này, chúng ta sẽ tạo lớp DecisionNode, lớp này kế thừa từ lớp Node và biểu diễn cây quyết định nhị phân

Thực hiện đệ quy của cây nhị phân là gì?

Làm cách nào để chuyển đổi số thập phân thành nhị phân trong Python bằng đệ quy?

Thuật toán cây có đệ quy không?

Làm thế nào để đệ quy làm việc trong cây?