二叉查找树BST(1)

#include <iostream>
using std::cout;
using std::endl;

using ElemType = int;

struct Node {
ElemType data;
Node *left;
Node *right;
};

class BST {
public:
BST();
~BST();
void insert(ElemType data);
Node *search(ElemType data);
void destroy_tree();
void preTraverse();
void inTraverse();

private:
void insert(ElemType data, Node *leaf);
Node *search(ElemType data, Node *leaf);
void destroy_tree(Node *leaf);
void preTraverse(Node *leaf);
void inTraverse(Node *leaf);

Node *root;
};

BST::BST() {
root = nullptr;
}

BST::~BST() {
destroy_tree();
}

void BST::insert(ElemType data, Node *leaf) {
if (data < leaf->data) {
if (leaf->left != nullptr) {
insert(data, leaf->left);
}
else {
leaf->left = new Node;
leaf->left->data = data;
leaf->left->left = nullptr;
leaf->left->right = nullptr;
}
}
else if (data > leaf->data) {
if (leaf->right != nullptr) {
insert(data, leaf->right);
}
else {
leaf->right = new Node;
leaf->right->data = data;
leaf->right->left = nullptr;
leaf->right->right = nullptr;
}
}
else {
return;
}
}

Node *BST::search(ElemType data, Node *leaf) {
if (leaf != nullptr) {
if (data == leaf->data) {
return leaf;
}

if (data < leaf->data) {
return search(data, leaf->left);
}
else {
return search(data, leaf->right);
}
}
else {
return nullptr;
}
}

void BST::destroy_tree(Node *leaf) {
if (leaf != nullptr) { //left-right-parent
destroy_tree(leaf->left);
destroy_tree(leaf->right);
delete leaf;
}
}

void BST::preTraverse(Node *leaf) {
if (leaf != nullptr) {
cout << leaf->data << ' ';
preTraverse(leaf->left);
preTraverse(leaf->right);
}
else {
return;
}
}

void BST::inTraverse(Node *leaf) {
if (leaf != nullptr) {
inTraverse(leaf->left);
cout << leaf->data << ' ';
inTraverse(leaf->right);
}
else {
return;
}
}

void BST::insert(ElemType data) {
if (root != nullptr) {
insert(data, root);
}
else {
root = new Node;
root->data = data;
root->left = nullptr;
root->right = nullptr;
}
}

Node *BST::search(ElemType data) {
return search(data, root);
}

void BST::destroy_tree() {
destroy_tree(root);
}

void BST::preTraverse() {
preTraverse(root);
}

void BST::inTraverse() {
inTraverse(root);
}

int main(void) {
BST bTree;

bTree.insert(10);
bTree.insert(6);
bTree.insert(14);
bTree.insert(5);
bTree.insert(8);
bTree.insert(11);
bTree.insert(18);

bTree.preTraverse(); //10 6 5 8 14 11 18
cout << endl;
//中序遍历结果就是二叉查找树中元素从小到大排列
bTree.inTraverse(); //5 6 8 10 11 14 18
cout << endl;

return 0;
}