二叉树基本操作C++实现

二叉树基本操作C++实现

基本操作预览:
先序遍历: element:1 element:2 element:3
中序遍历: element:2 element:1 element:3
二叉树的结点个数： 3
度为2的结点个数: 1
度为1的结点个数: 0
叶子结点个数: 2
二叉树的高度: 2
是不是完全二叉树(1-是;0-不是): 1

#include <stdio.h>

#include <iostream>


using namespace std;
typedef struct Node{
    int data;
    struct Node *lchild, *rchild;
}Node, *Tree;


void pre_order(Tree tree){
    
    cout << "element:" << tree->data << " " ;
    if (tree->lchild!=NULL) {
        pre_order(tree->lchild);
    }
    if (tree->rchild!=NULL) {
        pre_order(tree->rchild);
    }
   
}
// 中序遍历
void in_order(Tree tree){
    if (tree!=NULL) {
        in_order(tree->lchild);
        cout << "element:" << tree->data << " ";
        in_order(tree->rchild);
    }
    
}

// 创建二叉树
void create_tree(Tree &tree){
    int data = 0;

    cin >> data;
    
    if (data == -1) {
        tree = NULL;
    }else{
        tree = (Node *)malloc(sizeof(Node));
        tree->data = data;
        tree->lchild = NULL;
        tree->rchild = NULL;

        cout  << "结点:" << data << " 输入它的左结点, 若没有输入-1结束 " << endl;
        create_tree(tree->lchild);
        cout  << "结点:" << data << " 输入它的右结点, 若没有输入-1结束 " << endl;
        create_tree(tree->rchild);
    }
    
}
// 二叉树所有结点数量
int tree_count(Tree tree){
    if (tree == NULL) {
        return 0;
    }
    int left = 0, right = 0;
    if (tree->lchild!=NULL) {
        left = tree_count(tree->lchild);
    }
    if (tree->rchild!=NULL) {
        right = tree_count(tree->rchild);
    }
    return 1 + right + left;
}

// 度为2的结点数量
int tree_2_count(Tree tree){
    
    if (tree->lchild!=NULL&&tree->rchild!=NULL) {
        return 1+tree_2_count(tree->lchild)+tree_2_count(tree->rchild);
    }

    if (tree->lchild!=NULL) {
        return tree_2_count(tree->lchild);
    }
    if (tree->rchild!=NULL) {
        return tree_2_count(tree->rchild);
    }
    return 0;//tree == NULL
}

// 度为1的结点数量
int tree_1_count(Tree tree){
    // 前缀匹配
    if (tree->lchild!=NULL&&tree->rchild!=NULL) {
        return tree_1_count(tree->lchild)+tree_1_count(tree->rchild);
    }
    // 前缀匹配
    if (tree->lchild!=NULL) {
        return 1+tree_1_count(tree->lchild);
    }
    // 前缀匹配
    if (tree->rchild!=NULL) {
        return 1+tree_1_count(tree->rchild);
    }
    return 0;//tree == NULL
}

int tree_0_count(Tree tree){
    if (tree==NULL) {
        return 0;
    }
    if (tree->lchild==NULL&&tree->rchild==NULL) {
        return 1;
    }
    return tree_0_count(tree->lchild)+tree_0_count(tree->rchild);//tree != NULL
}

int tree_depth(Tree tree){
    if (tree == NULL) {
        return 0;
    }
    
    int m = tree_depth(tree->lchild);
    int n = tree_depth(tree->lchild);
    
    return m>n?m+1:n+1;
}
// 统计叶子结点数量
int leaf_count(Tree tree){
    
    if (tree==NULL) {
        return 0;
    }

    if (tree->lchild == NULL && tree->lchild == NULL) {
        return 1;
    }else{
    
        int num = leaf_count(tree->lchild) + leaf_count(tree->rchild);
        return num;
    }
}

typedef Node* ElemType;
typedef struct LNode{
    ElemType data;
    LNode *next;
}LNode;

typedef struct Queue{
    LNode *front;
    LNode *rear;
} Queue;

void InitQueue(Queue &queue){
    LNode *p = (LNode *)malloc(sizeof(LNode));
    p->data = 0;
    p->next = NULL;
    
    queue.front = queue.rear = p;
}
void EnQueue(Queue &queue, ElemType value){
    LNode *p = (LNode *)malloc(sizeof(LNode));
    p->data = value;
    p->next = NULL;
    
    queue.rear->next = p;
    queue.rear = p;
    
}
bool DeQueue(Queue &queue, ElemType &value){
    if (queue.front==queue.rear) {
        return false;
    }
    LNode *p = queue.front->next;
    value = p->data;
    queue.front->next = p->next;
    
    // 如果是最后一个数据元素，修改尾指针
    if (p == queue.rear) {
        queue.rear = queue.front;
    }
    free(p);
    return true;
}

// 判断是否完全二叉树
bool IsComplete(Tree tree){
    
    Queue queue;
    InitQueue(queue);
    EnQueue(queue, tree);
    
    Node *p = NULL;
    while (queue.front!=queue.rear) {
        DeQueue(queue, p);
        if (p!=NULL) {
//            cout << "level order: " << p->data << endl;
            EnQueue(queue, p->lchild);
            EnQueue(queue, p->rchild);
        }else{
            while (queue.front!=queue.rear) {
                DeQueue(queue, p);
                if (p!=NULL) {
                    return false;
                }
            }
        }
        p = NULL;
    }
    return true;
}
int main(){
    cout << "welcome, to my world!" << endl;
    Tree tree = NULL;

    cout << "size of:" << sizeof(tree) << endl;
    cout << "创建二叉树，请输入第一个结点: " << endl;
    create_tree(tree);
    cout << "先序遍历: ";
    pre_order(tree);
    cout << endl;
    cout << "中序遍历: ";
    in_order(tree);
    cout << endl;
    int leaf_num = 0;
 
    
    cout << "二叉树的结点个数： " << tree_count(tree) << endl;
    
    leaf_num = tree_2_count(tree);
    cout << "度为2的结点个数: " << leaf_num << endl;
    
    leaf_num = tree_1_count(tree);
    cout << "度为1的结点个数: " << leaf_num << endl;
    
    
    
    leaf_num = tree_0_count(tree);
    cout << "叶子结点个数: " << leaf_num << endl;
    
    
    leaf_num = tree_depth(tree);
    cout << "二叉树的高度: " << leaf_num << endl;
    
    bool is_complete = IsComplete(tree);
    cout << "是不是完全二叉树(1-是;0-不是): " << is_complete << endl;
    
    return 0;
}

输出

welcome, to my world!
size of:8
创建二叉树，请输入第一个结点:
1
结点:1 输入它的左结点, 若没有输入-1结束
2
结点:2 输入它的左结点, 若没有输入-1结束
-1
结点:2 输入它的右结点, 若没有输入-1结束
-1
结点:1 输入它的右结点, 若没有输入-1结束
3
结点:3 输入它的左结点, 若没有输入-1结束
-1
结点:3 输入它的右结点, 若没有输入-1结束
-1
先序遍历: element:1 element:2 element:3
中序遍历: element:2 element:1 element:3
二叉树的结点个数： 3
度为2的结点个数: 1
度为1的结点个数: 0
叶子结点个数: 2
二叉树的高度: 2
是不是完全二叉树(1-是;0-不是): 1
Program ended with exit code: 0