在中序树遍历中将节点推送到堆栈而不是它们的值

Question

I'm trying to implement a depth first search using a stack in C. However, I'm having a lot of difficulty trying to figure out how the stack should be utilized. I can only push the value of each tree node onto the stack. How do I push the node itself so that I can backtrack and find the children of a previous node?

void printorder(struct node* node, struct stack *pt) {
  if (node == NULL) {
    return;
  }

  if (!(node == NULL) || node->visited = false) {
    push(pt,node->data); //pushing root to stack
    int v = pop(&pt);
    printf("Value of pushed node %d",v);
    node->visited = true;
    push(pt,node->left->data);
  }
}

int main(void) {
  struct stack *pt = newStack(9); //Creating new stack with max capacity 9 (amount of nodes we have total)
  struct node *root = newNode(4); //creating root of tree with value 4
  root->left = newNode(7);
  root->right =newNode(98);
  root->left->left = newNode(28);
  root->left->left->left = newNode(77);
  root->left->left->right = newNode(23);
  root->left->right = newNode(86);
  root->left->right->left = newNode(3);
  root->left->right->right = newNode(9);
  printorder(root,pt);    
  return 0;
}

Answer 1

Recursive inorder tree traversal

There's no need for an explicit stack for an in order, depth-first tree traversal . Recursion uses the process' call stack as an implicit data structure. The code you've provided is practically doing this although it appears to conflate the stack push/pop and the recursive calls and is neglecting exploration of the right subtree of root .

Here's a minimal example:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct node {
    int data;
    struct node *left;
    struct node *right;
};

void printInOrder(struct node *root) {
    if (root) {
        printInOrder(root->left);
        printf("%d\n", root->data);
        printInOrder(root->right);
    }
}

struct node *newNode(int data) {
    struct node *result = malloc(sizeof(*result));
    memset(result, 0, sizeof(*result));
    result->data = data;
    return result;
}

void freeTree(struct node *root) {
    if (root) {
        freeTree(root->left);
        freeTree(root->right);
        free(root);
    }
}

int main() {
    /*      0
          /   \
         1     2
       /   \
      3     4
     / \   / \
    5   6 7   8   */
    struct node *root = newNode(0);
    root->left = newNode(1);
    root->right = newNode(2);
    root->left->left = newNode(3);
    root->left->left->left = newNode(5);
    root->left->left->right = newNode(6);
    root->left->right = newNode(4);
    root->left->right->left = newNode(7);
    root->left->right->right = newNode(8);
    printInOrder(root);
    freeTree(root);
    return 0;
}

---

Iterative inorder tree traversal

If you do need to do this iteratively, you're in for much more work than the recursive version.

The first design choice is whether to make the stack internal to the printInOrder function and use a simple array or to write a stack class. Writing a stack class is a lot more work, but is reusable (it looks like you've already gone down this route).

As for your existing function header, it's a bit unusual to force the caller to allocate resources that should be internal to the function call; ideally, printInOrder is a generic, stateless black box that the caller can trust to do its job without producing side effects .

Imagine making multiple calls to printInOrder using the same stack which might lead to surprising results, or the caller having to worry about allocation/deallocation of this stack.

The traversal algorithm also becomes more complicated. Instead of printing a node's data in the loop, we need to push it on to the stack and traverse to its left child, repeating until the current node is null. Then we can print the top of the stack and make the current node the just-printed node's right child. Repeat until the stack is exhausted.

Here's the iterative algorithm with an internal stack and works as a drop-in to the above code example:

void printInOrder(struct node *root) {
    int capacity = 4;
    int top = 0;
    struct node **stack = malloc(sizeof(*stack) * capacity);

    for (stack[top] = root; top >= 0;) {
        for (root = stack[top--]; root; root = root->left) {
            if (top >= capacity && 
                !(stack = realloc(stack, sizeof(stack) * (capacity *= 2)))) {
                fprintf(stderr, "%s [%d] realloc failed\n", __FILE__, __LINE__);
                exit(1);
            }

            stack[++top] = root;
        }

        if (top >= 0) {
            root = stack[top--];
            printf("%d\n", root->data);
            stack[++top] = root->right;
        }
    }

    free(stack);
}

Here's a version that uses a stack class. The logic is much cleaner but we've introduced a dependency.

stack.h

#ifndef STACK_H
#define STACK_H

#include <stdbool.h>
#include <stdlib.h>
#include <string.h>

struct stack {
    int top;
    int capacity;
    void **entries;
};

struct stack *createStack(int capacity) {
    if (capacity <= 0) return NULL;

    struct stack *s = malloc(sizeof(*s));
    s->top = -1;
    s->capacity = capacity;
    s->entries = malloc(sizeof(*s->entries) * capacity);
    return s;
}

bool empty(struct stack *s) {
    return s->top < 0;
}

void freeStack(struct stack *s) {
    free(s->entries);
    free(s);
}

void *pop(struct stack *stack) {  
    if (stack->top < stack->capacity / 2 - 1) {
        stack->entries = realloc(stack->entries, 
                                 sizeof(stack->entries) * 
                                 (stack->capacity /= 2));
        if (!stack->entries) {
            fprintf(stderr, "%s [%d] realloc failed\n", __FILE__, __LINE__);
            exit(1);
        }
    }

    return stack->entries[stack->top--];
}

void push(struct stack *stack, void *data) {
    if (stack->top >= stack->capacity) {
        stack->entries = realloc(stack->entries, 
                                 sizeof(stack->entries) * 
                                 (stack->capacity *= 2));
        if (!stack->entries) {
            fprintf(stderr, "%s [%d] realloc failed\n", __FILE__, __LINE__);
            exit(1);
        }
    }

    stack->entries[++stack->top] = data;
}

#endif

main.c

#include <stdio.h>
#include <stdlib.h>
#include "stack.h"

struct node {
    int data;
    struct node *left;
    struct node *right;
};

void printInOrder(struct node *root) {
    struct stack *stack = createStack(4);

    for (push(stack, root); !empty(stack);) {
        for (root = pop(stack); root; root = root->left) {
            push(stack, root);
        }

        if (!empty(stack)) {
            root = pop(stack);
            printf("%d\n", root->data);
            push(stack, root->right);
        }
    }

    freeStack(stack);
}

struct node *newNode(int data) {
    struct node *result = malloc(sizeof(*result));
    memset(result, 0, sizeof(*result));
    result->data = data;
    return result;
}

void freeTree(struct node *root) {
    if (root) {
        freeTree(root->left);
        freeTree(root->right);
        free(root);
    }
}

int main() {
    /*      0
          /   \
         1     2
       /   \
      3     4
     / \   / \
    5   6 7   8   */
    struct node *root = newNode(0);
    root->left = newNode(1);
    root->right = newNode(2);
    root->left->left = newNode(3);
    root->left->left->left = newNode(5);
    root->left->left->right = newNode(6);
    root->left->right = newNode(4);
    root->left->right->left = newNode(7);
    root->left->right->right = newNode(8);
    printInOrder(root);
    freeTree(root);
    return 0;
}