二叉树创建、遍历、查找等基本方法

二叉树创建、遍历（递归和非递归）、查找、高度、宽度、节点个数、叶子个数、找最近公共父节点，镜像树等基本方法

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

class Node
{
public:
    char value;
    Node *left;
    Node *right;
    Node():left(NULL),right(NULL){}
    Node(char ch):value(ch),left(NULL),right(NULL){}
};
class Tree
{
public:
    Node *root;
    Tree():root(NULL){}

void create(Node *&node,char *&str)   //树的创建
{
    if(*str=='#' || *str=='\0')
        node = NULL;
    else
    {
        node = new Node(*str);
        create(node->left,++str);
        create(node->right,++str);
    }
}
//前序遍历（递归）
void preOrder(Node *root)    
{
    if(root != NULL)
    {
        cout<<root->value;
        preOrder(root->left);
        preOrder(root->right);
    }
    
}
//中序遍历（递归）
void inOrder(Node *root)
{
    if(root!=NULL)
    {
        inOrder(root->left);
        cout<<root->value;
        inOrder(root->right);
    }
}
//后序遍历（递归）
void postOrder(Node *root)
{
    if(root != NULL)
    {
        postOrder(root->left);
        postOrder(root->right);
        cout<<root->value;
    }
}
//层次遍历（队列）
void floor(Node *root)
{
    queue<Node*> que;
    if(root != NULL)
        que.push(root);
    while(!que.empty())
    {
        Node *p = que.front();
        cout<<p->value;
        que.pop();
        if(p->left != NULL)
            que.push(p->left);
        if(p->right !=NULL)
            que.push(p->right);
    }
}
//求节点个数（递归）
int size(Node *root)
{
    if(root==NULL)
        return 0;
    else
        return size(root->left) + size(root->right) + 1 ;
}
//求树高度（递归）
int height(Node *root)
{
    if(root == NULL)
        return 0;
    else
    {
        int m = height(root->left);
        int n = height(root->right);
        return (m>n?m:n)+1;
    }
}
//搜索树节点（递归）
Node *search(Node *root,char k)
{
    Node *p = NULL;
    if(root == NULL)
        return NULL;
    if(root->value == k)
        return root;
    p = search(root->left,k);
    if(p != NULL)
        return p;
    return search(root->right,k);

}
//找父节点（递归）
Node *parent(Node *root,char k)
{
    Node *q = NULL;
    if(root == NULL || root->value==k)
        return NULL;
    if(root->left!=NULL&&root->left->value == k || root->right!=NULL&&root->right->value == k)
        return root;
    else
    {
    q = parent(root->left,k);
    if(q!=NULL)
        return q;
    
    return parent(root->right,k);
    }
}
//找左孩子
Node *leftChild(Node *node)
{
    if(node !=NULL)
        return node->left;
    return NULL;
}
//找右孩子
Node *rightChild(Node *node)
{
    if(node != NULL)
        return node->left;
    return NULL;
}
//前序遍历（非递归 栈）
void PreOrder(Node *root)
{
    stack<Node*> s;
    s.push(root);
    while(!s.empty())
    {
        Node *p = s.top();
        cout<<p->value<< " ";
        s.pop();
        if(p->right != NULL)
            s.push(p->right);
        if(p->left != NULL)
            s.push(p->left);
    }
}
//中序遍历（非递归 栈）
void InOrder(Node *root)
{
    stack<Node*> s;
    Node *p = root;
    while(p || !s.empty())
    {
        if(p != NULL)
        {
            s.push(p);
            p = p->left;
        }
        else
        {
             p = s.top();
             cout<<p->value;
             s.pop();
             p = p->right;

        }
    }
}
//后序遍历（非递归 栈）
void PostOrder(Node *root)
{
    stack<Node*> s;
    Node *pre = NULL;  //前一次访问的节点
    s.push(root);
    while(!s.empty())
    {
        Node *cur = s.top();
        if((cur->left==NULL && cur->right==NULL) || (pre!=NULL &&(pre==cur->left||pre==cur->right)))
        {
            cout<<cur->value;
            s.pop();
            pre=cur;
        }
        else
        {
            if(cur->right!=NULL)
                s.push(cur->right);
            if(cur->left!=NULL)
                s.push(cur->left);
        }
    }
}
//求叶子节点个数 (递归）
int leafSize(Node *root)
{
    if(root == NULL)
        return 0;
    if(root->left==NULL && root->right==NULL)
        return 1;
    else
        return leafSize(root->left) + leafSize(root->right);
}
//交换二叉树的左右儿子（镜像树）（递归）
void SwapLeftRightChild(Node *root)
{
    if(root==NULL ||(root->left==NULL && root->right==NULL))
        return;
    Node *tmp = root->left;
    root->left = root->right;
    root->right = tmp;

    SwapLeftRightChild(root->left);
    SwapLeftRightChild(root->right);
}
//最近公共父节点
Node* lowestAncestor(Node *root,char a,char b)
{
    if(root==NULL || root->value==a || root->value==b)
        return root;
    Node *p = lowestAncestor(root->left,a,b);
    Node *q = lowestAncestor(root->right,a,b);
    if(p != NULL && q !=NULL)
        return root;
    return p != NULL ? p:q;
}
//求宽度（双端队列）
int width(Node *root)
{
    if(root==NULL)
        return 0;
    deque<Node*> Q1,Q2;
    Q1.push_back(root);
    int tmp_width;
    int max_width = 1;
    while(!Q1.empty())
    {
        while(!Q1.empty())
        {
            Node *p = Q1.front();
            Q1.pop_front();
            if(p->left != NULL)
                Q2.push_back(p->left);
            if(p->right != NULL)
                Q2.push_back(p->right);
        }
        tmp_width = Q2.size();
        if(tmp_width > max_width)
            max_width = tmp_width;
        Q1 = Q2;
        Q2.clear();
    }
    return max_width;
}
};
void main()
{
    char *str = "ABC##DE##F##G#H##";
    Tree t;
    t.create(t.root,str);
    t.preOrder(t.root); 
    cout<<endl;
    t.floor(t.root);
    cout<<endl;
    t.postOrder(t.root);
    cout<<endl;
    t.PostOrder(t.root);
    cout<<endl;
    cout<<"size = "<<t.size(t.root)<<endl;
    cout<<"height = "<<t.height(t.root)<<endl;
    cout<<t.parent(t.root,'H')->value<<endl;
    cout<<t.leftChild(t.root)->value<<endl;
    cout<<"leafSize = "<<t.leafSize(t.root)<<endl;
    t.SwapLeftRightChild(t.root);
    t.preOrder(t.root); 
    cout<<endl;
    cout<<t.lowestAncestor(t.root,'B','G')->value<<endl;
    cout<<"width = "<<t.width(t.root)<<endl;

}