//前序
//用广度搜索
template
void AVLTree::preOrder(AVLTreeNode* tree) const
{
/**********递归形式走/
//if (nullptr != tree)
//{
// cout << tree->key << " ";
// preOrder(tree->left);
// preOrder(tree->right);
//}
if (tree == nullptr) {
return;
}
std::queue<AVLTreeNode>que;
que.push(tree);
while (!que.empty()) {
AVLTreeNode temp = que.front();
std::cout << temp->key << std::endl;
que.pop();
if (temp->left != nullptr){
que.push(temp->left);
}
if (temp->right != nullptr){
que.emplace(temp->right);
}
}
}

//中序遍历
//用深度搜索，层次遍历
template
void AVLTree::inOrder(AVLTreeNode* tree) const
{
//递归形式
//if (nullptr != tree)
//{
// inOrder(tree->left);
// cout << tree->key << " ";
// inOrder(tree->right);
//}
if (tree== nullptr){
return;
}
std::stack<AVLTreeNode*>stacks;
//保存父节点先
while (tree != nullptr || !stacks.empty()){
if (tree != nullptr){
stacks.emplace(tree);
tree = tree->left;
}else {
AVLTreeNode* ptr = stacks.top();
std::cout << ptr->key << std::endl;
stacks.pop();
tree = ptr->right;
}
}
}

//深度搜索，后序遍历
template
void AVLTree::postOrder(AVLTreeNode* tree) const
{
//递归的方式遍历
//if (nullptr != tree)
//{
// postOrder(tree->left);
// postOrder(tree->right);
// cout << tree->key << " ";
//}
if (tree == nullptr){
return;
}
std::stack<AVLTreeNode*>stacks1;
stacks1.emplace(tree);
std::stack<AVLTreeNode*>stacks2;
while (!stacks1.empty()){
AVLTreeNode* tmp = stacks1.top();
stacks1.pop();
stacks2.emplace(tmp);
if (tmp->left != nullptr){
stacks1.emplace(tmp->left);
}
if (tmp->right){
stacks1.emplace(tmp->right);
}
}
while (!stacks2.empty()){
AVLTreeNode* tmp = stacks2.top();
stacks2.pop();
std::cout << tmp->key << std::endl;
}

}

//非递归查找
template
typename AVLTree::iterative_search(AVLTreeNode* root, T key) const
{
while (root != nullptr && key != root->key) {
//如果查找小于当前值，就往左边查找
if (key < root->key) {
root = root->left;
continue;
}
//如果查找值大于当前值，就往右边查找
if (key > root->key) {
root = root->right;
continue;
}
}
return root;
}

// 销毁AVL树
//可以用广度搜索销毁树
template
void AVLTree::destroy(AVLTreeNode*& tree)
{
if (tree == nullptr) {
return;
}
std::queue<AVLTreeNode*>que;
que.emplace(tree);
while (!que.empty()){
tree = que.front();
que.pop();
if (tree->left != nullptr){
que.emplace(tree->left);
}
if (tree->right != nullptr){
que.emplace(tree->right);
}
tree->left = nullptr;
tree->right = nullptr;
delete tree;
tree = nullptr;
}
}