二叉树链表的基本操作

二叉树链表的基本操作包括以下几个方面：

1. 建立二叉树：根据输入的数据建立一个二叉树，可以采用递归或非递归的方式实现。

2. 遍历二叉树：分别采用前序、中序、后序的遍历方式显示输出二叉树的遍历结果，可以采用递归或非递归的方式实现。

3. 统计二叉树的节点个数：采用递归或非递归的方式实现。

4. 统计二叉树的度为1的节点个数：采用递归或非递归的方式实现。

5. 统计二叉树的度为2的节点个数：采用递归或非递归的方式实现。

6. 统计二叉树的叶子节点个数：采用递归或非递归的方式实现。

7. 计算二叉树的深度：采用递归的方式实现。

8. 复制二叉树：采用递归的方式实现。

9. 删除二叉树：采用递归的方式实现。

下面是一个使用递归方式实现的二叉树基本操作的示例代码：

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

class BinaryTree:
    def __init__(self):
        self.root = None

    # 建立二叉树
    def buildTree(self, vals):
        def build(i):
            if i >= len(vals) or vals[i] is None:
                return None
            node = TreeNode(vals[i])
            node.left = build(2 * i + 1)
            node.right = build(2 * i + 2)
            return node
        self.root = build(0)

    # 前序遍历
    def preorderTraversal(self, node):
        if not node:
            return []
        return [node.val] + self.preorderTraversal(node.left) + self.preorderTraversal(node.right)

    # 中序遍历
    def inorderTraversal(self, node):
        if not node:
            return []
        return self.inorderTraversal(node.left) + [node.val] + self.inorderTraversal(node.right)

    # 后序遍历
    def postorderTraversal(self, node):
        if not node:
            return []
        return self.postorderTraversal(node.left) + self.postorderTraversal(node.right) + [node.val]

    # 统计节点个数
    def countNodes(self, node):
        if not node:
            return 0
        return 1 + self.countNodes(node.left) + self.countNodes(node.right)

    # 统计度为1的节点个数
    def countDegreeOneNodes(self, node):
        if not node:
            return 0
        degree = 0
        if node.left:
            degree += 1
        if node.right:
            degree += 1
        return (degree == 1) + self.countDegreeOneNodes(node.left) + self.countDegreeOneNodes(node.right)

    # 统计度为2的节点个数
    def countDegreeTwoNodes(self, node):
        if not node:
            return 0
        degree = 0
        if node.left:
            degree += 1
        if node.right:
            degree += 1
        return (degree == 2) + self.countDegreeTwoNodes(node.left) + self.countDegreeTwoNodes(node.right)

    # 统计叶子节点个数
    def countLeafNodes(self, node):
        if not node:
            return 0
        if not node.left and not node.right:
            return 1
        return self.countLeafNodes(node.left) + self.countLeafNodes(node.right)

    # 计算深度
    def maxDepth(self, node):
        if not node:
            return 0
        return 1 + max(self.maxDepth(node.left), self.maxDepth(node.right))

    # 复制二叉树
    def copyTree(self, node):
        if not node:
            return None
        newNode = TreeNode(node.val)
        newNode.left = self.copyTree(node.left)
        newNode.right = self.copyTree(node.right)
        return newNode

    # 删除二叉树
    def deleteTree(self, node):
        if not node:
            return
        self.deleteTree(node.left)
        self.deleteTree(node.right)
        node.left = None
        node.right = None