vector<vector<int> > levelOrderBottom(TreeNode *root) {
vector<vector<int> > answer;
if (root == NULL)
{
return answer;
}
queue<traverseNode> tmpQueue;
traverseQueue.swap(tmpQueue);
traverseQueue.push(traverseNode(root, 1));
while(!traverseQueue.empty())
{
traverseNode topNode = traverseQueue.front();
if (topNode.level > answer.size())
{
vector<int> emptyVector;
answer.push_back(emptyVector);
}
answer[topNode.level - 1].push_back(topNode.node->val);
traverseQueue.pop();
if (topNode.node -> left != NULL)
{
traverseQueue.push(traverseNode(topNode.node->left, topNode.level + 1));
}
if (topNode.node -> right != NULL)
{
traverseQueue.push(traverseNode(topNode.node->right, topNode.level + 1));
}
}
for (int i = 0; i < (answer.size()/2); i++)
{
answer[i].swap(answer[answer.size() - i - 1]);
}
return answer;
}
void traverseNode(Node* n)
{
if (n != NULL) {
traverseNode(n->d);
printf("+%s\n",n->str);
traverseNode(n->r);
}
}
void traverseNode(Node* n)
{
if(n != NULL){
traverseNode(n->l);
// printf("n : %p n->l : %p n->r : %p %s \n",n,n->l,n->r,n->s);
printf("+%s",n->s);
traverseNode(n->r);
}
}
void TCBinaryObjectTree::traverseNode(TCBinaryObjectTreeNode *node,
TCTraversalFunc traversalFunc)
{
if (node)
{
traverseNode(node->left, traversalFunc);
traversalFunc(node->key, node->value);
traverseNode(node->right, traversalFunc);
}
}
void traverseNode(Node* n)
{
if(n != NULL)
{
traverseNode(n->l);
printf("n : %p n->l : %p n->r : %p n->p : %p +%s%d %d\n",n,n->l,n->r,n->p,n->str,n->i,n->count);
// printf("+%s%d ",n->str,n->i);
traverseNode(n->r);
}
}
void traverse(Tree* tp)
{
if(!isEmpty(tp))
{
traverseNode(tp->root);
}
}
Node* ComposedShadowTreeWalker::traverseLightChildren(const Node* node, TraversalDirection direction)
{
ASSERT(node);
if (Node* child = (direction == TraversalDirectionForward ? node->firstChild() : node->lastChild()))
return traverseNode(child, direction);
return 0;
}
void traverse(BTree* btp)
{
if(btp->root != NULL)
{
traverseNode(btp->root);
}
}
Node* ComposedShadowTreeWalker::traverseSiblings(const Node* node, TraversalDirection direction)
{
for (const Node* sibling = node; sibling; sibling = (direction == TraversalDirectionForward ? sibling->nextSibling() : sibling->previousSibling())) {
if (Node* found = traverseNode(sibling, direction))
return found;
}
return 0;
}
Node* ComposedShadowTreeWalker::traverseDistributedNodes(const Node* node, const InsertionPoint* insertionPoint, TraversalDirection direction)
{
for (const Node* next = node; next; next = (direction == TraversalDirectionForward ? insertionPoint->nextTo(next) : insertionPoint->previousTo(next))) {
if (Node* found = traverseNode(next, direction))
return found;
}
return 0;
}
Node* ComposedShadowTreeWalker::traverseSiblingInCurrentTree(const Node* node, TraversalDirection direction)
{
ASSERT(node);
if (Node* next = (direction == TraversalDirectionForward ? node->nextSibling() : node->previousSibling()))
return traverseNode(next, direction);
if (Node* next = traverseSiblingOrBackToYoungerShadowRoot(node, direction))
return next;
return escapeFallbackContentElement(node, direction);
}
void ParseXML::parseXmlString(const QString &xmlStr)
{
this->doc.setContent(xmlStr);
// docElement now refers to the node "xml"
QDomElement docElem = this->doc.documentElement();
traverseNode(docElem);
//
emit this->finished(true);
}
// traverse node
bool Bvh::traverseNode( const Bvh_Node* node , const Ray& ray , Intersection* intersect , float fmin , float fmax ) const
{
if( fmin < 0.0f )
return false;
if( intersect && intersect->t < fmin )
return true;
if( node->pri_num != 0 ){
unsigned _start = node->pri_offset;
unsigned _tri = node->pri_num;
unsigned _end = _start + _tri;
bool inter = false;
for( unsigned i = _start ; i < _end ; i++ ){
inter |= m_bvhpri[i].primitive->GetIntersect( ray , intersect );
if( intersect == 0 && inter )
return true;
}
return inter;
}
const Bvh_Node* left = node->left;
const Bvh_Node* right = node->right;
float _fmin0 , _fmax0;
_fmin0 = Intersect( ray , left->bbox , &_fmax0 );
float _fmin1 , _fmax1;
_fmin1 = Intersect( ray , right->bbox , &_fmax1 );
bool inter = false;
if( _fmin1 > _fmin0 ){
inter |= traverseNode( left , ray , intersect , _fmin0 , _fmax0 );
if( inter && intersect == 0 ) return true;
inter |= traverseNode( right , ray , intersect , _fmin1 , _fmax1 );
}else{
inter |= traverseNode( right , ray , intersect , _fmin1 , _fmax1 );
if( inter && intersect == 0 ) return true;
inter |= traverseNode( left , ray , intersect , _fmin0 , _fmax0 );
}
if( intersect == 0 )
return inter;
return true;
}
/**
* Traverses the "right boundary" of this range and
* operates on each "boundary node" according to the
* how parameter. It is a-priori assumed
* by this method that the right boundary does
* not contain the range's start container.
*
* A "right boundary" is best visualized by thinking
* of a sample tree:
* A
* /|\
* / | \
* / | \
* B C D
* /|\ /|\
* E F G H I J
*
* Imagine first a range that begins between the
* "E" and "F" nodes and ends between the
* "I" and "J" nodes. The start container is
* "B" and the end container is "D". Given this setup,
* the following applies:
*
* Partially Selected Nodes: B, D<br>
* Fully Selected Nodes: F, G, C, H, I
*
* The "right boundary" is the highest subtree node
* that contains the ending container. The root of
* this subtree is always partially selected.
*
* In this example, the nodes that are traversed
* as "right boundary" nodes are: H, I, and D.
*
*/
DOM_Node RangeImpl::traverseRightBoundary( DOM_Node root, int how )
{
DOM_Node next = getSelectedNode( fEndContainer, fEndOffset-1 );
bool isFullySelected = ( next!=fEndContainer );
if ( next==root )
return traverseNode( next, isFullySelected, false, how );
DOM_Node parent = next.getParentNode();
DOM_Node clonedParent = traverseNode( parent, false, false, how );
while( parent!=null )
{
while( next!=null )
{
DOM_Node prevSibling = next.getPreviousSibling();
DOM_Node clonedChild =
traverseNode( next, isFullySelected, false, how );
if ( how!=DELETE_CONTENTS )
{
clonedParent.insertBefore(
clonedChild,
clonedParent.getFirstChild()
);
}
isFullySelected = true;
next = prevSibling;
}
if ( parent==root )
return clonedParent;
next = parent.getPreviousSibling();
parent = parent.getParentNode();
DOM_Node clonedGrandParent = traverseNode( parent, false, false, how );
if ( how!=DELETE_CONTENTS )
clonedGrandParent.appendChild( clonedParent );
clonedParent = clonedGrandParent;
}
// should never occur
return null;
}
void traverse(Heap* hp)
{
if(hp->root != NULL)
{
traverseNode(hp->root);
}
else
{
printf("heap is empty\n");
}
}
Node* ComposedShadowTreeWalker::traverseNode(const Node* node, TraversalDirection direction)
{
ASSERT(node);
if (!isInsertionPoint(node))
return const_cast<Node*>(node);
const InsertionPoint* insertionPoint = toInsertionPoint(node);
if (!insertionPoint->isActive())
return const_cast<Node*>(node);
if (Node* next = (direction == TraversalDirectionForward ? insertionPoint->first() : insertionPoint->last()))
return traverseNode(next, direction);
return traverseLightChildren(node, direction);
}
/** Recursively traverses the children of a node.
*
* This functionality is implemented as a separate function, as opposed to
* incorporating it directly into <i>paint</i>, because some nodes need to
* traverse their children at different times.
*
* @param node Pointer to the parent node.
*/
void Traverser::traverseChildren(Node *node) {
Node::iterator it;
// Stop if sealed
if (!node->areChildrenTraversable())
return;
// Traverse each child
for (it=node->begin(); it!=node->end(); ++it) {
traverseNode(*it);
}
}
Node* ComposedShadowTreeWalker::traverseSiblingOrBackToInsertionPoint(const Node* node, TraversalDirection direction)
{
ASSERT(node);
ElementShadow* shadow = shadowOfParent(node);
if (!shadow)
return traverseSiblingInCurrentTree(node, direction);
InsertionPoint* insertionPoint = shadow->insertionPointFor(node);
if (!insertionPoint)
return traverseSiblingInCurrentTree(node, direction);
if (Node* next = (direction == TraversalDirectionForward ? insertionPoint->nextTo(node) : insertionPoint->previousTo(node)))
return traverseNode(next, direction);
return traverseSiblingOrBackToInsertionPoint(insertionPoint, direction);
}
/**
* Traverses the "left boundary" of this range and
* operates on each "boundary node" according to the
* how parameter. It is a-priori assumed
* by this method that the left boundary does
* not contain the range's end container.
*
* A "left boundary" is best visualized by thinking
* of a sample tree:
*
* A
* /|\
* / | \
* / | \
* B C D
* /|\ /|\
* E F G H I J
*
* Imagine first a range that begins between the
* "E" and "F" nodes and ends between the
* "I" and "J" nodes. The start container is
* "B" and the end container is "D". Given this setup,
* the following applies:
*
* Partially Selected Nodes: B, D<br>
* Fully Selected Nodes: F, G, C, H, I
*
* The "left boundary" is the highest subtree node
* that contains the starting container. The root of
* this subtree is always partially selected.
*
* In this example, the nodes that are traversed
* as "left boundary" nodes are: F, G, and B.
*
*/
DOM_Node RangeImpl::traverseLeftBoundary( DOM_Node root, int how )
{
DOM_Node next = getSelectedNode( getStartContainer(), getStartOffset() );
bool isFullySelected = ( next!=getStartContainer() );
if ( next==root )
return traverseNode( next, isFullySelected, true, how );
DOM_Node parent = next.getParentNode();
DOM_Node clonedParent = traverseNode( parent, false, true, how );
while( parent!=null )
{
while( next!=null )
{
DOM_Node nextSibling = next.getNextSibling();
DOM_Node clonedChild =
traverseNode( next, isFullySelected, true, how );
if ( how!=DELETE_CONTENTS )
clonedParent.appendChild(clonedChild);
isFullySelected = true;
next = nextSibling;
}
if ( parent==root )
return clonedParent;
next = parent.getNextSibling();
parent = parent.getParentNode();
DOM_Node clonedGrandParent = traverseNode( parent, false, true, how );
if ( how!=DELETE_CONTENTS )
clonedGrandParent.appendChild( clonedParent );
clonedParent = clonedGrandParent;
}
// should never occur
return null;
}
PERSON * findMemberByPhone(STRING phone)
{
personList.memberCnt = 0;
matchString = phone;
traverseNode(rootNode, getMemberListByPhone);
if (personList.memberCnt == 0)
return NULL;
else if (personList.memberCnt == 1)
return personList.member[0];
else
return choiceDuplicatedOne(personList);
}
static void traverseNode(TidyNode node, int level)
{
TidyNode child;
/* first the callback function */
(*traverse_tidycall) (node, level, true);
/* and now the children */
for (child = tidyGetChild(node); child; child = tidyGetNext(child))
traverseNode(child, level + 1);
(*traverse_tidycall) (node, level, false);
} /* traverseNode */
// get the intersection between the ray and the primitive set
bool Bvh::GetIntersect( const Ray& ray , Intersection* intersect ) const
{
float fmax;
float fmin = Intersect( ray , m_bbox , &fmax );
if( fmin < 0.0f )
return false;
if( traverseNode( m_root , ray , intersect , fmin , fmax ) ){
if( intersect == 0 )
return true;
return intersect->primitive != 0 ;
}
return false;
}
void Node::depthFirstTraversal()
{
traverseNode();
if( 0 == childrenList.size() )
{
return ;
}
else
{
for( unsigned int i = 0 ; i < childrenList.size() ; ++i )
{
(childrenList[i])->depthFirstTraversal();
}
glPopMatrix();
}
}
void TraversalNeighborGen::traverseNode(Visitor *v, TraversalData &td)
{
if (!v->onNode(td))
return;
// stop if all leaves
if (!td.node.data)
return;
// get children (in standard orientation)
TraversalData ch[2][2][2];
for (int i = 0; i < 8; i++)
{
const int x = i&1;
const int y = (i>>1)&1;
const int z = (i>>2)&1;
genNodeChild(ch[x][y][z], td, x, y, z);
}
traverseNode(v, ch[0][0][0]);
traverseNode(v, ch[0][1][0]);
traverseNode(v, ch[1][0][0]);
traverseNode(v, ch[1][1][0]);
traverseNode(v, ch[0][0][1]);
traverseNode(v, ch[0][1][1]);
traverseNode(v, ch[1][0][1]);
traverseNode(v, ch[1][1][1]);
recFace0(v, ch);
recFace1(v, ch);
recFace2(v, ch);
recEdge0(v, ch);
recEdge1(v, ch);
recEdge2(v, ch);
traverseVertex(v, ch);
}
void TestModel::load(const QByteArray data)
{
if (data.isEmpty()) {
return;
}
clear();
QByteArray d(QByteArray::fromBase64(data));
QDomDocument domDoc;
QString error;
int errLine = -1;
if(domDoc.setContent(d, &error, &errLine)) {
QDomElement domElement= domDoc.documentElement();
traverseNode(domElement);
} else {
// qDebug() << "Error while QDomDocument::setContent :" << error << "line: " << errLine;
}
}
void TraversalNeighborGen::traverse(OctTree &tree, Visitor *v)
{
TraversalData td;
td.node = tree.root;
td.depth = 0;
td.value = 0;
td.isCopy = false;
td.cellsize = 1 << (g.maxDepth+1);
td.x = td.y = td.z = 0;
static unsigned char root_neighborCells = 0;
td.neighborCells = &root_neighborCells;
static float blur_val = 0;
td.blur_val = &blur_val;
td.pt_num = 10000;
traverseNode(v, td);
}
void TCBinaryObjectTree::traverseTree(TCTraversalFunc traversalFunc)
{
traverseNode(rootNode, traversalFunc);
}
static void traverseTidy(void)
{
traverseNode(tidyGetRoot(tdoc), 0);
}
PERSONLIST getMemberList()
{
personList.memberCnt = 0;
traverseNode(rootNode, getMemberListByAll);
return personList;
}
void Traverser::start() {
traverseNode(scene->getRoot());
}
