binary search tree study

今天又写了delete的部分，时间就这么被一天天地浪费了，我感到十分惋惜呀

#pragma once
#include "stdio.h"

struct Node
{
    Node(int aValue)
        :m_Value(aValue)
        ,m_pLeft(NULL)
        ,m_pRight(NULL)
        ,m_pParent(NULL)
    {

    }
    int m_Value;
    Node* m_pLeft;
    Node* m_pRight;
    Node* m_pParent;
};

class BinarySearchTree
{
public:
    BinarySearchTree(void);
    ~BinarySearchTree(void);
    void Init();
    void Insert(int aValue);
    void Delete(int aValue);
    Node* MaxNode(Node* apNode);
    Node* MinNode(Node* apNode);
    Node* Search(int aValue);

    void PreOrderPrint();
    void AfterOrderPrint();
    void MidOrderPrint();

    void PrintNode( Node* lpNode ) 
    {
        printf("%d ", lpNode->m_Value);
    }

    Node* Successor(Node* aNode);

private:
    Node* m_pRootNode;
};

#include "BinarySearchTree.h"
#include <stack>
#include <queue>

BinarySearchTree::BinarySearchTree(void)
:m_pRootNode(NULL)
{
}

BinarySearchTree::~BinarySearchTree(void)
{
}

void BinarySearchTree::Insert( int aValue )
{
    Node* lpNewNode = new Node(aValue);
    if (NULL == m_pRootNode)
    {
        m_pRootNode = lpNewNode;
    }
    else
    {
        Node* lpNode = m_pRootNode;
        Node* lpPNode = NULL;

        while(lpNode)
        {
            lpPNode = lpNode;
            if (lpNode->m_Value > aValue)
            {
                lpNode = lpNode->m_pLeft;
            }
            else
            {
                lpNode = lpNode->m_pRight;
            }
        }

        if (lpPNode->m_Value > aValue)
        {
            lpPNode->m_pLeft = lpNewNode;
        }
        else
        {
            lpPNode->m_pRight = lpNewNode;
        }
        lpNewNode->m_pParent = lpPNode;
    }
}

void BinarySearchTree::Init()
{
}

void BinarySearchTree::Delete( int aValue )
{
    Node* lpNode = Search(aValue);
    if (NULL == lpNode)
    {
        return;
    }

    Node* lpDeleteNode = NULL;

    if (!lpNode->m_pLeft && !lpNode->m_pRight)
    {
        if (lpNode->m_pParent->m_pLeft = lpNode)
        {
            lpNode->m_pParent->m_pLeft = NULL;
        }
        else
        {
            lpNode->m_pParent->m_pRight = NULL;
        }
        delete lpNode;
    }
    else
    {
        if (!lpNode->m_pLeft && lpNode->m_pRight)
        {
            if (lpNode->m_pParent->m_pLeft == lpNode)
            {
                lpNode->m_pParent->m_pLeft = lpNode->m_pRight;
                lpNode->m_pRight->m_pParent = lpNode->m_pParent;
            }
            else
            {
                lpNode->m_pParent->m_pRight = lpNode->m_pRight;
                lpNode->m_pRight->m_pParent = lpNode->m_pParent;
            }
            delete lpNode;
            lpNode =NULL;
        }
        else if (lpNode->m_pLeft && !lpNode->m_pRight)
        {
            if (lpNode->m_pParent->m_pLeft == lpNode)
            {
                lpNode->m_pParent->m_pLeft = lpNode->m_pLeft;
                lpNode->m_pLeft->m_pParent = lpNode->m_pParent;
            }
            else
            {
                lpNode->m_pParent->m_pRight = lpNode->m_pLeft;
                lpNode->m_pLeft->m_pParent = lpNode->m_pParent;
            }
            delete lpNode;
            lpNode = NULL;
        }
        else
        {
            Node* lpSuccessorNode = Successor(lpNode);
            lpNode->m_Value = lpSuccessorNode->m_Value;
            if (lpSuccessorNode->m_pRight)
            {
                lpSuccessorNode->m_pParent->m_pLeft = lpSuccessorNode->m_pRight;
                lpSuccessorNode->m_pRight->m_pParent = lpSuccessorNode->m_pParent;
            }
            delete lpSuccessorNode;
            lpSuccessorNode = NULL;
        }
    }
}

void BinarySearchTree::PreOrderPrint()
{
    std::queue<Node*> lStack;
    Node* lpCurNode = m_pRootNode;
    
    if (NULL != lpCurNode)
    {
        lStack.push(lpCurNode);
        while(!lStack.empty())
        {
            Node* lpNode = lStack.front();
            lStack.pop();
            PrintNode(lpNode);
            if (lpNode->m_pLeft)
            {
                lStack.push(lpNode->m_pLeft);
            }
            if (lpNode->m_pRight)
            {
                lStack.push(lpNode->m_pRight);
            }
        }
    }
}

void BinarySearchTree::AfterOrderPrint()
{
    std::stack<Node*> lStack;
    Node* lpCurNode = m_pRootNode;
    bool lDone = true;
    while(!lStack.empty() || lpCurNode)
    {
        if (lpCurNode)
        {
            lStack.push(lpCurNode);
            lpCurNode = lpCurNode->m_pRight;
        }
        else
        {
            lpCurNode = lStack.top();
            lStack.pop();
            PrintNode(lpCurNode);
            lpCurNode = lpCurNode->m_pLeft;
        }
    }
}

void BinarySearchTree::MidOrderPrint()
{
    Node* lpNode = m_pRootNode;
    std::stack<Node*> lQueue;

    while(NULL != lpNode || !lQueue.empty())
    {
        if (NULL != lpNode)
        {
            lQueue.push(lpNode);
            lpNode = lpNode->m_pLeft;
        }
        else
        {
            lpNode = lQueue.top();
            lQueue.pop();
            PrintNode(lpNode);
            lpNode = lpNode->m_pRight;
        }
    }
}

Node* BinarySearchTree::MinNode(Node* apNode)
{
    Node* lpPreNode = NULL;
    Node* lpNode = apNode;

    while(lpNode)
    {
        lpPreNode = lpPreNode;
        lpNode = lpNode->m_pLeft;
    }

    return lpPreNode;
}

Node* BinarySearchTree::MaxNode(Node* apNode)
{
    Node* lpPreNode = NULL;
    Node* lpNode = apNode;

    while(lpNode)
    {
        lpPreNode = lpPreNode;
        lpNode = lpNode->m_pRight;
    }

    return lpPreNode;
}

Node* BinarySearchTree::Successor(Node* aNode)
{
    if (NULL == m_pRootNode)
    {
        return NULL;
    }

    Node* lpNode = aNode;
    if (lpNode->m_pRight)
    {
        return MinNode(lpNode->m_pRight);
    }
    else
    {
        while(lpNode && lpNode->m_pParent->m_pRight == lpNode)
        {
            lpNode = lpNode->m_pParent;
        }

        return lpNode;
    }
}

Node* BinarySearchTree::Search( int aValue )
{
    Node* lpNode = m_pRootNode;
    while(lpNode)
    {
        if (lpNode->m_Value > aValue)
        {
            lpNode = lpNode->m_pLeft;
        }
        else if (lpNode->m_Value < aValue)
        {
            lpNode = lpNode->m_pRight;
        }
        else
        {
            return lpNode;
        }
    }
    return NULL;
}