先序遍历非递归算法c语言

先序遍历的非递归算法可以使用栈来实现。基本思想是先将根节点入栈，然后循环执行以下步骤：

1. 弹出栈顶节点，并访问该节点。
2. 如果该节点有右子节点，则将右子节点入栈。
3. 如果该节点有左子节点，则将左子节点入栈。

重复执行以上步骤，直到栈为空。以下是C语言代码实现：

void PreorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    stack<TreeNode*> s;
    s.push(root);
    while (!s.empty()) {
        TreeNode* node = s.top();
        s.pop();
        visit(node);
        if (node->right != NULL) {
            s.push(node->right);
        }
        if (node->left != NULL) {
            s.push(node->left);
        }
    }
}

其中，visit(node)是用来访问节点的函数，可以根据需要进行修改。

相关问题

先序遍历非递归算法二叉树C语言

先序遍历的非递归算法可以通过使用栈来实现。具体步骤如下：

1. 创建一个栈，并将根节点入栈。
2. 当栈不为空时，执行以下操作：
1. 弹出栈顶节点并输出该节点的值。
2. 如果该节点的右子树非空，则将右子树入栈。
3. 如果该节点的左子树非空，则将左子树入栈。
3. 当栈为空时，遍历结束。

以下是C语言实现代码：

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

#define MAXSIZE 100

// 定义二叉树结构体
typedef struct TreeNode {
    int data;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 定义栈结构体
typedef struct Stack {
    TreeNode* data[MAXSIZE];
    int top;
} Stack;

// 初始化栈
void initStack(Stack* s) {
    s->top = -1;
}

// 判断栈是否为空
int isEmpty(Stack* s) {
    return s->top == -1;
}

// 判断栈是否已满
int isFull(Stack* s) {
    return s->top == MAXSIZE - 1;
}

// 入栈
void push(Stack* s, TreeNode* node) {
    if (isFull(s)) {
        printf("Stack is full!\n");
        return;
    }
    s->data[++(s->top)] = node;
}

// 出栈
TreeNode* pop(Stack* s) {
    if (isEmpty(s)) {
        printf("Stack is empty!\n");
        return NULL;
    }
    return s->data[(s->top)--];
}

// 先序遍历二叉树（非递归算法）
void preOrder(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    Stack s;
    initStack(&s);
    push(&s, root);
    while (!isEmpty(&s)) {
        TreeNode* cur = pop(&s);
        printf("%d ", cur->data);
        if (cur->right) {
            push(&s, cur->right);
        }
        if (cur->left) {
            push(&s, cur->left);
        }
    }
}

// 创建新节点
TreeNode* createNode(int data) {
    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
    return node;
}

// 构建二叉树
TreeNode* buildTree() {
    TreeNode* root = createNode(1);
    root->left = createNode(2);
    root->right = createNode(3);
    root->left->left = createNode(4);
    root->left->right = createNode(5);
    root->right->left = createNode(6);
    root->right->right = createNode(7);
    return root;
}

int main() {
    TreeNode* root = buildTree();
    preOrder(root); // 输出：1 2 4 5 3 6 7
    return 0;
}

假设二叉树采用链接存储方式存储，分别编写一个二叉树先序遍历的递归 算法和非递归算法，用c语言实现

好的，以下是二叉树先序遍历的递归算法和非递归算法的C语言实现：

递归算法：

void preorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    printf("%d ", root->val);
    preorderTraversal(root->left);
    preorderTraversal(root->right);
}

非递归算法：

void preorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    stack<TreeNode*> s;
    s.push(root);
    while (!s.empty()) {
        TreeNode* node = s.top();
        s.pop();
        printf("%d ", node->val);
        if (node->right != NULL) {
            s.push(node->right);
        }
        if (node->left != NULL) {
            s.push(node->left);
        }
    }
}

希望这个回答能够帮到你！