输入10个不同整数，依次插入到一颗初始为空的二叉排序树中，并对其进行中序遍历，以验证树的正确性。代码

### 回答1：
下面是一个 Python 实现的二叉排序树，并且插入了 10 个不同的整数，并通过中序遍历输出来验证树的正确性：

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

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

    def insert(self, val):
        node = TreeNode(val)
        if not self.root:
            self.root = node
            return
        curr = self.root
        while True:
            if val < curr.val:
                if not curr.left:
                    curr.left = node
                    return
                curr = curr.left
            else:
                if not curr.right:
                    curr.right = node
                    return
                curr = curr.right

    def inorder_traversal(self, node):
        if not node:
            return
        self.inorder_traversal(node.left)
        print(node.val, end=' ')
        self.inorder_traversal(node.right)

if __name__ == '__main__':
    bst = BinarySearchTree()
    nums = [5, 2, 7, 1, 4, 9, 8, 3, 6, 10]
    for num in nums:
        bst.insert(num)
    bst.inorder_traversal(bst.root)

输出结果为：

1 2 3 4 5 6 7 8 9 10 

可以看到，输出的结果是按照从小到大的顺序输出的，证明该二叉树是正确的。

### 回答2：
二叉排序树是一种二叉树，它的每个节点的值大于其左子树的所有节点值，小于其右子树的所有节点值。根据这个特性，我们可以通过插入元素的方式构建一颗二叉排序树。下面是用Python代码实现的过程：

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

def insert(root, val):
    if root is None:
        return TreeNode(val)
    if val < root.val:
        root.left = insert(root.left, val)
    else:
        root.right = insert(root.right, val)
    return root

def inorderTraversal(root):
    if root is not None:
        inorderTraversal(root.left)
        print(root.val, end=" ")
        inorderTraversal(root.right)

def main():
    nums = [1, 5, 3, 7, 9, 2, 4, 6, 8, 10]
    root = None

    for num in nums:
        root = insert(root, num)

    inorderTraversal(root)

if __name__ == "__main__":
    main()

运行以上代码，输出的结果为：1 2 3 4 5 6 7 8 9 10 ，说明二叉排序树的构建和中序遍历过程正确。

### 回答3：
首先，我们需要创建一个二叉排序树的结构。每个节点都包括一个值，和指向左右孩子节点的指针。接下来，我们创建一个insert()函数来将数值插入二叉排序树中。
定义结构体Node表示树的节点如下：

typedef struct Node {
    int value;
    struct Node *left;
    struct Node *right;
} Node;

定义二叉排序树的结构如下：

typedef struct BinarySearchTree {
    Node* root;
} BinarySearchTree;

然后，我们创建一个insert()函数，该函数将插入一个值到二叉排序树中。如果树为空，则创建一个新节点作为根节点。如果要插入的值小于当前节点的值，则将值插入到左子树中。如果要插入的值大于当前节点的值，则将值插入到右子树中。依次类推，直到找到一个叶子节点为空的位置来插入新的节点。

Node* insert(Node* node, int value) {
    if(node == NULL) {
        Node* new_node = (Node*)malloc(sizeof(Node));
        new_node->value = value;
        new_node->left = NULL;
        new_node->right = NULL;
        return new_node;
    }

    if(value < node->value) {
        node->left = insert(node->left, value);
    } else if(value > node->value) {
        node->right = insert(node->right, value);
    }

    return node;
}

最后，我们创建一个inOrderTraversal()函数来进行中序遍历二叉排序树。中序遍历按照从左到右的顺序输出树的节点值。

void inOrderTraversal(Node* node) {
    if(node != NULL) {
        inOrderTraversal(node->left);
        printf("%d ", node->value);
        inOrderTraversal(node->right);
    }
}

最后，我们将10个不同的整数输入插入到二叉排序树中，并进行中序遍历。代码如下：

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

typedef struct Node {
    int value;
    struct Node *left;
    struct Node *right;
} Node;

typedef struct BinarySearchTree {
    Node* root;
} BinarySearchTree;

Node* insert(Node* node, int value) {
    if(node == NULL) {
        Node* new_node = (Node*)malloc(sizeof(Node));
        new_node->value = value;
        new_node->left = NULL;
        new_node->right = NULL;
        return new_node;
    }

    if(value < node->value) {
        node->left = insert(node->left, value);
    } else if(value > node->value) {
        node->right = insert(node->right, value);
    }

    return node;
}

void inOrderTraversal(Node* node) {
    if(node != NULL) {
        inOrderTraversal(node->left);
        printf("%d ", node->value);
        inOrderTraversal(node->right);
    }
}

BinarySearchTree* createBinarySearchTree() {
    BinarySearchTree* tree = (BinarySearchTree*)malloc(sizeof(BinarySearchTree));
    tree-> root = NULL;
    return tree;
}

int main() {
    BinarySearchTree* tree = createBinarySearchTree();
    int nums[] = {1, 5, 3, 7, 2, 9, 8, 4, 10, 6};
    for(int i = 0; i < 10; i++) {
        tree->root = insert(tree->root, nums[i]);
    }
    inOrderTraversal(tree->root);
    return 0;
}