本文整理汇总了C++中Tree::GetNodeCount方法的典型用法代码示例。如果您正苦于以下问题:C++ Tree::GetNodeCount方法的具体用法?C++ Tree::GetNodeCount怎么用?C++ Tree::GetNodeCount使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类Tree
的用法示例。
在下文中一共展示了Tree::GetNodeCount方法的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: ClusterByHeight
void ClusterByHeight(const Tree &tree, double dMaxHeight, unsigned Subtrees[],
unsigned *ptruSubtreeCount)
{
if (!tree.IsRooted())
Quit("ClusterByHeight: requires rooted tree");
#if TRACE
Log("ClusterByHeight, max height=%g\n", dMaxHeight);
#endif
unsigned uSubtreeCount = 0;
const unsigned uNodeCount = tree.GetNodeCount();
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
if (tree.IsRoot(uNodeIndex))
continue;
unsigned uParent = tree.GetParent(uNodeIndex);
double dHeight = tree.GetNodeHeight(uNodeIndex);
double dParentHeight = tree.GetNodeHeight(uParent);
#if TRACE
Log("Node %3u Height %5.2f ParentHeight %5.2f\n",
uNodeIndex, dHeight, dParentHeight);
#endif
if (dParentHeight > dMaxHeight && dHeight <= dMaxHeight)
{
Subtrees[uSubtreeCount] = uNodeIndex;
#if TRACE
Log("Subtree[%u]=%u\n", uSubtreeCount, uNodeIndex);
#endif
++uSubtreeCount;
}
}
*ptruSubtreeCount = uSubtreeCount;
}
示例2: PhyEnumEdges
// Return false when done
bool PhyEnumEdges(const Tree &tree, PhyEnumEdgeState &ES)
{
unsigned uNode1 = uInsane;
if (!ES.m_bInit)
{
if (tree.GetNodeCount() <= 1)
{
ES.m_uNodeIndex1 = NULL_NEIGHBOR;
ES.m_uNodeIndex2 = NULL_NEIGHBOR;
return false;
}
uNode1 = tree.FirstDepthFirstNode();
ES.m_bInit = true;
}
else
{
uNode1 = tree.NextDepthFirstNode(ES.m_uNodeIndex1);
if (NULL_NEIGHBOR == uNode1)
return false;
if (tree.IsRooted() && tree.IsRoot(uNode1))
{
uNode1 = tree.NextDepthFirstNode(uNode1);
if (NULL_NEIGHBOR == uNode1)
return false;
}
}
unsigned uNode2 = tree.GetParent(uNode1);
ES.m_uNodeIndex1 = uNode1;
ES.m_uNodeIndex2 = uNode2;
return true;
}
示例3: ClusterBySubfamCount
// Divide a tree containing N leaves into k families by
// cutting the tree at a horizontal line at some height.
// Each internal node defines a height for the cut,
// considering all internal nodes enumerates all distinct
// cuts. Visit internal nodes in decreasing order of height.
// Visiting the node corresponds to moving the horizontal
// line down to cut the tree at the height of that node.
// We consider the cut to be "infinitestimally below"
// the node, so the effect is to remove the current node
// from the list of subfamilies and add its two children.
// We must visit a parent before its children (so care may
// be needed to handle zero edge lengths properly).
// We assume that N is small, and write dumb O(N^2) code.
// More efficient strategies are possible for large N
// by maintaining a list of nodes sorted by height.
void ClusterBySubfamCount(const Tree &tree, unsigned uSubfamCount,
unsigned Subfams[], unsigned *ptruSubfamCount)
{
const unsigned uNodeCount = tree.GetNodeCount();
const unsigned uLeafCount = (uNodeCount + 1)/2;
// Special case: empty tree
if (0 == uNodeCount)
{
*ptruSubfamCount = 0;
return;
}
// Special case: more subfamilies than leaves
if (uSubfamCount >= uLeafCount)
{
for (unsigned n = 0; n < uLeafCount; ++n)
Subfams[n] = n;
*ptruSubfamCount = uLeafCount;
return;
}
// Initialize list of subfamilies to be root
Subfams[0] = tree.GetRootNodeIndex();
// Iterate
for (unsigned i = 1; i < uSubfamCount; ++i)
ClusterBySubfamCount_Iteration(tree, Subfams, i);
*ptruSubfamCount = uSubfamCount;
}
示例4: RefineTreeE
void RefineTreeE(MSA &msa, const SeqVect &v, Tree &tree, ProgNode *ProgNodes)
{
MuscleContext *ctx = getMuscleContext();
const unsigned uSeqCount = msa.GetSeqCount();
if (tree.GetLeafCount() != uSeqCount)
Quit("Refine tree, tree has different number of nodes");
if (uSeqCount < 3)
return;
#if DEBUG
ValidateMuscleIds(msa);
ValidateMuscleIds(tree);
#endif
const unsigned uNodeCount = tree.GetNodeCount();
unsigned *uNewNodeIndexToOldNodeIndex= new unsigned[uNodeCount];
Tree Tree2;
TreeFromMSA(msa, Tree2, ctx->params.g_Cluster2, ctx->params.g_Distance2, ctx->params.g_Root2, ctx->params.g_pstrDistMxFileName2);
#if DEBUG
ValidateMuscleIds(Tree2);
#endif
DiffTreesE(Tree2, tree, uNewNodeIndexToOldNodeIndex);
unsigned uRoot = Tree2.GetRootNodeIndex();
if (NODE_CHANGED == uNewNodeIndexToOldNodeIndex[uRoot])
{
MSA msa2;
RealignDiffsE(msa, v, Tree2, tree, uNewNodeIndexToOldNodeIndex, msa2, ProgNodes);
if (!ctx->isCanceled()) {
tree.Copy(Tree2);
msa.Copy(msa2);
#if DEBUG
ValidateMuscleIds(msa2);
#endif
}
}
delete[] uNewNodeIndexToOldNodeIndex;
if (ctx->isCanceled()) {
throw MuscleException("Canceled");
}
SetCurrentAlignment(msa);
ProgressStepsDone();
}
示例5: LogLeafNames
static void LogLeafNames(const Tree &tree, unsigned uNodeIndex)
{
const unsigned uNodeCount = tree.GetNodeCount();
unsigned *Leaves = new unsigned[uNodeCount];
unsigned uLeafCount;
GetLeaves(tree, uNodeIndex, Leaves, &uLeafCount);
for (unsigned i = 0; i < uLeafCount; ++i)
{
if (i > 0)
Log(",");
Log("%s", tree.GetLeafName(Leaves[i]));
}
delete[] Leaves;
}
示例6: GetInternalNodesInHeightOrder
void GetInternalNodesInHeightOrder(const Tree &tree, unsigned NodeIndexes[])
{
const unsigned uNodeCount = tree.GetNodeCount();
if (uNodeCount < 3)
Quit("GetInternalNodesInHeightOrder: %u nodes, none are internal",
uNodeCount);
const unsigned uInternalNodeCount = (uNodeCount - 1)/2;
double *Heights = new double[uInternalNodeCount];
unsigned uIndex = 0;
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
if (tree.IsLeaf(uNodeIndex))
continue;
NodeIndexes[uIndex] = uNodeIndex;
Heights[uIndex] = tree.GetNodeHeight(uNodeIndex);
++uIndex;
}
if (uIndex != uInternalNodeCount)
Quit("Internal error: GetInternalNodesInHeightOrder");
// Simple but slow bubble sort (probably don't care about speed here)
bool bDone = false;
while (!bDone)
{
bDone = true;
for (unsigned i = 0; i < uInternalNodeCount - 1; ++i)
{
if (Heights[i] > Heights[i+1])
{
double dTmp = Heights[i];
Heights[i] = Heights[i+1];
Heights[i+1] = dTmp;
unsigned uTmp = NodeIndexes[i];
NodeIndexes[i] = NodeIndexes[i+1];
NodeIndexes[i+1] = uTmp;
bDone = false;
}
}
}
#if TRACE
Log("Internal node index Height\n");
Log("------------------- --------\n");
// 1234567890123456789 123456789
for (unsigned n = 0; n < uInternalNodeCount; ++n)
Log("%19u %9.3f\n", NodeIndexes[n], Heights[n]);
#endif
delete[] Heights;
}
示例7: GetSubfams
// Identify subfamilies in a tree.
// Returns array of internal node indexes, one for each subfamily.
// First try is to select groups by height (which should approximate
// minimum percent identity), if this gives too many subfamilies then
// we cut at a point that gives the maximum allowed number of subfams.
static void GetSubfams(const Tree &tree, double dMaxHeight,
unsigned uMaxSubfamCount, unsigned **ptrptrSubfams, unsigned *ptruSubfamCount)
{
const unsigned uNodeCount = tree.GetNodeCount();
unsigned *Subfams = new unsigned[uNodeCount];
unsigned uSubfamCount;
ClusterByHeight(tree, dMaxHeight, Subfams, &uSubfamCount);
if (uSubfamCount > uMaxSubfamCount)
ClusterBySubfamCount(tree, uMaxSubfamCount, Subfams, &uSubfamCount);
*ptrptrSubfams = Subfams;
*ptruSubfamCount = uSubfamCount;
}
示例8: ApplyMinEdgeLength
void ApplyMinEdgeLength(Tree &tree, double dMinEdgeLength)
{
const unsigned uNodeCount = tree.GetNodeCount();
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
const unsigned uNeighborCount = tree.GetNeighborCount(uNodeIndex);
for (unsigned n = 0; n < uNeighborCount; ++n)
{
const unsigned uNeighborNodeIndex = tree.GetNeighbor(uNodeIndex, n);
if (!tree.HasEdgeLength(uNodeIndex, uNeighborNodeIndex))
continue;
if (tree.GetEdgeLength(uNodeIndex, uNeighborNodeIndex) < dMinEdgeLength)
tree.SetEdgeLength(uNodeIndex, uNeighborNodeIndex, dMinEdgeLength);
}
}
}
示例9: LogSubfams
static void LogSubfams(const Tree &tree, const unsigned Subfams[],
unsigned uSubfamCount)
{
const unsigned uNodeCount = tree.GetNodeCount();
Log("%u subfamilies found\n", uSubfamCount);
Log("Subfam Sequence\n");
Log("------ --------\n");
unsigned *Leaves = new unsigned[uNodeCount];
for (unsigned uSubfamIndex = 0; uSubfamIndex < uSubfamCount; ++uSubfamIndex)
{
unsigned uSubfamNodeIndex = Subfams[uSubfamIndex];
unsigned uLeafCount;
GetLeaves(tree, uSubfamNodeIndex, Leaves, &uLeafCount);
for (unsigned uLeafIndex = 0; uLeafIndex < uLeafCount; ++uLeafIndex)
Log("%6u %s\n", uSubfamIndex + 1, tree.GetLeafName(Leaves[uLeafIndex]));
Log("\n");
}
delete[] Leaves;
}
示例10: GetNextNodeIndex
static unsigned GetNextNodeIndex(const Tree &tree, unsigned uPrevNodeIndex)
{
if (g_bStable)
{
const unsigned uNodeCount = tree.GetNodeCount();
unsigned uNodeIndex = uPrevNodeIndex;
for (;;)
{
++uNodeIndex;
if (uNodeIndex >= uNodeCount)
return NULL_NEIGHBOR;
if (tree.IsLeaf(uNodeIndex))
return uNodeIndex;
}
}
unsigned uNodeIndex = uPrevNodeIndex;
for (;;)
{
uNodeIndex = tree.NextDepthFirstNode(uNodeIndex);
if (NULL_NEIGHBOR == uNodeIndex || tree.IsLeaf(uNodeIndex))
return uNodeIndex;
}
}
示例11: TestBiPart
void TestBiPart()
{
SetListFileName("c:\\tmp\\lobster.log", false);
Tree tree;
TextFile fileIn("c:\\tmp\\test.phy");
tree.FromFile(fileIn);
tree.LogMe();
const unsigned uNodeCount = tree.GetNodeCount();
unsigned *Leaves1 = new unsigned[uNodeCount];
unsigned *Leaves2 = new unsigned[uNodeCount];
PhyEnumEdgeState ES;
bool bDone = false;
for (;;)
{
unsigned uCount1 = uInsane;
unsigned uCount2 = uInsane;
bool bOk = PhyEnumBiParts(tree, ES, Leaves1, &uCount1, Leaves2, &uCount2);
Log("PEBP=%d ES.Init=%d ES.ni1=%d ES.ni2=%d\n",
bOk,
ES.m_bInit,
ES.m_uNodeIndex1,
ES.m_uNodeIndex2);
if (!bOk)
break;
Log("\n");
Log("Part1: ");
for (unsigned n = 0; n < uCount1; ++n)
Log(" %d(%s)", Leaves1[n], tree.GetLeafName(Leaves1[n]));
Log("\n");
Log("Part2: ");
for (unsigned n = 0; n < uCount2; ++n)
Log(" %d(%s)", Leaves2[n], tree.GetLeafName(Leaves2[n]));
Log("\n");
}
}
示例12: CalcClustalWWeights
void CalcClustalWWeights(const Tree &tree, WEIGHT Weights[])
{
#if TRACE
Log("CalcClustalWWeights\n");
tree.LogMe();
#endif
const unsigned uLeafCount = tree.GetLeafCount();
if (0 == uLeafCount)
return;
else if (1 == uLeafCount)
{
Weights[0] = (WEIGHT) 1.0;
return;
}
else if (2 == uLeafCount)
{
Weights[0] = (WEIGHT) 0.5;
Weights[1] = (WEIGHT) 0.5;
return;
}
if (!tree.IsRooted())
Quit("CalcClustalWWeights requires rooted tree");
const unsigned uNodeCount = tree.GetNodeCount();
unsigned *LeavesUnderNode = new unsigned[uNodeCount];
memset(LeavesUnderNode, 0, uNodeCount*sizeof(unsigned));
const unsigned uRootNodeIndex = tree.GetRootNodeIndex();
unsigned uLeavesUnderRoot = CountLeaves(tree, uRootNodeIndex, LeavesUnderNode);
if (uLeavesUnderRoot != uLeafCount)
Quit("WeightsFromTreee: Internal error, root count %u %u",
uLeavesUnderRoot, uLeafCount);
#if TRACE
Log("Node Leaves Length Strength\n");
Log("---- ------ -------- --------\n");
// 1234 123456 12345678 12345678
#endif
double *Strengths = new double[uNodeCount];
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
if (tree.IsRoot(uNodeIndex))
{
Strengths[uNodeIndex] = 0.0;
continue;
}
const unsigned uParent = tree.GetParent(uNodeIndex);
const double dLength = tree.GetEdgeLength(uNodeIndex, uParent);
const unsigned uLeaves = LeavesUnderNode[uNodeIndex];
const double dStrength = dLength / (double) uLeaves;
Strengths[uNodeIndex] = dStrength;
#if TRACE
Log("%4u %6u %8g %8g\n", uNodeIndex, uLeaves, dLength, dStrength);
#endif
}
#if TRACE
Log("\n");
Log(" Seq Path..Weight\n");
Log("-------------------- ------------\n");
#endif
for (unsigned n = 0; n < uLeafCount; ++n)
{
const unsigned uLeafNodeIndex = tree.LeafIndexToNodeIndex(n);
#if TRACE
Log("%20.20s %4u ", tree.GetLeafName(uLeafNodeIndex), uLeafNodeIndex);
#endif
if (!tree.IsLeaf(uLeafNodeIndex))
Quit("CalcClustalWWeights: leaf");
double dWeight = 0;
unsigned uNode = uLeafNodeIndex;
while (!tree.IsRoot(uNode))
{
dWeight += Strengths[uNode];
uNode = tree.GetParent(uNode);
#if TRACE
Log("->%u(%g)", uNode, Strengths[uNode]);
#endif
}
if (dWeight < 0.0001)
{
#if TRACE
Log("zero->one");
#endif
dWeight = 1.0;
}
Weights[n] = (WEIGHT) dWeight;
#if TRACE
Log(" = %g\n", dWeight);
#endif
}
delete[] Strengths;
delete[] LeavesUnderNode;
Normalize(Weights, uLeafCount);
//.........这里部分代码省略.........
示例13: DiffTrees
void DiffTrees(const Tree &Tree1, const Tree &Tree2, Tree &Diffs,
unsigned IdToDiffsLeafNodeIndex[])
{
#if TRACE
Log("Tree1:\n");
Tree1.LogMe();
Log("\n");
Log("Tree2:\n");
Tree2.LogMe();
#endif
if (!Tree1.IsRooted() || !Tree2.IsRooted())
Quit("DiffTrees: requires rooted trees");
const unsigned uNodeCount = Tree1.GetNodeCount();
const unsigned uNodeCount2 = Tree2.GetNodeCount();
const unsigned uLeafCount = Tree1.GetLeafCount();
const unsigned uLeafCount2 = Tree2.GetLeafCount();
assert(uLeafCount == uLeafCount2);
if (uNodeCount != uNodeCount2)
Quit("DiffTrees: different node counts");
// Allocate tables so we can convert tree node index to
// and from the unique id with a O(1) lookup.
unsigned *NodeIndexToId1 = new unsigned[uNodeCount];
unsigned *IdToNodeIndex2 = new unsigned[uNodeCount];
bool *bIsBachelor1 = new bool[uNodeCount];
bool *bIsDiff1 = new bool[uNodeCount];
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
NodeIndexToId1[uNodeIndex] = uNodeCount;
bIsBachelor1[uNodeIndex] = false;
bIsDiff1[uNodeIndex] = false;
// Use uNodeCount as value meaning "not set".
IdToNodeIndex2[uNodeIndex] = uNodeCount;
}
// Initialize node index <-> id lookup tables
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
if (Tree1.IsLeaf(uNodeIndex))
{
const unsigned uId = Tree1.GetLeafId(uNodeIndex);
if (uId >= uNodeCount)
Quit("Diff trees requires existing leaf ids in range 0 .. (N-1)");
NodeIndexToId1[uNodeIndex] = uId;
}
if (Tree2.IsLeaf(uNodeIndex))
{
const unsigned uId = Tree2.GetLeafId(uNodeIndex);
if (uId >= uNodeCount)
Quit("Diff trees requires existing leaf ids in range 0 .. (N-1)");
IdToNodeIndex2[uId] = uNodeIndex;
}
}
// Validity check. This verifies that the ids
// pre-assigned to the leaves in Tree1 are unique
// (note that the id<N check above does not rule
// out two leaves having duplicate ids).
for (unsigned uId = 0; uId < uLeafCount; ++uId)
{
unsigned uNodeIndex2 = IdToNodeIndex2[uId];
if (uNodeCount == uNodeIndex2)
Quit("DiffTrees, check 2");
}
// Ids assigned to internal nodes are N, N+1 ...
// An internal node id uniquely identifies a set
// of two or more leaves.
unsigned uInternalNodeId = uLeafCount;
// Depth-first traversal of tree.
// The order guarantees that a node is visited before
// its parent is visited.
for (unsigned uNodeIndex1 = Tree1.FirstDepthFirstNode();
NULL_NEIGHBOR != uNodeIndex1;
uNodeIndex1 = Tree1.NextDepthFirstNode(uNodeIndex1))
{
#if TRACE
Log("Main loop: Node1=%u IsLeaf=%d IsBachelor=%d\n",
uNodeIndex1,
Tree1.IsLeaf(uNodeIndex1),
bIsBachelor1[uNodeIndex1]);
#endif
// Leaves are trivial; nothing to do.
if (Tree1.IsLeaf(uNodeIndex1) || bIsBachelor1[uNodeIndex1])
continue;
// If either child is a bachelor, flag
// this node as a bachelor and continue.
unsigned uLeft1 = Tree1.GetLeft(uNodeIndex1);
if (bIsBachelor1[uLeft1])
//.........这里部分代码省略.........
示例14: DoMuscle
//.........这里部分代码省略.........
v.SetSeqId(uSeqIndex, uSeqIndex);
if (0 == uSeqCount)
Quit("Input file '%s' has no sequences", g_pstrInFileName.get());
if (1 == uSeqCount)
{
TextFile fileOut(g_pstrOutFileName.get(), true);
v.ToFile(fileOut);
return;
}
if (uSeqCount > 1)
MHackStart(v);
// First iteration
Tree GuideTree;
if (0 != g_pstrUseTreeFileName.get())
{
// Discourage users...
if (!g_bUseTreeNoWarn.get())
fprintf(stderr, g_strUseTreeWarning);
// Read tree from file
TextFile TreeFile(g_pstrUseTreeFileName.get());
GuideTree.FromFile(TreeFile);
// Make sure tree is rooted
if (!GuideTree.IsRooted())
Quit("User tree must be rooted");
if (GuideTree.GetLeafCount() != uSeqCount)
Quit("User tree does not match input sequences");
const unsigned uNodeCount = GuideTree.GetNodeCount();
for (unsigned uNodeIndex = 0; uNodeIndex < uNodeCount; ++uNodeIndex)
{
if (!GuideTree.IsLeaf(uNodeIndex))
continue;
const char *LeafName = GuideTree.GetLeafName(uNodeIndex);
unsigned uSeqIndex;
bool SeqFound = v.FindName(LeafName, &uSeqIndex);
if (!SeqFound)
Quit("Label %s in tree does not match sequences", LeafName);
unsigned uId = v.GetSeqIdFromName(LeafName);
GuideTree.SetLeafId(uNodeIndex, uId);
}
}
else
TreeFromSeqVect(v, GuideTree, g_Cluster1.get(), g_Distance1.get(), g_Root1.get(),
g_pstrDistMxFileName1.get());
const char *Tree1 = ValueOpt("Tree1");
if (0 != Tree1)
{
TextFile f(Tree1, true);
GuideTree.ToFile(f);
if (g_bClusterOnly.get())
return;
}
SetMuscleTree(GuideTree);
ValidateMuscleIds(GuideTree);
MSA msa;
ProgNode *ProgNodes = 0;
if (g_bLow.get())
示例15: DiffTreesE
void DiffTreesE(const Tree &NewTree, const Tree &OldTree,
unsigned NewNodeIndexToOldNodeIndex[])
{
#if TRACE
Log("DiffTreesE NewTree:\n");
NewTree.LogMe();
Log("\n");
Log("OldTree:\n");
OldTree.LogMe();
#endif
if (!NewTree.IsRooted() || !OldTree.IsRooted())
Quit("DiffTrees: requires rooted trees");
const unsigned uNodeCount = NewTree.GetNodeCount();
const unsigned uOldNodeCount = OldTree.GetNodeCount();
const unsigned uLeafCount = NewTree.GetLeafCount();
const unsigned uOldLeafCount = OldTree.GetLeafCount();
if (uNodeCount != uOldNodeCount || uLeafCount != uOldLeafCount)
Quit("DiffTreesE: different node counts");
{
unsigned *IdToOldNodeIndex = new unsigned[uNodeCount];
for (unsigned uOldNodeIndex = 0; uOldNodeIndex < uNodeCount; ++uOldNodeIndex)
{
if (OldTree.IsLeaf(uOldNodeIndex))
{
unsigned Id = OldTree.GetLeafId(uOldNodeIndex);
IdToOldNodeIndex[Id] = uOldNodeIndex;
}
}
// Initialize NewNodeIndexToOldNodeIndex[]
// All internal nodes are marked as changed, but may be updated later.
for (unsigned uNewNodeIndex = 0; uNewNodeIndex < uNodeCount; ++uNewNodeIndex)
{
if (NewTree.IsLeaf(uNewNodeIndex))
{
unsigned uId = NewTree.GetLeafId(uNewNodeIndex);
assert(uId < uLeafCount);
unsigned uOldNodeIndex = IdToOldNodeIndex[uId];
assert(uOldNodeIndex < uNodeCount);
NewNodeIndexToOldNodeIndex[uNewNodeIndex] = uOldNodeIndex;
}
else
NewNodeIndexToOldNodeIndex[uNewNodeIndex] = NODE_CHANGED;
}
delete[] IdToOldNodeIndex;
}
// Depth-first traversal of tree.
// The order guarantees that a node is visited before
// its parent is visited.
for (unsigned uNewNodeIndex = NewTree.FirstDepthFirstNode();
NULL_NEIGHBOR != uNewNodeIndex;
uNewNodeIndex = NewTree.NextDepthFirstNode(uNewNodeIndex))
{
if (NewTree.IsLeaf(uNewNodeIndex))
continue;
// If either child is changed, flag this node as changed and continue.
unsigned uNewLeft = NewTree.GetLeft(uNewNodeIndex);
unsigned uOldLeft = NewNodeIndexToOldNodeIndex[uNewLeft];
if (NODE_CHANGED == uOldLeft)
{
NewNodeIndexToOldNodeIndex[uNewLeft] = NODE_CHANGED;
continue;
}
unsigned uNewRight = NewTree.GetRight(uNewNodeIndex);
unsigned uOldRight = NewNodeIndexToOldNodeIndex[uNewRight];
if (NODE_CHANGED == NewNodeIndexToOldNodeIndex[uNewRight])
{
NewNodeIndexToOldNodeIndex[uNewRight] = NODE_CHANGED;
continue;
}
unsigned uOldParentLeft = OldTree.GetParent(uOldLeft);
unsigned uOldParentRight = OldTree.GetParent(uOldRight);
if (uOldParentLeft == uOldParentRight)
NewNodeIndexToOldNodeIndex[uNewNodeIndex] = uOldParentLeft;
else
NewNodeIndexToOldNodeIndex[uNewNodeIndex] = NODE_CHANGED;
}
#if TRACE
{
Log("NewToOld ");
for (unsigned uNewNodeIndex = 0; uNewNodeIndex < uNodeCount; ++uNewNodeIndex)
{
Log(" [%3u]=", uNewNodeIndex);
if (NODE_CHANGED == NewNodeIndexToOldNodeIndex[uNewNodeIndex])
Log(" X");
else
Log("%3u", NewNodeIndexToOldNodeIndex[uNewNodeIndex]);
if ((uNewNodeIndex+1)%8 == 0)
Log("\n ");
}
//.........这里部分代码省略.........