二叉树前序遍历

二叉树递归遍历一

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef char ElemType;
typedef struct TreeNode
{
    ElemType data;
    struct TreeNode *Lchild;
    struct TreeNode *Rchild;
}TreeNode;
//创建二叉树
void CreatTreeNode(TreeNode**root)
{
    ElemType data;
    scanf(" %c",&data);
    if(data=='#')
    {
        *root=NULL;
        return ;
    }
    else
    {
        *root=(TreeNode*)malloc(sizeof(TreeNode));
        (*root)->data=data;
        CreatTreeNode(&(*root)->Lchild);
        CreatTreeNode(&(*root)->Rchild);
    }
    return ;
}
//二叉树的节点数
int returnTreeNode_size(TreeNode*root)
{
    int size=0;
    if(root==NULL)
    {
        return 0;
    }
    else
    {
        size++;
        size+=returnTreeNode_size(root->Lchild);
        size+=returnTreeNode_size(root->Rchild);
    }
    return size;
}
void preorder(TreeNode* root, char* res, int* resSize) 
{
    if (root == NULL)
    {
        return; 
    }
    res[(*resSize)++] = root->data;
    preorder(root->Lchild, res, resSize);
    preorder(root->Rchild, res, resSize);
}
char* preorderTraversal(TreeNode* root, int* returnSize) 
{
    char* res = (char*)malloc(sizeof(char) * returnTreeNode_size(root));
    //初始化res这段内存中每个字节上的值为\0,即空字符
    memset(res,'\0',returnTreeNode_size(root));
    *returnSize = 0;
    preorder(root, res, returnSize);
    return res;
}
int main()
{
    TreeNode *root;
    CreatTreeNode(&root);
    int *returnsize=(int*)malloc(sizeof(int));
    char *res=NULL;
    res=preorderTraversal(root,returnsize);
    puts(res);
    return 0;
}

二叉树递归遍历二

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef char ElemType;
typedef struct TreeNode
{
    ElemType data;
    struct TreeNode *Lchild;
    struct TreeNode *Rchild;
}TreeNode;
void preorderNode(TreeNode *root)
{
    if(root!=NULL)
    {
        printf("%c",root->data);
        preorderNode(root->Lchild);
        preorderNode(root->Rchild);
    }
    return ;
}
//创建二叉树
void CreatTreeNode(TreeNode**root)
{
    ElemType data;
    scanf(" %c",&data);
    if(data=='#')
    {
        *root=NULL;
        return ;
    }
    else
    {
        *root=(TreeNode*)malloc(sizeof(TreeNode));
        (*root)->data=data;
        CreatTreeNode(&(*root)->Lchild);
        CreatTreeNode(&(*root)->Rchild);
    }
    return ;
}
//二叉树的节点数
int returnTreeNode_size(TreeNode*root)
{
    int size=0;
    if(root==NULL)
    {
        return 0;
    }
    else
    {
        size++;
        size+=returnTreeNode_size(root->Lchild);
        size+=returnTreeNode_size(root->Rchild);
    }
    return size;
}
int main()
{
    TreeNode *root;
    CreatTreeNode(&root);
    preorderNode(root);
    return 0;
}

二叉树递归遍历三

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef char ElemType;
typedef struct TreeNode
{
    ElemType data;
    struct TreeNode *Lchild;
    struct TreeNode *Rchild;
}TreeNode;
int visit(ElemType data)
{
    printf("%c",data);
    return 1;
}
int preorderNode1(TreeNode *root,int (*visit)(ElemType data))
{
    if(root!=NULL)
    {
        if(visit(root->data))
        {
            if(preorderNode1(root->Lchild,visit))
            {
                preorderNode1(root->Rchild,visit);
            }
        }
    }
    return 1;
}
//创建二叉树
void CreatTreeNode(TreeNode**root)
{
    ElemType data;
    scanf(" %c",&data);
    if(data=='#')
    {
        *root=NULL;
        return ;
    }
    else
    {
        *root=(TreeNode*)malloc(sizeof(TreeNode));
        (*root)->data=data;
        CreatTreeNode(&(*root)->Lchild);
        CreatTreeNode(&(*root)->Rchild);
    }
    return ;
}
//二叉树的节点数
int returnTreeNode_size(TreeNode*root)
{
    int size=0;
    if(root==NULL)
    {
        return 0;
    }
    else
    {
        size++;
        size+=returnTreeNode_size(root->Lchild);
        size+=returnTreeNode_size(root->Rchild);
    }
    return size;
}
int main()
{
    TreeNode *root;
    CreatTreeNode(&root);
    preorderNode1(root,visit);
    return 0;
}

二叉树迭代遍历

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef char ElemType;
typedef struct TreeNode
{
    ElemType data;
    struct TreeNode *Lchild;
    struct TreeNode *Rchild;
}TreeNode,*BiTree;
//迭代算法来自LEETCODE
char* preorderTraversal(struct TreeNode* root, int* returnSize) 
{
    char* res = malloc(sizeof(int) * 2000);
    *returnSize = 0;
    if (root == NULL) 
    {
        return res;
    }
    struct TreeNode* stk[2000];
    struct TreeNode* node = root;
    int stk_top = 0;
    while (stk_top > 0 || node != NULL)
    {
        while (node != NULL) 
        {
            res[(*returnSize)++] = node->data;
            stk[stk_top++] = node;
            node = node->Lchild;                        
        }
        node = stk[--stk_top];
        node = node->Rchild;
    }
    return res;
}
void Creat_TreeNode(BiTree *root)
{
    ElemType data;
    scanf(" %c",&data);
    if(data=='#')
    {
        *root=NULL;
        return ;
    }
    else
    {
        *root=(TreeNode*)malloc(sizeof(TreeNode));
        (*root)->data=data;
        Creat_TreeNode(&(*root)->Lchild);
        Creat_TreeNode(&(*root)->Rchild);
    }
    return ;
}
int main()
{
    BiTree root;
    int *returnSize=(int *)malloc(sizeof(int));
    Creat_TreeNode(&root);
    char *res=preorderTraversal(root,returnSize);
    puts(res);
    return 0;
}