（1） 二叉树的相关操作演示。 自定义结点结构，以二叉链表为存储结构，完成以下功能： 1) 以先序递归方式创建一棵二叉树； 2) 输出二叉树的先序、中序和后序递归或非递归遍历下的结点访问次序； 3) 输出二叉树所有的叶子节点和叶子节点个数； 4) 输出二叉树的高度； 5) 输出二叉树的按层次遍历序列（提示：实现需用到队列）； 6) 输出二叉树的形状

好的，这是一个用C语言实现二叉树的示例代码，其中包含了先序递归方式创建二叉树、二叉树的遍历、叶子节点的查找、二叉树的高度、按层次遍历二叉树和输出二叉树形状等功能。

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

// 二叉树节点结构
struct TreeNode {
    char val;
    struct TreeNode *left;
    struct TreeNode *right;
};

// 创建一个新节点
struct TreeNode* new_node(char val) {
    struct TreeNode *node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = val;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// 以先序递归方式创建二叉树
struct TreeNode* create_tree() {
    char val;
    printf("请输入节点的值（输入#表示空节点）：");
    scanf(" %c", &val);
    if (val == '#') {
        return NULL;
    }
    struct TreeNode *node = new_node(val);
    node->left = create_tree();
    node->right = create_tree();
    return node;
}

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

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

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

// 前序非递归遍历二叉树
void pre_order_iterative(struct TreeNode *root) {
    if (root == NULL) {
        return;
    }
    struct TreeNode *stack[100];
    int top = -1;
    stack[++top] = root;
    while (top >= 0) {
        struct TreeNode *node = stack[top--];
        printf("%c ", node->val);
        if (node->right) {
            stack[++top] = node->right;
        }
        if (node->left) {
            stack[++top] = node->left;
        }
    }
}

// 中序非递归遍历二叉树
void in_order_iterative(struct TreeNode *root) {
    if (root == NULL) {
        return;
    }
    struct TreeNode *stack[100];
    int top = -1;
    struct TreeNode *p = root;
    while (top >= 0 || p) {
        while (p) {
            stack[++top] = p;
            p = p->left;
        }
        p = stack[top--];
        printf("%c ", p->val);
        p = p->right;
    }
}

// 后序非递归遍历二叉树
void post_order_iterative(struct TreeNode *root) {
    if (root == NULL) {
        return;
    }
    struct TreeNode *stack1[100];
    struct TreeNode *stack2[100];
    int top1 = -1;
    int top2 = -1;
    stack1[++top1] = root;
    while (top1 >= 0) {
        struct TreeNode *node = stack1[top1--];
        stack2[++top2] = node;
        if (node->left) {
            stack1[++top1] = node->left;
        }
        if (node->right) {
            stack1[++top1] = node->right;
        }
    }
    while (top2 >= 0) {
        printf("%c ", stack2[top2--]->val);
    }
}

// 查找二叉树的叶子节点
void find_leaf_nodes(struct TreeNode *root, char *nodes, int *count) {
    if (root == NULL) {
        return;
    }
    if (root->left == NULL && root->right == NULL) {
        nodes[*count] = root->val;
        (*count)++;
    }
    find_leaf_nodes(root->left, nodes, count);
    find_leaf_nodes(root->right, nodes, count);
}

// 计算二叉树的高度
int get_tree_height(struct TreeNode *root) {
    if (root == NULL) {
        return 0;
    }
    int left_height = get_tree_height(root->left);
    int right_height = get_tree_height(root->right);
    return (left_height > right_height) ? left_height + 1 : right_height + 1;
}

// 按层次遍历二叉树
void level_order_traversal(struct TreeNode *root) {
    if (root == NULL) {
        return;
    }
    struct TreeNode *queue[100];
    int front = 0;
    int rear = 0;
    queue[rear++] = root;
    while (front < rear) {
        struct TreeNode *node = queue[front++];
        printf("%c ", node->val);
        if (node->left) {
            queue[rear++] = node->left;
        }
        if (node->right) {
            queue[rear++] = node->right;
        }
    }
}

// 输出二叉树形状
void print_tree_shape(struct TreeNode *root, int level) {
    if (root == NULL) {
        return;
    }
    print_tree_shape(root->right, level+1);
    int i;
    for (i = 0; i < level; i++) {
        printf("   ");
    }
    printf("%c\n", root->val);
    print_tree_shape(root->left, level+1);
}

int main() {
    struct TreeNode *root = create_tree();

    printf("先序递归遍历：");
    pre_order_recursive(root);
    printf("\n");

    printf("中序递归遍历：");
    in_order_recursive(root);
    printf("\n");

    printf("后序递归遍历：");
    post_order_recursive(root);
    printf("\n");

    printf("先序非递归遍历：");
    pre_order_iterative(root);
    printf("\n");

    printf("中序非递归遍历：");
    in_order_iterative(root);
    printf("\n");

    printf("后序非递归遍历：");
    post_order_iterative(root);
    printf("\n");

    char leaf_nodes[100];
    int leaf_count = 0;
    find_leaf_nodes(root, leaf_nodes, &leaf_count);
    printf("叶子节点：");
    int i;
    for (i = 0; i < leaf_count; i++) {
        printf("%c ", leaf_nodes[i]);
    }
    printf("\n");

    int height = get_tree_height(root);
    printf("树的高度：%d\n", height);

    printf("按层次遍历：");
    level_order_traversal(root);
    printf("\n");

    printf("树的形状：\n");
    print_tree_shape(root, 0);

    return 0;
}

在这个示例代码中，我们首先实现了一个`create_tree`函数，用于以先序递归方式创建二叉树。接着，我们实现了先序、中序和后序递归遍历二叉树的函数，以及先序、中序和后序非递归遍历二叉树的函数。我们还实现了一个`find_leaf_nodes`函数，用于查找二叉树的叶子节点，一个`get_tree_height`函数，用于计算二叉树的高度，一个`level_order_traversal`函数，用于按层次遍历二叉树，以及一个`print_tree_shape`函数，用于输出二叉树的形状。

您可以根据自己的需要使用这个示例代码，并根据自己的情况进行修改。