创建如下的二叉树。用栈完成二叉树的先序遍历。通过递归的方式求此二叉树的叶子节点个数与深度。

二叉树：

        1
      /   \
     2     3
    / \   / \
   4   5 6   7

先序遍历结果为：1 2 4 5 3 6 7

递归求叶子节点个数为：4，深度为：3

相关问题

用c语言建立一棵二叉树，实现一下功能 先序遍历 中序遍历 后序遍历 求二叉树的深度 求二叉树叶子结点个数

好的，我会尽力回答你关于C语言建立二叉树的问题。

在C语言中，可以使用结构体来定义二叉树节点的结构，包括其左右子节点指针和数据值等。以下是示例代码：

struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
};

接下来，我们可以使用递归的方式来遍历二叉树并实现相关功能，具体代码如下：

// 建立二叉树
struct TreeNode* buildTree(int* preorder, int preStart, int preEnd, int* inorder, int inStart, int inEnd) {
    if (preStart > preEnd || inStart > inEnd) {
        return NULL;
    }
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = preorder[preStart];
    int inIndex = 0; // 找到根节点在中序遍历中的索引位置
    for (int i = inStart; i <= inEnd; i++) {
        if (inorder[i] == root->val) {
            inIndex = i;
            break;
        }
    }
    root->left = buildTree(preorder, preStart + 1, preStart + inIndex - inStart, inorder, inStart, inIndex - 1);
    root->right = buildTree(preorder, preStart + inIndex - inStart + 1, preEnd, inorder, inIndex + 1, inEnd);
    return root;
}

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

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

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

// 求二叉树的深度
int maxDepth(struct TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    int leftDepth = maxDepth(root->left);
    int rightDepth = maxDepth(root->right);
    return fmax(leftDepth, rightDepth) + 1;
}

// 求二叉树叶子节点个数
int countLeaves(struct TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    if (root->left == NULL && root->right == NULL) {
        return 1;
    }
    return countLeaves(root->left) + countLeaves(root->right);
}

int main() {
    int preorder[] = {1, 2, 4, 5, 3, 6};
    int inorder[] = {4, 2, 5, 1, 3, 6};
    int n = sizeof(preorder) / sizeof(int);
    struct TreeNode* root = buildTree(preorder, 0, n - 1, inorder, 0, n - 1);
    printf("先序遍历：");
    preorderTraversal(root);
    printf("\n中序遍历：");
    inorderTraversal(root);
    printf("\n后序遍历：");
    postorderTraversal(root);
    printf("\n二叉树深度：%d\n", maxDepth(root));
    printf("叶子节点个数：%d\n", countLeaves(root));
    return 0;
}

希望这些代码和功能对您有所帮助！

用代码非递归创建二叉树，并且实现非递归先序遍历和非递归中序遍历

下面是用 Python 语言实现的非递归创建二叉树和非递归遍历的代码示例：

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def createTree(nums):
    if not nums:
        return None
    root = TreeNode(nums[0])
    stack = [root]
    i = 1
    while i < len(nums):
        node = TreeNode(nums[i])
        if not stack:
            break
        if stack[-1].left is None:
            stack[-1].left = node
        else:
            stack[-1].right = node
            stack.pop()
        stack.append(node)
        i += 1
    return root

def preorderTraversal(root):
    if not root:
        return []
    result = []
    stack = [root]
    while stack:
        node = stack.pop()
        result.append(node.val)
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)
    return result

def inorderTraversal(root):
    if not root:
        return []
    result = []
    stack = []
    node = root
    while stack or node:
        while node:
            stack.append(node)
            node = node.left
        node = stack.pop()
        result.append(node.val)
        node = node.right
    return result

这里我们用到了栈来实现非递归遍历。在创建二叉树时，我们用一个栈来保存节点，如果当前节点的左子树为空，就将其作为左子树；否则，看是否有右兄弟节点，如果有，就将当前节点弹出栈，并将其右兄弟节点作为新的当前节点；如果没有，就继续将新节点作为左子树。

在先序遍历中，我们将根节点压入栈中，然后弹出栈顶元素，将其值加入结果数组中，再将其右子节点、左子节点依次压入栈中。在中序遍历中，我们需要一直将左子节点压入栈中，直到没有左子节点了，就取出栈顶元素，将其值加入结果数组中，并将当前节点设置为其右子节点，继续进行遍历。