二叉树递归与非递归遍历，最近公共父节点算法

#include <iostream>
#include <stack>
using namespace std;

#define MAX 100           //字符串最大长度
typedef struct Node       //二叉树结点
{
    char data;
    Node *lchild,*rchild;
} *Btree;


void createBT(Btree &t);  //先序构造二叉树

void preorder(Btree &t);  //二叉树递归先序遍历
void inorder(Btree &t);   //递归中序遍历
void postorder(Btree &t); //递归后序遍历

void preorderbyStack(Btree &t); //先序非递归遍历
void inorderbyStack(Btree &t);  //中序非递归遍历
void postorderbyStack(Btree &t);//后序非递归遍历

/*****************最近公共父结点算法LCF*******************/
int findNode1(Btree &t,char ch,char p[]); //找出结点1到根的路径
int findNode2(Btree &t,char ch,char q[]); //找出结点2到根的路径

void compare(char *p,char *q);            //比较两条路径，找到第一个公共结点
static int i = 0;
static int j = 0;
/*****************最近公共父结点算法LCF*******************/

void createBT(Btree &t)   //先序创建二叉树 #表示空指针
{
    char ch;
    cin>>ch;
    if(ch == '#') t = NULL;
    
    else
    {
        if(!(t = new Node)) exit(1);
        
        t ->data = ch;    //递归创建二叉树
        createBT(t->lchild);
        createBT(t->rchild);
    }
}



void preorder(Btree &t)
{
    if(t == NULL)
        return ;
    else
    {
        cout<<t->data<<" ";
        preorder(t->lchild);
        preorder(t->rchild);
    }
}

void inorder(Btree &t)
{
    if(!t)
        return;
    else
    {
        inorder(t->lchild);
        cout<<t->data<<" ";
        inorder(t->rchild);
    }
}

void postorder(Btree &t)
{
    if(!t)
        return;
    else
    {
        postorder(t->lchild);
        postorder(t->rchild);
        cout<<t->data<<" ";
    }
}

void preorderbyStack(Btree &t)
{
    stack<Node*>s;
    Node *p = t;
    while (p || !s.empty())
    {
        if(p)
        {
            cout<<p->data<<" ";    //先序遍历二叉树，先访问根节点，再访问左子树
            s.push(p);
            p = p->lchild;
        }
        else
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
}

void inorderbyStack(Btree &t)
{
    stack<Node*>s;
    
    Node *p = t;
    
    while (p || !s.empty())
    {
        if(p)
        {
            s.push(p);
            p = p->lchild;
        }
        else
        {
            p = s.top();
            cout<<p->data<<" ";   //中序遍历二叉树，先访问左子树
            s.pop();
            p = p->rchild;
        }
    }
}

void postorderbyStack(Btree &t)
{
    stack<Node*> s;
    
    Node *p = t;
    Node *flag = nullptr;
    
    while (p || !s.empty())
    {
        if(p)                      //后序遍历先访问左结点，再右结点，最后根结点
        {
            s.push(p);
            p = p->lchild;
        }
        else
        {
            p = s.top();
            if( p->rchild&&p->rchild != flag) //如果右子树不为空且没有被访问过
            {
                p = p->rchild;                //转到右子树
                s.push(p);
                p = p->lchild;
            }
            else                            //如果右子树为空，当前结点为访问结点
            {
                s.pop();
                cout<<p->data<<" ";
                
                flag = p;                  //把刚刚访问的结点做标记，防止重复访问
                p = nullptr;               //把p置为空指针，如果不置位空。还要压入栈一次，就造成死循环
            }
        }
    }
}

bool isEmpty(Btree &t)
{
    return t == NULL?true:false;
}

int findNode1(Btree &t,char ch,char p[])
{
    if(!t)
        return 0;
    else if(t->data == ch)             //从所给的结点出发，搜索到达根节点的路径，并将路径记录下来
    {
        *(p+i) = t->data;
        ++i;
        return 1;
    }
    else
    {
        if(findNode1(t->lchild, ch, p))
        {
            *(p+i) = t->data;
            ++i;
            return 1;
        }
        else if(findNode1(t->rchild, ch, p))
        {
            *(p+i) = t->data;
            ++i;
            return 1;
        }
        else
            return 0;
    }
}

int findNode2(Btree &t,char ch,char q[])
{
    if(!t)
        return 0;
    else if(t->data == ch)
    {
        *(q+j) = t->data;
        ++j;
        return 1;
    }
    else
    {
        if(findNode2(t->lchild, ch, q))
        {
            *(q+j) = t->data;
            ++j;
            return 1;
        }
        else if(findNode2(t->rchild, ch, q))
        {
            *(q+j) = t->data;
            ++j;
            return 1;
        }
        else
            return 0;
    }
}

void compare(char *p,char *q)   //比较两条路径，第一个不同的路径点的父结点就是其公共父结点
{
    i--;
    j--;
    while(p[i] == q[j])
    {
        i--;
        j--;
    }
    
    cout<<"LCF is :"<<p[i+1]<<endl;
}

int main()
{
    //测试用例：abc##de#g##f###
    
    Btree t = new Node;
    createBT(t);
    preorder(t);
    cout<<endl;
    preorderbyStack(t);
    cout<<endl;
    inorder(t);
    cout<<endl;
    inorderbyStack(t);
    cout<<endl;
    postorder(t);
    cout<<endl;
    postorderbyStack(t);
    cout<<endl;
    
    char a[MAX];
    char b[MAX];
    

    
    findNode1(t, 'c',a);
    findNode2(t, 'e',b);
    
    compare(a, b);
    return 0;
}

 前序构造二叉树 字符#表示空。

二叉树的递归遍历与非递归遍历。后者借助栈

最近公共父节点是指对于二叉树中的两个结点 找到最近的公共父节点

转载于:https://www.cnblogs.com/cliviazhou/p/3916924.html