剑指offer面试题19二叉树的镜像和二叉树的前中后遍历递归和非递归算法

#include<iostream>
#include<cstdio>
#include<cstring>
#include<stack>
#include<queue>
using namespace std;

struct BinaryTreeNode
{
    int data;
    BinaryTreeNode * leftchild;
    BinaryTreeNode * rightchild;
    BinaryTreeNode(int t)
    {
        data=t;
        leftchild=rightchild=NULL;
    }
};

BinaryTreeNode * root;
void CreateTree()
{
    root=new BinaryTreeNode(8);
    root->leftchild=new BinaryTreeNode(6);
    root->rightchild=new BinaryTreeNode(10);
    BinaryTreeNode * tmp=root->leftchild;
    tmp->leftchild=new BinaryTreeNode(5);
    tmp->rightchild=new BinaryTreeNode(7);
    tmp=root->rightchild;
    tmp->leftchild=new BinaryTreeNode(9);
    tmp->rightchild=new BinaryTreeNode(11);
}

void PreorderTravel(BinaryTreeNode * root)
{
    if(root==NULL)
    return ;
    printf("%d\t",root->data);
    PreorderTravel(root->leftchild);
    PreorderTravel(root->rightchild);
}

//非递归的先序遍历。。早忘掉了 重新写一次 主要是用栈。先一路往左找。压入栈内
//总之可以发现 每次先vis 根节点 然后一路往左 再由栈一路弹出看是否有右节点
void PreorderTravelNoRecrusive(BinaryTreeNode * root)
{
    stack<BinaryTreeNode *> sstack;
    BinaryTreeNode * p=root;
    while(p!=NULL || !sstack.empty())
    {
        while(p!=NULL)
        {
            printf("%d\t",p->data);//先序 先vis 根节点 然后压入栈 一路往左边走
            sstack.push(p);
            p=p->leftchild;
        }//一直往左边走到头，直到再没有左节点 这个时候这个节点指针在栈顶 开始弹栈看有没有右节点
        if(!sstack.empty())
        {
            p=sstack.top();
            sstack.pop();//弹出后变成右节点 如果空的话 继续弹出 知道有了右节点不空的 再一路向左 这么循环
            p=p->rightchild;
        }
    }
}


void InorderTravel(BinaryTreeNode * root)
{
    if(root==NULL) return ;
    InorderTravel(root->leftchild);
    printf("%d\t",root->data);
    InorderTravel(root->rightchild);
}

void InorderTravelNoRecursive(BinaryTreeNode * root)
{
    stack<BinaryTreeNode *> sstack;
    BinaryTreeNode * p=root;
    while(p!=NULL || !sstack.empty())
    {
        while(p!=NULL)//首先 一路把左子树压入栈
        {
            sstack.push(p);
            p=p->leftchild;
        }

        if(!sstack.empty())
        {
            p=sstack.top();
            sstack.pop();
            printf("%d\t",p->data);
            p=p->rightchild;
        }
    }
}
//后续稍微难一点 已经忘了。。需要定义一个enum呢
struct stackelement
{
    BinaryTreeNode * p;
    bool rvis;
};
void PostorderTravelRecursive(BinaryTreeNode * root)
{
    stackelement element;
    stack<stackelement> sstack;
    BinaryTreeNode * p=root;
    while(p!=NULL)//首先，从根节点开始，往左下方走，一直走到头，将路径上的每一个结点入栈。
    {
        element.p=p;
        element.rvis=false;//刚压入栈的 右孩子肯定没有访问过
        sstack.push(element);
        p=p->leftchild;
    }
    while(!sstack.empty())
    {
        element=sstack.top();//任意一个结点N，只要他有左孩子，则在N入栈之后，N的左孩子必然也跟着入栈了(这个体现在算法的后半部分)
        //所以当我们拿到栈顶元素的时候，可以确信这个元素要么没有左孩子，要么其左孩子已经被访问过，
        //所以此时我们就不关心它的左孩子了，我们只关心其右孩子。
        if(element.p->rightchild==NULL || element.rvis==true)//若其右孩子已经被访问过，或是该元素没有右孩子，可以visit这个结点了
        {
            printf("%d\t",element.p->data);
            sstack.pop();
        }

        /*

        //若它的右孩子存在且rvisited为0，说明以前还没有动过它的右孩子，于是就去处理一下其右孩子
        //此时我们要从其右孩子结点开始一直往左下方走，直至走到尽头，将这条路径上的所有结点都入栈。
　　//当然，入栈之前要先将该结点的rvisited设成1，因为其右孩子的入栈意味着它的右孩子必将先于它被访问
        //(这很好理解，因为我们总是从栈顶取出元素来进行visit)。
    //由此可知，下一次该元素再处于栈顶时，其右孩子必然已被visit过了，所以此处可以将rvisited设置为1。
        */
        else
        {
                sstack.top().rvis=1;//注意这里是top 不是修改element
                p=element.p->rightchild;
                while(p!=NULL)
                {
                    element.p=p;
                    element.rvis=false;
                    sstack.push(element);
                    p=p->leftchild;
                }
        }
    }
}
void PostorderTravel(BinaryTreeNode * root)
{
    if(root==NULL) return ;
    PostorderTravel(root->leftchild);
    PostorderTravel(root->rightchild);
    printf("%d\t",root->data);
}
//这个函数很简单 按照先序的遍历 如果遇到空的节点 或者叶子节点 就返回 否则交换两个子树后再 改变左右子树
void MirrorBinaryTree(BinaryTreeNode * root)
{
    if(root==NULL || (root->leftchild==NULL && root->rightchild ==NULL))  return ;
    BinaryTreeNode * tmp=root->leftchild;
    root->leftchild=root->rightchild;
    root->rightchild=tmp;
    MirrorBinaryTree(root->leftchild);
    MirrorBinaryTree(root->rightchild);
}

int main()
{
    CreateTree();
    cout<<"先序"<<endl;
    PreorderTravel(root);
    cout<<endl;
    PreorderTravelNoRecrusive(root);
    cout<<endl;
    cout<<"中序"<<endl;
    InorderTravel(root);
    cout<<endl;
    InorderTravelNoRecursive(root);
    cout<<endl;
    cout<<"后序"<<endl;
    PostorderTravel(root);
    cout<<endl;
    PostorderTravelRecursive(root);
    cout<<endl;
    MirrorBinaryTree(root);
    cout<<"镜像的前序"<<endl;
    PreorderTravel(root);

    return 0;
}