二叉樹的遍歷和查找 刪除

//前序
//用廣度搜索
template <class T>
void AVLTree<T>::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 <class T>
void AVLTree<T>::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 <class T>
void AVLTree<T>::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 <class T>
typename AVLTree<T>::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 <class T>
void AVLTree<T>::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;
    }
}