输入元素序列构造二叉排序树c语言代码,二叉排序树

#include 

#include 

#include 

#include 

#include 

using namespace std;

template 

struct BSTNode

{

using valueType = T;

BSTNode* leftChild;

BSTNode* rightChild;

valueType element;

explicit BSTNode(const valueType data = T(), BSTNode* left = nullptr, BSTNode* right = nullptr) : element(data), leftChild(left), rightChild(right)

{

}

};

template 

class BSTree

{

public:

using valueType = T;

BSTNode* root;

explicit BSTree()

{

root = nullptr;

}

void insert(const valueType& data);

void clear();

bool empty() { return root == nullptr; }

};

template 

void freeTree(BSTNode* &root)

{

if (root->leftChild)

freeTree(root->leftChild);

if (root->rightChild)

freeTree(root->rightChild);

if (root)

{

delete root;

root = nullptr;

}

return;

}

template 

void BSTree::insert(const valueType& data)

{

BSTNode* parent = nullptr, * node = root;

while (node)

{

parent = node;

if (node->element > data)

node = node->leftChild;

else if (node->element 

node = node->rightChild;

else if (node->element == data)

return;

}

if (root == nullptr)

root = new BSTNode(data);

else if (parent->element 

parent->rightChild = new BSTNode(data);

else if (parent->element > data)

parent->leftChild = new BSTNode(data);

return;

}

template 

void BSTree::clear()

{

if (root)

freeTree(root);

return;

}

void preOrderTraversal(BSTNode* node)

{

cout <element <

if (node->leftChild)

preOrderTraversal(node->leftChild);

if (node->rightChild)

preOrderTraversal(node->rightChild);

}

void inOrderTraversal(BSTNode* node)

{

if (node->leftChild)

inOrderTraversal(node->leftChild);

cout <element <

if (node->rightChild)

inOrderTraversal(node->rightChild);

}

void postOrderTraversal(BSTNode* node)

{

if (node->leftChild)

postOrderTraversal(node->leftChild);

if (node->rightChild)

postOrderTraversal(node->rightChild);

cout <element <

}

int main()

{

BSTree tree;

int n, temp;

while (cin >> n)

{

for (int i = 0; i 

{

cin >> temp;

tree.insert(temp);

}

preOrderTraversal(tree.root);

cout <

inOrderTraversal(tree.root);

cout <

postOrderTraversal(tree.root);

cout <

tree.clear();

assert(tree.empty());

}

return 0;

}