treenode.cpp

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

// TreeNode.cpp: implementation of the CTreeNode class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SellMan.h"
#include "TreeNode.h"

#include "TabXC.h"
#include "TabCS.h"
#include "TabDL.h"
#include "TabSP.h"
#include "TabYJ.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

extern _ConnectionPtr connection;
extern BOOL bConnected;

CTreeNode::CTreeNode()
{
	m_pParentTreeNode = NULL;
	m_pLeftTreeNode   = NULL;
	m_pRightTreeNode = NULL;

	m_lSequence	= 0;
	m_lIntro	= 0;
	m_lCharge	= 0;
	m_lAgent	= 0;
}

CTreeNode::~CTreeNode()
{

}

CTreeNode * CTreeNode::LeftNode()
{
	return m_pLeftTreeNode;
}

CTreeNode * CTreeNode::RightNode()
{
	return m_pRightTreeNode;
}

CTreeNode * CTreeNode::ParentNode()
{
	return m_pParentTreeNode;
}

long CTreeNode::IsAgent()
{
	return m_lAgent;
}

long CTreeNode::IsPlugger()
{
	return m_lSequence;
}

short CTreeNode::Position()
{
	CTreeNode * pLeftNode  = NULL;
	CTreeNode * pRightNode = NULL;
	if( m_pParentTreeNode )
	{
		if( this == m_pParentTreeNode->LeftNode() ) return -1;
		else return 1;
	}
	else return 0;
}

void CTreeNode::DeleteLeftChild()
{
	int nCount = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;

	CPtrArray arTmp;
	CStack stack;

	if( m_pLeftTreeNode )
	{
		pNode = m_pLeftTreeNode;
		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_pLeftTreeNode = NULL;
	}
}

void CTreeNode::DeleteRightChild()
{
	int nCount = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;

	CPtrArray arTmp;
	CStack stack;

	if( m_pRightTreeNode )
	{
		pNode = m_pRightTreeNode;
		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_pRightTreeNode = NULL;
	}
}

///////////////      CStack     /////////////////
CStack::CStack()
{
}

CStack::~CStack()
{
}

long CStack::Push(void *pPointer)
{
	if( pPointer ) m_arStack.Add( pPointer );

	return m_arStack.GetSize();
}

void * CStack::Pop()
{
	long lCount = 0;
	void * pPointer = NULL;

	lCount = m_arStack.GetSize();
	if( lCount > 0 )
	{
		pPointer = m_arStack.GetAt( lCount - 1 );
		m_arStack.RemoveAt( lCount - 1 );
	}

	return pPointer;
}

long CStack::PushTreeNode(CTreeNode *pTreeNode)
{
	if( pTreeNode ) m_arStack.Add( pTreeNode );

	return m_arStack.GetSize() - 1;
}

CTreeNode * CStack::PopTreeNode()
{
	long lCount = 0;
	CTreeNode * pTreeNode = NULL;

	lCount = m_arStack.GetSize();
	if( lCount > 0 )
	{
		pTreeNode = (CTreeNode *)m_arStack.GetAt( lCount - 1 );
		m_arStack.RemoveAt( lCount - 1 );
	}

	return pTreeNode;
}

void CStack::ClearStack()
{
	m_arStack.RemoveAll();
}

BOOL CStack::IsEmptyStack()
{
	return !m_arStack.GetSize();
}

///////////////   CTwoForkTree  /////////////////
CTwoForkTree::CTwoForkTree()
{
	m_pTreeNode = NULL;
	m_nCompanyRetail = 0;
}

CTwoForkTree::~CTwoForkTree()
{
	RemoveAll();
	m_pTreeNode = NULL;
}

CTreeNode * CTwoForkTree::GetRootNode()
{
	return m_pTreeNode;
}

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

	if( m_pTreeNode )
	{
		pNode = m_pTreeNode;
		while( !pTreeNode && (!stack.IsEmptyStack() || pNode) )
		{
			if( pNode )
			{
				stack.PushTreeNode( pNode );
				if( pNode->m_lSequence == lSequence )
					pTreeNode = pNode;
				pNode = pNode->LeftNode();
			}
			else
			{
				pNode = stack.PopTreeNode()->RightNode();
			}
		}
	}

	return pTreeNode;
}

CTreeNode * CTwoForkTree::FindChildFromSequence( long lSequence, CTreeNode * pSourceNode )
{
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	CStack stack;

	if( pSourceNode )
	{
		pNode = pSourceNode;
		while( !pTreeNode && (!stack.IsEmptyStack() || pNode) )
		{
			if( pNode )
			{
				stack.PushTreeNode( pNode );
				if( pNode->m_lSequence == lSequence )
					pTreeNode = pNode;
				pNode = pNode->LeftNode();
			}
			else
			{
				pNode = stack.PopTreeNode()->RightNode();
			}
		}
	}

	return pTreeNode;
}

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

	if( m_pTreeNode )
	{
		pNode = m_pTreeNode->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 lCount = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	CStack stack;

	if( m_pTreeNode )
	{
		pNode = m_pTreeNode->RightNode();
		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::NodeCount()
{
	long lCount = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	CStack stack;

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

	return lCount;
}

void CTwoForkTree::ImportPlugger( BOOL bImportAgent )
{
	CTabXC tabxc;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	CStack stack;

	try
	{
		tabxc.Open( "order by xcygid" );
		while( tabxc.IsOpen() && !tabxc.IsEOF() )
		{
			pTreeNode = new CTreeNode;
			pTreeNode->m_lSequence		= atol( tabxc.XCYGID.GetValue() );
			pTreeNode->m_strSequence	= tabxc.XCYGID.GetValue();
			pTreeNode->m_strCode		= tabxc.XCYGBH.GetValue();
			pTreeNode->m_strName		= tabxc.XCYGMC.GetValue();
			pTreeNode->m_strGrade		= tabxc.XCTZKH.GetValue();
			pTreeNode->m_strInDate		= tabxc.XCJRRQ.GetValue();
			pTreeNode->m_lIntro			= atol( tabxc.XCTJRH.GetValue() );
			pTreeNode->m_lCharge		= atol( tabxc.XCYGZG.GetValue() );
			pTreeNode->m_lAgent			= atol( tabxc.XCDLMC.GetValue() );
			pTreeNode->m_lAgency		= atol( tabxc.XCDLCH.GetValue() );
			pTreeNode->m_lAdRate1		= atol( tabxc.XCYBYE.GetValue() );
			pTreeNode->m_lAdRate2		= atol( tabxc.XCEBYE.GetValue() );
			if( bImportAgent ) ImportAgent( pTreeNode->m_lSequence, pTreeNode );

			// 根据 ID 在推栈中找到结点
			pNode = FindNodeInStackFromSeq( pTreeNode->m_lCharge, stack );
			if( pNode )
			{
				// 找到相应的结点
				if( !pNode->LeftNode() )
				{
					// 没有左子树，将新建结点插入左子树
					pNode->m_pLeftTreeNode		 = pTreeNode;
					pTreeNode->m_pParentTreeNode = pNode;
				}
				else if( !pNode->RightNode() )
				{
					// 有左子树，将新建结点插入右子树
					pNode->m_pRightTreeNode	 = pTreeNode;
					pTreeNode->m_pParentTreeNode = pNode;
				}
				else delete pTreeNode;
			}
			else
			{
				// 找不到，将新建结点压栈
				stack.PushTreeNode( pTreeNode );
			}

			tabxc.MoveNext();
		}

		while( !stack.IsEmptyStack() )
		{
			pTreeNode = stack.PopTreeNode();
			pNode = FindNodeInStackFromSeq( pTreeNode->m_lCharge, stack );
			if( pNode )
			{
				if( pNode->LeftNode() )
				{
					pNode->m_pRightTreeNode = pTreeNode;
					pTreeNode->m_pParentTreeNode = pNode;
				}
				else
				{
					pNode->m_pLeftTreeNode = pTreeNode;
					pTreeNode->m_pParentTreeNode = pNode;
				}
			}
			else m_pTreeNode = pTreeNode;
		}
	}
	catch( _com_error &e )
	{
		AfxMessageBox( e.ErrorMessage() );
	}
	catch( ... )
	{
	}
}

CTreeNode * CTwoForkTree::FindNodeInStackFromSeq(long lSequence, CStack& stack)
{
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;
	int nCount = stack.m_arStack.GetSize();

	for( int i = 0; i < nCount && !pTreeNode; i ++ )
	{
		pNode     = (CTreeNode *)stack.m_arStack.GetAt( i );
		pTreeNode = FindChildFromSequence( lSequence, pNode );
	}

	return pTreeNode;
}

void CTwoForkTree::RemoveAll()
{
	int nCount = 0;
	CTreeNode * pNode     = NULL;
	CTreeNode * pTreeNode = NULL;