C++二叉树打印功能实现求助（Visual Studio 2017环境）

Hey there! Let's work through your binary tree printing issue together. Since you've already got the insertion logic sorted, we'll focus on fixing the print function and verifying your tree works as expected.

First, let's start by aligning on a typical binary tree structure (matching your mentioned .h and .cpp files) and then implement the printing logic.

Step 1: Check Your Header File (cseatreebin.h) #

Make sure your node structure and class interface includes the necessary helper functions for printing. Here's a standard setup:

#ifndef CSEATREEBIN_H
#define CSEATREEBIN_H

#include <iostream>

// Define your tree node structure
struct TreeNode {
    int data; // Adjust the data type if you're storing something else
    TreeNode* left;
    TreeNode* right;
    TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};

class BinaryTree {
private:
    TreeNode* root;
    // Recursive helper function to traverse and print nodes
    void printInOrder(TreeNode* node);
public:
    BinaryTree() : root(nullptr) {}
    // Your existing insertion function
    void insert(int val);
    // Public print function to trigger the traversal
    void printTree();
    // Optional: Add destructor to avoid memory leaks
    ~BinaryTree();
};

#endif

Step 2: Fix the Print Logic in bintree.cpp #

Your original Print function probably only outputs a static message—we need to add tree traversal logic. Recursive traversal is the most intuitive way for binary trees. Let's implement an in-order traversal (left → root → right), which is common for binary search trees:

#include "cseatreebin.h"

// Your existing insertion implementation (example for reference)
void BinaryTree::insert(int val) {
    if (root == nullptr) {
        root = new TreeNode(val);
        return;
    }

    TreeNode* current = root;
    while (true) {
        if (val < current->data) {
            if (current->left == nullptr) {
                current->left = new TreeNode(val);
                break;
            }
            current = current->left;
        } else {
            if (current->right == nullptr) {
                current->right = new TreeNode(val);
                break;
            }
            current = current->right;
        }
    }
}

// Recursive helper for in-order traversal
void BinaryTree::printInOrder(TreeNode* node) {
    if (node == nullptr) return; // Base case: stop if we hit a null node

    printInOrder(node->left);   // Print left subtree first
    std::cout << node->data << " "; // Print current node's data
    printInOrder(node->right);  // Print right subtree last
}

// Public print function to start the traversal
void BinaryTree::printTree() {
    if (root == nullptr) {
        std::cout << "Tree is empty!" << std::endl;
        return;
    }
    std::cout << "Binary Tree nodes (in-order): ";
    printInOrder(root);
    std::cout << std::endl;
}

// Optional: Destructor to clean up memory
void deleteTree(TreeNode* node) {
    if (node == nullptr) return;
    deleteTree(node->left);
    deleteTree(node->right);
    delete node;
}

BinaryTree::~BinaryTree() {
    deleteTree(root);
}

Step 3: Test Your Tree #

Add a main function to verify insertion and printing work:

#include "cseatreebin.h"

int main() {
    BinaryTree myTree;
    // Insert some test values
    myTree.insert(10);
    myTree.insert(5);
    myTree.insert(15);
    myTree.insert(3);
    myTree.insert(7);

    // Print the tree
    myTree.printTree(); // Should output: 3 5 7 10 15
    return 0;
}

Common Issues to Check #

If your original print function wasn't working, these are likely culprits:

• No traversal logic: You were only outputting a static message instead of iterating/recursing through nodes.
• Access permissions: If your TreeNode's data member was private, the print function couldn't access it. Ensure it's public or add a getter method.
• Null node handling: Forgetting to check if a node is nullptr can cause crashes during traversal.

Want Different Traversal Orders? #

Adjust the printInOrder function to use other common traversals:

• Pre-order (root → left → right):

  void BinaryTree::printPreOrder(TreeNode* node) {
      if (node == nullptr) return;
      std::cout << node->data << " ";
      printPreOrder(node->left);
      printPreOrder(node->right);
  }
  

• Post-order (left → right → root):

  void BinaryTree::printPostOrder(TreeNode* node) {
      if (node == nullptr) return;
      printPostOrder(node->left);
      printPostOrder(node->right);
      std::cout << node->data << " ";
  }
  

内容的提问来源于stack exchange，提问作者Private Joker