编写算法，在以二叉链表存储的二叉树中，统计二叉树中叶子结点个数

可以使用递归的方式来统计二叉树中叶子节点的个数。具体算法如下：

1. 如果二叉树为空，则叶子节点个数为。
2. 如果二叉树只有一个节点，则叶子节点个数为1。
3. 否则，递归计算左子树和右子树中叶子节点的个数，然后将它们相加即可。

以下是具体的代码实现：

int countLeafNodes(TreeNode* root) {
    if (root == nullptr) {
        return ;
    }
    if (root->left == nullptr && root->right == nullptr) {
        return 1;
    }
    int leftCount = countLeafNodes(root->left);
    int rightCount = countLeafNodes(root->right);
    return leftCount + rightCount;
}

其中，`TreeNode` 表示二叉树节点的结构体，包含左右子节点指针和节点值等信息。

相关问题

编写算法，在以二叉链表存储的二叉树中，求度为2的结点个数

### 回答1：
二叉树是一种数据结构，每个节点最多只有两个子节点，分别称为左子节点和右子节点。在以二叉树为存储结构的情况下，要求求值为2的节点个数，可以通过遍历整棵树来实现，对每个节点进行判断，如果节点的值等于2，则将计数器加1。最后得到的计数器的值就是二叉树中值为2的节点个数。

### 回答2：
算法如下：

1.判断二叉树是否为空，如果为空则返回0；

2.如果当前节点是度为2节点，则计数器加1，并递归遍历左右子树统计度为2节点个数；

3.如果当前节点不是度为2节点，则递归遍历左右子树统计度为2节点个数；

实现代码如下：

int countDegreeTwo(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    int count = 0;
    if (root->left != NULL && root->right != NULL) {
        count++;
        count += countDegreeTwo(root->left);
        count += countDegreeTwo(root->right);
    } else {
        count += countDegreeTwo(root->left);
        count += countDegreeTwo(root->right);
    }
    return count;
}

在以上算法中，我们定义了一个递归函数countDegreeTwo，其参数为当前节点root，返回值为当前节点为根的子树中度为2节点的个数。

对于二叉树为空的情况，我们直接返回0；

对于当前节点为度为2节点的情况，我们计数器加1，并递归遍历左右子树统计度为2节点个数；

对于当前节点不是度为2节点的情况，我们递归遍历左右子树统计度为2节点个数；

最终，函数返回所有子树中度为2节点的个数的总和。

### 回答3：
在以二叉链表存储的二叉树中，求度为2的结点个数，我们可以采用遍历二叉树的方式进行解决，遍历二叉树的方法有前序遍历、中序遍历和后序遍历等。这里我们以中序遍历为例进行说明。

中序遍历二叉树的方法如下：

首先，判断当前结点是否为空，若为空则返回。

其次，遍历当前结点的左子树。

然后，判断当前结点的度，若为2，则将计数器加1。

最后，遍历当前结点的右子树。

最终，返回计数器的值。

根据以上方法，我们可以写出求度为2的结点个数的算法如下：

int count2(BiTree T) {
    int cnt = 0;
    if (T != NULL) {
        count2(T->lchild);
        if (T->lchild != NULL && T->rchild != NULL) {
            cnt++;
        }
        count2(T->rchild);
    }
    return cnt;
}

其中，BiTree是存储二叉树的结构体，包含两个指针分别指向左子树和右子树。count2函数接受一个指向二叉树根结点的指针，返回度为2的结点个数。我们可以看到，该算法中采用了递归的方法遍历二叉树，对于每个结点，判断其左右子树是否存在，若存在则计数器加1。最终返回计数器的值即为度为2的结点个数。

需要注意的是，在遍历左右子树时也要进行判断，否则可能会漏掉一些结点。同时，在使用该算法时，我们需要传入根节点的指针，即调用函数时应该采用count2(root)，其中root为根节点的指针。

c语言 编写算法 以二叉链表存储的二叉树中交换二叉树各结点的左右子树

可以按照以下步骤编写算法：

1. 定义二叉树结点的结构体，包含数据域、左子树指针和右子树指针。

typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
}TreeNode;

2. 定义交换左右子树的函数，函数接受一个二叉树的根节点指针作为参数。

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

3. 测试函数。

int main() {
    // 构造二叉树
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->data = 1;
    root->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->data = 2;
    root->left->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->left->data = 4;
    root->left->left->left = NULL;
    root->left->left->right = NULL;
    root->left->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->right->data = 5;
    root->left->right->left = NULL;
    root->left->right->right = NULL;
    root->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->data = 3;
    root->right->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->left->data = 6;
    root->right->left->left = NULL;
    root->right->left->right = NULL;
    root->right->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->right->data = 7;
    root->right->right->left = NULL;
    root->right->right->right = NULL;

    // 交换左右子树
    swap(root);

    // 遍历交换后的二叉树
    printf("Inorder traversal of the swapped binary tree is: ");
    inorder(root);
    printf("\n");

    return 0;
}

完整代码如下：