用C语言写出先序、中序、后序遍历的递归算法。

先序遍历的递归算法：

void preorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    printf("%d ", root->val);
    preorderTraversal(root->left);
    preorderTraversal(root->right);
}

中序遍历的递归算法：

void inorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    inorderTraversal(root->left);
    printf("%d ", root->val);
    inorderTraversal(root->right);
}

后序遍历的递归算法：

void postorderTraversal(TreeNode* root) {
    if (root == NULL) return;
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    printf("%d ", root->val);
}

其中，`TreeNode`是二叉树节点的结构体，包含左右子树指针和节点的值`val`。以上算法都是基于先访问左子树，再访问右子树的原则，只是访问节点的时机不同。

相关问题

请用C语言写出程序：输入字符序列，建立二叉树；按先序中序后序遍历二叉树（三种递归算法和中序遍历的非递归算法）

#include <stdio.h>
#include <stdlib.h>

//定义二叉树结构体
struct TreeNode {
    char data;
    struct TreeNode* left;
    struct TreeNode* right;
};

//根据输入的字符序列建立二叉树
struct TreeNode* createBinaryTree() {
    char ch;
    scanf("%c", &ch);
    if (ch == '#') {
        return NULL;
    }
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->data = ch;
    root->left = createBinaryTree();
    root->right = createBinaryTree();
    return root;
}

//先序遍历二叉树（递归算法）
void preOrderTraversalRecursive(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    printf("%c ", root->data);
    preOrderTraversalRecursive(root->left);
    preOrderTraversalRecursive(root->right);
}

//中序遍历二叉树（递归算法）
void inOrderTraversalRecursive(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inOrderTraversalRecursive(root->left);
    printf("%c ", root->data);
    inOrderTraversalRecursive(root->right);
}

//后序遍历二叉树（递归算法）
void postOrderTraversalRecursive(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postOrderTraversalRecursive(root->left);
    postOrderTraversalRecursive(root->right);
    printf("%c ", root->data);
}

//中序遍历二叉树（非递归算法）
void inOrderTraversal(struct TreeNode* root) {
    struct TreeNode* stack[100];
    int top = -1;
    struct TreeNode* p = root;
    while (p != NULL || top != -1) {
        if (p != NULL) {
            stack[++top] = p;
            p = p->left;
        } else {
            p = stack[top--];
            printf("%c ", p->data);
            p = p->right;
        }
    }
}

int main() {
    printf("请输入字符序列，以#表示空节点：\n");
    struct TreeNode* root = createBinaryTree();
    printf("先序遍历结果：");
    preOrderTraversalRecursive(root);
    printf("\n中序遍历结果：");
    inOrderTraversalRecursive(root);
    printf("\n后序遍历结果：");
    postOrderTraversalRecursive(root);
    printf("\n中序遍历结果（非递归算法）：");
    inOrderTraversal(root);
    return 0;
}

先序中序后序遍历二叉树的递归算法C语言,编写一个程序，实现二叉树的先序遍历，中序遍历，后序遍历的各种递归和非递归算法，以及层次遍历的算法...

好的，下面是二叉树的递归算法实现以及非递归算法实现：

1. 先序遍历递归算法实现：

void preOrderTraversal(TreeNode* root) {
    if (root == NULL)
        return;
    printf("%d ", root->val);
    preOrderTraversal(root->left);
    preOrderTraversal(root->right);
}

2. 中序遍历递归算法实现：

void inOrderTraversal(TreeNode* root) {
    if (root == NULL)
        return;
    inOrderTraversal(root->left);
    printf("%d ", root->val);
    inOrderTraversal(root->right);
}

3. 后序遍历递归算法实现：

void postOrderTraversal(TreeNode* root) {
    if (root == NULL)
        return;
    postOrderTraversal(root->left);
    postOrderTraversal(root->right);
    printf("%d ", root->val);
}

4. 先序遍历非递归算法实现：

void preOrderTraversalNonRecursion(TreeNode* root) {
    if (root == NULL)
        return;
    TreeNode* stack[1000];
    int top = -1;
    stack[++top] = root;
    while (top != -1) {
        TreeNode* node = stack[top--];
        printf("%d ", node->val);
        if (node->right)
            stack[++top] = node->right;
        if (node->left)
            stack[++top] = node->left;
    }
}

5. 中序遍历非递归算法实现：

void inOrderTraversalNonRecursion(TreeNode* root) {
    if (root == NULL)
        return;
    TreeNode* stack[1000];
    int top = -1;
    TreeNode* node = root;
    while (node != NULL || top != -1) {
        while (node != NULL) {
            stack[++top] = node;
            node = node->left;
        }
        node = stack[top--];
        printf("%d ", node->val);
        node = node->right;
    }
}

6. 后序遍历非递归算法实现：

void postOrderTraversalNonRecursion(TreeNode* root) {
    if (root == NULL)
        return;
    TreeNode* stack1[1000];
    TreeNode* stack2[1000];
    int top1 = -1, top2 = -1;
    stack1[++top1] = root;
    while (top1 != -1) {
        TreeNode* node = stack1[top1--];
        stack2[++top2] = node;
        if (node->left)
            stack1[++top1] = node->left;
        if (node->right)
            stack1[++top1] = node->right;
    }
    while (top2 != -1) {
        TreeNode* node = stack2[top2--];
        printf("%d ", node->val);
    }
}

7. 层次遍历算法实现：

void levelOrderTraversal(TreeNode* root) {
    if (root == NULL)
        return;
    TreeNode* queue[1000];
    int front = 0, rear = 0;
    queue[rear++] = root;
    while (front < rear) {
        TreeNode* node = queue[front++];
        printf("%d ", node->val);
        if (node->left)
            queue[rear++] = node->left;
        if (node->right)
            queue[rear++] = node->right;
    }
}

注意：以上代码中的 TreeNode 结构体可以根据具体情况自行定义。