二叉树的各种操作

#include<stdio.h>
#include "stdlib.h"
#include<iostream>
#include<stack>
#include<queue>
using namespace std;

//节点定义
typedef struct biNode{
    char val;
    biNode* left;
    biNode* right;
}biNode;

//创建一棵树
void createBiTree(biNode* &root){
    char c;
    cin >> c;
    if(c == '#'){
        root = NULL;
    }else{
       if( !(root = (biNode*)malloc(sizeof(biNode))) ) exit(OVERFLOW); //分配存储空间
       root->val = c;      
       //生成根节点
       createBiTree(root->left);            //生成左子树
       createBiTree(root->right);           //生成右子树
    }
}

//前序遍历（根左右）递归
void preSeqOrderRec(biNode *root){
    if(root == NULL){
        return ;
    }
    printf("%c ",root->val);
    preSeqOrderRec(root->left);
    preSeqOrderRec(root->right);
}

//前序遍历（根左右）非递归
void preSeqOrderNoRec(biNode *root){
    if(root == NULL)
        return;
    stack<biNode*> st;
    while(root || !st.empty()){
        while(root){
            st.push(root);
            printf("%c ",root->val);
            root = root->left;
        }
        root = st.top();
        st.pop();
        root = root->right;
    }
}

//中序遍历（左根右）递归
void inSeqOrderRec(biNode *root){
    if(root == NULL){
        return ;
    }
    inSeqOrderRec(root->left);
    printf("%c ",root->val);
    inSeqOrderRec(root->right);
}

//中序遍历（左根右）非递归
void intSeqOrderNoRec(biNode *root){
    if(root == NULL)
        return;
    stack<biNode*> st;
    while(root || !st.empty()){
        while(root){
            st.push(root);
            root = root->left;
        }
        root = st.top();
        st.pop();
        printf("%c ",root->val);
        root = root->right;
    }
}

//后序遍历（左右根）递归
void postSeqOrderRec(biNode *root){
    if(root == NULL){
        return ;
    }
    postSeqOrderRec(root->left);    
    postSeqOrderRec(root->right);
    printf("%c ",root->val);
}

//后序遍历（左右根）非递归
void postSeqOrderNoRec(biNode *root){
    if(root == NULL){
        return ;
    }
    stack<biNode*> st;
    biNode* p;
    p = root;
    do
    {
       while (p){//左子树进栈
        st.push(p);
        p = p->left;
       }
       while (!st.empty() && st.top()->right == p){
        p = st.top();    //栈顶结点出栈
        st.pop();
        printf("%c ",p->val);
       }
       if (!st.empty())
        p = st.top()->right; //开始遍历右子树
    }while(!st.empty());
}

//层序遍历
void levelSeqVisit(biNode *root){
    if(root == NULL)
        return ;
    queue<biNode*> que;
    que.push(root);
    biNode *p;
    while(!que.empty()){
        p = que.front();
        que.pop();
        printf("%c ",p->val);
        if(p->left)
            que.push(p->left);
        if(p->right)
            que.push(p->right);
    }
}

//所有节点个数
int getNodeCount(biNode* root){
    if(root == NULL)
        return 0;
    int count = 1;
    count += getNodeCount(root->left);
    count += getNodeCount(root->right);
    return count;
}

//得到叶子节点个数
int getLeafCount(biNode* root){
    if(root == NULL)
        return 0;
    int count = 0;
    if(root->left == NULL && root->right == NULL){
        count ++;
    }else{
        count += getLeafCount(root->left);
        count += getLeafCount(root->right);
    }
    return count;
}

//树的高度
int getDepth(biNode *root){
    if(root == NULL)
        return 0;
    int leftDepth = getDepth(root->left);
    int rightDepth = getDepth(root->right);
    return leftDepth>rightDepth ? (leftDepth+1) : (rightDepth+1);
}

//某节点所在层次
int getLevelByNode(biNode *root,char toFind,int &count){
    
    if(root==NULL || toFind==NULL)
        return 0;
    if(root->val == toFind ){
        count++;
        return 1;
    }
    if(getLevelByNode(root->left,toFind,count) || getLevelByNode(root->right,toFind,count)){
        count++;
        return 1;
    }

    return 0;
}

//是否为平衡树
bool isBalanceTree(biNode* root){
    if(root == NULL)
        return false;
    int leftDepth  = getDepth(root->left);
    int rightDepth = getDepth(root->right);
    if(leftDepth-rightDepth>1 || rightDepth-leftDepth<-1)
        return false;
    return true;
}

//是否为平衡树（优化版）
bool isBalanceTreeOptimize(biNode* root, int* Depth){
    if(root == NULL){
        *Depth = 0;
        return true;
    }
    int left=0,right=0;
    if(isBalanceTreeOptimize(root->left,&left) && isBalanceTreeOptimize(root->right,&right)){
        int diff = left - right;
        if(diff<=1 && diff>=-1){
            *Depth = 1 + (left>right ? left : right);
            return true;
        }
    }
    return false;
}

//是否为完全二叉树
bool isCompleteTree(biNode *root){
    queue<biNode*> que;
    que.push(root);
    biNode* p;
    bool isFirstLeaf = false;
    while(!que.empty()){
        p = que.front();
        que.pop();
        //第一个叶子节点
        if(p->left==NULL && p->right==NULL){
            isFirstLeaf = true;
        }
        bool LOrR  = p->left != NULL || p->right != NULL;
        bool LAndR = p->left != NULL && p->right != NULL; 
        //第一个叶子节点之后的节点，都是叶子节点
        if(isFirstLeaf && LOrR){
            return false;
        }
        //第一个叶子之前的节点，都有两个孩子
        if(!isFirstLeaf && !LAndR){
            return false;
        }
        if(p->left != NULL)
            que.push(p->left);
        if(p->right != NULL)
            que.push(p->right);
    }
    return true;
}

//是否满二叉树
bool isFullTree(biNode* root){
    if(root==NULL){
        return true;
    }
    int lDepth = getDepth(root->left);
    int rDepth = getDepth(root->right);
    int diff = lDepth - rDepth;
    if(diff==0 && isFullTree(root->left) && isFullTree(root->right)){
        return true;
    }
    return false;
}

int main(){
     biNode* T;
     
     //ab#c##d##
     printf("\n创建树:\n"); 
     createBiTree(T);
     
     printf("\n前序遍历（递归）：\n");
     preSeqOrderRec(T);
     printf("\n前序遍历（非递归）：\n");
     preSeqOrderNoRec(T);

     printf("\n中序遍历（递归）：\n");
     inSeqOrderRec(T);
     printf("\n中序遍历（非递归）：\n");
     intSeqOrderNoRec(T);

     printf("\n后序遍历（递归）：\n");
     postSeqOrderRec(T);
     printf("\n后序遍历（非递归）：\n");
     postSeqOrderNoRec(T);

     
     printf("\n节点数为：\n%d",getNodeCount(T));
     printf("\n叶子节点数为：\n%d",getLeafCount(T));

     printf("\n树的高度为：\n%d",getDepth(T));

     printf("\n层序遍历：\n");
     levelSeqVisit(T);

     int level = 0 ;
     getLevelByNode(T,'d',level);
     printf("\n某个节点所在层次：\n%d",level);

     printf("\n是否为平衡数：%d\n",isBalanceTree(T));

     int depth = 0;
     bool isBanlance = isBalanceTreeOptimize(T,&depth);
     printf("\n是否为平衡树优化版：%d,且高度为：%d\n",isBanlance,depth);

     printf("\n是否为完全二叉树：%d\n",isCompleteTree(T));

     printf("\n是否为满二叉树：%d\n",isFullTree(T));

     printf("\n");
}