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;
 }