解释左子右兄弟遍历

Question

我有一个左右兄弟姐妹，如下所示：

    10 
*    | 
*    2 -> 3 -> 4 -> 5 
*              |    | 
*              6    7 -> 8 -> 9  */

我想从根节点遍历到最后一个节点，遍历函数如下：

void traverseTree(Node * root) 
{ 
    if (root == NULL) 
        return; 

    while (root) 
    { 
        cout << " " << root->data; 
        if (root->child) 
            traverseTree(root->child); 
        root = root->next; 
    } 
} 

正如我所理解的，如果节点有一个子节点，那么指针指向它的子节点，否则指向同级节点（下一个）。在这种情况下，当指针指向元素6时，它将转到根-

下面是重新创建树的代码：

// CPP program to create a tree with left child 
// right sibling representation. 
#include<bits/stdc++.h> 
using namespace std; 

struct Node 
{ 
    int data; 
    struct Node *next; 
    struct Node *child; 
}; 

// Creating new Node 
Node* newNode(int data) 
{ 
    Node *newNode = new Node; 
    newNode->next = newNode->child = NULL; 
    newNode->data = data; 
    return newNode; 
} 

// Adds a sibling to a list with starting with n 
Node *addSibling(Node *n, int data) 
{ 
    if (n == NULL) 
        return NULL; 

    while (n->next) 
        n = n->next; 

    return (n->next = newNode(data)); 
} 

// Add child Node to a Node 
Node *addChild(Node * n, int data) 
{ 
    if (n == NULL) 
        return NULL; 

    // Check if child list is not empty. 
    if (n->child) 
        return addSibling(n->child, data); 
    else
        return (n->child = newNode(data)); 
} 

// Traverses tree in level order 
void traverseTree(Node * root) 
{ 
    if (root == NULL) 
        return; 

    while (root) 
    { 
        cout << " " << root->data; 
        if (root->child) 
            traverseTree(root->child); 
        root = root->next; 
    } 
} 

//Driver code 

int main() 
{ 
    Node *root = newNode(10); 
    Node *n1 = addChild(root, 2); 
    Node *n2 = addChild(root, 3); 
    Node *n3 = addChild(root, 4); 
    Node *n4 = addChild(n3, 6); 
    Node *n5 = addChild(root, 5); 
    Node *n6 = addChild(n5, 7); 
    Node *n7 = addChild(n5, 8); 
    Node *n8 = addChild(n5, 9); 
    traverseTree(root); 
    return 0; 
} 

Answer 1

执行traverseTree（root-

void traverseTree(Node * root) 
{ 
    if (root == NULL) 
        return; 

    while (root) 
    { 
        cout << " " << root->data; 
        if (root->child) 
            traverseTree(root->child); // First, if child exists, traverse child. No return statement following here.
        root = root->next; // Next, traverse sibling
    } 
} 

如果您仍然有疑问，那么在调用函数时阅读有关程序流的信息会对您有好处。

更新（与问题完全无关）：根据OP的要求，使用堆栈解决方案：

void traverseTree(Node * root) 
{ 
    if (root == NULL) 
        return; 
    stack<Node*> s;
    s.push(root);
    while (!s.empty())
    {
        Node* top = s.top();
        cout << " " << top->data;
        s.pop();
        if (top->next) s.push(top->next);
        if (top->child) s.push(top->child);
    }
}