词法分析器(1.二叉排序树)

//////////////////////////////////////////////////////////////////////////
//     Fundamentals of Compiler
//project:  World analysis
//written by: kejie 03 computer science and techology 086
//create time: 2006.3.25
//modified:  2006.4.2
//file name: BSTree.h
//note:   This file is declearation of binary sort tree declearation
//Copyright University of electronic science and technology of China, ZhongShan Institute.
//////////////////////////////////////////////////////////////////////////

#include<iostream.h>
#include<string.h>
#include<stdlib.h>
#include<fstream.h>
#include <iomanip.h>
#include <assert.h>

class BSTree;

//二叉排序树结点类
class BSTreeNode
{
public:
 friend class BSTree;

 BSTreeNode();
 ~BSTreeNode();
private:
 char * world;      //字符串
 short int code;      //编码
 BSTreeNode * lchild, * rchild; 
};

//二叉排序树
class BSTree
{
public:
 BSTree();
 BSTree(char * file, int CurCodeValue);
 ~BSTree();

 bool LoadFile( const char * path);      //从外部读入文件
 bool SerachBst( char * keyword, BSTreeNode ** p);  //从二叉树中查找
 int GetWordCode( char * keyword );      //取得指定字符串在树中编码
 int GetCurCode();          //取得当前编码号
 void SetCurCode(int value);        
 
 bool InsertBst( char * keyword);      //插入结点

 void CodeTree();          //给整棵树编码
 void PrintTree();
 void DestroyTree();          //释放所有结点

 
private:
 void CodeTreeNode(BSTreeNode * root);
 void PrintTreeNode(BSTreeNode * root);
 void DestroyTreeNode(BSTreeNode * root);
 BSTreeNode * Troot;
 char CurCode;

};

//////////////////////////////////////////////////////////////////////////
//     Fundamentals of Compiler
//project:  World analysis
//written by: kejie 03 computer science and techology 086
//create time: 2006.3.25
//modified:  2006.4.13
//file name: BSTree.cpp
//note:   This file is the implenment of binary sort tree.
//    It uses to store key worlds which load from file!
//Copyright University of electronic science and technology of China, ZhongShan Institute.
//////////////////////////////////////////////////////////////////////////
#include"BSTree.h"

char * KeyWorldPath = "keyworld.txt";

BSTreeNode::BSTreeNode()
{
 code = 0x00;
 world = 0;
 lchild = rchild = NULL;
}

BSTreeNode::~BSTreeNode()
{
 if ( world )
  delete [] world;
}

BSTree::BSTree()
{
 Troot = NULL;
 //Troot->lchild = Troot->rchild = NULL;
 CurCode = 0x00;
}

BSTree::BSTree(char * file, int CurCodeValue)
{
 Troot = NULL;
 //Troot->lchild = Troot->rchild = NULL;

 assert(CurCodeValue>=0);
 CurCode = 0x00;
 
 LoadFile(file);
 SetCurCode(CurCodeValue);
 CodeTree();
}

BSTree::~BSTree()
{
 DestroyTree();
}

//从外部文件读入关键子，默认路径为当前目录
bool BSTree::LoadFile( const char * path )
{

 char buffer[20], *word;
 int len =0;

 ifstream input;
 input.open(path);

 while(input>>buffer)
 {
  len = strlen(buffer);
  word = new char[len+1];

  strcpy(word,buffer);
  if ( !InsertBst(word) )
   return false;

  delete word;
 }

 

 input.close();

 return true;

}

//从排序树中查找关键字  
bool  BSTree::SerachBst(char * keyword, BSTreeNode ** p)
{
 int compres = 0;
 BSTreeNode * ptr = Troot;

 *p = NULL;
 
 while( ptr )
 {
  //比较关键字字符串: 0 符合 >0 向右搜索 <0 向左搜索
  compres = strcmp(ptr->world,keyword);
  if ( compres == 0 )
  {
   *p = ptr;
   return true;
  }
  else
  {
   *p = ptr;
   ptr = compres>0?ptr->lchild:ptr->rchild;
  }
 }

 return false;
}

//从排序树中插入关键字，插入同时给关键字等长编码 从 0x00 - 0xFF 最多256个
bool  BSTree::InsertBst(char * keyword)
{
 BSTreeNode *s, *p;
 s = NULL;
 p = NULL;

 //查找不到结点时插入
 if( ! SerachBst(keyword,&p ))
 {
  s = new BSTreeNode;
  if (!s)
   return false;

  //加多一位保存 "/0"
  s->world = new char[strlen(keyword)+1];
  strcpy(s->world,keyword);
  s->lchild = s->rchild = NULL;

  //如是Troot根结点为空,直接指定,如果不是,关键字少的放左边,大的放右边
  if( !Troot )
  {
   Troot = s;
  }
  else if ( strcmp(p->world,keyword)<0)
   p->rchild = s;
  else
   p->lchild = s;

 }
 return true;
}

//给用中序遍历给所有结点编码，以后查找时可实现最优
void  BSTree::CodeTreeNode(BSTreeNode * root)
{
 if(root)
 {
  CodeTreeNode(root->lchild);
  root->code = CurCode++;
  CodeTreeNode(root->rchild);
 }
}

void BSTree::CodeTree()
{
 CodeTreeNode(Troot);
}

//打印有序树及编码
void BSTree::PrintTreeNode(BSTreeNode * root)
{
 if(root)
 {
  PrintTreeNode(root->lchild);
  cout<<root->world<<setw((15 - strlen(root->world)))<<":"<<hex<<root->code<<endl;
  PrintTreeNode(root->rchild);
 }
}

void BSTree::PrintTree()
{
 PrintTreeNode(Troot);
}

//说明:释放所有结点
//过程:
 //不断删除顶点结点,有以下几种情况
 //1.如果顶点无左右结点,完成
 //2.有左结点无右结点,将左结点设为新顶点
 //3.有右结点无左结点,将右结点设为新顶点
 //4.左右结点都有,将左结点设为新顶点,同时将右结点的父结点设为左结点子树中最右下结点,构成一棵新树
void  BSTree::DestroyTreeNode(BSTreeNode * root)
{
 BSTreeNode *p, *q;
  
 while( root != NULL )
 {
  if ( root->lchild == NULL && root->rchild == NULL )
  {
   delete [] root->world;
   root->world = NULL;
   delete root;
   return;
  }

  if ( root->lchild != NULL && root->rchild == NULL )
  {
   p = root;
   root = root->lchild;

   //先释放结点中的字符串,再删除整个结点! 字符串释放后要设为NULL,否则再删除结点时会出错
   delete [] p->world;
   p->world = NULL;
   delete p;
  }
  else if (root->lchild == NULL && root->rchild != NULL )
  {
   p = root;
   root = root->rchild;

   delete [] p->world;
   p->world = NULL;
   delete p;
  }
  else
  {
   p = root;
   q = root->rchild;
   root = root->lchild;

   delete [] p->world;
   p->world = NULL;
   delete p;
   
   p = root;

   //和并右子树,找出当前root的最右下结点,指向q
   while ( p->rchild != NULL )
    p = p->rchild;

   p->rchild = q;

  }
 }

}

//取得当前编码值
int BSTree::GetCurCode()
{
 return CurCode;
}

//设置当前编码值
void BSTree::SetCurCode(int value)
{
 CurCode = value;
}

void BSTree::DestroyTree()
{
 DestroyTreeNode(Troot);
}

//查找关键字编码
int BSTree::GetWordCode( char * keyword )
{
 int compres = 0;
 BSTreeNode * ptr = Troot;
 
 while( ptr )
 {
  //比较关键字字符串: 0 符合 >0 向右搜索 <0 向左搜索
  compres = strcmp(ptr->world,keyword);
  if ( compres == 0 )
  {
   return ptr->code;
  }
  else
  {
   ptr = compres>0?ptr->lchild:ptr->rchild;
  }
 }

 return -1;
}

/*
int main()
{
 BSTree btree;

 btree.LoadKeyWorld(KeyWorldPath);
 btree.CodeTree();

 btree.DestroyTree();

 //cout<<btree.GetWordCode("struct");

 return 0;
}
*/