skyrainreg.h

《数据结构》中二叉树的常用算法的练习。包括排序、兄弟－孩子链表的建立

\***************************************************************************/

typedef SkyRain::CNodeInfo   REGINFO;        
typedef SkyRain::CNodeInfo  *PREGINFO;        
typedef SkyRain::CKeyNode    REGKEY;         
typedef SkyRain::CValueNode  REGVALUE;       
typedef SkyRain::CKeyNode   *PREGKEY;         
typedef SkyRain::CValueNode *PREGVALUE;     

class CSkyRainReg
{
	// 孩子--兄弟二叉链表

    /***************************************************************\
     *               Root ---> ■A
     *						  /
     *                       /
     *						■B───●b0───●b1
     *					   /  \
     *					  /    \
     *			   c0●───■C     ■F───●f0───●f1
     *			   	 	  \     /
     *				       \   /
     *				       ■D ■G───●g0
     *						 /
     *                      /
     *	     OpenKeyPtr --> ■H───●h0───●h1───●h2
    \****************************************************************/

//
// 属性
// 
private:

protected:    
    PREGKEY     Root;            	  // 根结点
	PREGKEY     OpenKeyPtr;       	  // 当前打开主键结点的指针
    PSTRTYPE    FileName;    		  // 保存数据信息的文件名
	PREGVALUE   NewValue;             // 利用WriteData新建的键值结点

public:
	
//
// 方法
//

//
// 二叉树建立
//
private:
    bool CreateRoot(void);

    void DestoryRoot(void);
    
    void SetUnvisited(PREGKEY pRoot);
    
    PREGINFO CreateInfoNode(PSTRTYPE Name);

    PREGKEY CreateKeyNode(PREGINFO InfoNode, PSTRTYPE Name);

    PREGVALUE CreateValueNode(PREGINFO InfoNode, PSTRTYPE Name);

    void CreateNode(PREGKEY &Node, PREGINFO InfoNode, PSTRTYPE Key);

    void CreateNode(PREGVALUE &Node, PREGINFO InfoNode, PSTRTYPE Name);

    PREGKEY Insert(PREGKEY pNode, PSTRTYPE Name);

    void Insert(PREGKEY pParentKey, PREGKEY pInsertPos, PREGKEY pSubKey);

    void Insert(PREGKEY pKey, PREGVALUE pPrev, PREGVALUE pNode);

    void CutDownNode(PREGKEY pMainKey, PREGKEY &pSubKey);
    
    bool BiTreeIsEmpty(void);

    bool DeleteBiTree(PSTRTYPE KeyName);
    
    void DeleteBiTreeNode(PREGKEY &RootPtr);
    
    bool PreOrderCreateBiTree(HANDLE hFile); 

protected:   
public:
    void SortSiblingTree(PREGKEY pParent, PREGKEY pSubKey);
    
    void SortValueList(PREGKEY pKeyNode, PREGVALUE pValueNode);

//
// 文件操作
//
private:
    bool ReadValueList(PREGKEY ParentKey, HANDLE hFile); 
    
    bool ReadCreateKeyNode(PREGKEY &KeyNode, HANDLE hFile); 
    
    CLoadFileActive LoadFromFile(PSTRTYPE AFileName);
    
    bool SaveToFile(PSTRTYPE AFileName);

    void PreOrderWrite(HANDLE hFile, PREGKEY pNode); 
    
    void WriteKey(HANDLE hFile, PREGKEY pNode); 
    
    void WriteValue(HANDLE hFile, PREGKEY pNode);

public:
    void Save(void);

//
// 主键操作
//
private:
    int  GetSubKeyCount(void);

    PSTRTYPE GetSubKey(PSTRTYPE &Key);

    CSearchActive Search(PREGKEY pNode, PSTRTYPE Name, PREGKEY &ptr);

protected:
    PREGKEY CreateKey(PSTRTYPE Name);

public:
    bool OpenKey(PSTRTYPE Key, bool CanCreate);
    
    void DeleteKey(PSTRTYPE Key);

    //void 
    void PreVisit(PREGKEY p)
    {
       if (p)
        {
            ShowMsg(p->Name);
            PreVisit(p->SubKey);
            PreVisit(p->SibKey);
        }
    }

    void InVisit(PREGKEY p)
    {
        if (p)
        {
            InVisit(p->SubKey);
            ShowMsg(p->Name);
            InVisit(p->SibKey);
        }
    }
    
    void AftVisit(PREGKEY p)
    {
        if (p)
        {
            AftVisit(p->SubKey);
            AftVisit(p->SibKey);
            ShowMsg(p->Name);
        }
    }

    void VisitKey()
    {
        PREGKEY p = Root;
        if (p)
        {
            ShowMsg("开始遍历");
            ShowMsg("先序遍历");
            PreVisit(p);
            ShowMsg("中序遍历");
            InVisit(p);
            ShowMsg("后序遍历");
            AftVisit(p);
            ShowMsg("遍历结束");
        }
    }
//
// 键值操作
//
private:
    int  GetValueCount(PREGKEY pKey);

    WORD CreateValue(PREGVALUE &pValue, PSTRTYPE Name);
    
    void DeleteValueList(PREGVALUE &pVlaue);

    WORD Search(PREGVALUE pValue, PSTRTYPE Name, PREGVALUE &ptr);

    template <class T> void WriteData(PSTRTYPE Name, T *Data, ULONG DTByteLen, CADataType dtType);
    
    template <class T> T *  ReadData(PSTRTYPE Name, T *Default);

protected:

public:
    void DeleteValue(PSTRTYPE Name);

    void WriteInt(PSTRTYPE Name, long Value);

    void WriteBool(PSTRTYPE Name, bool Value);

    void WriteFloat(PSTRTYPE Name, float Value);
    
    void WriteString(PSTRTYPE Name, PSTRTYPE Value);
    
    void WriteDateTime(PSTRTYPE Name, CDateTime Value);
    
    long ReadInt(PSTRTYPE Name, long Default);
    
    bool ReadBool(PSTRTYPE Name, bool Default);
    
    float ReadFloat(PSTRTYPE Name, float Default);
    
    CDateTime ReadDateTime(PSTRTYPE Name, CDateTime Default);
    
    PSTRTYPE ReadString(PSTRTYPE Name, PSTRTYPE Default);

    /*
private:
    
    double DateTimeToSec(CTime DateTime);
    CTime  SecToDateTime(double Sec);
    void  CopyPasteKeyNode(SkyRain::CKeyNode *pDestNode,
                SkyRain::CKeyNode *pSurNode);
    void  CopyPasteValueNode(SkyRain::CKeyNode *pDestNode,
                SkyRain::CKeyNode *pSurNode);
    void  PasteKeyNode(SkyRain::CKeyNode *pParent,
                SkyRain::CKeyNode *pSur);

public:	
    
    SkyRain::CKeyNode *  GeCurrentOpenKey(void)
    {
		return OpenKeyPtr;
	}

    SkyRain::CKeyNode *  GetCurrentTempKeyNode(void)
    {
		return PrisorKey;
    }
        
    SkyRain::CValueNode *  GetCurrenCValueNode(void)
    {
		return ValueParent;
    }

    void  SetFileName(PSTRTYPE AFileName)
    {
		StrCopy(FileName, AFileName);
    }
    
    // void DeleteBiTreeNode(SkyRain::CKeyNode *&RootPtr);
    bool  CopyKey(SkyRain::CKeyNode *pSur);
    bool  CopyValue(SkyRain::CValueNode *pSur);
    bool  PasteKey(SkyRain::CKeyNode * pPastDestKey);
    bool  PasteValue(SkyRain::CKeyNode *pDes);
    bool  Move(SkyRain::CKeyNode *pSur,SkyRain::CKeyNode *pDes);
    bool  IsSubkey(SkyRain::CKeyNode *pKey1, SkyRain::CKeyNode*pKey2);
    void  GetKeyNames(PSTRTYPE Strings);
    void  GetValueNames(PSTRTYPE  Strings);
    void  GetAllStringValue(PSTRTYPE Strings);
    PSTRTYPE  CurrentPath(void);
    void  AddValuesList(PSTRTYPE List);
    void  SaveValuesList(PSTRTYPE List);    
    // void  WriteDateTime(PSTRTYPE Name,CTime Value);
        //bool DeleteKey(PSTRTYPE Key);


*/
    CSkyRainReg(PSTRTYPE AFileName);
    virtual ~CSkyRainReg(void);
};
//---------------------------------------------------------------------------