treenode.cpp

我自己整理的一些VC源代码

	CPtrArray arTmp;
	CStack stack;

	if( m_pTreeNode )
	{
		pNode = m_pTreeNode;
		while( !stack.IsEmptyStack() || pNode )
		{
			if( pNode )
			{
				stack.PushTreeNode( pNode );
				arTmp.Add( pNode );
				pNode = pNode->LeftNode();
			}
			else
			{
				pNode = stack.PopTreeNode()->RightNode();
			}
		}

		nCount = arTmp.GetSize();
		for( int i = nCount - 1; i >= 0; i -- )
		{
			pNode = (CTreeNode *)arTmp.GetAt( i );
			delete pNode;
			arTmp.RemoveAt( i );
		}

		m_pTreeNode = NULL;
	}
}

void CTwoForkTree::ToTreeCtrl(CTreeCtrl *pTreeCtrl, long lSequence)
{
	int nCount = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	HTREEITEM hItem       = NULL;
	HTREEITEM hRoot       = NULL;
	CString strTmp;

	CStack stack;

	if( lSequence )
		pNode = FindChildFromSequence( lSequence );
	else
		pNode = m_pTreeNode;

	pTreeCtrl->DeleteAllItems();

	if( pNode )
	{
		while( !stack.IsEmptyStack() || pNode )
		{
			if( pNode )
			{
				hRoot = FindItemFromData( pTreeCtrl, pNode->m_lCharge );
				if( hRoot )
				{
					strTmp.Format( "%s(%d)", pNode->m_strName, DeptCount( pNode ) );
					hItem = pTreeCtrl->InsertItem( strTmp, 0, 0, hRoot );
					pTreeCtrl->SetItemData( hItem, pNode->m_lSequence );
				}
				else
				{
					strTmp.Format( "%s(%d)", pNode->m_strName, DeptCount( pNode ) );
					hItem = pTreeCtrl->InsertItem( strTmp, 0, 0 );
					pTreeCtrl->SetItemData( hItem, pNode->m_lSequence );
				}

				stack.PushTreeNode( pNode );
				pNode = pNode->LeftNode();
			}
			else
			{
				pNode = stack.PopTreeNode()->RightNode();
			}
		}

		ExpandAllItem( pTreeCtrl );
	}
}

HTREEITEM CTwoForkTree::FindItemFromData(CTreeCtrl *pTreeCtrl, DWORD dwData)
{
	BOOL bRet = FALSE;
	HTREEITEM hItem = NULL;
	HTREEITEM hTemp = NULL;
	HTREEITEM hRoot = pTreeCtrl->GetRootItem();
	CStack stack;

	if( hRoot )
	{
		while( !hItem && ( !stack.IsEmptyStack() || !bRet ) )
		{
			if( hRoot )
			{
				stack.PushTreeNode( (CTreeNode *)hRoot );
				if( dwData == pTreeCtrl->GetItemData( hRoot ) )
					hItem = hRoot;
				hRoot = pTreeCtrl->GetNextItem( hRoot, TVGN_CHILD );
				bRet = TRUE;
			}
			else
			{
				hTemp = (HTREEITEM)stack.PopTreeNode();
				hRoot = pTreeCtrl->GetParentItem( hTemp );
				if( hRoot ) hRoot = pTreeCtrl->GetNextItem( hTemp, TVGN_NEXT );
			}
		}
	}

	return hItem;
}

void CTwoForkTree::ExpandAllItem(CTreeCtrl *pTreeCtrl)
{
	BOOL bRet = FALSE;
	HTREEITEM hTemp = NULL;
	HTREEITEM hRoot = pTreeCtrl->GetRootItem();
	CStack stack;

	if( hRoot )
	{
		while( !stack.IsEmptyStack() || !bRet )
		{
			if( hRoot )
			{
				stack.PushTreeNode( (CTreeNode *)hRoot );
				pTreeCtrl->Expand( hRoot, TVE_EXPAND );
				hRoot = pTreeCtrl->GetNextItem( hRoot, TVGN_CHILD );
				bRet = TRUE;
			}
			else
			{
				hTemp = (HTREEITEM)stack.PopTreeNode();
				hRoot = pTreeCtrl->GetParentItem( hTemp );
				if( hRoot ) hRoot = pTreeCtrl->GetNextItem( hTemp, TVGN_NEXT );
			}
		}
	}
}

long CTwoForkTree::LeftDeptAccount(long lSequence, CString strStartDate, CString strEndDate)
{
	int nType = 0;
	long lRet = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	CStack stack;

	pNode = FindChildFromSequence( lSequence );
	if( pNode ) pNode = pNode->LeftNode();
	if( pNode )
	{
		lRet = pNode->m_lAdRate2;
		while( !stack.IsEmptyStack() || pNode )
		{
			if( pNode )
			{
				stack.PushTreeNode( pNode );
				if( pNode->m_strInDate.Compare( strStartDate ) >= 0 && pNode->m_strInDate.Compare( strEndDate ) <= 0 )	
				{
					nType = atoi( pNode->m_strGrade );
					if( nType == 1 ) lRet += 900;
					else if( nType == 2 ) lRet += 300;
					else if( nType == 3 ) lRet += 100;
				}
				pNode = pNode->LeftNode();
			}
			else
			{
				pNode = stack.PopTreeNode()->RightNode();
			}
		}
	}

	return lRet;
}

long CTwoForkTree::RightDeptAccount(long lSequence, CString strStartDate, CString strEndDate)
{
	int nType = 0;
	long lRet = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	CStack stack;

	pNode = FindChildFromSequence( lSequence );
	if( pNode ) pNode = pNode->RightNode();
	if( pNode )
	{
		lRet = pNode->m_lAdRate2;
		while( !stack.IsEmptyStack() || pNode )
		{
			if( pNode )
			{
				stack.PushTreeNode( pNode );
				if( pNode->m_strInDate.Compare( strStartDate ) >= 0 && pNode->m_strInDate.Compare( strEndDate ) <= 0 )	
				{
					nType = atoi( pNode->m_strGrade );
					if( nType == 1 ) lRet += 900;
					else if( nType == 2 ) lRet += 300;
					else if( nType == 3 ) lRet += 100;
				}
				pNode = pNode->LeftNode();
			}
			else
			{
				pNode = stack.PopTreeNode()->RightNode();
			}
		}
	}

	return lRet;
}

int CTwoForkTree::DeptCount(CTreeNode *pTreeNode)
{
	int nCount = 0;
	if( pTreeNode->LeftNode() ) nCount ++;
	if( pTreeNode->RightNode() ) nCount ++;
	return nCount;
}

long CTwoForkTree::LeftAgentCount(long lSequence)
{
	long lCount = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	CStack stack;

	pNode = FindChildFromSequence( lSequence );
	if( pNode )
	{
		pNode = pNode->LeftNode();
		while( !stack.IsEmptyStack() || pNode )
		{
			if( pNode )
			{
				stack.PushTreeNode( pNode );
				if( pNode->IsAgent() ) lCount ++;
				pNode = pNode->LeftNode();
			}
			else
			{
				pNode = stack.PopTreeNode()->RightNode();
			}
		}
	}

	return lCount;
}

long CTwoForkTree::RightAgentCount(long lSequence)
{
	long lCount = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	CStack stack;

	pNode = FindChildFromSequence( lSequence );
	if( pNode )
	{
		pNode = pNode->RightNode();
		while( !stack.IsEmptyStack() || pNode )
		{
			if( pNode )
			{
				stack.PushTreeNode( pNode );
				if( pNode->IsAgent() ) lCount ++;
				pNode = pNode->LeftNode();
			}
			else
			{
				pNode = stack.PopTreeNode()->RightNode();
			}
		}
	}

	return lCount;
}

void CTwoForkTree::ImportAgent( long lSequence, CTreeNode * pParentNode )
{
	char szSQL[ 255 ];
	CTreeNode * pTreeNode = NULL;
	CTabDL tabdl;

	try
	{
		sprintf( szSQL, "where dldlzg = %ld", lSequence );
		tabdl.Open( szSQL );
		while( tabdl.IsOpen() && !tabdl.IsEOF() && DeptCount( pParentNode ) < 2 )
		{
			pTreeNode = new CTreeNode;
			pTreeNode->m_lAdRate1		= 0;
			pTreeNode->m_lAdRate2		= 0;
			pTreeNode->m_lAgency		= atol( tabdl.DLDLCH.GetValue() );
			pTreeNode->m_lAgent			= atol( tabdl.DLDLID.GetValue() );
			pTreeNode->m_lCharge		= atol( tabdl.DLDLZG.GetValue() );
			pTreeNode->m_lIntro			= lSequence;
			pTreeNode->m_lSequence		= 0;
			pTreeNode->m_pLeftTreeNode	= NULL;
			pTreeNode->m_pRightTreeNode	= NULL;
			pTreeNode->m_pParentTreeNode= pParentNode;
			pTreeNode->m_strCode		= tabdl.DLDLBH.GetValue();
			pTreeNode->m_strGrade		= tabdl.DLDLJB.GetValue();
			pTreeNode->m_strInDate		= tabdl.DLJRRQ.GetValue();
			pTreeNode->m_strName		= tabdl.DLDLMC.GetValue();
			pTreeNode->m_strSequence	= tabdl.DLDLID.GetValue();
			if( !pParentNode->LeftNode() )
				pParentNode->m_pLeftTreeNode = pTreeNode;
			else if( !pParentNode->RightNode() )
				pParentNode->m_pRightTreeNode = pTreeNode;
			tabdl.MoveNext();
		}
	}
	catch( _com_error &e )
	{
		AfxMessageBox( e.ErrorMessage() );
	}
	catch( ... )
	{
	}
}

void CTwoForkTree::Contraction()	// 紧缩，将子树无代理商或只有一个代理商的结点清除
{
	int nLeftAgentCount		= 0;
	int nRightAgentCount	= 0;
	CTreeNode * pNode		= NULL;
	CTreeNode * pTreeNode	= NULL;
	StackNode * pStackNode	= NULL;
	CStack stack;

	if( m_pTreeNode )
	{
		// 后序遍历
		pNode = m_pTreeNode;
		while( !stack.IsEmptyStack() || pNode )
		{
			if( pNode )
			{
				pStackNode = new StackNode;
				pStackNode->nAccessCount = 0;
				pStackNode->pTreeNode = pNode;
				stack.Push( pStackNode );
				pNode = pNode->LeftNode();
			}
			else
			{
				pStackNode = (StackNode *)stack.Pop();
				pNode = pStackNode->pTreeNode;
				if( !pStackNode->nAccessCount )
				{
					pStackNode->nAccessCount = 1;
					stack.Push( pStackNode );
					pNode = pNode->RightNode();
				}
				else
				{
					delete pStackNode;
					// 先访问此结点再删除
					nLeftAgentCount  = LeftAgentCount( pNode );
					nRightAgentCount = RightAgentCount( pNode );
					if( !( nLeftAgentCount + nRightAgentCount ) )
					{
						// 如果一个结点代理商数为零，将其子树删除
						pNode->DeleteLeftChild();
						pNode->DeleteRightChild();
						// 且其自身也非代理商，则将其也删除
						if( !pNode->IsAgent() )
						{
							if( pNode->Position() < 0 )
							{
								if( pNode->ParentNode() ) pNode->ParentNode()->m_pLeftTreeNode = NULL;
							}
							else if( pNode->Position() > 0 )
							{
								if( pNode->ParentNode() ) pNode->ParentNode()->m_pRightTreeNode = NULL;
							}
							if( pNode != m_pTreeNode )
								delete pNode;
						}
						/*else if( pNode == m_pTreeNode ) // 如其为根结点，要将跟结点指针清空
						{
							m_pTreeNode = NULL;
							delete pNode;
						}*/
					}
					else if( !nLeftAgentCount )
					{
						// 如果其左子树代理商为0，删除左子树，右子树跟上父接点，并将其删除
						pNode->DeleteLeftChild();
						if( !pNode->IsAgent() )
						{
							if( pNode->ParentNode() && pNode->RightNode() )
							{
								if( pNode->Position() < 0 )	// 是左子树
								{
									pNode->ParentNode()->m_pLeftTreeNode  = pNode->RightNode();
									pNode->RightNode()->m_pParentTreeNode = pNode->ParentNode();
									pNode->RightNode()->m_lCharge		  = pNode->m_lCharge;
								}
								else if( pNode->Position() > 0 )	// 是右子树
								{
									pNode->ParentNode()->m_pRightTreeNode  = pNode->RightNode();
									pNode->RightNode()->m_pParentTreeNode  = pNode->ParentNode();
									pNode->RightNode()->m_lCharge		  = pNode->m_lCharge;
								}
							}
							//else if( !pNode->ParentNode() ) pNode->DeleteRightChild();	// 如没有父结点将其右子树也删除
							if( pNode != m_pTreeNode )
								delete pNode;
						}
					}
					else if( !nRightAgentCount )
					{
						// 如果其右子树代理商为0，删除右子树，左子树跟上父接点，并将其删除
						pNode->DeleteRightChild();
						if( !pNode->IsAgent() )
						{
							if( pNode->ParentNode() && pNode->LeftNode() )
							{
								if( pNode->Position() < 0 )	// 是左子树
								{
									pNode->ParentNode()->m_pLeftTreeNode  = pNode->LeftNode();
									pNode->LeftNode()->m_pParentTreeNode  = pNode->ParentNode();
									pNode->LeftNode()->m_lCharge		  = pNode->m_lCharge;
								}
								else if( pNode->Position() > 0 )	// 是右子树
								{
									pNode->ParentNode()->m_pRightTreeNode  = pNode->LeftNode();
									pNode->LeftNode()->m_pParentTreeNode   = pNode->ParentNode();
									pNode->LeftNode()->m_lCharge		   = pNode->m_lCharge;
								}
							}
							//else if( !pNode->ParentNode() ) pNode->DeleteLeftChild();	// 如没有父结点将其左子树也删除
							if( pNode != m_pTreeNode )
								delete pNode;
						}
					}
					pNode = NULL;
				}
			}
		}
	}
}

long CTwoForkTree::LeftAgentCount(CTreeNode *pTreeNode)
{
	long lCount = 0;
	CTreeNode * pNode     = NULL;
	CStack stack;

	pNode = pTreeNode->LeftNode();
	if( pNode )
	{
		while( !stack.IsEmptyStack() || pNode )
		{
			if( pNode )
			{
				stack.PushTreeNode( pNode );
				if( pNode->IsAgent() ) lCount ++;
				pNode = pNode->LeftNode();
			}
			else
			{
				pNode = stack.PopTreeNode()->RightNode();
			}
		}
	}

	return lCount;
}

long CTwoForkTree::RightAgentCount(CTreeNode *pTreeNode)
{
	long lCount = 0;
	CTreeNode * pNode     = NULL;
	CStack stack;