408数据结构——5树与二叉树

1. 二叉树的链式存储

2. 中序线索化二叉树

typedef struct ThreadNode{
    ElemType data;
    struct ThreadNode *lchild,*rchild;
    int ltag,rtag;//左右线索标志

//全局变量pre，指向当前节点的前驱
Thread *pre=NULL;

//中序线索化二叉树主过程
void CreateInThread(ThreadTree T){
    pre=null;       //pre初始值位null   
    if(T!=null){    //非空二叉树才能线索化
    InThread(T);    //中序线索化二叉树
    if(pre->rchild=null)
        pre->rtag=1;//处理遍历的最后一个结点
    }
}

//中序遍历二叉树，一边遍历一遍线索化
void InThread(ThreadTree T){
    if(T!=null){
    InThread(T->lchild);    //中序遍历左子树
    visit(T);               //访问根节点
    InThread(T->rchild);    //中序遍历右子树
    }
}
void visit（ThreadNode *q){
    if(q->lchild==null){    //左子树为空，建立前驱线索
        q->lchild=pre;
        q->ltag=1;
    }
    if(pre!=null && pre->rchild==null){
        pre->rchild=1;      //建立前驱结点的后继线索
        pre->rtag=1;
    }
    pre=q;
}

2.2 先序线索化二叉树

//整体跟中序差不多，只需要注意一点
void PreThread(ThreadTree T){
    if(T!=null){
    visit(T);               //访问根节点    
    if(T->ltag==0)          //lchild不是前驱线索
    PreThread(T->lchild);    //遍历左子树
    PreThread(T->rchild);    //遍历右子树
    }
}

2.3 后序线索化二叉树

void PostThread(ThreadTree T){
    if(T!=null){        
    PostThread(T->lchild);    //遍历左子树
    PostThread(T->rchild);    //遍历右子树
    visit(T);                 //访问根节点
    }
}

3. 遍历，找前驱后继

3.1 中序线索二叉树找后继

在中序二叉树中，根节点p的后继结点是右子树中最左下的结点

//找到以p为根的子树中，第一个被中序遍历的结点
ThreadNode *Firstnode(ThreadNode *p){
    //循环找到最坐下结点（不一定是叶结点）
    while(p->ltag==0)    p=p->lchild;
    return p;
}

//在中序线索二叉树中找到结点p的后继结点
ThreadNode *Nextnode(ThreadNode *p){
    //右子树中最左下结点
    if(p->rtag==0)    return Firstnode(p->rchild);
    else return p->rchild;//rtag==1直接返回后继线索
}

//对中序线索二叉树进行中序遍历（利用线索实现的非递归算法）
    void Inorder(ThreadNode *T){
        for(ThreadNode *p=Firstnode(T);p!=null;p=Nextnode(p))
            visit(p);
    }

3.2 中序线索二叉树找前驱

//找到以p为根的子树中，最后一个被中序遍历的结点
ThreadNode *Lastnode(ThreadNode *p){
    //循环找多最右下结点（不一定是叶结点）
    while(p->rtag==0)    p=p->rchild;
    return p;
}

//在中序线索二叉树中找到结点p的前驱结点
ThreadNode *Prenode(ThreadNode *p){
    //左子树中最右下结点
    if(p->ltag==0) return Lastnode(p->lchild);
    else return p->lchild;//ltag==1直接返回前驱线索
}

//对中序线索二叉树进行逆向中序遍历
void RevInorder(ThreadNode *T){
    for(ThreadNode *p=Lastnode(T);p!=null;p=Prenode(p))
        visit(p);
}

3.3 先序找后继

若p有左孩子，则先序后继为左孩子；

若p没有左孩子，则先序后继为右孩子。

 3.4 先序找前驱

①如果一个结点只有孩子结点，无法找到先序前驱结点，因为先序是“根左右”，其中“左右”都是该结点的后继，所以找不到前驱

②如果能逆向找到父结点（三叉链表），有以下4种情况

 在第三种情况中，先从左子树结点往右找，没有结点了再往左找，没了再往右

 3.5 后序找前驱

 3.6 后序找后继

①如果一个结点只有孩子结点，无法找到后序后继结点，因为左右根中”左右“都是前驱

②如果能逆向找到父结点（三叉链表），有以下4种情况

 第三种情况中，先从右子树往左找，左边没有了就往右，再往左

4. 树的存储结构

4.3 孩子兄弟表示法（链式存储）——左孩子右兄弟

typedef struct CSNode{
    ElemType data;                        //数据域
    struct CSNode *firstchild,*nextchild; //第一个孩子和右兄弟指针
}CSNode,*CSTree;

5. 并查集

5.1union操作优化

void Union(int S[],int Root1,int Root2){
    if(Root1==Root2)    return;
    if(S[Root2]>S[Root1]){    //root2结点数更少
        S[Root1]+=S[Root2];   //修改root1的结点总数
        S[Root2]=Root1;       //小树合并到大树
    }else {
        S[Root2]+=S[Root1];
        S[Root1]=Root2;
    }
}

5.2 find操作优化

int Find(int S[],int x){
    int root=x;
    while(S[root]>0)    root=S[root];//循环找到根
    while(x!=root){    //压缩路径
        int t=S[x];    //t指向x的父节点
        S[x]=root;     //x直接挂到根节点下
        x=t;
    }
    return root;    //返回根节点编号
}