二叉树的三种遍历（递归+非递归）

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <stack>
using namespace std;

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

TreeNode node[11],node1[3];
TreeNode *root1=&node[0],*root2=&node1[0];

int compare(TreeNode *p1,TreeNode *p2)
{
    if(p2==NULL)return 1;
    else if(p1==NULL)return 0;
    if(p1->data!=p2->data)
    {
        return compare(p1->left,root2)||compare(p1->right,root2);
    }
    else
    {
        return compare(p1->left,p2->left)&&compare(p1->right,p2->right);
    }
}

void preorder(TreeNode *p)
{
    if(p!=NULL)
    {
        printf("%d ",p->data);
        preorder(p->left);
        preorder(p->right);
    }
}

void inorder(TreeNode *p)
{
    if(p!=NULL)
    {
        inorder(p->left);
        printf("%d ",p->data);
        inorder(p->right);
    }
}

void postorder(TreeNode *p)
{
    if(p!=NULL)
    {
        postorder(p->left);
        postorder(p->right);
        printf("%d ",p->data);
    }
}

void print_data(TreeNode *p)
{
    printf("%d ",p->data);
}

void println()
{
    printf("\n");
}

void preorder_loop(TreeNode *p)
{
    stack<TreeNode*> s;
    while(p!=NULL)
    {
        print_data(p);
        s.push(p);
        p = p->left;
    }
    while(!s.empty())
    {
        TreeNode * temp = s.top();
        s.pop();
        temp = temp->right;
        while(temp!=NULL)
        {
            print_data(temp);
            s.push(temp);
            temp = temp->left;
        }
    }
}

void inorder_loop(TreeNode *p)
{
    stack<TreeNode*> s;
    while(p!=NULL)
    {
        s.push(p);
        p = p->left;
    }
    while(!s.empty())
    {
        TreeNode * temp = s.top();
        s.pop();
        print_data(temp);
        temp = temp->right;
        while(temp!=NULL)
        {
            s.push(temp);
            temp = temp->left;
        }
    }
}

TreeNode* visited[100];
int vnum=0;

int find(TreeNode *temp)
{
    int i;
    for(i=0;i<vnum;i++)
    {
        if(visited[i]==temp)return 1;
    }
    visited[vnum++] = temp;
    return 0;
}

void postorder_loop(TreeNode *p)
{
    stack<TreeNode*> s;
    while(p!=NULL)
    {
        s.push(p);
        p = p->left;
    }
    while(!s.empty())
    {
        TreeNode * temp = s.top();
        if(temp->right==NULL||find(temp))
        {
            print_data(temp);
            s.pop();
        }
        else
        {
            temp = temp->right;
            while(temp!=NULL)
            {
                s.push(temp);
                temp = temp->left;
            }
        }
    }
}

TreeNode *pathp[100],*pathq[100];
int pnum=0,qnum=0;
int f=0;
void dfs(TreeNode *root,TreeNode *p,TreeNode**path,int *num)
{
    if(f)return;
    if(root==p)
    {
        f = 1;
        return;
    }
    if(root->left!=NULL&&!f)
    {
        path[(*num)++] = root->left;
        dfs(root->left,p,path,num);
        if(!f)(*num)--;
    }
    if(root->right!=NULL&&!f)
    {
        path[(*num)++] = root->right;
        dfs(root->right,p,path,num);
        if(!f)(*num)--;
    }
}

TreeNode * find_last_same_node()
{
    int i=0;
    while(pathp[i]==pathq[i])i++;
    return pathp[i-1];
}

TreeNode * find_first_father(TreeNode *root,TreeNode * p,TreeNode *q)
{
    dfs(root,p,pathp,&pnum);
    f = 0;
    dfs(root,q,pathq,&qnum);
    TreeNode * first_father = find_last_same_node();
    return first_father;
//    printf("%d\n",first_father->data);
}

int main()
{
    
    node[0].data = 0;
    node[0].left = &node[1];
    node[0].right = &node[2];
    node[1].data = 1;
    node[1].left = &node[3];
    node[1].right = &node[4];
    node[2].data = 2;
    node[2].left = &node[5];
    node[2].right = &node[6];
    node[3].data = 3;
    node[3].left = &node[7];
    node[3].right = NULL;
    node[4].data = 4;
    node[4].left = &node[8];
    node[4].right = NULL;
    node[5].data = 2;
    node[5].left = &node[9];
    node[5].right = &node[10];
    node[6].data = 6;
    node[6].left = NULL;
    node[6].right = NULL;
    node[7].data = 7;
    node[7].left = NULL;
    node[7].right = NULL;
    node[8].data = 8;
    node[8].left = NULL;
    node[8].right = NULL;
    node[9].data = 5;
    node[9].left = NULL;
    node[9].right = NULL;
    node[10].data = 9;
    node[10].left = NULL;
    node[10].right = NULL;

    node1[0].data = 2;
    node1[0].left = &node1[1];
    node1[0].right = &node1[2];
    node1[1].data = 2;
    node1[1].left = NULL;
    node1[1].right = NULL;
    node1[2].data = 6;
    node1[2].left = NULL;
    node1[2].right = NULL;

    preorder(root1);
//    printf("\n");
//    preorder(root2);
//    printf("\n");

//    printf("%d\n",compare(root1,root2));
    println();
    preorder_loop(root1);
    println();
    println();
    inorder(root1);
    println();
    inorder_loop(root1);
    println();
    println();
    postorder(root1);
    println();
    postorder_loop(root1);
    println();
    println();
    TreeNode * first_father = find_first_father(root1,&node[6],&node[9]);
    printf("%d\n",first_father->data);
    return 0;
}