二叉树基本操作2

//删除以cur为根结点的树
void delete_tree(node *&cur){
    if(cur!=NULL){
        delete_tree(cur->lchild);
        delete_tree(cur->rchild);
        //delete只是释放内存,指针可能成为野指针
        delete cur;
        cur=NULL;
    }
}


//删除所有值为value的结点的子树
//注意参数为指针的引用或指针的指针
void delete_all(node* &cur, char value){
    if(cur->lchild!=NULL){
        delete_all(cur->lchild,value);
    }
    if(cur->rchild!=NULL){
        delete_all(cur->rchild,value);
    }
    if(cur->data==value){
        delete_tree(cur);
    }
}



//借助队列实现层序遍历
void layorder(Node* root, int max_len){
    Node* Queue[max_len];
    Node* temp;
    int head=0,tail=-1;
    tail++;
    Queue[tail]=root;
    while(head<=tail){
        temp=Queue[head];
        if(temp!=root) cout<<" ";
        cout<<temp->data;
        if(temp->lchild!=NULL){
            tail++;
            Queue[tail]=temp->lchild;
        }
        if(temp->rchild!=NULL){
            tail++;
            Queue[tail]=temp->rchild;
        }
        head++;
    }
}


//以三元组形式(e.g.^AL,ABL,^^L)输入二叉树
Node* build(){
    Node* Queue[100];
    Node *temp, *root=NULL;
    int head=0,tail=-1;
    string buffer;
    cin>>buffer;
    while(buffer[1]!='^'){
        temp=new Node;
        temp->data=buffer[1];
        if(buffer[0]=='^'){
            root=temp;
            tail++;
            Queue[tail]=temp;
        }
        else{
            while(Queue[head]->data!=buffer[0]){
                head++;
            }
            if(buffer[2]=='L'){
                Queue[head]->lchild=temp;
                tail++;
                Queue[tail]=temp;
            }
            else if(buffer[2]=='R'){
                Queue[head]->rchild=temp;
                tail++;
                Queue[tail]=temp;
            }
        }
        cin>>buffer;
    }
    return root;
}



//返回data域为goal的结点指针
Node *find_node(Node *cur, Type goal){
    Node *temp;
    if(cur==NULL){
        return NULL;
    }
    else if(cur->data==goal){
        return cur;
    }
    else{
        temp=find_node(cur->lchild,goal);
        if(temp!=NULL) return temp;
        else return find_node(cur->rchild,goal);
    }
}



//递归寻找目标结点(same data)的父结点
//当然也可以不用递归,用队列进行层序遍历并比较
Node* find_parent(Node *&cur,Node *&goal){
    if(cur->lchild!=NULL){
        if(cur->lchild->data==goal->data){
            return cur;
        }
        if(find_parent(cur->lchild,goal)!=NULL){
            return find_parent(cur->lchild,goal);
        }
    }
    if(cur->rchild!=NULL){
        if(cur->rchild->data==goal->data){
            return cur;
        }
        if(find_parent(cur->rchild,goal)!=NULL){
            return find_parent(cur->rchild,goal);
        }
    }
    return NULL;
}

//递归求树的高度
//也可以不用递归,用栈求
int height(Node *cur){
    int lmax,rmax;
    if(cur==NULL) return 0;
    lmax=height(cur->lchild);
    rmax=height(cur->rchild);
    return max(lmax,rmax)+1;
}



//求二叉树的宽度(结点数最多的那一层的结点个数)
//在层序遍历的基础上,给队列元素加上一个变量记录层数
//最后从头到尾记录下每层结点数并找出最大值
int max_width(Node *root){
    if(root==NULL) return 0;
    struct{
        int level_no;
        Node *p;
    }Queue[MAX_SIZE];
    Node *temp;
    int head=0,tail=-1,cur_level;
    tail++;
    Queue[tail].p=root;
    Queue[tail].level_no=1;
    while(tail>=head){
        cur_level=Queue[head].level_no;
        temp=Queue[head].p;
        head++;
        if(temp->lchild!=NULL){
            tail++;
            Queue[tail].p=temp->lchild;
            Queue[tail].level_no=cur_level+1;
        }
        if(temp->rchild!=NULL){
            tail++;
            Queue[tail].p=temp->rchild;
            Queue[tail].level_no=cur_level+1;
        }
    }
    int i=0,max=0,cur_max;
    cur_level=1;
    while(i<=tail){
        cur_max=0;
        while(i<=tail&&Queue[i].level_no==cur_level){
            cur_max++;
            i++;
        }
        if(max<cur_max) max=cur_max;
        //这一层结束了就进入下一层数结点
        cur_level++;
    }
    return max;
}


//求二叉树叶子结点的个数
int leaf_nodes(Node *cur){
    if(cur==NULL){
        return 0;
    }
    else if(cur->lchild==NULL&&cur->rchild==NULL){
        return 1;
    }
    else{
        return leaf_nodes(cur->lchild)+leaf_nodes(cur->rchild);
    }
}


//求结点data==goal的结点的深度(假设只有1个)
int level(Node *cur, Type goal, int cur_level){
    int left,right;
    if(cur==NULL){
        return 0;
    }
    else if(cur->data==goal){
        return cur_level;
    }
    else{
        left=level(cur->lchild,goal,cur_level+1);
        if(left!=0) return left;
        else return right=level(cur->rchild,goal,cur_level+1);
    }
}