（1）从空的二叉树开始，每输入一个节点数据，就建立一个新节点插入到当前已生成的二叉排序树中； （2）在二叉排序树中查找某一结点； （3）删除任一指定的结点

好的，你的第一个问题是关于二叉排序树的操作。我可以回答你的问题：

1. 从空的二叉树开始，每输入一个节点数据，就建立一个新节点插入到当前已生成的二叉排序树中：

这个操作可以通过以下步骤实现：

- 如果二叉排序树为空，则创建一个新节点作为根节点。
- 如果插入的节点值小于当前节点值，则将其插入到当前节点的左子树中。
- 如果插入的节点值大于当前节点值，则将其插入到当前节点的右子树中。
- 重复上述步骤，直到找到一个空的位置插入新节点。

2. 在二叉排序树中查找某一结点：

这个操作可以通过以下步骤实现：

- 从根节点开始，比较要查找的节点值与当前节点值的大小关系。
- 如果要查找的节点值小于当前节点值，则在左子树中继续查找。
- 如果要查找的节点值大于当前节点值，则在右子树中继续查找。
- 如果要查找的节点值等于当前节点值，则返回该节点。
- 如果在二叉排序树中没有找到要查找的节点，则返回空。

3. 删除任一指定的结点：

这个操作可以通过以下步骤实现：

- 如果要删除的节点没有子节点，则直接删除该节点。
- 如果要删除的节点只有一个子节点，则将其子节点替换为该节点。
- 如果要删除的节点有两个子节点，则找到其右子树中的最小节点，将其值赋给要删除的节点，然后删除右子树中的最小节点。

希望这些解答可以回答你的问题。

相关问题

用C++实现二叉排序树（1）从空的二叉树开始，每输入一个节点数据，就建立一个新节点插入到当前已生成的二叉排序树中； （2）在二叉排序树中查找某一结点； （3）删除任一指定的结点

以下是C++实现二叉排序树的代码。其中包括从空的二叉树开始插入节点、查找节点和删除节点的操作：

#include <iostream>
using namespace std;

//定义二叉排序树节点
struct BSTNode {
    int data;
    BSTNode* left;
    BSTNode* right;
};

//创建新节点
BSTNode* createNode(int data) {
    BSTNode* newNode = new BSTNode();
    newNode->data = data;
    newNode->left = newNode->right = NULL;
    return newNode;
}

//插入节点
BSTNode* insertNode(BSTNode* root, int data) {
    if (root == NULL) {
        root = createNode(data);
    }
    else if (data <= root->data) {
        root->left = insertNode(root->left, data);
    }
    else {
        root->right = insertNode(root->right, data);
    }
    return root;
}

//查找节点
bool searchNode(BSTNode* root, int data) {
    if (root == NULL) {
        return false;
    }
    else if (root->data == data) {
        return true;
    }
    else if (data <= root->data) {
        return searchNode(root->left, data);
    }
    else {
        return searchNode(root->right, data);
    }
}

//查找最小节点
BSTNode* findMinNode(BSTNode* root) {
    while (root->left != NULL) {
        root = root->left;
    }
    return root;
}

//删除节点
BSTNode* deleteNode(BSTNode* root, int data) {
    if (root == NULL) {
        return root;
    }
    else if (data < root->data) {
        root->left = deleteNode(root->left, data);
    }
    else if (data > root->data) {
        root->right = deleteNode(root->right, data);
    }
    else {
        //节点需要被删除
        //情况1：没有子节点（叶子节点）
        if (root->left == NULL && root->right == NULL) {
            delete root;
            root = NULL;
        }
        //情况2：只有一个子节点
        else if (root->left == NULL) {
            BSTNode* temp = root;
            root = root->right;
            delete temp;
        }
        else if (root->right == NULL) {
            BSTNode* temp = root;
            root = root->left;
            delete temp;
        }
        //情况3：有两个子节点
        else {
            BSTNode* temp = findMinNode(root->right);
            root->data = temp->data;
            root->right = deleteNode(root->right, temp->data);
        }
    }
    return root;
}

//中序遍历二叉排序树
void inorder(BSTNode* root) {
    if (root == NULL) {
        return;
    }
    inorder(root->left);
    cout << root->data << " ";
    inorder(root->right);
}

int main() {
    BSTNode* root = NULL;
    root = insertNode(root, 5);
    insertNode(root, 3);
    insertNode(root, 7);
    insertNode(root, 1);
    insertNode(root, 4);
    insertNode(root, 6);
    insertNode(root, 8);
    cout << "中序遍历二叉排序树：";
    inorder(root);
    cout << endl;
    cout << "5是否在二叉排序树中：" << searchNode(root, 5) << endl;
    cout << "2是否在二叉排序树中：" << searchNode(root, 2) << endl;
    root = deleteNode(root, 5);
    cout << "删除节点5后的中序遍历二叉排序树：";
    inorder(root);
    cout << endl;
    return 0;
}

输出结果为：

中序遍历二叉排序树：1 3 4 5 6 7 8 
5是否在二叉排序树中：1
2是否在二叉排序树中：0
删除节点5后的中序遍历二叉排序树：1 3 4 6 7 8 

注意：以上代码中的数据类型为int，如果想存储其他类型的数据，需要修改代码中的数据类型。

用用c++实现二叉搜索树（1）从空的二叉树开始，每输入一个节点数据，就建立一个新节点插入到当前已生成的二叉排序树中； （2）在二叉排序树中查找某一结点； （3）删除任一指定的结点并计算查找成功时和查找失败时的平均查找长度

好的，以下是C++实现二叉搜索树的代码：

#include<iostream>
using namespace std;

struct BSTNode {
    int data;                //数据域
    BSTNode *leftChild;      //左子树指针
    BSTNode *rightChild;     //右子树指针
};

class BSTree {
private:
    BSTNode *root;           //根节点指针
public:
    BSTree() { root = NULL; }  //构造函数
    void insertNode(int);      //插入节点
    void searchNode(int);      //查找节点
    void deleteNode(int);      //删除节点
    int searchCount(int);      //查找节点个数
    int getDepth(BSTNode *);   //获取深度
    void inOrder(BSTNode *);   //中序遍历
    void preOrder(BSTNode *);  //前序遍历
    void postOrder(BSTNode *); //后序遍历
};

//插入节点
void BSTree::insertNode(int data) {
    BSTNode *newNode = new BSTNode;  //创建新节点
    newNode->data = data;            //赋值
    newNode->leftChild = NULL;
    newNode->rightChild = NULL;

    if (root == NULL) {              //如果根节点为空
        root = newNode;              //将新节点作为根节点
    }
    else {
        BSTNode *current = root;
        while (true) {                //循环查找插入位置
            if (data < current->data) {
                if (current->leftChild == NULL) {
                    current->leftChild = newNode;
                    break;
                }
                else {
                    current = current->leftChild;
                }
            }
            else {
                if (current->rightChild == NULL) {
                    current->rightChild = newNode;
                    break;
                }
                else {
                    current = current->rightChild;
                }
            }
        }
    }
}

//查找节点
void BSTree::searchNode(int data) {
    BSTNode *current = root;
    int count = 0;
    while (current != NULL) {
        count++;
        if (data == current->data) {
            cout << "查找成功！查找次数为：" << count << endl;
            return;
        }
        else if (data < current->data) {
            current = current->leftChild;
        }
        else {
            current = current->rightChild;
        }
    }
    cout << "查找失败！查找次数为：" << count << endl;
}

//删除节点
void BSTree::deleteNode(int data) {
    BSTNode *current = root;
    BSTNode *parent = NULL;
    while (current != NULL && current->data != data) {
        parent = current;
        if (data < current->data) {
            current = current->leftChild;
        }
        else {
            current = current->rightChild;
        }
    }
    if (current == NULL) {
        cout << "该节点不存在！" << endl;
        return;
    }
    if (current->leftChild == NULL && current->rightChild == NULL) {  //情况1：该节点为叶节点
        if (current == root) {
            root = NULL;
        }
        else {
            if (current == parent->leftChild) {
                parent->leftChild = NULL;
            }
            else {
                parent->rightChild = NULL;
            }
        }
        delete current;
    }
    else if (current->leftChild != NULL && current->rightChild == NULL) {  //情况2：该节点只有左子树
        if (current == root) {
            root = current->leftChild;
        }
        else {
            if (current == parent->leftChild) {
                parent->leftChild = current->leftChild;
            }
            else {
                parent->rightChild = current->leftChild;
            }
        }
        delete current;
    }
    else if (current->leftChild == NULL && current->rightChild != NULL) {  //情况2：该节点只有右子树
        if (current == root) {
            root = current->rightChild;
        }
        else {
            if (current == parent->leftChild) {
                parent->leftChild = current->rightChild;
            }
            else {
                parent->rightChild = current->rightChild;
            }
        }
        delete current;
    }
    else {  //情况3：该节点既有左子树，又有右子树
        BSTNode *successor = current->rightChild;
        while (successor->leftChild != NULL) {
            successor = successor->leftChild;
        }
        int temp = successor->data;
        deleteNode(successor->data);
        current->data = temp;
    }
}

//查找节点个数
int BSTree::searchCount(int data) {
    BSTNode *current = root;
    int count = 0;
    while (current != NULL) {
        count++;
        if (data == current->data) {
            return count;
        }
        else if (data < current->data) {
            current = current->leftChild;
        }
        else {
            current = current->rightChild;
        }
    }
    return 0;
}

//获取深度
int BSTree::getDepth(BSTNode *node) {
    if (node == NULL) {
        return 0;
    }
    int leftDepth = getDepth(node->leftChild);
    int rightDepth = getDepth(node->rightChild);
    return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}

//中序遍历
void BSTree::inOrder(BSTNode *node) {
    if (node != NULL) {
        inOrder(node->leftChild);
        cout << node->data << " ";
        inOrder(node->rightChild);
    }
}

//前序遍历
void BSTree::preOrder(BSTNode *node) {
    if (node != NULL) {
        cout << node->data << " ";
        preOrder(node->leftChild);
        preOrder(node->rightChild);
    }
}

//后序遍历
void BSTree::postOrder(BSTNode *node) {
    if (node != NULL) {
        postOrder(node->leftChild);
        postOrder(node->rightChild);
        cout << node->data << " ";
    }
}

int main() {
    BSTree bst;

    //插入节点
    bst.insertNode(15);
    bst.insertNode(6);
    bst.insertNode(18);
    bst.insertNode(3);
    bst.insertNode(7);
    bst.insertNode(17);
    bst.insertNode(20);
    bst.insertNode(2);
    bst.insertNode(4);
    bst.insertNode(13);
    bst.insertNode(9);

    //中序遍历
    cout << "中序遍历结果：";
    bst.inOrder(bst.root);
    cout << endl;

    //查找节点
    bst.searchNode(13);
    bst.searchNode(8);

    //删除节点
    bst.deleteNode(13);
    bst.deleteNode(6);
    bst.deleteNode(15);

    //中序遍历
    cout << "中序遍历结果：";
    bst.inOrder(bst.root);
    cout << endl;

    //前序遍历
    cout << "前序遍历结果：";
    bst.preOrder(bst.root);
    cout << endl;

    //后序遍历
    cout << "后序遍历结果：";
    bst.postOrder(bst.root);
    cout << endl;

    //查找节点个数
    cout << "节点18的查找次数为：" << bst.searchCount(18) << endl;
    cout << "节点8的查找次数为：" << bst.searchCount(8) << endl;

    //获取深度
    cout << "树的深度为：" << bst.getDepth(bst.root) << endl;

    return 0;
}

在该代码中，我们首先定义了一个二叉搜索树的节点结构 `BSTNode`，包括数据域 `data` 和左右子树指针 `leftChild` 和 `rightChild`。然后定义了一个二叉搜索树类 `BSTree`，包含插入节点、查找节点、删除节点、查找节点个数、获取深度、中序遍历、前序遍历和后序遍历等操作。

我们通过 `insertNode` 方法向二叉搜索树插入节点，通过 `searchNode` 方法查找节点，并统计查找次数，通过 `deleteNode` 方法删除节点，通过 `searchCount` 方法查找节点个数，通过 `getDepth` 方法获取树的深度，通过 `inOrder`、`preOrder` 和 `postOrder` 方法分别进行中序遍历、前序遍历和后序遍历。

在 `main` 函数中，我们创建一个二叉搜索树对象 `bst`，插入了一些节点，并进行一些操作，包括中序遍历、查找节点、删除节点、前序遍历、后序遍历、查找节点个数和获取深度等。

以上就是用 C++ 实现二叉搜索树的完整代码，希望能对你有所帮助。