天勤数据结构笔记——第六章 树与二叉树（代码）

二叉树的链式存储结构 

typedef struct BTNode{
    char data;
    struct BTNode *lchild;
    struct BTNode *rchild;
}BTNode;

先序遍历

void preorder(BTNode *p){
    if(p!=NULL){
        visit(p);
        preorder(p->lchild);
        preorder(p->rchild);
    }
}

中序遍历

void preorder(BTNode *p){
    if(p!=NULL){
        preorder(p->lchild);
        visit(p);
        preorder(p->rchild);
    }
}

后序遍历

void preorder(BTNode *p){
    if(p!=NULL){
        preorder(p->lchild);
        preorder(p->rchild);
        visit(p);
    }
}

eg6-1 求出表达式的值 

int comp(BTNode *p){
    int A,B;
    if(p!=NULL){
        if(p->lchild!=NULL && p->rchild!=NULL){
            A=comp(p->lchild);
            B=comp(p->rchild);
            return op(A,B,p->data);
        }else{
            return p->data-'0';
        }
    }else{
        return 0;
    }
}

eg6-2 求二叉树的深度

int getDepth(BTNode *p){
    int LD,RD;
    if(p!=NULL){
        LD=getDepth(p->lchild);
        RD=getDepth(p->rchild);
        return (LD>RD?LD:RD)+1;
    }else{
        return 0;
    }
}

 eg6-3 按值查找

void search(BTNode *p,BTNode *&q,int key){
    if(p!=NULL){
        if(p->data==key){
            q=p;
        }else{
            search(p->lchild,q,key);
            if(q==NULL)
                search(p->rchild,q,key);
        }
    }
}

eg6-4 分别输出先序/中序/后续遍历的第k个值

int n=0;
//先序
void travel(BTNode *p,int k){
    if(p!=NULL){
        n++;
        if(k==n){
            cout<<p->data<<endl;
            return;
        } 
        travel(p->lchild,k);
        travel(p->rchild,k);
    }
}
//中序
void travel(BTNode *p,int k){
    if(p!=NULL){
        travel(p->lchild,k);
        n++;
        if(k==n){
            cout<<p->data<<endl;
            return;
        } 
        travel(p->rchild,k);
    }
}
//后序
void travel(BTNode *p,int k){
    if(p!=NULL){
        travel(p->lchild,k);
        travel(p->rchild,k);
        n++;
        if(k==n){
            cout<<p->data<<endl;
            return;
        }
    }
}

层次遍历

void level(BTNode *p){
    //初始化循环队列
    int front=rear=0;
    BTNode *que[maxSize];
    BTNode *q;//指向每次出队的结点
    if(p!=NULL){
        //根结点入队
        rear=(rear+1)%maxSize;
        que[rear]=p;
        //出队开始
        while(front!=rear){
            front=(front+1)%maxSize;
            q=que[front];
            visit(q);
            if(q->lchild!=NULL){
                rear=(rear+1)%maxSize;
                que[rear]=p->lchild;
            }
            if(q->rchild!=NULL){
                rear=(rear+1)%maxSize;
                que[rear]=p->rchild;
            }
        }
    }
}

eg6-5 求二叉树宽度

}BTNode;
typedef struct{
    BTNode *p;
    int lno;
}St;
int getWidth(BTNode *b){
    St que[maxSize];
    int front=rear=0;
    BTNode *q;
    int par_no;
    //层次遍历二叉树，给每个结点赋层号
    if(b!=NULL){
        ++rear;
        que[rear].p=b;
        que[rear].lno=1;
        while(front!=rear){
            front++;
            q=que[front].p;
            par_no=que[front].lno;
            if(q->lchild!=NULL){
                rear++;
                que[rear].p=q->lchild;
                que[rear].lno=par_no+1;
            }
            if(q->rchild!=NULL){
                rear++;
                que[rear].p=q->rchild;
                que[rear].lno=par_no+1;
            }
        }//最后par_no保留的是最大（后）一层的层号
        int max=0,n;
        for(int i=0;i<par_no;i++){//查找每一层
            n=0;
            if(int j=1;j<=rear;++j){
                if(que[j].lno==i) n++;
                if(max<n) max=n;
            }
        }
        return max;
    }else{
        return 0;//空树
    }
}

先序遍历的非递归算法

void preorderNonrecursion(BTNode *bt){
    if(bt!=NULL){
        BTNode *Stack[maxSize];
        int top=-1;
        Stack[++top]=bt;
        BTNode *p;
        while(top!=-1){
            p=Stack[top--];
            visit(p);
            if(p->rchild!=NULL){
                Stack[++top]=p->rchild;
            }
            if(p->lchild!=NULL){
                Stack[++top]=p->lchild;
            }
        }
    }
}

中序遍历的非递归算法

void inorderNonrecursion(BTNode *bt){
    if(bt!=NULL){
        BTNode *Stack[maxSize];
        int top=-1;
        BTNode *p=bt;
        while(top!=-1||p!=NULL){
            //左孩子存在则入栈
            while(p->lchild!=NULL){
                Stack[++top]=p;
                p=p->lchild;
            }
            //左孩子没了就输出，找右孩子
            if(top!=-1){
                p=Stack[top--];
                visit(p);p=p->rchild;
            }
        }
    }
}

后序遍历的非递归算法

void posorderNonrecursion(BTNode *bt){
    if(bt!=NULL){
        BTNode *Stack1[maxSize];int top1=-1;
        BTNode *Stack2[maxSize];int top2=-1;
        Stack1[++top1]=bt;
        BTNode *p=NULL;
        while(top1!=-1){
            p=Stack1[top1--];
            Stack2[++top2]=p;
            if(p->lchild!=NULL){
                Stack1[++top1]=p->lchild;
            }
            if(p->rchild!=NULL){
                Stack1[++top1]=p->rchild;
            }
        }
        while(top2!=-1){
            p=Stack2[top2--];
            visit(p);
        }
    }
}

中序线索化

void InThread(TBTNode *p, TBTNode *&pre){
    if(p!=NULL){
        InThread(p->lchild,pre);
        if(p->lchild==NULL){
            p->lchild=pre;
            p->ltag=1;
        }
        if(pre!=NULL&&pre->lchild==NULL){
            pre->rchild=p;
            pre->rtag=1;
        }
        pre=p;
        InThread(p->rchild,pre);
    }
}

遍历中序线索二叉树

//第一个
TBTNode *First(TBTNode *p){
    while(p->ltag==0){
        p=p->lchild;
    }
}
//下一个
TBTNode *Next(TBTNode *p){
    if(p->rtag==0)
        return First(p->rchild);
    else
        return p->rchild;
}
//打印整个中序序列
TBTNode Inorder(TBTNode *root){
    for(TBTNode *p=First(root);p!=NULL;p=Next(p)){
        visit(p);
    }
}

前序线索化

void preThread(TBTNode *p, TBTNode *&pre){
    if(p!=NULL){
        
        if(p->lchild==NULL){
            p->lchild=pre;
            p->ltag=1;
        }
        if(pre!=NULL&&pre->lchild==NULL){
            pre->rchild=p;
            pre->rtag=1;
        }
        pre=p;
        if(p->ltag==0)
            InThread(p->lchild,pre);
        if(p->rtag==0)
            InThread(p->rchild,pre);
    }
}

 遍历前序线索二叉树

void preorder(TBTNode *root){
    if(root!=NULL){
        TBTNode *p=root;
        while(p!=NULL){
            while(p->ltag==0){
                visit(p);
                p=p->lchild;
            }
            visit(p);
            p=p->rchild;
        }
    }
}

后序线索化

void posThread(TBTNode *p, TBTNode *&pre){
    if(p!=NULL){
        InThread(p->lchild,pre);
        InThread(p->rchild,pre);
        if(p->lchild==NULL){
            p->lchild=pre;
            p->ltag=1;
        }
        if(pre!=NULL&&pre->lchild==NULL){
            pre->rchild=p;
            pre->rtag=1;
        }
        pre=p;
    }
}