建立一棵二叉树，并用递归或非递归的算法分别用先序、中序和后序遍历之。实验要求：(1) 应用先序遍历法建立任意一棵二叉树；(2) 实现二叉树先序、中序、后序遍历的递归算法；（编写代码并运行）

首先，让我们讨论如何建立一棵二叉树。我们可以使用递归的方式创建一个简单的二叉树节点结构，然后通过递归的方法进行插入操作来构建整个二叉树。

// 定义二叉树节点结构
typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 递归插入节点到二叉树
TreeNode* insertNode(TreeNode* root, int val) {
    if (root == NULL) {
        return (TreeNode*)malloc(sizeof(TreeNode));
    }
    if (val < root->val) {
        root->left = insertNode(root->left, val);
    } else {
        root->right = insertNode(root->right, val);
    }
    return root;
}

接下来，我们分别介绍三种遍历方法：

### 先序遍历（Preorder Traversal）
- 访问根节点
- 遍历左子树
- 遍历右子树

递归实现：

void preorderTraversal(TreeNode* root) {
    if (root != NULL) {
        printf("%d ", root->val); // 访问根节点
        preorderTraversal(root->left); // 左子树
        preorderTraversal(root->right); // 右子树
    }
}

非递归实现（使用栈）：

void preorderTraversalNonRecursive(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    Stack<TreeNode*> stack;
    stack.push(root);

    while (!stack.isEmpty()) {
        TreeNode* node = stack.pop();
        printf("%d ", node->val);
        
        if (node->right) {
            stack.push(node->right);
        }
        if (node->left) {
            stack.push(node->left);
        }
    }
}

### 中序遍历（Inorder Traversal）
- 遍历左子树
- 访问根节点
- 遍历右子树

递归实现：

void inorderTraversal(TreeNode* root) {
    if (root != NULL) {
        inorderTraversal(root->left); // 左子树
        printf("%d ", root->val); // 访问根节点
        inorderTraversal(root->right); // 右子树
    }
}

非递归实现（使用栈）：

void inorderTraversalNonRecursive(TreeNode* root) {
    Stack<TreeNode*> stack;
    TreeNode* current = root;

    while (current || !stack.isEmpty()) {
        while (current) {
            stack.push(current);
            current = current->left;
        }
        current = stack.top();
        stack.pop();

        printf("%d ", current->val);
        current = current->right;
    }
}

### 后序遍历（Postorder Traversal）
- 遍历左子树
- 遍历右子树
- 访问根节点

递归实现：

void postorderTraversal(TreeNode* root) {
    if (root != NULL) {
        postorderTraversal(root->left); // 左子树
        postorderTraversal(root->right); // 右子树
        printf("%d ", root->val); // 访问根节点
    }
}

非递归实现（使用两个栈）：

void postorderTraversalNonRecursive(TreeNode* root) {
    Stack<TreeNode*> stack1, stack2;
    TreeNode* current = root;

    if (current) {
        stack2.push(current);
        while (!stack1.isEmpty() || !stack2.isEmpty()) {
            while (current && current->left) {
                stack1.push(current);
                current = current->left;
            }
            if (current) {
                stack2.push(current);
                current = current->right;
            } else {
                current = stack1.top();
                stack1.pop();
                printf("%d ", current->val);
                current = stack2.top();
                stack2.pop();
            }
        }
    }
}

完成了以上代码，你可以根据需求选择递归或非递归版本，以及针对具体数据构建二叉树，然后调用相应的遍历函数。记得为每个函数定义好主程序来测试它们的效果。