※数据结构※→☆非线性结构（tree）☆============树 链式存储结构（tree list）（十七）

于 2013-09-24 10:56:15 发布
阅读量5.6w 收藏 3
点赞数 1
分类专栏： 数据结构 数据结构（DataStructure） 文章标签： 数据结构 树 tree 链式存储
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoting451292510/article/details/11966397
版权

树（tree）

        树（tree）是包含n（n>0）个结点的有穷集合，其中：

  • 每个元素称为结点（node）；
  • 有一个特定的结点被称为根结点或树根（root）。
  • 除根结点之外的其余数据元素被分为m（m≥0）个互不相交的集合T1，T2，……Tm-1，其中每一个集合Ti（1<=i<=m）本身也是一棵树，被称作原树的子树（subtree）。

        树也可以这样定义：树是由根结点和若干颗子树构成的。树是由一个集合以及在该集合上定义的一种关系构成的。集合中的元素称为树的结点，所定义的关系称为父子关系。父子关系在树的结点之间建立了一个层次结构。在这种层次结构中有一个结点具有特殊的地位，这个结点称为该树的根结点，或称为树根。


        我们可以形式地给出树的递归定义如下:

  • 单个结点是一棵树，树根就是该结点本身。
  • 设T1,T2,..,Tk是树，它们的根结点分别为n1,n2,..,nk。用一个新结点n作为n1,n2,..,nk的父亲，则得到一棵新树，结点n就是新树的根。我们称n1,n2,..,nk为一组兄弟结点，它们都是结点n的子结点。我们还称n1,n2,..,nk为结点n的子树。
  • 空集合也是树，称为空树。空树中没有结点。

        


树的四种遍历

        1.先序遍历 （仅二叉树）
                指先访问根，然后访问孩子的遍历方式

        2.中序遍历（仅二叉树）
                指先访问左（右）孩子，然后访问根，最后访问右（左）孩子的遍历方式

        3.后序遍历（仅二叉树）
                指先访问孩子，然后访问根的遍历方式

        4.层次遍历
                一层一层的访问，所以一般用广度优先遍历。


======================================================================================================

树结点 链式存储结构（tree node list）

结点：

        包括一个数据元素及若干个指向其它子树的分支；例如，A，B，C，D等。

在数据结构的图形表示中，对于数据集合中的每一个数据元素用中间标有元素值的方框表示，一般称之为数据结点，简称结点。


        在C语言中，链表中每一个元素称为“结点”，每个结点都应包括两个部分：一为用户需要用的实际数据；二为下一个结点的地址，即指针域和数据域。


        数据结构中的每一个数据结点对应于一个储存单元，这种储存单元称为储存结点，也可简称结点


树结点（树节点）：

        


树节点相关术语：

  • 节点的度：一个节点含有的子树的个数称为该节点的度；
  • 叶节点或终端节点：度为0的节点称为叶节点；
  • 非终端节点或分支节点：度不为0的节点；
  • 双亲节点或父节点：若一个结点含有子节点，则这个节点称为其子节点的父节点；
  • 孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；
  • 兄弟节点：具有相同父节点的节点互称为兄弟节点；
  • 节点的层次：从根开始定义起，根为第1层，根的子结点为第2层，以此类推；
  • 堂兄弟节点：双亲在同一层的节点互为堂兄弟；
  • 节点的祖先：从根到该节点所经分支上的所有节点；
  • 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。

        根据树结点的相关定义，采用“双亲孩子表示法”。其属性如下：

	DWORD								m_dwLevel;				//Node levels: starting from the root to start defining the root of the first layer, the root node is a sub-layer 2, and so on;	
	T									m_data;					//the friend class can use it directly

	AL_TreeNodeSeq<T>*					m_pParent;				//Parent position
	AL_ListSeq<AL_TreeNodeSeq<T>*>		m_listChild;			//All Child tree node

树的几种表示法

        在实际中，可使用多种形式的存储结构来表示树，既可以采用顺序存储结构，也可以采用链式存储结构，但无论采用何种存储方式，都要求存储结构不但能存储各结点本身的数据信息，还要能唯一地反映树中各结点之间的逻辑关系。


        1．双亲表示法

                由于树中的每个结点都有唯一的一个双亲结点，所以可用一组连续的存储空间（一维数组）存储树中的各个结点，数组中的一个元素表示树中的一个结点，每个结点含两个域，数据域存放结点本身信息，双亲域指示本结点的双亲结点在数组中位置。

                


        2．孩子表示法

                1.多重链表：每个结点有多个指针域，分别指向其子树的根
                        1）结点同构：结点的指针个数相等，为树的度k,这样n个结点度为k的树必有n(k-1)+1个空链域.
                                                
                        2）结点不同构：结点指针个数不等，为该结点的度d
                                                

                2.孩子链表：每个结点的孩子结点用单链表存储，再用含n个元素的结构数组指向每个孩子链表

                


        3．双亲孩子表示法

                1.双亲表示法，PARENT（T，x）可以在常量时间内完成，但是求结点的孩子时需要遍历整个结构。
                2.孩子链表表示法，适于那些涉及孩子的操作，却不适于PARENT（T，x）操作。
                3.将双亲表示法和孩子链表表示法合在一起，可以发挥以上两种存储结构的优势，称为带双亲的孩子链表表示法
                


        4．双亲孩子兄弟表示法 （二叉树专用）

                又称为二叉树表示法，以二叉链表作为树的存储结构。

                                

                



链式存储结构
        在计算机中用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的).
        它不要求逻辑上相邻的元素在物理位置上也相邻.因此它没有顺序存储结构所具有的弱点,但也同时失去了顺序表可随机存取的优点.


        链式存储结构特点：
                1、比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成，所以相同空间内假设全存满的话顺序比链式存储更多)。
                2、逻辑上相邻的节点物理上不必相邻。
                3、插入、删除灵活 (不必移动节点，只要改变节点中的指针)。
                4、查找结点时链式存储要比顺序存储慢。
                5、每个结点是由数据域和指针域组成。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

以后的笔记潇汀会尽量详细讲解一些相关知识的，希望大家继续关注我的博客。

本节笔记到这里就结束了。


潇汀一有时间就会把自己的学习心得，觉得比较好的知识点写出来和大家一起分享。
编程开发的路很长很长，非常希望能和大家一起交流，共同学习，共同进步。
如果文章中有什么疏漏的地方，也请大家指正。也希望大家可以多留言来和我探讨编程相关的问题。
最后，谢谢你们一直的支持~~~


       C++完整个代码示例（代码在VS2005下测试可运行）

       


AL_TreeNodeList.h

/**
  @(#)$Id: AL_TreeNodeList.h 52 2013-09-23 10:38:22Z xiaoting $
  @brief	Each of the data structure corresponds to a data node storage unit, this storage unit is called storage node, the node can 
  also be referred to.

  The related concepts of tree node 
  1.degree		degree node: A node of the subtree containing the number is called the node degree;
  2.leaf			leaf nodes or terminal nodes: degree 0 are called leaf nodes;
  3.branch		non-terminal node or branch node: node degree is not 0;
  4.parent		parent node or the parent node: If a node contains a child node, this node is called its child node's parent;
  5.child			child node or child node: A node subtree containing the root node is called the node's children;
  6.slibing		sibling nodes: nodes with the same parent node is called mutual sibling;
  7.ancestor		ancestor node: from the root to the node through all the nodes on the branch;
  8.descendant	descendant nodes: a node in the subtree rooted at any node is called the node's descendants.

  Chain storage structure//
  The computer using a set of arbitrary linear table storage unit stores data elements (which may be a continuous plurality of memory 
  cells, it can be discontinuous).

  It does not require the logic elements of adjacent physical location is adjacent to and therefore it is not sequential storage 
  structure has a weakness, but also lost the sequence table can be accessed randomly advantages.

  Chain store structural features:
  1, compared with sequential storage density storage structure (each node consists of data fields and pointers domains, so the same 
  space is full, then assume full order of more than chain stores).
  2, the logic is not required on the adjacent node is physically adjacent.
  3, insert, delete and flexible (not the mobile node, change the node as long as the pointer).
  4, find the node when stored sequentially slower than the chain stores.
  5, each node is a pointer to the data fields and domains.

  @Author $Author: xiaoting $
  @Date $Date: 2013-09-23 18:38:22 +0800 (周一, 23 九月 2013) $
  @Revision $Revision: 52 $
  @URL $URL: https://svn.code.sf.net/p/xiaoting/game/trunk/MyProject/AL_DataStructure/groupinc/AL_TreeNodeList.h $
  @Header $Header: https://svn.code.sf.net/p/xiaoting/game/trunk/MyProject/AL_DataStructure/groupinc/AL_TreeNodeList.h 52 2013-09-23 10:38:22Z xiaoting $
 */

#ifndef CXX_AL_TREENODELIST_H
#define CXX_AL_TREENODELIST_H

#ifndef CXX_AL_LISTSINGLE_H
#include "AL_ListSingle.h"
#endif

#ifndef CXX_AL_QUEUELIST_H
#include "AL_QueueList.h"
#endif

///
//			AL_TreeNodeList
///

template<typename T> 
class AL_TreeNodeList
{
public:
	/**
	* Destruction
	*
	* @param
	* @return
	* @note
	* @attention 
	*/
	~AL_TreeNodeList();
	
	/**
	* GetLevel
	*
	* @param
	* @return	DWORD
	* @note Node levels: starting from the root to start defining the root of the first layer, the root node is a sub-layer 2, and so on;	
	* @attention 
	*/
	DWORD GetLevel() const;

	/**
	* SetLevel
	*
	* @param	DWORD dwLevel <IN>
	* @return	
	* @note Node levels: starting from the root to start defining the root of the first layer, the root node is a sub-layer 2, and so on;	
	* @attention 
	*/
	VOID SetLevel(DWORD dwLevel);

	/**
	* GetData
	*
	* @param
	* @return	T
	* @note 
	* @attention 
	*/
	T GetData() const;

	/**
	* SetData
	*
	* @param	const T& tTemplate <IN>
	* @return	
	* @note 
	* @attention 
	*/
	VOID SetData(const T& tTemplate);

	/**
	* GetParent
	*
	* @param	
	* @return	AL_TreeNodeList<T>*	
	* @note parent node pointer, not to manager memory
	* @attention 
	*/
	AL_TreeNodeList<T>*	GetParent() const;

	/**
	* SetParent
	*
	* @param	DWORD dwIndex <IN>
	* @param	AL_TreeNodeList<T>* pParent <IN>
	* @return	BOOL
	* @note parent node pointer, not to manager memory
	* @attention as the child to set the parent at the index (from the left of parent's child )
	*/
	BOOL SetParent(DWORD dwIndex, AL_TreeNodeList<T>* pParent);

	/**
	* SetParentLeft
	*
	* @param	AL_TreeNodeList<T>* pParent <IN>
	* @return	BOOL
	* @note parent node pointer, not to manager memory
	* @attention as the child to set the parent at the left (from the left of parent's child )
	*/
	BOOL SetParentLeft(AL_TreeNodeList<T>* pParent);

	/**
	* SetParentRight
	*
	* @param	AL_TreeNodeList<T>* pParent <IN>
	* @return	BOOL
	* @note parent node pointer, not to manager memory
	* @attention as the child to set the parent at the right (from the right of parent's child )
	*/
	BOOL SetParentRight(AL_TreeNodeList<T>* pParent);

	/**
	* Insert
	*
	* @param	DWORD dwIndex <IN>
	* @param	AL_TreeNodeList<T>* pInsertChild <IN> 
	* @return	BOOL
	* @note inset the const AL_TreeNodeList<T>*  into the child notes at the position
	* @attention
	*/
	BOOL Insert(DWORD dwIndex, AL_TreeNodeList<T>* pInsertChild);

	/**
	* InsertLeft
	*
	* @param	AL_TreeNodeList<T>* pInsertChild <IN> 
	* @return	BOOL
	* @note inset the const AL_TreeNodeList<T>*  into the child notes at the left
	* @attention
	*/
	BOOL InsertLeft(AL_TreeNodeList<T>* pInsertChild);

	/**
	* InsertRight
	*
	* @param	AL_TreeNodeList<T>* pInsertChild <IN> 
	* @return	BOOL
	* @note inset the const AL_TreeNodeList<T>*  into the child notes at the right
	* @attention
	*/
	BOOL InsertRight(AL_TreeNodeList<T>* pInsertChild);

	/**
	* GetChild
	*
	* @param	DWORD dwIndex <IN>
	* @return	AL_TreeNodeList<T>*
	* @note the dwIndex must is little than the node degree
	* @attention
	*/
	AL_TreeNodeList<T>* GetChild(DWORD dwIndex) const;

	/**
	* GetChildLeft
	*
	* @param	
	* @return	AL_TreeNodeList<T>*
	* @note 
	* @attention
	*/
	AL_TreeNodeList<T>* GetChildLeft() const;

	/**
	* GetChildRight
	*
	* @param	
	* @return	AL_TreeNodeList<T>*
	* @note 
	* @attention
	*/
	AL_TreeNodeList<T>* GetChildRight() const;
	
	/**
	* GetDegree
	*
	* @param
	* @return	DWORD
	* @note degree node: A node of the subtree containing the number is called the node degree;
	* @attention 
	*/
	DWORD GetDegree() const;

	/**
	* IsLeaf
	*
	* @param
	* @return	BOOL
	* @note leaf nodes or terminal nodes: degree 0 are called leaf nodes;
	* @attention 
	*/
	BOOL IsLeaf() const;

	/**
	* IsBranch
	*
	* @param
	* @return	BOOL
	* @note non-terminal node or branch node: node degree is not 0;
	* @attention 
	*/
	BOOL IsBranch() const;

	/**
	* IsParent
	*
	* @param	const AL_TreeNodeList<T>* pChild <IN>
	* @return	BOOL
	* @note parent node or the parent node: If a node contains a child node, this node is called its child 
	* @attention 
	*/
	BOOL IsParent(const AL_TreeNodeList<T>* pChild) const;

	/**
	* GetSibling
	*
	* @param	AL_ListSingle<AL_TreeNodeList<T>*>& listSibling <OUT>
	* @return	BOOL
	* @note sibling nodes: nodes with the same parent node is called mutual sibling;
	* @attention 
	*/
	BOOL GetSibling(AL_ListSingle<AL_TreeNodeList<T>*>& listSibling) const;

	/**
	* GetAncestor
	*
	* @param	AL_ListSingle<AL_TreeNodeList<T>*>& listAncestor <OUT>
	* @return	BOOL
	* @note ancestor node: from the root to the node through all the nodes on the branch;
	* @attention 
	*/
	BOOL GetAncestor(AL_ListSingle<AL_TreeNodeList<T>*>& listAncestor) const;

	/**
	* GetDescendant
	*
	* @param	AL_ListSingle<AL_TreeNodeList<T>*>& listDescendant <OUT>
	* @return	BOOL
	* @note ancestor node: from the root to the node through all the nodes on the branch;
	* @attention 
	*/
	BOOL GetDescendant(AL_ListSingle<AL_TreeNodeList<T>*>& listDescendant) const;

protected:
public:

	/**
	* Construction
	*
	* @param
	* @return
	* @note private the Construction, avoid the others use it
	* @attention
	*/
	AL_TreeNodeList();
	
	/**
	* Construction
	*
	* @param	const T& tTemplate <IN>
	* @return
	* @note
	* @attention private the Construction, avoid the others use it
	*/
	AL_TreeNodeList(const T& tTemplate);

	/**
	*Copy Construct
	*
	* @param	const AL_TreeNodeList<T>& cAL_TreeNodeList
	* @return
	*/
	AL_TreeNodeList(const AL_TreeNodeList<T>& cAL_TreeNodeList);

	/**
	*Assignment
	*
	* @param	const AL_TreeNodeList<T>& cAL_TreeNodeList
	* @return	AL_TreeNodeList<T>&
	*/
	AL_TreeNodeList<T>& operator = (const AL_TreeNodeList<T>& cAL_TreeNodeList);

public:
protected:
private:
	DWORD								m_dwLevel;				//Node levels: starting from the root to start defining the root of the first layer, the root node is a sub-layer 2, and so on;	
	T									m_data;					//the friend class can use it directly

	AL_TreeNodeList<T>*						m_pParent;				//Parent tree node
	AL_ListSingle<AL_TreeNodeList<T>*>		m_listChild;			//All Child tree node
};

///
//			AL_TreeNodeList
///

/**
* Construction
*
* @param
* @return
* @note private the Construction, avoid the others use it
* @attention
*/
template<typename T>
AL_TreeNodeList<T>::AL_TreeNodeList():
m_dwLevel(0x00),
m_pParent(NULL)
{
	//memset(&m_data, 0x00, sizeof(T));		//can not use memset, as to pointer or virtural pointer of class
	m_listChild.Clear();
}

/**
* Construction
*
* @param	const T& tTemplate <IN>
* @return
* @note
* @attention private the Construction, avoid the others use it
*/
template<typename T>
AL_TreeNodeList<T>::AL_TreeNodeList(const T& tTemplate):
m_dwLevel(0x00),
m_data(tTemplate),
m_pParent(NULL)
{
	m_listChild.Clear();
}


/**
* Destruction
*
* @param
* @return
* @note
* @attention 
*/
template<typename T>
AL_TreeNodeList<T>::~AL_TreeNodeList()
{
	//it doesn't matter to clear the pointer or not.
	m_dwLevel = 0x00;
	m_pParent = NULL;		//not to manager the memory
	m_listChild.Clear();
}

/**
* GetLevel
*
* @param
* @return	DWORD
* @note Node levels: starting from the root to start defining the root of the first layer, the root node is a sub-layer 2, and so on;	
* @attention 
*/
template<typename T> DWORD 
AL_TreeNodeList<T>::GetLevel() const
{
	return m_dwLevel;
}

/**
* SetLevel
*
* @param	DWORD dwLevel <IN>
* @return	
* @note Node levels: starting from the root to start defining the root of the first layer, the root node is a sub-layer 2, and so on;	
* @attention 
*/
template<typename T> VOID 
AL_TreeNodeList<T>::SetLevel(DWORD dwLevel)
{
	m_dwLevel = dwLevel;
}

/**
* GetData
*
* @param
* @return	T
* @note 
* @attention 
*/
template<typename T> T 
AL_TreeNodeList<T>::GetData() const
{
	return m_data;
}

/**
* SetData
*
* @param	const T& tTemplate <IN>
* @return	
* @note 
* @attention 
*/
template<typename T> VOID 
AL_TreeNodeList<T>::SetData(const T& tTemplate)
{
	m_data = tTemplate;
}

/**
* GetParent
*
* @param	
* @return	AL_TreeNodeList<T>*	
* @note parent node pointer, not to manager memory
* @attention 
*/
template<typename T> AL_TreeNodeList<T>* 
AL_TreeNodeList<T>::GetParent() const
{
	return m_pParent;
}

/**
* SetParent
*
* @param	DWORD dwIndex <IN>
* @param	AL_TreeNodeList<T>* pParent <IN>
* @return	BOOL
* @note parent node pointer, not to manager memory
* @attention as the child to set the parent at the index (from the left of parent's child )
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::SetParent(DWORD dwIndex, AL_TreeNodeList<T>* pParent)
{
	BOOL  bSetParent = FALSE;
	bSetParent = pParent->Insert(dwIndex, this);
	if (TRUE == bSetParent) {
		//current node insert to the parent successfully
		m_pParent = pParent;
	}
	return bSetParent;
}

/**
* SetParentLeft
*
* @param	AL_TreeNodeList<T>* pParent <IN>
* @return	
* @note parent node pointer, not to manager memory
* @attention as the child to set the parent at the left (from the left of parent's child )
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::SetParentLeft(AL_TreeNodeList<T>* pParent)
{
	return SetParent(0x00, pParent);
}

/**
* SetParentRight
*
* @param	AL_TreeNodeList<T>* pParent <IN>
* @return	
* @note parent node pointer, not to manager memory
* @attention as the child to set the parent at the right (from the right of parent's child )
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::SetParentRight(AL_TreeNodeList<T>* pParent)
{
	return SetParent(pParent->GetDegree(), pParent);
}

/**
* Insert
*
* @param	DWORD dwIndex <IN>
* @param	AL_TreeNodeList<T>* pInsertChild <IN> 
* @return	BOOL
* @note inset the const AL_TreeNodeList<T>*  into the child notes at the position
* @attention
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::Insert(DWORD dwIndex, AL_TreeNodeList<T>* pInsertChild)
{
	BOOL  bInsert = FALSE;
	bInsert = m_listChild.Insert(dwIndex, pInsertChild);
	if (TRUE == bInsert) {
		if (GetLevel()+1 != pInsertChild->GetLevel()) {
			//deal with the child level
			INT iLevelDiff = pInsertChild->GetLevel() - GetLevel();
			pInsertChild->SetLevel(GetLevel()+1);

			AL_ListSingle<AL_TreeNodeList<T>*> listDescendant;
			if (FALSE == GetDescendant(listDescendant)) {
				return FALSE;
			}
			AL_TreeNodeList<T>* pDescendant = NULL;
			for (DWORD dwCnt=0; dwCnt<listDescendant.Length(); dwCnt++) {
				if (TRUE == listDescendant.Get(pDescendant, dwCnt)) {
					if (NULL != pDescendant) {
						//set child level
						pDescendant->SetLevel(pDescendant->GetLevel()-iLevelDiff+1);
					}
					else {
						//error
						return FALSE;
					}
				}
				else {
					//error
					return FALSE;
				}
			}
		}
		//child node insert to the current successfully
		pInsertChild->m_pParent = this;
	}
	return bInsert;
}

/**
* InsertLeft
*
* @param	AL_TreeNodeList<T>* pInsertChild <IN> 
* @return	BOOL
* @note inset the const AL_TreeNodeList<T>*  into the child notes at the left
* @attention
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::InsertLeft(AL_TreeNodeList<T>* pInsertChild)
{
	return Insert(0x00, pInsertChild);
}

/**
* InsertRight
*
* @param	AL_TreeNodeList<T>* pInsertChild <IN> 
* @return	BOOL
* @note inset the const AL_TreeNodeList<T>*  into the child notes at the right
* @attention
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::InsertRight(AL_TreeNodeList<T>* pInsertChild)
{
	return Insert(GetDegree(), pInsertChild);
}

/**
* GetChild
*
* @param	DWORD dwIndex <IN>
* @return	AL_TreeNodeList<T>*
* @note the dwIndex must is little than the node degree
* @attention
*/
template<typename T> AL_TreeNodeList<T>* 
AL_TreeNodeList<T>::GetChild(DWORD dwIndex) const
{
	AL_TreeNodeList<T>* pChild = NULL;
	if (TRUE == m_listChild.Get(pChild, dwIndex)) {
		return pChild;
	}
	return NULL;
}

/**
* GetChildLeft
*
* @param	
* @return	AL_TreeNodeList<T>*
* @note 
* @attention
*/
template<typename T> AL_TreeNodeList<T>* 
AL_TreeNodeList<T>::GetChildLeft() const
{
	return GetChild(0x00);
}

/**
* GetChildRight
*
* @param	
* @return	AL_TreeNodeList<T>*
* @note 
* @attention
*/
template<typename T> AL_TreeNodeList<T>* 
AL_TreeNodeList<T>::GetChildRight() const
{
	return GetChild(GetDegree());
}

/**
* GetDegree
*
* @param
* @return	DWORD
* @note degree node: A node of the subtree containing the number is called the node degree;
* @attention 
*/
template<typename T> DWORD 
AL_TreeNodeList<T>::GetDegree() const
{
	return m_listChild.Length();
}

/**
* IsLeaf
*
* @param
* @return	BOOL
* @note leaf nodes or terminal nodes: degree 0 are called leaf nodes;
* @attention 
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::IsLeaf() const
{
//	return (TRUE == m_listChild.IsEmpty()) ? TRUE:FALSE;
	return (0x00 == GetDegree()) ? TRUE:FALSE;
}

/**
* IsBranch
*
* @param
* @return	BOOL
* @note non-terminal node or branch node: node degree is not 0;
* @attention 
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::IsBranch() const
{
//	return (FALSE == m_listChild.IsEmpty()) ? TRUE:FALSE;
	return (0x00 != GetDegree()) ? TRUE:FALSE;
}

/**
* IsParent
*
* @param	const AL_TreeNodeList<T>* pChild <IN>
* @return	BOOL
* @note parent node or the parent node: If a node contains a child node, this node is called its child 
* @attention 
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::IsParent(const AL_TreeNodeList<T>* pChild) const
{
// 	AL_TreeNodeList<T>* pCompare = NULL;
// 	for (DWORD dwCnt=0; dwCnt<GetDegree(); dwCnt++) {
// 		if (TRUE == m_listChild.Get(pCompare, dwCnt)) {
// 			if (pCompare == pChild) {
// 				//find the child
// 				return TRUE;
// 			}
// 		}
// 	}
// 	return FALSE;

	if (this == pChild->m_pParent) {
		return TRUE;
	}
	return FALSE;
}

/**
* GetSibling
*
* @param	AL_ListSingle<AL_TreeNodeList<T>*>& listSibling <OUT>
* @return	BOOL
* @note sibling nodes: nodes with the same parent node is called mutual sibling;
* @attention 
*/
template<typename T> BOOL
AL_TreeNodeList<T>::GetSibling(AL_ListSingle<AL_TreeNodeList<T>*>& listSibling) const
{
	BOOL bSibling = FALSE;
	if (NULL == m_pParent) {
		//not parent node
		return bSibling;
	}
	AL_ListSingle<AL_TreeNodeList<T>*>&	listParentChild = m_pParent->m_listChild;
	AL_TreeNodeList<T>* pParentChild = NULL;
	for (DWORD dwCnt=0; dwCnt<m_pParent->GetDegree(); dwCnt++) {
		pParentChild = m_pParent->GetChild(dwCnt);
		if (NULL != pParentChild) {
			//get the child
			if (pParentChild == this) {
				//itself
				continue;
			}
			listSibling.InsertEnd(pParentChild);
			bSibling = TRUE;
		}
		else {
			//error can not get the child
			return FALSE;
		}
	}
	return bSibling;
}

/**
* GetAncestor
*
* @param	AL_ListSingle<AL_TreeNodeList<T>*>& listAncestor <OUT>
* @return	BOOL
* @note ancestor node: from the root to the node through all the nodes on the branch;
* @attention 
*/
template<typename T> BOOL
AL_TreeNodeList<T>::GetAncestor(AL_ListSingle<AL_TreeNodeList<T>*>& listAncestor) const
{
	if (NULL == m_pParent) {
		//not parent node
		return FALSE;
	}

	AL_TreeNodeList<T>* pParent = m_pParent;
	while (NULL != pParent) {
		listAncestor.InsertEnd(pParent);
		pParent = pParent->m_pParent;
	}
	return TRUE;
}

/**
* GetDescendant
*
* @param	AL_ListSingle<AL_TreeNodeList<T>*>& listDescendant <OUT>
* @return	BOOL
* @note ancestor node: from the root to the node through all the nodes on the branch;
* @attention 
*/
template<typename T> BOOL 
AL_TreeNodeList<T>::GetDescendant(AL_ListSingle<AL_TreeNodeList<T>*>& listDescendant) const
{
	if (TRUE == IsLeaf()) {
		//child node
		return FALSE;
	}

	AL_TreeNodeList<T>* pDescendant = NULL;
	for (DWORD dwCnt=0; dwCnt<GetDegree(); dwCnt++) {
		pDescendant = GetChild(dwCnt);
		if (NULL != pDescendant) {
			//get the child
			listDescendant.InsertEnd(pDescendant);
		}
		else {
			//error can not get the child
			return FALSE;
		}
	}

	//loop the all node in listDescendant
	DWORD dwDescendantLoop = 0x00;
	AL_TreeNodeList<T>* pDescendantLoop = NULL;
	while (TRUE == listDescendant.Get(pDescendant, dwDescendantLoop)) {
		dwDescendantLoop++;
		if (NULL != pDescendant) {
			for (DWORD dwCnt=0; dwCnt<pDescendant->GetDegree(); dwCnt++) {
				pDescendantLoop = pDescendant->GetChild(dwCnt);
				if (NULL != pDescendantLoop) {
					//get the descendant
					listDescendant.InsertEnd(pDescendantLoop);
				}
				else {
					//error can not get the descendant
					return FALSE;
				}
			}
		}
		else {
			//error
			return FALSE;
		}
	}
	return TRUE;
	/*
	AL_TreeNodeList<T>* pDescendant = NULL;
	AL_QueueList<AL_TreeNodeList<T>*> queueDescendant;
	for (DWORD dwCnt=0; dwCnt<GetDegree(); dwCnt++) {
		pDescendant = GetChild(dwCnt);
		if (NULL != pDescendant) {
			//get the child
			queueDescendant.Push(pDescendant);
		}
		else {
			//error can not get the child
			return FALSE;
		}
	}
	AL_TreeNodeList<T>* pDescendantLoop = NULL;
	AL_TreeNodeList<T>* pDescendantChild = NULL;
	while (FALSE == queueDescendant.IsEmpty()) {
		if (TRUE == queueDescendant.Pop(pDescendantLoop)) {
			if (NULL != pDescendantLoop) {
				listDescendant.InsertEnd(pDescendantLoop); 
				for (DWORD dwCnt=0; dwCnt<pDescendantLoop->GetDegree(); dwCnt++) {
					pDescendantChild = pDescendantLoop->GetChild(dwCnt);
					if (NULL != pDescendantChild) {
						queueDescendant.Push(pDescendantChild);
					}
				}
			}
			else {
				return FALSE;
			}
		}
		else {
			return FALSE;
		}
	}
	return TRUE;
	*/
}

/**
*Assignment
*
* @param	const AL_TreeNodeList<T>& cAL_TreeNodeList
* @return	AL_TreeNodeList<T>&
*/
template<typename T> AL_TreeNodeList<T>& 
AL_TreeNodeList<T>::operator = (const AL_TreeNodeList<T>& cAL_TreeNodeList)
{
	m_dwLevel = cAL_TreeNodeList.m_dwLevel;
	m_data = cAL_TreeNodeList.m_data;
	m_pParent = cAL_TreeNodeList.m_pParent;
	m_listChild = cAL_TreeNodeList.m_listChild;
	return *this;
}
#endif // CXX_AL_TREENODELIST_H
/* EOF */

AL_TreeList.h 

/**
  @(#)$Id: AL_TreeList.h 54 2013-09-24 05:59:38Z xiaoting $
  @brief	Tree (tree) that contains n (n> 0) nodes of a finite set, where:
	(1) Each element is called node (node);
	(2) there is a particular node is called the root node or root (root).
	(3) In addition to the remaining data elements other than the root node is divided into m (m ≥ 0) disjoint set of T1, T2, ...... 
	Tm-1, wherein each set of Ti (1 <= i <= m ) itself is a tree, the original tree is called a subtree (subtree).
  
  
  Trees can also be defined as: the tree is a root node and several sub-tree consisting of stars. And a tree is a set defined on the 
  set consisting of a relationship. Elements in the collection known as a tree of nodes, the defined relationship is called 
  parent-child relationship. Parent-child relationship between the nodes of the tree establishes a hierarchy. In this there is a 
  hierarchy node has a special status, this node is called the root of the tree, otherwise known as root.

  We can give form to the tree recursively defined as follows:
	Single node is a tree, the roots is the node itself.
	Let T1, T2, .., Tk is a tree, the root node are respectively n1, n2, .., nk. With a new node n as n1, n2, .., nk's father, then 
	get a new tree node n is the new root of the tree. We call n1, n2, .., nk is a group of siblings, they are sub-node n junction. 
	We also said that n1, n2, .., nk is the sub-tree node n.

	Empty tree is also called the empty tree. Air no node in the tree.

 The related concepts of tree 
  1. Degree of tree: a tree, the maximum degree of the node of the tree is called degree;
  2. Height or depth of the tree: the maximum level of nodes in the tree;
  3. Forests: the m (m> = 0) disjoint trees set of trees called forest;

  The related concepts of tree node 
  1.degree		degree node: A node of the subtree containing the number is called the node degree;
  2.leaf			leaf nodes or terminal nodes: degree 0 are called leaf nodes;
  3.branch		non-terminal node or branch node: node degree is not 0;
  4.parent		parent node or the parent node: If a node contains a child node, this node is called its child node's parent;
  5.child			child node or child node: A node subtree containing the root node is called the node's children;
  6.slibing		sibling nodes: nodes with the same parent node is called mutual sibling;
  7.ancestor		ancestor node: from the root to the node through all the nodes on the branch;
  8.descendant	descendant nodes: a node in the subtree rooted at any node is called the node's descendants.

  Sequential storage structure//
  Using a set of addresses in the computer storage unit sequentially stores continuous linear form of individual data elements, called 
  the linear order of the table storage structure.

  Sequential storage structure is a type of a storage structure, the structure is the logically adjacent nodes stored in the physical 
  location of the adjacent memory cells, the logical relationship between nodes from the storage unit to reflect the adjacency. 
  Storage structure thus obtained is stored in order structure, usually by means of sequential storage structure computer programming 
  language (e.g., c / c) of the array to describe.

  The main advantage of the storage structure in order to save storage space, because the allocation to the data storage unit storing 
  all nodes with data (without regard to c / c language in the array size required for the case), the logical relationship between 
  the nodes does not take additional storage space. In this method, the node can be realized on a random access, that is, each node 
  corresponds to a number, the number can be calculated directly from the node out of the memory address. However, the main 
  disadvantage of sequential storage method is easy to modify the node insert, delete operations, may have to move a series of nodes.
          
  Benefits:
	Random Access table elements. 
  Disadvantages: 
    insert and delete operations need to move elements.

  @Author $Author: xiaoting $
  @Date $Date: 2013-09-24 13:59:38 +0800 (周二, 24 九月 2013) $
  @Revision $Revision: 54 $
  @URL $URL: https://svn.code.sf.net/p/xiaoting/game/trunk/MyProject/AL_DataStructure/groupinc/AL_TreeList.h $
  @Header $Header: https://svn.code.sf.net/p/xiaoting/game/trunk/MyProject/AL_DataStructure/groupinc/AL_TreeList.h 54 2013-09-24 05:59:38Z xiaoting $
 */

#ifndef CXX_AL_TREELIST_H
#define CXX_AL_TREELIST_H

#ifndef CXX_AL_LISTSINGLE_H
#include "AL_ListSingle.h"
#endif

#ifndef CXX_AL_QUEUELIST_H
#include "AL_QueueList.h"
#endif

///
//			AL_TreeList
///

template<typename T> 
class AL_TreeList
{
public:
	/**
	* Construction
	*
	* @param	DWORD dwSize (default value: TREESEQ_DEFAULTSIZE)
	* @return
	* @note
	* @attention
	*/
	AL_TreeList();

	/**
	* Destruction
	*
	* @param
	* @return
	* @note
	* @attention 
	*/
	~AL_TreeList();

	/**
	* IsEmpty
	*
	* @param VOID
	* @return BOOL
	* @note the tree has data?
	* @attention
	*/
	BOOL IsEmpty() const;
	
	/**
	* GetRootNode
	*
	* @param
	* @return	const AL_TreeNodeList<T>*
	* @note Get the root data
	* @attention 
	*/
	const AL_TreeNodeList<T>* GetRootNode() const;

	/**
	* GetDegree
	*
	* @param
	* @return	DWORD
	* @note Degree of tree: a tree, the maximum degree of the node of the tree is called degree;
	* @attention 
	*/
	DWORD GetDegree() const;


	/**
	* GetHeight
	*
	* @param	
	* @return	DWORD
	* @note Height or depth of the tree: the maximum level of nodes in the tree;
	* @attention 
	*/
	DWORD GetHeight() const;

	/**
	* GetNodesNum
	*
	* @param
	* @return	DWORD
	* @note get the notes number of the tree 
	* @attention 
	*/
	DWORD GetNodesNum() const;

	/**
	* Clear
	*
	* @param
	* @return	
	* @note 
	* @attention 
	*/
	VOID Clear();

	/**
	* LevelOrderTraversal
	*
	* @param	AL_ListSingle<T>& listOrder <OUT>
	* @return	BOOL
	* @note Level-order traversal
	* @attention 
	*/
	BOOL LevelOrderTraversal(AL_ListSingle<T>& listOrder) const;

	/**
	* GetSiblingAtNode
	*
	* @param	AL_ListSingle<T>& listSibling <OUT>
	* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
	* @return	BOOL
	* @note sibling nodes: nodes with the same parent node is called mutual sibling;
	* @attention the current tree node must be in the tree
	*/
	BOOL GetSiblingAtNode(AL_ListSingle<T>& listSibling, const AL_TreeNodeList<T>* pCurTreeNode) const;

	/**
	* GetAncestorAtNode
	*
	* @param	AL_ListSingle<T>& listAncestor <OUT>
	* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
	* @return	BOOL
	* @note ancestor node: from the root to the node through all the nodes on the branch;
	* @attention the current tree node must be in the tree
	*/
	BOOL GetAncestorAtNode(AL_ListSingle<T>& listAncestor, const AL_TreeNodeList<T>* pCurTreeNode) const;

	/**
	* GetDescendantAtNode
	*
	* @param	AL_ListSingle<T>& listDescendant <OUT>
	* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
	* @return	BOOL
	* @note ancestor node: from the root to the node through all the nodes on the branch;
	* @attention the current tree node must be in the tree
	*/
	BOOL GetDescendantAtNode(AL_ListSingle<T>& listDescendant, const AL_TreeNodeList<T>* pCurTreeNode) const;

	/**
	* InsertRoot
	*
	* @param	const T& tTemplate <IN> 
	* @return	BOOL
	* @note
	* @attention
	*/
	BOOL InsertRoot(const T& tTemplate);

	/**
	* InsertAtNode
	*
	* @param	AL_TreeNodeList<T>* pCurTreeNode <IN>	
	* @param	DWORD dwIndex <IN>
	* @param	const T& tTemplate <IN> 
	* @return	BOOL
	* @note insert the tTemplate as child tree node to the current tree node (pCurTreeNode) at the position (dwIndex)
	* @attention if NULL == pCurTreeNode, it will be insert as root tree node, the current tree node must be in the tree
	*/
	BOOL InsertAtNode(AL_TreeNodeList<T>* pCurTreeNode, DWORD dwIndex, const T& tTemplate);

	/**
	* InsertLeftAtNode
	*
	* @param	AL_TreeNodeList<T>* pCurTreeNode <IN>	
	* @param	const T& tTemplate <IN> 
	* @return	BOOL
	* @note insert the tTemplate as child tree node to the current tree node (pCurTreeNode) at the position (left)
	* @attention  if NULL == pCurTreeNode, it will be insert as root tree node, the current tree node must be in the tree
	*/
	BOOL InsertLeftAtNode(AL_TreeNodeList<T>* pCurTreeNode, const T& tTemplate);

	/**
	* InsertRightAtNode
	*
	* @param	AL_TreeNodeList<T>* pCurTreeNode <IN>	
	* @param	const T& tTemplate <IN> 
	* @return	BOOL
	* @note insert the tTemplate as child tree node to the current tree node (pCurTreeNode) at the position (right)
	* @attention  if NULL == pCurTreeNode, it will be insert as root tree node, the current tree node must be in the tree
	*/
	BOOL InsertRightAtNode(AL_TreeNodeList<T>* pCurTreeNode, const T& tTemplate);

	/**
	* GetChildNodeAtNode
	*
	* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
	* @param	DWORD dwIndex <IN>
	* @return	const AL_TreeNodeList<T>*
	* @note get the current tree node (pCurTreeNode)'s child node at the position (dwIndex)
	* @attention the current tree node must be in the tree
	*/
	const AL_TreeNodeList<T>* GetChildNodeAtNode(const AL_TreeNodeList<T>* pCurTreeNode, DWORD dwIndex) const;

	/**
	* GetChildNodeLeftAtNode
	*
	* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
	* @return	const AL_TreeNodeList<T>*
	* @note get the current tree node (pCurTreeNode)'s child node at the position (left)
	* @attention the current tree node must be in the tree
	*/
	const AL_TreeNodeList<T>* GetChildNodeLeftAtNode(const AL_TreeNodeList<T>* pCurTreeNode) const;

	/**
	* GetChildNodeRightAtNode
	*
	* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
	* @return	const AL_TreeNodeList<T>*
	* @note get the current tree node (pCurTreeNode)'s child node at the position (right)
	* @attention the current tree node must be in the tree
	*/
	const AL_TreeNodeList<T>*  GetChildNodeRightAtNode(const AL_TreeNodeList<T>* pCurTreeNode) const;

protected:
private:
	
	/**
	*Copy Construct
	*
	* @param	const AL_TreeList<T>& cAL_TreeList
	* @return
	*/
	AL_TreeList(const AL_TreeList<T>& cAL_TreeList);

	/**
	*Assignment
	*
	* @param	const AL_TreeList<T>& cAL_TreeList
	* @return	AL_TreeList<T>&
	*/
	AL_TreeList<T>& operator = (const AL_TreeList<T>& cAL_TreeList);

public:
protected:
private:
	DWORD								m_dwDegree;
	DWORD								m_dwHeight;
	DWORD								m_NumNodes;
	AL_TreeNodeList<T>*					m_pRootNode;
};

///
//			AL_TreeList
///

/**
* Construction
*
* @param
* @return
* @note
* @attention
*/
template<typename T> 
AL_TreeList<T>::AL_TreeList():
m_dwDegree(0xffffffff),
m_dwHeight(0x00),
m_NumNodes(0x00),
m_pRootNode(NULL)
{

}

/**
* Destruction
*
* @param
* @return
* @note
* @attention 
*/
template<typename T> 
AL_TreeList<T>::~AL_TreeList()
{
	Clear();
}

/**
* IsEmpty
*
* @param VOID
* @return BOOL
* @note the tree has data?
* @attention
*/
template<typename T> BOOL 
AL_TreeList<T>::IsEmpty() const
{
	return (0x00 == m_NumNodes) ? TRUE:FALSE;
}

/**
* GetRootNode
*
* @param
* @return	const AL_TreeNodeList<T>*
* @note Get the root data
* @attention 
*/
template<typename T> const AL_TreeNodeList<T>* 
AL_TreeList<T>::GetRootNode() const
{
	return m_pRootNode;
}

/**
* GetDegree
*
* @param
* @return	DWORD
* @note Degree of tree: a tree, the maximum degree of the node of the tree is called degree;
* @attention 
*/
template<typename T> DWORD 
AL_TreeList<T>::GetDegree() const
{
	return m_dwDegree;
}


/**
* GetHeight
*
* @param	
* @return	DWORD
* @note Height or depth of the tree: the maximum level of nodes in the tree;
* @attention 
*/
template<typename T> DWORD 
AL_TreeList<T>::GetHeight() const
{
	return m_dwHeight;
}

/**
* GetNodesNum
*
* @param
* @return	DWORD
* @note get the notes number of the tree 
* @attention 
*/
template<typename T> DWORD 
AL_TreeList<T>::GetNodesNum() const
{
	return m_NumNodes;
}

/**
* Clear
*
* @param
* @return	
* @note 
* @attention 
*/
template<typename T> VOID 
AL_TreeList<T>::Clear()
{
	m_dwDegree = 0xffffffff;
	m_dwHeight = 0x00;
	m_NumNodes = 0x00;

	AL_ListSingle<AL_TreeNodeList<T>*> listDescendant;
	if (NULL != m_pRootNode) {
		if (TRUE == m_pRootNode->GetDescendant(listDescendant)) {
			AL_TreeNodeList<T>* pDescendant;
			for (DWORD dwDelete=0; dwDelete<listDescendant.Length(); dwDelete++) {
				if (TRUE == listDescendant.Get(pDescendant, dwDelete)) {
					if (NULL != pDescendant) {
						delete pDescendant;
						pDescendant = NULL;
					}
				}
			}
		}
	}
	delete m_pRootNode;
	m_pRootNode = NULL;
}

/**
* LevelOrderTraversal
*
* @param	AL_ListSingle<T>& listOrder <OUT>
* @return	BOOL
* @note Level-order traversal
* @attention 
*/
template<typename T> BOOL 
AL_TreeList<T>::LevelOrderTraversal(AL_ListSingle<T>& listOrder) const
{
	if (TRUE == IsEmpty()) {
		return FALSE;
	}

	if (NULL == m_pRootNode) {
		return FALSE;
	}
	listOrder.Clear();
	/*
	AL_ListSingle<AL_TreeNodeList<T>*> listNodeOrder;
	listNodeOrder.InsertEnd(m_pRootNode);
	//loop the all node
	DWORD dwNodeOrderLoop = 0x00;
	AL_TreeNodeList<T>* pNodeOrderLoop = NULL;
	AL_TreeNodeList<T>* pNodeOrderChild = NULL;
	while (TRUE == listNodeOrder.Get(pNodeOrderLoop, dwNodeOrderLoop)) {
		dwNodeOrderLoop++;
		if (NULL != pNodeOrderLoop) {
			listOrder.InsertEnd(pNodeOrderLoop->GetData());
			for (DWORD dwCnt=0; dwCnt<pNodeOrderLoop->GetDegree(); dwCnt++) {
				pNodeOrderChild = pNodeOrderLoop->GetChild(dwCnt);
				if (NULL != pNodeOrderChild) {
					//get the descendant
					listNodeOrder.InsertEnd(pNodeOrderChild);
				}
				else {
					//error can not get the descendant
					return FALSE;
				}
			}
		}
		else {
			//error
			return FALSE;
		}
	}
	return TRUE;
	*/
	
	AL_QueueList<AL_TreeNodeList<T>*> queueOrder;
	queueOrder.Push(m_pRootNode);
	
	AL_TreeNodeList<T>* pNodeOrderLoop = NULL;
	AL_TreeNodeList<T>* pNodeOrderChild = NULL;
	while (FALSE == queueOrder.IsEmpty()) {
		if (TRUE == queueOrder.Pop(pNodeOrderLoop)) {
			if (NULL != pNodeOrderLoop) {
				listOrder.InsertEnd(pNodeOrderLoop->GetData()); 
				for (DWORD dwCnt=0; dwCnt<pNodeOrderLoop->GetDegree(); dwCnt++) {
					pNodeOrderChild = pNodeOrderLoop->GetChild(dwCnt);
					if (NULL != pNodeOrderChild) {
						queueOrder.Push(pNodeOrderChild);
					}
				}
			}
			else {
				return FALSE;
			}
		}
		else {
			return FALSE;
		}
	}
	return TRUE;
}


/**
* GetSiblingAtNode
*
* @param	AL_ListSingle<T>& listSibling <OUT>
* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
* @return	BOOL
* @note sibling nodes: nodes with the same parent node is called mutual sibling;
* @attention the current tree node must be in the tree
*/
template<typename T> BOOL 
AL_TreeList<T>::GetSiblingAtNode(AL_ListSingle<T>& listSibling, const AL_TreeNodeList<T>* pCurTreeNode) const
{
	if (NULL == pCurTreeNode) {
		return FALSE;
	}

	AL_ListSingle<AL_TreeNodeList<T>*> listTreeNodeSibling;
	if (FALSE == pCurTreeNode->GetSibling(listTreeNodeSibling)) {
		return FALSE;
	}
	//clear listSibling 
	listSibling.Clear();
	AL_TreeNodeList<T>* pTreeNodeSibling = NULL;
	for (DWORD dwCnt=0; dwCnt<listTreeNodeSibling.Length(); dwCnt++) {
		if (TRUE == listTreeNodeSibling.Get(pTreeNodeSibling, dwCnt)) {
			if (NULL != pTreeNodeSibling) {
				//inset the data to listSibling
				listSibling.InsertEnd(pTreeNodeSibling->GetData());
			}
			else {
				//error
				return FALSE;
			}
		}
		else {
			//error
			return FALSE;
		}
	}
	return TRUE;
}

/**
* GetAncestorAtNode
*
* @param	AL_ListSingle<T>& listAncestor <OUT>
* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
* @return	BOOL
* @note ancestor node: from the root to the node through all the nodes on the branch;
* @attention the current tree node must be in the tree
*/
template<typename T> BOOL 
AL_TreeList<T>::GetAncestorAtNode(AL_ListSingle<T>& listAncestor, const AL_TreeNodeList<T>* pCurTreeNode) const
{
	if (NULL == pCurTreeNode) {
		return FALSE;
	}

	AL_ListSingle<AL_TreeNodeList<T>*> listTreeNodeAncestor;
	if (FALSE == pCurTreeNode->GetAncestor(listTreeNodeAncestor)) {
		return FALSE;
	}
	//clear listAncestor 
	listAncestor.Clear();
	AL_TreeNodeList<T>* pTreeNodeAncestor = NULL;
	for (DWORD dwCnt=0; dwCnt<listTreeNodeAncestor.Length(); dwCnt++) {
		if (TRUE == listTreeNodeAncestor.Get(pTreeNodeAncestor, dwCnt)) {
			if (NULL != pTreeNodeAncestor) {
				//inset the data to listSibling
				listAncestor.InsertEnd(pTreeNodeAncestor->GetData());
			}
			else {
				//error
				return FALSE;
			}
		}
		else {
			//error
			return FALSE;
		}
	}
	return TRUE;
}

/**
* GetDescendantAtNode
*
* @param	AL_ListSingle<T>& listDescendant <OUT>
* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
* @return	BOOL
* @note ancestor node: from the root to the node through all the nodes on the branch;
* @attention the current tree node must be in the tree
*/
template<typename T> BOOL 
AL_TreeList<T>::GetDescendantAtNode(AL_ListSingle<T>& listDescendant, const AL_TreeNodeList<T>* pCurTreeNode) const
{
	if (NULL == pCurTreeNode) {
		return FALSE;
	}

	AL_ListSingle<AL_TreeNodeList<T>*> listTreeNodeDescendant;
	if (FALSE == pCurTreeNode->GetDescendant(listTreeNodeDescendant)) {
		return FALSE;
	}
	//clear listAncestor 
	listDescendant.Clear();
	AL_TreeNodeList<T>* pTreeNodeDescendant = NULL;
	for (DWORD dwCnt=0; dwCnt<listTreeNodeDescendant.Length(); dwCnt++) {
		if (TRUE == listTreeNodeDescendant.Get(pTreeNodeDescendant, dwCnt)) {
			if (NULL != pTreeNodeDescendant) {
				//inset the data to listSibling
				listDescendant.InsertEnd(pTreeNodeDescendant->GetData());
			}
			else {
				//error
				return FALSE;
			}
		}
		else {
			//error
			return FALSE;
		}
	}
	return TRUE;
}


/**
* InsertRoot
*
* @param	const T& tTemplate <IN> 
* @return	BOOL
* @note
* @attention
*/
template<typename T> BOOL 
AL_TreeList<T>::InsertRoot(const T& tTemplate)
{
	return InsertAtNode(NULL, 0x00, tTemplate);
}

/**
* InsertAtNode
*
* @param	AL_TreeNodeList<T>* pCurTreeNode <IN>	
* @param	DWORD dwIndex <IN>
* @param	const T& tTemplate <IN> 
* @return	BOOL
* @note insert the tTemplate as child tree node to the current tree node (pCurTreeNode) at the position (dwIndex)
* @attention if NULL == pCurTreeNode, it will be insert as root tree node, the current tree node must be in the tree
*/
template<typename T> BOOL 
AL_TreeList<T>::InsertAtNode(AL_TreeNodeList<T>* pCurTreeNode, DWORD dwIndex, const T& tTemplate)
{
	AL_TreeNodeList<T>* pTreeNode = NULL;
	if (TRUE == IsEmpty()) {
		if (NULL != pCurTreeNode) {
			//error can not insert to the current node pCurTreeNode, is not exist in the tree
			return FALSE;
		}
		else {
			pTreeNode = new AL_TreeNodeList<T>;
			if (NULL ==  pTreeNode) {
				return FALSE;
			}
			pTreeNode->SetData(tTemplate);
			pTreeNode->SetLevel(0x00);

			m_pRootNode = pTreeNode;
			m_dwDegree = 0x00;
			m_dwHeight = 0x00;			//empty tree 0xffffffff (-1)
			m_NumNodes++;
			return TRUE;
		}
	}

	if (NULL == pCurTreeNode) {
		return FALSE;
	}

	//inset to the current tree node
	pTreeNode = new AL_TreeNodeList<T>;
	if (NULL ==  pTreeNode) {
		return FALSE;
	}
	pTreeNode->SetData(tTemplate);
	pTreeNode->SetLevel(pCurTreeNode->GetLevel() + 1);

	if (FALSE ==  pCurTreeNode->Insert(dwIndex, pTreeNode)) {
		delete pTreeNode;
		pTreeNode = NULL;
		return FALSE;
	}

	DWORD dwCurNodeDegree = 0x00;
	//loop all node to get the current node degree
	if (pCurTreeNode->GetDegree() > m_dwDegree) {
		m_dwDegree = pCurTreeNode->GetDegree();
	}

	if (pTreeNode->GetLevel() > m_dwHeight) {
		m_dwHeight =pTreeNode->GetLevel();
	}
	m_NumNodes++;

	return TRUE;
}

/**
* InsertLeftAtNode
*
* @param	AL_TreeNodeList<T>* pCurTreeNode <IN>	
* @param	const T& tTemplate <IN> 
* @return	BOOL
* @note insert the tTemplate as child tree node to the current tree node (pCurTreeNode) at the position (left)
* @attention  if NULL == pCurTreeNode, it will be insert as root tree node, the current tree node must be in the tree
*/
template<typename T> BOOL 
AL_TreeList<T>::InsertLeftAtNode(AL_TreeNodeList<T>* pCurTreeNode, const T& tTemplate)
{
	return InsertAtNode(pCurTreeNode, 0x00, tTemplate);
}

/**
* InsertRightAtNode
*
* @param	AL_TreeNodeList<T>* pCurTreeNode <IN>	
* @param	const T& tTemplate <IN> 
* @return	BOOL
* @note insert the tTemplate as child tree node to the current tree node (pCurTreeNode) at the position (right)
* @attention  if NULL == pCurTreeNode, it will be insert as root tree node, the current tree node must be in the tree
*/
template<typename T> BOOL 
AL_TreeList<T>::InsertRightAtNode(AL_TreeNodeList<T>* pCurTreeNode, const T& tTemplate)
{
	return InsertAtNode(pCurTreeNode, pCurTreeNode->GetDegree(), tTemplate);
}

/**
* GetChildNodeAtNode
*
* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
* @param	DWORD dwIndex <IN>
* @return	const AL_TreeNodeList<T>*
* @note get the current tree node (pCurTreeNode)'s child node at the position (dwIndex)
* @attention the current tree node must be in the tree
*/
template<typename T> const AL_TreeNodeList<T>* 
AL_TreeList<T>::GetChildNodeAtNode(const AL_TreeNodeList<T>* pCurTreeNode, DWORD dwIndex) const
{
	if (NULL == pCurTreeNode) {
		return NULL;
	}

	return pCurTreeNode->GetChild(dwIndex);
}

/**
* GetChildNodeLeftAtNode
*
* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
* @return	const AL_TreeNodeList<T>*
* @note get the current tree node (pCurTreeNode)'s child node at the position (left)
* @attention the current tree node must be in the tree
*/
template<typename T> const AL_TreeNodeList<T>* 
AL_TreeList<T>::GetChildNodeLeftAtNode(const AL_TreeNodeList<T>* pCurTreeNode) const
{
	return GetChildNodeAtNode(pCurTreeNode, 0x00);
}

/**
* GetChildNodeRightAtNode
*
* @param	const AL_TreeNodeList<T>* pCurTreeNode <IN>	
* @return	const AL_TreeNodeList<T>*
* @note get the current tree node (pCurTreeNode)'s child node at the position (right)
* @attention
*/
template<typename T> const AL_TreeNodeList<T>* 
AL_TreeList<T>::GetChildNodeRightAtNode(const AL_TreeNodeList<T>* pCurTreeNode) const
{
	return GetChildNodeAtNode(pCurTreeNode, pCurTreeNode->GetDegree());
}
#endif // CXX_AL_TREELIST_H
/* EOF */

测试代码

#ifdef TEST_AL_TREELIST
	AL_TreeList<DWORD> cTreeList;
	BOOL bEmpty = cTreeList.IsEmpty();
	std::cout<<bEmpty<<std::endl;
	const AL_TreeNodeList<DWORD>* pConstRootNode = cTreeList.GetRootNode();
	AL_TreeNodeList<DWORD>* pRootNode = const_cast<AL_TreeNodeList<DWORD>*>(pConstRootNode);
	std::cout<<pRootNode<<std::endl;
	DWORD dwDegree = cTreeList.GetDegree();
	std::cout<<dwDegree<<std::endl;
	DWORD dwHeight = cTreeList.GetHeight();
	std::cout<<dwHeight<<std::endl;
	DWORD dwNodesNum = cTreeList.GetNodesNum();
	std::cout<<dwNodesNum<<std::endl;

	cTreeList.InsertRoot(0);
	pConstRootNode = cTreeList.GetRootNode();
	pRootNode = const_cast<AL_TreeNodeList<DWORD>*>(pConstRootNode);
	std::cout<<pRootNode<<std::endl;

	cTreeList.InsertAtNode(pRootNode, 0x00, 10);

	const AL_TreeNodeList<DWORD>* pConstTreeNode = cTreeList.GetChildNodeAtNode(pRootNode, 0x00);
	AL_TreeNodeList<DWORD>* pTreeNode = const_cast<AL_TreeNodeList<DWORD>*>(pConstTreeNode);
	std::cout<<pTreeNode<<std::endl;

	cTreeList.InsertAtNode(pTreeNode, 0x00, 21);
	cTreeList.InsertLeftAtNode(pTreeNode, 20);
	cTreeList.InsertRightAtNode(pTreeNode, 22);
	cTreeList.InsertAtNode(pTreeNode, 0x03, 23);

	const AL_TreeNodeList<DWORD>* pConstTreeNode20 = cTreeList.GetChildNodeAtNode(pTreeNode, 0x00);
	AL_TreeNodeList<DWORD>* pTreeNode20 = const_cast<AL_TreeNodeList<DWORD>*>(pConstTreeNode20);
	std::cout<<pTreeNode<<std::endl;

	cTreeList.InsertAtNode(pTreeNode20, 0x00, 31);
	cTreeList.InsertLeftAtNode(pTreeNode20, 30);
	cTreeList.InsertRightAtNode(pTreeNode20, 32);
	cTreeList.InsertAtNode(pTreeNode20, 0x03, 33);

	const AL_TreeNodeList<DWORD>* pConstTreeNode33 = cTreeList.GetChildNodeAtNode(pTreeNode20, 0x3);
	AL_TreeNodeList<DWORD>* pTreeNode33 = const_cast<AL_TreeNodeList<DWORD>*>(pConstTreeNode33);

	if (NULL != pTreeNode) {
		std::cout<<pTreeNode->GetLevel()<<"    "<<pTreeNode->GetData()<<"    "<<pTreeNode->GetDegree()<<std::endl;
		std::cout<<pTreeNode->IsLeaf()<<"    "<<pTreeNode->IsBranch()<<"    "<<pTreeNode->IsParent(pTreeNode)<<"    "<<pTreeNode->IsParent(pTreeNode33)<<std::endl;
	}
	if (NULL != pTreeNode20) {
		std::cout<<pTreeNode20->GetLevel()<<"    "<<pTreeNode20->GetData()<<"    "<<pTreeNode20->GetDegree()<<std::endl;
		std::cout<<pTreeNode20->IsLeaf()<<"    "<<pTreeNode20->IsBranch()<<"    "<<pTreeNode20->IsParent(pTreeNode)<<"    "<<pTreeNode20->IsParent(pTreeNode33)<<std::endl;
	}
	if (NULL != pTreeNode33) {
		std::cout<<pTreeNode33->GetLevel()<<"    "<<pTreeNode33->GetData()<<"    "<<pTreeNode33->GetDegree()<<std::endl;
		std::cout<<pTreeNode33->IsLeaf()<<"    "<<pTreeNode33->IsBranch()<<"    "<<pTreeNode33->IsParent(pTreeNode)<<"    "<<pTreeNode33->IsParent(pTreeNode33)<<std::endl;
	}

	const AL_TreeNodeList<DWORD>*	pChild = NULL;
	pChild = cTreeList.GetChildNodeAtNode(pTreeNode, 0x01);
	if (NULL != pChild) {
		std::cout<<pChild->GetLevel()<<"    "<<pChild->GetData()<<"    "<<pChild->GetDegree()<<std::endl;
		std::cout<<pChild->IsLeaf()<<"    "<<pChild->IsBranch()<<"    "<<pChild->IsParent(pTreeNode)<<"    "<<pChild->IsParent(pTreeNode33)<<std::endl;
	}
	pChild = cTreeList.GetChildNodeAtNode(pTreeNode, 0x00);
	if (NULL != pChild) {
		std::cout<<pChild->GetLevel()<<"    "<<pChild->GetData()<<"    "<<pChild->GetDegree()<<std::endl;
		std::cout<<pChild->IsLeaf()<<"    "<<pChild->IsBranch()<<"    "<<pChild->IsParent(pTreeNode)<<"    "<<pChild->IsParent(pTreeNode33)<<std::endl;
	}
	pChild = cTreeList.GetChildNodeLeftAtNode(pTreeNode);
	if (NULL != pChild) {
		std::cout<<pChild->GetLevel()<<"    "<<pChild->GetData()<<"    "<<pChild->GetDegree()<<std::endl;
		std::cout<<pChild->IsLeaf()<<"    "<<pChild->IsBranch()<<"    "<<pChild->IsParent(pTreeNode)<<"    "<<pChild->IsParent(pTreeNode33)<<std::endl;
	}
	pChild = cTreeList.GetChildNodeAtNode(pTreeNode, 0x03);
	if (NULL != pChild) {
		std::cout<<pChild->GetLevel()<<"    "<<pChild->GetData()<<"    "<<pChild->GetDegree()<<std::endl;
		std::cout<<pChild->IsLeaf()<<"    "<<pChild->IsBranch()<<"    "<<pChild->IsParent(pTreeNode)<<"    "<<pChild->IsParent(pTreeNode33)<<std::endl;
	}
	pChild = cTreeList.GetChildNodeRightAtNode(pTreeNode);
	if (NULL != pChild) {
		std::cout<<pChild->GetLevel()<<"    "<<pChild->GetData()<<"    "<<pChild->GetDegree()<<std::endl;
		std::cout<<pChild->IsLeaf()<<"    "<<pChild->IsBranch()<<"    "<<pChild->IsParent(pTreeNode)<<"    "<<pChild->IsParent(pTreeNode33)<<std::endl;
	}

	bEmpty = cTreeList.IsEmpty();
	std::cout<<bEmpty<<std::endl;
	dwDegree = cTreeList.GetDegree();
	std::cout<<dwDegree<<std::endl;
	dwHeight = cTreeList.GetHeight();
	std::cout<<dwHeight<<std::endl;
	dwNodesNum = cTreeList.GetNodesNum();
	std::cout<<dwNodesNum<<std::endl;

	AL_ListSingle<DWORD> cListSingle;
	DWORD dwData;
	BOOL bSibling = cTreeList.GetSiblingAtNode(cListSingle, pTreeNode);
	if (TRUE == bSibling) {
		for (DWORD dwCnt=0; dwCnt<cListSingle.Length(); dwCnt++) {
			if (TRUE == cListSingle.Get(dwData, dwCnt)) {
				std::cout<<dwData<<", ";
			}
		}	
		std::cout<<std::endl;
	}
	cListSingle.Clear();

	bSibling = cTreeList.GetSiblingAtNode(cListSingle, pTreeNode20);
	if (TRUE == bSibling) {
		for (DWORD dwCnt=0; dwCnt<cListSingle.Length(); dwCnt++) {
			if (TRUE == cListSingle.Get(dwData, dwCnt)) {
				std::cout<<dwData<<", ";
			}
		}	
		std::cout<<std::endl;
	}
	cListSingle.Clear();


	BOOL bAncestor = cTreeList.GetAncestorAtNode(cListSingle, pRootNode);
	if (TRUE == bAncestor) {
		for (DWORD dwCnt=0; dwCnt<cListSingle.Length(); dwCnt++) {
			if (TRUE == cListSingle.Get(dwData, dwCnt)) {
				std::cout<<dwData<<", ";
			}
		}	
		std::cout<<std::endl;
	}

	bAncestor = cTreeList.GetAncestorAtNode(cListSingle, pTreeNode33);
	if (TRUE == bAncestor) {
		for (DWORD dwCnt=0; dwCnt<cListSingle.Length(); dwCnt++) {
			if (TRUE == cListSingle.Get(dwData, dwCnt)) {
				std::cout<<dwData<<", ";
			}
		}	
		std::cout<<std::endl;
	}
	cListSingle.Clear();

	BOOL bDescendant = cTreeList.GetDescendantAtNode(cListSingle, pRootNode);
	if (TRUE == bDescendant) {
		for (DWORD dwCnt=0; dwCnt<cListSingle.Length(); dwCnt++) {
			if (TRUE == cListSingle.Get(dwData, dwCnt)) {
				std::cout<<dwData<<", ";
			}
		}	
		std::cout<<std::endl;
	}
	cListSingle.Clear();

	bDescendant = cTreeList.GetDescendantAtNode(cListSingle, pTreeNode33);
	if (TRUE == bDescendant) {
		for (DWORD dwCnt=0; dwCnt<cListSingle.Length(); dwCnt++) {
			if (TRUE == cListSingle.Get(dwData, dwCnt)) {
				std::cout<<dwData<<", ";
			}
		}	
		std::cout<<std::endl;
	}
	cListSingle.Clear();

	BOOL bOrder = cTreeList.LevelOrderTraversal(cListSingle);
	if (TRUE == bOrder) {
		for (DWORD dwCnt=0; dwCnt<cListSingle.Length(); dwCnt++) {
			if (TRUE == cListSingle.Get(dwData, dwCnt)) {
				std::cout<<dwData<<", ";
			}
		}	
		std::cout<<std::endl;
	}
	cListSingle.Clear();

#endif



评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值