c语言堆栈实现前序遍历

以下是使用堆栈实现前序遍历的c语言代码：

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

#define MAXSIZE 50

typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

typedef struct Stack {
    TreeNode* data[MAXSIZE];
    int top;
} Stack;

void push(Stack* s, TreeNode* node) {
    if (s->top == MAXSIZE - 1) {
        printf("Error: Stack is full.\n");
        return;
    }
    s->top++;
    s->data[s->top] = node;
}

TreeNode* pop(Stack* s) {
    if (s->top == -1) {
        printf("Error: Stack is empty.\n");
        return NULL;
    }
    TreeNode* node = s->data[s->top];
    s->top--;
    return node;
}

void preorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    Stack* s = (Stack*)malloc(sizeof(Stack));
    s->top = -1;
    push(s, root);
    while (s->top != -1) {
        TreeNode* node = pop(s);
        printf("%d ", node->data);
        if (node->right != NULL) {
            push(s, node->right);
        }
        if (node->left != NULL) {
            push(s, node->left);
        }
    }
    free(s);
}

int main() {
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->data = 1;
    root->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->left->data = 2;
    root->left->left = NULL;
    root->left->right = NULL;
    root->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->data = 3;
    root->right->left = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->left->data = 4;
    root->right->left->left = NULL;
    root->right->left->right = NULL;
    root->right->right = (TreeNode*)malloc(sizeof(TreeNode));
    root->right->right->data = 5;
    root->right->right->left = NULL;
    root->right->right->right = NULL;
    printf("Preorder Traversal: ");
    preorderTraversal(root);
    printf("\n");
    return 0;
}

在这个代码中，我们定义了一个`Stack`结构体和一个`TreeNode`结构体。`Stack`用于实现堆栈，其中包含一个数组和一个指向堆栈顶部的指针。`TreeNode`用于表示二叉树的节点，其中包含一个整数数据和左右子节点的指针。

我们定义了几个函数来操作堆栈，包括`push`和`pop`函数。`push`函数用于将节点压入堆栈，`pop`函数用于将节点弹出堆栈。

`preorderTraversal`函数实现了前序遍历。我们首先创建一个堆栈，并将根节点压入堆栈。接着，我们进入一个循环，每次从堆栈中弹出一个节点并打印它的数据。然后，我们将其右子节点压入堆栈，再将其左子节点压入堆栈。这样，下一次循环时，我们会先访问左子节点，然后访问右子节点。

最后，我们在`main`函数中创建一个二叉树并调用`preorderTraversal`函数来进行前序遍历。