二叉树各种递归算法集合

1。递归求二叉树高度

int height(BiTree T) {
    if(T == NULL) return 0;   // 若不存在返回0
    int a = height(T->lchild);
    int b = height(T->rchild);
    return a > b ? a+1 : b+1; // 返回左子树和右子树中较高的，并且+1
}

2。

递归求二叉树中度数为1的结点个数

int degree1(BiTree T){
    if(T == NULL) return 0;
    int a = degree1(T->lchild);
    int b = degree1(T->rchild);
    if( (T->lchild != NULL && T->rchild == NULL) ||
        (T->lchild == NULL && T->rchild != NULL)) 
            return a+b+1; // 若左右子树有且仅有一个存在，则返回左右子树之和再+1
    return a+b;           // 其他情况，返回左右子树之和
}

递归求二叉树中度数为0的结点个数

int degree1(BiTree T){
    if(T == NULL) return 0;
    int a = degree1(T->lchild);
    int b = degree1(T->rchild);
    if(T->lchild == NULL && T->rchild == NULL) 
        return a+b+1; // 若左右子树都不存在，则返回左右子树之和再+1
    return a+b;           // 其他情况，返回左右子树之和
}

递归求二叉树中度数为2的结点个数

int degree1(BiTree T){
    if(T == NULL) return 0;
    int a = degree1(T->lchild);
    int b = degree1(T->rchild);
    if(T->lchild != NULL && T->rchild != NULL) 
        return a+b+1; // 若左右子树都存在，则返回左右子树之和再+1
    return a+b;           // 其他情况，返回左右子树之和
}

3。统计二叉树的宽度

const int maxsize = 100;
typedef struct{
    Bitree data[maxsize];
    int level[maxsize];    // 保存data中相同下标结点的层次
    int front,rear;
}Q;

int Width(BiTree T){
    Bitree p;
    int k, max, i, n;
    Q.front = Q.rear = -1;  // 初始化队列
    Q.data[++Q.rear] = T;   // 根节点进入队列
    Q.level[Q.rear] = 1;

    while(Q.front < Q.rear) {
        p = Q.data[++Q.front];  // 出队
        k = Q.level[Q.front];   // 当前节点的层次
        // 左右孩子进队列，且层次加1
        if(p->lchild != NULL) {
            Q.data[++Q.rear] = p->lchild;
            Q.level[Q.rear] = k + 1;
        }
        if(p->lchild != NULL) {
            Q.data[++Q.rear] = p->lchild;
            Q.level[Q.rear] = k + 1;
        }
    }

    max = 0; i = 0;             // max保存同一层最多的结点个数
    k = 1;
    while(i <= Q.rear) {
        n = 0;                  // n统计 k层的结点个数
        while(i <= Q.rear && Q.level[i] == k) {
            n++; i++;
        }
        k = Q.level[i];
        if(n > max) max = n;
    }
    return max;
}

4。删去二叉树中所以叶节点

// 二叉树删去所有叶节点
// 先序 否则有可能子树删除以后把自己也删了
void delete(BiTree T){
    if(T != NULL) {
        if(T->lchild == NULL && T->rchild == NULL)      // 删除叶节点
            free(T);
        else {
            delete(T->lchild);   // 左树删除
            delete(T->rchild);   // 右树删除
        }
    }
}

5。计算指定节点*p所在层次

struct BiNode {
    struct BiNode * lchild, * rchild;
} BiNode, *BiTree;

int level_output(BiTree T, BiNode *p){
    return T ? __level(T, p, 1) : 0;  // 若T不存在返回0
}

int __level(BiTree T, BiNode *p, int l){
    if(T == NULL) return 0;
    if(p = T) return l;     // 返回当前层

    int lc = __level(T->lchild, p, l+1);
    if (lc > 0) return lc;

    int rc = __level(T->rchild, p, l+1);
    if (rc > 0) return rc;

    return -1;
}

6。计算二叉树中各节点最大元素的值

int max = -1;
void Max(BiTree T){
    if(p != NULL) {
        if(T->data > max) max = T->data;
        Max(T->lchild);
        Max(T->rchild);
    }
}

7。交换二叉树中每个节点的两个孩子

// 后序，左右子树都反转完成后，再将左右交换
void reverse(BiTree T) {
    if(T) {
        reverse(T->lchild);
        reverse(T->rchild);

        BiTree p = T->lchild;
        T->lchild = T->rchild;
        T->rchild = p;
    }
}

8。先序遍历输出所有节点值和其所在层次

void print(BiTree T) {
    __print(T,1);
}
void output(BiTree T, int level) {
    printf("%d %d\n", T->data, level);
}
void __print(BiTree T, int level) {
    if(T) {
        output(T, level);
        __print(T->lchild, level + 1);
        __print(T->rchild, level + 1);
    }
}

二叉树各种递归算法集合

猜你喜欢