二叉树的实现

功能

1. 前、中、后序方法建立二叉树。

2. 实现二叉树前、中、后序遍历(包括递归与非递归算法)。

3. 实现二叉树的层次遍历。

4. 交换二叉树的左右子数。

5. 求二叉树的叶子总数，高度。

#include <iostream>
using namespace std;
#include <stack>
#include <queue>
struct BinTreeNode{
    int data;
    BinTreeNode *leftChild,*rightChild;
};

void preOrder(BinTreeNode *t){
    if(t!=0){cout<<t->data<<" ";
        preOrder(t->leftChild);
        preOrder(t->rightChild);
    }
}

void preOrderWithoutRecursion(BinTreeNode *t){
    /*：如果二叉树非空，则
     （1）将二叉树的根结点作为当前结点。
     （2）若当前结点非空，则先输出该结点，并将该结点进栈，再将其左孩子结点作为当前结点，重复步骤(2)，直到当前结点为空为止。
     （3）若栈非空，则将栈顶结点出栈，并将该结点的右孩子结点作为当前结点。
     （4）重复步骤(2), (3)，直到栈为空且当前结点为空为止。*/
    stack<BinTreeNode*> s;
    while(!s.empty()||t!=NULL){
        while(t!=NULL){cout<<t->data<<" ";s.push(t);t=t->leftChild;}
        if(!s.empty()){t=s.top();s.pop();t=t->rightChild;}
    }
}

void inOrder(BinTreeNode *t){
    if(t!=NULL){
        inOrder(t->leftChild);
        cout<<t->data<<" ";
        inOrder(t->rightChild);
    }
}

void inOrderWithoutRecursion(BinTreeNode *t){
    /*如果二叉树非空，则
     （1）将二叉树的根结点作为当前结点；
     （2）若当前结点非空，则该结点进栈并将其左孩子结点作为当前结点，重复步骤（2），直到当前结点为空为止；
     （3）若栈非空，则将栈顶结点出栈并作为当前结点，接着访问当前结点，再将当前结点的右孩子结点作为当前结点；
     （4）重复步骤（2）、（3），直到栈为空且当前结点为空为止。*/
    stack<BinTreeNode*> s;
    while(!s.empty()||t!=NULL){
        while(t!=NULL){s.push(t);t=t->leftChild;}
        if(!s.empty()){t=s.top();s.pop();cout<<t->data<<" ";t=t->rightChild;}
    }
}
void postOrder(BinTreeNode *t){
    if(t!=NULL){
        postOrder(t->leftChild);
        postOrder(t->rightChild);
        cout<<t->data<<" ";
    }
}


void postOrderWithoutRecursion(BinTreeNode *t){
    //用非递归算法进行后序遍历二叉树时，一个结点需要进栈，出栈各两次。为了区别同一个结点的两次进栈，需要设置一个标志flag, flag=0为第一次进栈，表示该结点出栈之后不能访问；flag=1为第二次进栈，表示该结点出栈之后可以访问
    stack<BinTreeNode*> s;
    stack<int> num;int flag;
    while(!s.empty()||t!=NULL){
        while(t!=NULL){s.push(t);num.push(0);t=t->leftChild;}
        if(!s.empty()){
            t=s.top();s.pop();flag=num.top();num.pop();
            if(flag==1){cout<<t->data<<" ";t=0;}
            else{s.push(t);num.push(1);t=t->rightChild;}
        }
    }
}

void levelOrder(BinTreeNode *t){
    /*层次遍历的过程：
     (1)遍历进行之前先将二叉树的根结点存入队列中。
     (2)然后依次从队列中取出队头结点，每取出一个结点，都先访问该结点。
     (3)接着分别检查该结点是否存在左、右孩子，若存在则先后入列。
     (4)如此反复，直到队列为空为止。*/
    queue<BinTreeNode* > q; q.push(t);
    while (!q.empty()){
        t=q.front();
        q.pop();
        cout<<t->data<<" ";
        if(t->leftChild!=NULL) q.push(t->leftChild);
        if(t->rightChild!=NULL) q.push(t->rightChild);
    }
}


int size(BinTreeNode *t){
    if(t==0) return 0;
    else if(t->leftChild==0&&t->rightChild==0) return 1;
    else return size(t->rightChild)+size(t->leftChild);
}

int height(BinTreeNode *t){
    if(t==0) return 0;
    else{
        int LeftHeight = height(t->leftChild);
        int RightHeight = height(t->rightChild);
        return LeftHeight>RightHeight?LeftHeight+1:RightHeight+1;
    }
}

BinTreeNode * preOrderCreate(int value){
    BinTreeNode *current;
    int i;cin>>i;
    if(i==value) return NULL;
    else{
        current = new BinTreeNode;
        current->data=i;
        current->leftChild=preOrderCreate(value);
        current->rightChild=preOrderCreate(value);
        return current;
    }
}

BinTreeNode * inOrderCreate(int value){
    BinTreeNode *current,*q;
    int i;cin>>i;
    if(i==value) return NULL;
    else{
        q=inOrderCreate(value);
        current = new BinTreeNode;
        current->data=i;
        current->leftChild=q;
        current->rightChild=inOrderCreate(value);
        return current;
    }
}

BinTreeNode * postOrderCreate(int value){
    BinTreeNode *current,*l,*r;
    int i;cin>>i;
    if(i==value) return NULL;
    else{
        l=postOrderCreate(value);
        r=postOrderCreate(value);
        current = new BinTreeNode;
        current->data=i;
        current->leftChild=l;
        current->rightChild=r;
        return current;
    }
}

void swop(BinTreeNode *t){
    BinTreeNode *temp;
    if(t->leftChild!=NULL&&t->rightChild!=NULL){
        temp=t->leftChild;t->leftChild=t->rightChild;t->rightChild=temp;
        swop(t->leftChild);swop(t->rightChild);
    }
}

void nodePrint(BinTreeNode *t){
    if(t){
        cout<<t->data<<" ";
        nodePrint(t->leftChild);
        nodePrint(t->rightChild);
    }
}

int main(){
    cout<<"**************输入数字实现对应功能**************"<<endl;
    cout<<"              1. 前序建立一棵二叉树"<<endl;
    cout<<"              2. 前序建立一棵二叉树"<<endl;
    cout<<"              3. 前序建立一棵二叉树"<<endl;
    cout<<"              4. 前序遍历递归算法"<<endl;
    cout<<"              5. 前序遍历非递归算法"<<endl;
    cout<<"              6. 中序遍历递归算法"<<endl;
    cout<<"              7. 中序遍历非递归算法"<<endl;
    cout<<"              8. 后序遍历递归算法"<<endl;
    cout<<"              9. 后序遍历非递归算法"<<endl;
    cout<<"              10. 层次遍历算法"<<endl;
    cout<<"              11. 求树高"<<endl;
    cout<<"              12. 求叶子总数"<<endl;
    cout<<"              13. 输出二叉树"<<endl;
    cout<<"              14. 交换左右子数"<<endl;
    cout<<"              15. 退出"<<endl;
    BinTreeNode *root;
    int i;
    while(cin>>i){
        switch (i) {
        case 1:root = preOrderCreate(-1);break;
        case 2:root = inOrderCreate(-1);break;
        case 3:root = postOrderCreate(-1);break;
        case 4: preOrder(root);break;
        case 5: preOrderWithoutRecursion(root);break;
        case 6: inOrder(root);break;
        case 7: inOrderWithoutRecursion(root);break;
        case 8: postOrder(root);break;
        case 9: postOrderWithoutRecursion(root);break;
        case 10:levelOrder(root);break;
        case 11:cout<<"Height: "<<height(root)<<endl;break;
        case 12:cout<<"Size: "<<size(root)<<endl;break;
        case 13:nodePrint(root);break;
        case 14:swop(root);break;
        case 15:exit(0);break;

        }
    }

}