新一篇: 五月的鲜花  | 旧一篇: 玩具程序之LinkedList

#include<iostream>
#define SIZE_KEY 32
#define SIZE_VALUE 256
using namespace std;

typedef struct Metadata
{
        Metadata(char* pszKey, char* pszValue)
        {
         strcpy(this->key, pszKey);
         strcpy(this->value, pszValue);                       
         left = NULL;
         right = NULL;
        }
        
        char key[SIZE_KEY];
        char value[SIZE_VALUE];
        struct Metadata* left;
        struct Metadata* right;

}METADATA;


class CBinarySearchTree
{
private:
        int m_nSize;
        METADATA* root;
        
        bool ContainsNode(METADATA* pNode, char* pszKey);
        void ProcessNodesInOrder(METADATA* pNode);
        bool AddNode(METADATA** pCurrentNode, METADATA* pNewNode);
        bool GetNode(METADATA* pCurrentNode, char* pszKey, char* pszValue);
        
        void RemoveAllNodes(METADATA* pNode);
        bool RemoveNode(METADATA** pNode, char* pszKey );
        void RemoveRootNode(METADATA** pNode);
        
        void MoveLeftMostNode(METADATA** pNode, METADATA* root);
        int  GetTreeDepth(METADATA* pNode);

public:        

        CBinarySearchTree();
        virtual ~CBinarySearchTree();
        bool Add(char* pszKey, char* pszValue);
        bool Get(char* pszKey, char* pszValue);
        bool Contains(char* pszKey);
        void DisplayInOrder();

        
        int GetDepth();
        int GetSize();        

};


CBinarySearchTree::CBinarySearchTree()
{
 root = NULL;
 m_nSize = 0;                                      
}

CBinarySearchTree::~CBinarySearchTree()
{
}


bool CBinarySearchTree::GetNode(METADATA* pNode, char* pszKey, char* pszValue)
{
     if(pNode == NULL)
     {
              pszValue[0] = '\0';
              return false;
     }
     else
     {
         if(strcmp(pszKey, pNode->key) == 0)
         {
          strcpy(pszValue, pNode->value);
          return true;
         }
         else if(strcmp(pszKey, pNode->key) < 0 )
         {
              return GetNode(pNode->left, pszKey, pszValue);
         }
         else
         {
             return GetNode(pNode->right, pszKey, pszValue);
         }
     }

}


void CBinarySearchTree::MoveLeftMostNode(METADATA** pNode, METADATA* root)
{
 if(*pNode != NULL && (*pNode)->left == NULL)
 {
           METADATA* pTemp = (*pNode);
           strcpy(root->key,(*pNode)->key);
           strcpy(root->value,(*pNode)->value);
           
           *pNode = (*pNode)->right;
           delete (pTemp);
 }
 else
 {
     MoveLeftMostNode(&((*pNode)->left), root );
 }

}


void CBinarySearchTree::RemoveRootNode(METADATA** root)
{
     METADATA* pTemp;
     if((*root)->left == NULL && (*root)->right == NULL)
     {
      delete(*root);
      (*root) = NULL;
     }
     else if( (*root)->right == NULL )
     {
          pTemp = (*root);
          (*root) = (*root)->left;
          delete(pTemp);
     }
     else if((*root)->left == NULL)
     {
          pTemp = (*root);
          (*root) = (*root)->right;
          delete(pTemp);
     }
     else
     {
         MoveLeftMostNode(  &((*root)->right), (*root) );
     }
}

void CBinarySearchTree::RemoveAllNodes(METADATA* pNode)
{
 if( pNode != NULL )
 {
     RemoveAllNodes(pNode->left);
     RemoveAllNodes(pNode->right);
     cout << "Removing node -key:" << pNode->key << "\t" << pNode->value << endl;
     delete pNode;
 }
}

bool CBinarySearchTree::RemoveNode(METADATA** pNode, char* pszKey)
{
     if(*pNode != NULL)
     {
              if(strcmp(pszKey, (*pNode)->key ) == 0)
              {
               RemoveRootNode(pNode);
               m_nSize--;
               return true;
              }
              else if(strcmp(pszKey, (*pNode)->key) < 0)
              {
                   return RemoveNode( &((*pNode)->left), pszKey);
              }
              else
              {
                  return RemoveNode( &((*pNode)->right), pszKey );
              }
     }
     else
     {
         return false;
     }
}

bool CBinarySearchTree::Add(char* pszKey, char* pszValue)
{
     if(pszKey == NULL
               || pszValue == NULL
               || strlen(pszKey) > SIZE_KEY -1
               || strlen(pszValue) > SIZE_VALUE -1     )
     {
      return false;
     }
     
     METADATA* pNewNode = new METADATA(pszKey, pszValue);
     return AddNode(&root, pNewNode);
}



bool CBinarySearchTree::AddNode(METADATA** pCurrentNode, METADATA* pNewNode)
{
     if(*pCurrentNode == NULL)
     {
      *pCurrentNode = pNewNode;                      
      m_nSize++;
      return true;
     }
     else
     {
      if(strcmp(pNewNode->key, (*pCurrentNode)->key) < 0)
      {
       return AddNode(&((*pCurrentNode)->left), pNewNode);                               
      }
      else if(strcmp(pNewNode->key, (*pCurrentNode)->key) > 0)
      {
       return AddNode(&((*pCurrentNode)->right), pNewNode);
      }
      else
      {
          delete pNewNode;
          return false;
      }      
     }
}

void CBinarySearchTree::DisplayInOrder()
{
     ProcessNodesInOrder(root);
}



void CBinarySearchTree::ProcessNodesInOrder(METADATA* pNode)
{
 if(pNode != NULL)
 {
  ProcessNodesInOrder(pNode->left);
  cout << "key:" << pNode->key <<"\tvalue:" << pNode->value << endl;
  ProcessNodesInOrder(pNode->right);
 }
}




bool CBinarySearchTree::Contains(char* pszKey)
{
     return ContainsNode(root, pszKey);
}


bool CBinarySearchTree::ContainsNode(METADATA* pNode, char* pszKey)
{
     if(pNode == NULL)
     {
              return false;
     }
     else
     {
         if(strcmp(pszKey, pNode->key) == 0)
         {
          return true;
         }
         else if(strcmp(pszKey, pNode->key) < 0 )
         {
          return ContainsNode( pNode->left, pszKey );    
         }
         else
         {
          return ContainsNode( pNode->right, pszKey );
         }
     }
}

bool CBinarySearchTree::Get(char* pszKey, char* pszValue)
{
 return GetNode(root , pszKey, pszValue);
}


int CBinarySearchTree::GetDepth()
{
 return GetTreeDepth(root);
}

int CBinarySearchTree::GetTreeDepth(METADATA* pNode)
{
    int nDepth_left;
    int nDepth_right;
    
    if(pNode == NULL)
    {
     return 0;             
    }
    else
    {
        nDepth_left = GetTreeDepth(pNode->left);
        nDepth_right = GetTreeDepth(pNode->right);
        if( nDepth_left > nDepth_right )
        {
            return nDepth_left + 1;
        }
        else
        {
            return nDepth_right + 1;
        }
    }
       
}


int CBinarySearchTree::GetSize()
{
    return m_nSize;
}

发表于 @ 2008年01月11日 13:56:00|评论(loading...)|编辑

新一篇: 五月的鲜花  | 旧一篇: 玩具程序之LinkedList