(1)建立一棵二叉树（以链表存储），对该二叉树进行遍历并输出该二叉树的前序，中序，后序遍历序列。要求前序、中序遍历用非递归方法，后序遍历用递归方法完成。 (2)实现二叉树左右子树的交换。 (3)统计二叉树中叶子结点个数。(要求用非递归算法完成)，用c语言实现

下面是一份完成要求的C语言代码：

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

// 二叉树结构体
struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
};

// 创建二叉树
struct TreeNode* createBinaryTree() {
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = 1;
    root->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->left->val = 2;
    root->left->left = NULL;
    root->left->right = NULL;
    root->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->right->val = 3;
    root->right->left = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->right->left->val = 4;
    root->right->left->left = NULL;
    root->right->left->right = NULL;
    root->right->right = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->right->right->val = 5;
    root->right->right->left = NULL;
    root->right->right->right = NULL;
    return root;
}

// 前序遍历（非递归）
void preorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    struct TreeNode* stack[100];  // 用栈存储节点，栈的最大容量为100
    int top = -1;  // 栈顶指针
    stack[++top] = root;  // 先将根节点入栈
    while (top >= 0) {
        struct TreeNode* cur = stack[top--];  // 出栈并访问该节点
        printf("%d ", cur->val);
        if (cur->right != NULL) {  // 先将右节点入栈
            stack[++top] = cur->right;
        }
        if (cur->left != NULL) {  // 再将左节点入栈
            stack[++top] = cur->left;
        }
    }
}

// 中序遍历（非递归）
void inorderTraversal(struct TreeNode* root) {
    struct TreeNode* stack[100];  // 用栈存储节点，栈的最大容量为100
    int top = -1;  // 栈顶指针
    struct TreeNode* cur = root;
    while (cur != NULL || top >= 0) {
        while (cur != NULL) {  // 将左子树所有节点入栈
            stack[++top] = cur;
            cur = cur->left;
        }
        cur = stack[top--];  // 出栈并访问该节点
        printf("%d ", cur->val);
        cur = cur->right;  // 将右子树节点入栈
    }
}

// 后序遍历（递归）
void postorderTraversal(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postorderTraversal(root->left);
    postorderTraversal(root->right);
    printf("%d ", root->val);
}

// 交换左右子树
void swapLeftAndRight(struct TreeNode* root) {
    if (root == NULL) {
        return;
    }
    struct TreeNode* temp = root->left;
    root->left = root->right;
    root->right = temp;
    swapLeftAndRight(root->left);
    swapLeftAndRight(root->right);
}

// 统计叶子节点个数（非递归）
int countLeafNodes(struct TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    struct TreeNode* stack[100];  // 用栈存储节点，栈的最大容量为100
    int top = -1;  // 栈顶指针
    int count = 0;
    stack[++top] = root;
    while (top >= 0) {
        struct TreeNode* cur = stack[top--];
        if (cur->left == NULL && cur->right == NULL) {  // 如果该节点是叶子节点，则计数器加1
            count++;
        }
        if (cur->right != NULL) {  // 先将右节点入栈
            stack[++top] = cur->right;
        }
        if (cur->left != NULL) {  // 再将左节点入栈
            stack[++top] = cur->left;
        }
    }
    return count;
}

int main() {
    // 创建二叉树
    struct TreeNode* root = createBinaryTree();

    // 前序遍历（非递归）
    printf("前序遍历：");
    preorderTraversal(root);
    printf("\n");

    // 中序遍历（非递归）
    printf("中序遍历：");
    inorderTraversal(root);
    printf("\n");

    // 后序遍历（递归）
    printf("后序遍历：");
    postorderTraversal(root);
    printf("\n");

    // 交换左右子树
    swapLeftAndRight(root);
    printf("交换左右子树后的中序遍历：");
    inorderTraversal(root);
    printf("\n");

    // 统计叶子节点个数（非递归）
    int count = countLeafNodes(root);
    printf("叶子节点个数：%d\n", count);

    return 0;
}

以上代码中，我们先定义了一个二叉树结构体 `TreeNode`，包含节点值 `val` 和左右孩子指针 `left` 和 `right`。然后我们实现了五个函数，分别对应创建二叉树、前序遍历、中序遍历、后序遍历和交换左右子树。其中前序遍历和中序遍历使用了非递归方法，后序遍历使用了递归方法，交换左右子树和统计叶子节点个数都使用了非递归方法。最后我们在 `main` 函数中创建了一个二叉树，并分别调用这些函数进行操作。