Hướng dẫn tree in python - cây trong trăn

Trong hướng dẫn này, bạn sẽ tìm hiểu về cây nhị phân hoàn hảo. Ngoài ra, bạn sẽ tìm thấy các ví dụ làm việc để kiểm tra một cây nhị phân hoàn hảo trong C, C ++, Java và Python.

Nội phân Chính showShow

• Ví dụ về Python, Java và C/C ++
• Định lý cây nhị phân hoàn hảo
• Làm thế nào để bạn tạo ra một cây nhị phân hoàn chỉnh trong Python?
• Làm thế nào để bạn tạo ra một cây nhị phân hoàn hảo?
• Cây nhị phân hoàn hảo hoàn toàn là gì?
• Cây nhị phân hoàn hảo có phải là một cây nhị phân hoàn chỉnh không?

Nội phân chính

• Ví dụ về Python, Java và C/C ++
• Định lý cây nhị phân hoàn hảo
• Làm thế nào để bạn tạo ra một cây nhị phân hoàn chỉnh trong Python?
• Làm thế nào để bạn tạo ra một cây nhị phân hoàn hảo?
• Cây nhị phân hoàn hảo hoàn toàn là gì?
• Cây nhị phân hoàn hảo có phải là một cây nhị phân hoàn chỉnh không?

Nội phân chính

Một cây nhị phân hoàn hảo là một loại cây nhị phân trong đó mọi nút bên trong đều có chính xác hai nút con và tất cả các nút lá đều ở cùng cấp độ.

Cây nhị phân hoàn hảo

Tất cả các nút bên trong có một mức độ 2.

1. Theo cách đệ quy, một cây nhị phân hoàn hảo có thể được định nghĩa là:
2. Nếu một nút duy nhất không có con, thì đó là một cây nhị phân hoàn hảo có chiều cao h = 0,

Nếu một nút có h > 0, thì đó là một cây nhị phân hoàn hảo nếu cả hai người con của nó có chiều cao h - 1 và không chồng chéo.

---

Ví dụ về Python, Java và C/C ++

Cây nhị phân hoàn hảo (đại diện đệ quy)

# Checking if a binary tree is a perfect binary tree in Python


class newNode:
    def __init__(self, k):
        self.key = k
        self.right = self.left = None


# Calculate the depth
def calculateDepth(node):
    d = 0
    while (node is not None):
        d += 1
        node = node.left
    return d


# Check if the tree is perfect binary tree
def is_perfect(root, d, level=0):

    # Check if the tree is empty
    if (root is None):
        return True

    # Check the presence of trees
    if (root.left is None and root.right is None):
        return (d == level + 1)

    if (root.left is None or root.right is None):
        return False

    return (is_perfect(root.left, d, level + 1) and
            is_perfect(root.right, d, level + 1))


root = None
root = newNode(1)
root.left = newNode(2)
root.right = newNode(3)
root.left.left = newNode(4)
root.left.right = newNode(5)

if (is_perfect(root, calculateDepth(root))):
    print("The tree is a perfect binary tree")
else:
    print("The tree is not a perfect binary tree")

// Checking if a binary tree is a perfect binary tree in Java

class PerfectBinaryTree {

  static class Node {
    int key;
    Node left, right;
  }

  // Calculate the depth
  static int depth(Node node) {
    int d = 0;
    while (node != null) {
      d++;
      node = node.left;
    }
    return d;
  }

  // Check if the tree is perfect binary tree
  static boolean is_perfect(Node root, int d, int level) {

    // Check if the tree is empty
    if (root == null)
      return true;

    // If for children
    if (root.left == null && root.right == null)
      return (d == level + 1);

    if (root.left == null || root.right == null)
      return false;

    return is_perfect(root.left, d, level + 1) && is_perfect(root.right, d, level + 1);
  }

  // Wrapper function
  static boolean is_Perfect(Node root) {
    int d = depth(root);
    return is_perfect(root, d, 0);
  }

  // Create a new node
  static Node newNode(int k) {
    Node node = new Node();
    node.key = k;
    node.right = null;
    node.left = null;
    return node;
  }

  public static void main(String args[]) {
    Node root = null;
    root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(4);
    root.left.right = newNode(5);

    if (is_Perfect(root) == true)
      System.out.println("The tree is a perfect binary tree");
    else
      System.out.println("The tree is not a perfect binary tree");
  }
}

// Checking if a binary tree is a perfect binary tree in C

#include 
#include 
#include 

struct node {
  int data;
  struct node *left;
  struct node *right;
};

// Creating a new node
struct node *newnode(int data) {
  struct node *node = (struct node *)malloc(sizeof(struct node));
  node->data = data;
  node->left = NULL;
  node->right = NULL;

  return (node);
}

// Calculate the depth
int depth(struct node *node) {
  int d = 0;
  while (node != NULL) {
    d++;
    node = node->left;
  }
  return d;
}

// Check if the tree is perfect
bool is_perfect(struct node *root, int d, int level) {
    // Check if the tree is empty
  if (root == NULL)
    return true;

  // Check the presence of children
  if (root->left == NULL && root->right == NULL)
    return (d == level + 1);

  if (root->left == NULL || root->right == NULL)
    return false;

  return is_perfect(root->left, d, level + 1) &&
       is_perfect(root->right, d, level + 1);
}

// Wrapper function
bool is_Perfect(struct node *root) {
  int d = depth(root);
  return is_perfect(root, d, 0);
}

int main() {
  struct node *root = NULL;
  root = newnode(1);
  root->left = newnode(2);
  root->right = newnode(3);
  root->left->left = newnode(4);
  root->left->right = newnode(5);
  root->right->left = newnode(6);

  if (is_Perfect(root))
    printf("The tree is a perfect binary tree\n");
  else
    printf("The tree is not a perfect binary tree\n");
}

// Checking if a binary tree is a perfect binary tree in C++

#include 
using namespace std;

struct Node {
  int key;
  struct Node *left, *right;
};

int depth(Node *node) {
  int d = 0;
  while (node != NULL) {
    d++;
    node = node->left;
  }
  return d;
}

bool isPerfectR(struct Node *root, int d, int level = 0) {
  if (root == NULL)
    return true;

  if (root->left == NULL && root->right == NULL)
    return (d == level + 1);

  if (root->left == NULL || root->right == NULL)
    return false;

  return isPerfectR(root->left, d, level + 1) &&
       isPerfectR(root->right, d, level + 1);
}

bool isPerfect(Node *root) {
  int d = depth(root);
  return isPerfectR(root, d);
}

struct Node *newNode(int k) {
  struct Node *node = new Node;
  node->key = k;
  node->right = node->left = NULL;
  return node;
}

int main() {
  struct Node *root = NULL;
  root = newNode(1);
  root->left = newNode(2);
  root->right = newNode(3);
  root->left->left = newNode(4);
  root->left->right = newNode(5);
  root->right->left = newNode(6);

  if (isPerfect(root))
    cout << "The tree is a perfect binary tree\n";
  else
    cout << "The tree is not a perfect binary tree\n";
}

---

Định lý cây nhị phân hoàn hảo

1. Làm thế nào để bạn tạo ra một cây nhị phân hoàn chỉnh trong Python?
2. Làm thế nào để bạn tạo ra một cây nhị phân hoàn hảo?
3. Cây nhị phân hoàn hảo hoàn toàn là gì?
4. Cây nhị phân hoàn hảo có phải là một cây nhị phân hoàn chỉnh không?

Làm thế nào để bạn tạo ra một cây nhị phân hoàn chỉnh trong Python?

Làm thế nào để bạn tạo ra một cây nhị phân hoàn hảo?use is-perfect = True then it will create a perfect binary tree with the given height. To get the output, I have used print(my_root). You can refer to the below screenshot for the output.

Làm thế nào để bạn tạo ra một cây nhị phân hoàn hảo?

Cây nhị phân hoàn hảo hoàn toàn là gì?If a single node has no children, it is a perfect binary tree of height h = 0 , If a node has h > 0 , it is a perfect binary tree if both of its subtrees are of height h - 1 and are non-overlapping.

Cây nhị phân hoàn hảo hoàn toàn là gì?

Cây nhị phân hoàn hảo có phải là một cây nhị phân hoàn chỉnh không?

Cây nhị phân hoàn hảo có phải là một cây nhị phân hoàn chỉnh không?

Nội phân chính