我的二进制搜索树的预遍历代码正在工作，但是每个元素都是指向结构的指针的堆栈如何工作？

Question

This is my code of preorder traversal of BST. It's working fine on Ubuntu. But I don't understand one thing. In the function iterative_preorder() , I actually wanted a stack to store the pointers to the structure that I defined on the top. I want to know the concept that how is it working. Since, while allocating memory to the stack, I didn't specify anywhere separately that stack should contain size number of pointers to the structure.

Like, when we define:

int stack[size];

We know that stack[1] will be the second block in the stack. But here, I used malloc , which actually just makes one block of the size specified as size * sizeof(node *) .

So when the program executes:

stack[++top] = root;

How does the program understand that it has to go to the next pointer to the structure in the stack? I hope my question is clear.

I made another small program, based on the confusion that I had. Here, instead of structure, I used int . I tried to create a stack of size 2, which stores pointers to the integer. Here's the code:

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

void main() {
    int** stack = (int**)malloc(2 * sizeof(int*));
    printf("%d", *stack[0]);
}

But this code is throwing segmentation fault (core dumped) . As both the codes used the same logic, just that this one used int instead of structure, I don't understand why this is throwing error.

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

int size = 0;

typedef struct mylist {
    int data;
    struct mylist *left;
    struct mylist *right;
} node;
node *root;

void create_root(node *root) {
    root = NULL;
}

//Inserting nodes
node *insert(node *root, int val) {
    node *ptr, *parentptr, *nodeptr;
    ptr = (node*)malloc(sizeof(node));
    ptr->data = val;
    ptr->left = NULL;
    ptr->right = NULL;
    if (root == NULL)
        root = ptr;
    else {
        parentptr = NULL;
        nodeptr = root;
        while (nodeptr != NULL) {
            parentptr = nodeptr;
            if (val < nodeptr->data)
                nodeptr = nodeptr->left;
            else
                nodeptr = nodeptr->right;
        }
        if (val < parentptr->data)
            parentptr->left = ptr;
        else
            parentptr->right = ptr;
    }
    return root;
}

void iterative_preorder(node *root) {
    if (root != NULL) {
        int top = -1;
        node **stack = (node**)malloc(size * sizeof(node*));
        node *cur;
        stack[++top] = root;
        while (top > -1) {
            cur = stack[top--];
            printf("%d\t", cur->data);
            if (cur->right != NULL)
                stack[++top] = cur->right;
            if (cur->left != NULL)
                stack[++top] = cur->left;
        }
    }
}

void main() {
    int option, val;
    node *ptr;
    int flag = 1;
    create_root(root);
    while (flag != 2) {
        printf("\nChoose-\n1-Insert\n2-Iterative Preorder Traversal\n3-Exit\n");
        scanf("%d", &option);
        switch (option) {
        case 1: {
                printf("\nEnter the value of new node\n");
                size++;
                scanf("%d", &val);
                root = insert(root, val);
            }
            break;
        case 2:
            iterative_preorder(root);
            break;
        case 3:
            flag = 2;
            break;
        default:
            printf("\nWrong entry\n");
        }
    }
}

Answer 1

Your code has a dereference of uninitialized pointer error.

    int** stack = (int**)malloc(2*sizeof(int*));
    printf("%d",*stack[0]);

In the above code, stack points to an array of two int pointers, what stack[0] points to? it's not initialized.

A live test of your code is available here segfault . you can modify and test it again.