Comments

• 
  

  0

  

  kienduy1221  commented on Oct. 31, 2024, 2:08 p.m.

  Copy

  #include<bits/stdc++.h>
  #include <iostream>
  #include <vector>
  #include <algorithm>
  
  using namespace std;
  
  struct Node {
      int data; // Giá tr? c?a nút
      vector<Node*> children; // Danh sách các con c?a nút
  
      Node(int val) : data(val) {}
  };
  
  class GeneralTree {
  private:
      Node* root; // G?c c?a cây
  
  public:
      // Kh?i t?o cây v?i g?c có giá tr? `rootData`
      GeneralTree(int rootData) {
          root = new Node(rootData);
      }
  
      // Hàm thêm con cho m?t nút
      Node* insert(Node* parent, int childData) {
          Node* child = new Node(childData);
          parent->children.push_back(child);
          return child; // Tr? v? nút con v?a thêm
      }
  
      // Hàm truy c?p g?c c?a cây
      Node* getRoot() {
          return root;
      }
  
      // Hàm t?o cây theo công th?c `(a - 1) * (x / a + 1)`
      void buildTree(Node* parent) {
          if (parent->data > 0) {
              int x = parent->data;
              for (int a = 1; a * a <= x; a++) {
                  if (x % a == 0) {
                      int y = (a - 1) * (x / a + 1);
                      if (y >= 0) { // N?u y >= 0 th? thêm vào cây
                          Node* child = insert(parent, y);
                          buildTree(child); // Đ? quy đ? xây d?ng cây cho con
                      }
                  }
              }
          }
      }
  
      // Hàm duy?t cây theo ki?u ti?n th? t? (preOrder)
      void preOrder(Node* node, void (*visit)(Node*)) {
          if (node == nullptr) return;
          visit(node); // Th?c hi?n hành đ?ng trên nút
          for (Node* child : node->children) {
              preOrder(child, visit); // Duy?t qua các con
          }
      }
  
      void inOrder(Node* node, void (*visit)(Node*)) {
      if (node == nullptr) return;
  
      // Duy?t in-order con đ?u tiên (n?u có)
      if (!node->children.empty()) {
          inOrder(node->children[0], visit);
      }
  
      // Th?c hi?n thao tác trên nút hi?n t?i
      visit(node);
  
      // Duy?t in-order các con c?n l?i (n?u có)
      for (size_t i = 1; i < node->children.size(); i++) {
          inOrder(node->children[i], visit);
      }
  }
  
  
  
      // Hàm duy?t cây theo ki?u h?u th? t? (postOrder)
      void postOrder(Node* node, void (*visit)(Node*)) {
          if (node == nullptr) return;
          for (Node* child : node->children) {
              postOrder(child, visit); // Duy?t qua các con
          }
          visit(node); // Th?c hi?n hành đ?ng trên nút
      }
  };
  
  // Hàm in giá tr? c?a m?t nút
  void printNode(Node* node) {
      cout << node->data << " ";
  }
  
  int main() {
      int n;
  //    cout << "Nhap gia tri n: ";
      cin >> n;
  
      // T?o cây v?i nút g?c là `n`
      GeneralTree tree(n);
  
      // Xây d?ng cây b?t đ?u t? g?c
      tree.buildTree(tree.getRoot());
  
      // Duy?t cây theo các ki?u duy?t
  //    cout << "Duyet Preorder: ";
      tree.preOrder(tree.getRoot(), printNode);
      cout << endl;
  
  //    cout << "Duyet Inorder: ";
      tree.inOrder(tree.getRoot(), printNode);
      cout << endl;
  
  //    cout << "Duyet Postorder: ";
      tree.postOrder(tree.getRoot(), printNode);
      cout << endl;
  
      return 0;
  }