#pragma once

#include <iostream>
#include <stack>
#include <queue>

namespace Lenyiin
{
    template <class K, class V>
    struct BSTreeNode
    {
        BSTreeNode(const K &key = K(), const V &value = V())
            : _key(key), _value(value), _left(nullptr), _right(nullptr)
        {
        }

        K _key;
        V _value;
        BSTreeNode<K, V> *_left;
        BSTreeNode<K, V> *_right;
    };

    template <class K, class V>
    class BSTree
    {
    private:
        typedef BSTreeNode<K, V> Node;

        Node *_Copy(Node *root)
        {
            if (root == nullptr)
            {
                return nullptr;
            }

            Node *cur = new Node(root->_key, root->_value);
            cur->_left = _Copy(root->_left);
            cur->_right = _Copy(root->_right);

            return cur;
        }

    public:
        // 默认构造
        BSTree()
            : _root(nullptr)
        {
        }

        // 拷贝构造
        BSTree(const BSTree<K, V> &tree)
        {
            _root = _Copy(tree._root);
        }

        // 非递归插入
        // bool Insert(const K& key, const V& value)
        //{
        //	// 如果根为空, 直接插入
        //	if (_root == nullptr)
        //	{
        //		_root = new Node(key, value);
        //		return true;
        //	}

        //	// 如果根不为空, 找到插入位置
        //	Node* parent = nullptr;
        //	Node* cur = _root;
        //	while (cur)
        //	{
        //		if (cur->_key > key)
        //		{
        //			parent = cur;
        //			cur = cur->_left;
        //		}
        //		else if (cur->_key < key)
        //		{
        //			parent = cur;
        //			cur = cur->_right;
        //		}
        //		else
        //		{
        //			return false;	// 如果相等, 表示我已经有了, 不需要插入了
        //		}
        //	}

        //	// 插入节点
        //	cur = new Node(key, value);
        //	if (parent->_key > key)
        //	{
        //		parent->_left = cur;
        //	}
        //	else
        //	{
        //		parent->_right = cur;
        //	}

        //	return true;
        //}

        // 递归插入
        // 辅助函数
        Node *_insert(Node *root, const K &key, const V &value)
        {
            if (root == nullptr)
            {
                return new Node(key, value);
            }
            if (key < root->_key)
            {
                root->_left = _insert(root->_left, key, value);
            }
            else if (key > root->_key)
            {
                root->_right = _insert(root->_right, key, value);
            }
            return root;
        }

        // 插入
        void Insert(const K &key, const V &value)
        {
            _root = _insert(_root, key, value);
        }

        // 非递归查找节点
        // Node* Find(const K& key)
        //{
        //	Node* cur = _root;
        //	while (cur)
        //	{
        //		if (cur->_key > key)
        //		{
        //			cur = cur->_left;
        //		}
        //		else if (cur->_key < key)
        //		{
        //			cur = cur->_right;
        //		}
        //		else
        //		{
        //			return cur;
        //		}
        //	}
        //	return nullptr;
        //}

        // 递归查找节点
        // 辅助函数
        Node *_find(Node *root, const K &key)
        {
            if (root == nullptr || root->_key == key)
            {
                return root;
            }
            if (key < root->_key)
            {
                return _find(root->_left, key);
            }
            else
            {
                return _find(root->_right, key);
            }
        }

        // 查找节点
        Node *Find(const K &key)
        {
            return _find(_root, key);
        }

        // 非递归删除节点
        // bool Erase(const K& key)
        //{
        //	// 找到要删除的节点
        //	Node* parent = nullptr;
        //	Node* cur = _root;
        //	while (cur)
        //	{
        //		if (cur->_key > key)
        //		{
        //			parent = cur;
        //			cur = cur->_left;
        //		}
        //		else if (cur->_key < key)
        //		{
        //			parent = cur;
        //			cur = cur->_right;
        //		}
        //		else
        //		{
        //			break;
        //		}
        //	}

        //	// 没找到
        //	if (cur == nullptr)
        //	{
        //		return false;
        //	}

        //	// 找到了
        //	// 1. 要删除的节点没有左孩子
        //	if (cur->_left == nullptr)
        //	{
        //		if (cur == _root)
        //		{
        //			_root = cur->_right;
        //		}
        //		else
        //		{
        //			if (parent->_left == cur)
        //			{
        //				parent->_left = cur->_right;
        //			}
        //			else
        //			{
        //				parent->_right = cur->_right;
        //			}
        //		}
        //		delete cur;
        //	}
        //	// 2. 要删除的节点没有右孩子
        //	else if (cur->_right == nullptr)
        //	{
        //		if (cur == _root)
        //		{
        //			_root = cur->_left;
        //		}
        //		else
        //		{
        //			if (parent->_left == cur)
        //			{
        //				parent->_left = cur->_left;
        //			}
        //			else
        //			{
        //				parent->_right = cur->_left;
        //			}
        //		}
        //		delete cur;
        //	}
        //	// 3. 左右都不为空, 不能直接删除, 使用替换法删除
        //	// 可以找左子树的最大节点或者右子树的最小节点去替代它
        //	else
        //	{
        //		// 右子树最小节点
        //		Node* rightMinParent = cur;
        //		Node* rightMin = cur->_right;
        //		while (rightMin->_left)
        //		{
        //			rightMinParent = rightMin;
        //			rightMin = rightMin->_left;
        //		}

        //		// 替换删除的节点
        //		std::swap(cur->_key, rightMin->_key);
        //		std::swap(cur->_value, rightMin->_value);

        //		// 把问题转换成删除 rightMin
        //		if (rightMinParent->_left == rightMin)
        //		{
        //			rightMinParent->_left = rightMin->_right;
        //		}
        //		else
        //		{
        //			rightMinParent->_right = rightMin->_right;
        //		}

        //		delete rightMin;
        //	}

        //	return true;
        //}

        // 递归删除节点
        // 辅助函数
        Node *_erase(Node *root, const K &key)
        {
            if (root == nullptr)
            {
                return root;
            }
            if (key < root->_key)
            {
                root->_left = _erase(root->_left, key);
            }
            else if (key > root->_key)
            {
                root->_right = _erase(root->_right, key);
            }
            else
            {
                if (root->_left == nullptr)
                {
                    Node *ret = root->_right;
                    delete root;
                    return ret;
                }
                if (root->_right == nullptr)
                {
                    Node *ret = root->_left;
                    delete root;
                    return ret;
                }
                Node *minNode = getMin(root->_right);
                root->_key = minNode->_key;
                root->_right = _erase(root->_right, minNode->_key);
            }
            return root;
        }

        Node *getMin(Node *node)
        {
            while (node->_left != nullptr)
            {
                node = node->_left;
            }
            return node;
        }

        // 删除节点
        void Erase(const K &key)
        {
            _erase(_root, key);
        }

        // 递归中序遍历
        // 辅助函数
        // void _InOrder(Node* root)
        //{
        //	if (root == nullptr)
        //	{
        //		return;
        //	}

        //	_InOrder(root->_left);
        //	 //std::cout << root->_key << " : " << root->_value << std::endl;
        //	std::cout << root->_key << " ";
        //	_InOrder(root->_right);
        //}

        // void InOrder()
        //{
        //	_InOrder(_root);
        //	std::cout << std::endl;
        // }

        // 非递归中序遍历
        void InOrder()
        {
            std::stack<Node *> stack;
            Node *cur = _root;

            while (cur != nullptr || !stack.empty())
            {
                // 找到最左边的节点
                while (cur != nullptr)
                {
                    stack.push(cur);
                    cur = cur->_left;
                }

                // 处理当前节点
                cur = stack.top();
                stack.pop();
                std::cout << cur->_key << " ";

                // 转向右子树
                cur = cur->_right;
            }
            std::cout << std::endl;
        }

        // 递归前序遍历
        // 辅助函数
        // void _PreOrder(Node* root)
        //{
        //	if (root == nullptr)
        //	{
        //		return;
        //	}

        //	std::cout << root->_key << " ";   // 访问根节点
        //	_PreOrder(root->_left);   // 访问左子树
        //	_PreOrder(root->_right);  // 访问右子树
        //}

        // void PreOrder()
        //{
        //	_PreOrder(_root);
        //	std::cout << std::endl;
        // }

        // 非递归前序遍历
        void PreOrder()
        {
            if (_root == nullptr)
            {
                return;
            }

            std::stack<Node *> stack;
            stack.push(_root);

            while (!stack.empty())
            {
                Node *cur = stack.top();
                stack.pop();
                std::cout << cur->_key << " "; // 访问当前节点

                // 先压入右子树再压入左子树（确保左子树先处理）
                if (cur->_right != nullptr)
                {
                    stack.push(cur->_right);
                }
                if (cur->_left != nullptr)
                {
                    stack.push(cur->_left);
                }
            }
            std::cout << std::endl;
        }

        // 递归后序遍历
        // 辅助函数
        // void _PostOrder(Node* root) {
        //	if (root == nullptr)
        //	{
        //		return;
        //	}

        //	_PostOrder(root->_left);    // 访问左子树
        //	_PostOrder(root->_right);   // 访问右子树
        //	std::cout << root->_key << " ";     // 访问根节点
        //}

        // void PostOrder()
        //{
        //	_PostOrder(_root);
        //	std::cout << std::endl;
        // }

        // 非递归后序遍历
        void PostOrder()
        {
            if (_root == nullptr)
            {
                return;
            }

            std::stack<Node *> st;
            Node *cur = _root;
            Node *lastNode = nullptr; // 最近访问的节点
            while (cur || !st.empty())
            {
                while (cur)
                {
                    st.push(cur);
                    cur = cur->_left;
                }

                Node *top = st.top();
                if ((top->_right == nullptr) || (lastNode == top->_right))
                {
                    std::cout << top->_key << " ";
                    lastNode = top;
                    st.pop();
                }
                else
                {
                    cur = top->_right;
                }
            }
            std::cout << std::endl;
        }

        // 层序遍历
        void LevelOrder()
        {
            if (_root == nullptr)
            {
                return;
            }

            std::queue<Node *> queue;
            queue.push(_root);

            while (!queue.empty())
            {
                Node *cur = queue.front();
                queue.pop();
                std::cout << cur->_key << " "; // 访问当前节点

                if (cur->_left != nullptr)
                {
                    queue.push(cur->_left); // 将左子树压入队列
                }
                if (cur->_right != nullptr)
                {
                    queue.push(cur->_right); // 将右子树压入队列
                }
            }
            std::cout << std::endl;
        }

        // 查找前驱节点
        Node *findMax(Node *node)
        {
            while (node->_right != nullptr)
            {
                node = node->_right;
            }
            return node;
        }

        Node *FindPredecessor(Node *node)
        {
            if (node->_left != nullptr)
            {
                return findMax(node->_left);
            }

            Node *cur = _root;
            Node *predecessor = nullptr;
            while (cur != nullptr)
            {
                if (node->_key < cur->_key)
                {
                    cur = cur->_left;
                }
                else if (node->_key > cur->_key)
                {
                    predecessor = cur;
                    cur = cur->_right;
                }
                else
                {
                    break;
                }
            }
            return predecessor;
        }

        // 查找后继节点
        Node *findMin(Node *node)
        {
            while (node->_left != nullptr)
            {
                node = node->_left;
            }
            return node;
        }

        Node *FindSuccessor(Node *node)
        {
            if (node->_right != nullptr)
            {
                return findMin(node->_right);
            }

            Node *cur = _root;
            Node *successor = nullptr;
            while (cur != nullptr)
            {
                if (node->_key < cur->_key)
                {
                    successor = cur;
                    cur = cur->_left;
                }
                else if (node->_key > cur->_key)
                {
                    cur = cur->_right;
                }
                else
                {
                    break;
                }
            }
            return successor;
        }

    private:
        Node *_root = nullptr;
    };
}