树和二叉树相关算法（二) c/c++

//层次遍历算法
//顺序环形队列
typedef struct{
    BTNode *data[MaxSize];
    int front;
    int rear;
}SqQueue; 

void InitQueue(SqQueue *&qu)
{
    qu = (SqQueue*)malloc(sizeof(SqQueue));
    qu->front = -1;
    qu->rear = -1;
}

bool enQueue(SqQueue *&qu,BTNode *b)
{
    if((qu->rear + 1) % MaxSize == qu->front)
        return false;
    qu->rear = (qu->rear + 1) % MaxSize;
    qu->data[qu->rear] = b;
    return true;
}

bool deQueue(SqQueue *&qu,BTNode *&b)
{
    if(qu->front == qu->rear)
        return false;
    qu->front = (qu->front + 1) % MaxSize;
    b = qu->data[qu->front];
}

bool QueueEmpty(SqQueue *&qu)
{
    return qu->front == qu->rear;
}

void LevelOrder(BTNode *b)
{
    SqQueue *qu;
    BTNode *p;
    p = b;
    InitQueue(qu);
    enQueue(qu,p);
    while(!QueueEmpty(qu))
    {
        deQueue(qu,p);
        cout<<p->data;
        if(p->lchild != NULL)
            enQueue(qu,p->lchild);
        if(p->rchild != NULL)
            enQueue(qu,p->rchild);
    }
}

//用层次遍历输出根节点到所有叶子节点的路径（迷宫问题的思路）
//结点类型 
typedef struct{
    BTNode *b;
    int parent;        //存放双亲结点在顺序队中的位置 
}NodeType; 
//顺序队 
    
void AllPath2(BTNode *b)
{
    NodeType Path[MaxSize];            //创建顺序队并初始化 
    int rear = -1;int front = -1;
    NodeType p;
    NodeType q; 
    
    p.b = b;
    p.parent = -1;
    Path[++rear] = p; 
    
    while(rear != front)
    {
        p = Path[++front];
        if(p.b->lchild == NULL && p.b->rchild == NULL)
        {
            int k = front;
            while(Path[k].parent != -1)
            {
                cout<<Path[k].b->data;
                k = Path[k].parent;
            }
            cout<<Path[k].b->data<<endl;
        }
        if(p.b->lchild != NULL)
        {
            q.b = p.b->lchild;
            q.parent = front;
            Path[++rear] = q;
        }
        if(p.b->rchild != NULL)
        {
            q.b = p.b->rchild;
            q.parent = front;
            Path[++rear] = q;
        }
    }
}
//先序序列和中序序列生成二叉树 
BTNode *CreateBT1(char *pre,char *in,int n)
{
    BTNode *b;
    char *p;
    int k;
    
    if(n <= 0)
        return NULL;
    b = (BTNode *)malloc(sizeof(BTNode));
    for(p = in;p<in + n;p++)
    {
        if(*p == *pre)
            break;
    }
    k  = p - in;
    b->data = *p;
    b->lchild = CreateBT1(pre + 1,in,k);
    b->rchild = CreateBT1(pre+k+1,p+1,n-k-1);
    
    return b;
}
//后序序列和中序序列生成二叉树
BTNode *CreateBT2(char *in,char *post,int n)
{
    BTNode  *b;
    char *p;
    int k;
    
    if(n <= 0)
        return NULL;
    b = (BTNode *)malloc(sizeof(BTNode));
    for(p = in;p < in + n; p++)
    {
        if(*p == *(post + n - 1))
            break;
    } 
    k = p - in;
    b->data = *p;
    b->lchild = CreateBT2(in,post,k);
    b->rchild = CreateBT2(in+k+1,post+k,n-k-1);
    
    return b;
} 
//二叉树顺序储存结构转换为链式储存结构
typedef ElemType SqBTree[MaxSize];
BTNode *trans(SqBTree a,int i)
{
    BTNode *b;
    if(i > MaxSize)
        return NULL;
    if(a[i] == '#')
        return NULL;
    b = (BTNode *)malloc(sizeof(BTNode));
    b->data = a[i];
    b->lchild = trans(a,2*i);
    b->rchild = trans(a,2*i+1);
    
    return b;    
} 

//中序线索化二叉树
typedef struct tbtnode{
    ElemType data;
    int ltag;
    struct tbtnode *lchild;
    struct tbtnode *rchild;
    int rtag;
}TBTNode;

TBTNode *pre;

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

TBTNode *CreateThread(TBTNode *b)
{
    TBTNode *root;
    root = (TBTNode *)malloc(sizeof(TBTNode));
    
    root->ltag = 0;root->rtag = 1;
    root->rchild = b;
    if(b == NULL)
        root->lchild = root;
    else
    {
        root->lchild = root;
        pre = root;
        Thread(b);
        pre->rchild = root;
        pre->rtag = 1;
        root->rchild = pre;
    }
    return root;
} 

//构造哈夫曼树 
typedef struct{
    char data;
    int parent;
    int lchild;
    int rchild;
    double weight;
}HTNode;

void CreateHT(HTNode ht[],int n0)
{
    int lnode,rnode;
    double min1,min2;
    for(int i = 0; i < 2*n0 - 2;i++)
        ht[i].parent = ht[i].lchild = ht[i].rchild = -1;
    for(int i = n0; i < 2*n0 - 2;i++)
    {
        min1 = min2 = 100000;
        rnode = lnode = -1;
        for(int k = 0; k < i ;k++)
        {
            if(ht[k].parent == -1)
            {
                if(ht[k].weight < min1)
                {
                    min2 = min1;rnode = lnode;
                    min1 = ht[k].weight;
                    lnode = k;
                }
                else if(ht[k].weight < min2)
                {
                    min2 = ht[k].weight;
                    rnode = k;
                }
            }
        }
        ht[lnode].parent = i;
        ht[rnode].parent = i;
        ht[i].lchild = lnode;
        ht[i].rchild = rnode;
        ht[i].weight = ht[lnode].weight + ht[rnode].weight;
    }
}

//根据哈夫曼树求对应的哈夫曼编码
typedef struct
{
    char cd[100];
    int start;    
}HCode; 
void CreateHCode(HTNode ht[],HCode hcd[],int n0)
{
    int f,c;
    HCode hc;
    for(int i = 0;i < n0; i++)
    {
        hc.start = n0;c = i;
        f = ht[i].parent;
        while(f != -1)
        {
            if(ht[f].lchild == c)
                hc.cd[hc.start--] = '0';
            else
                hc.cd[hc.start--] = '1';
            c = f; f = ht[f].parent;
        }
        hc.start++;
        hcd[i] = hc;
    }
}

//用树实现并查集
//并查集节点类型 
typedef struct{
    int data;
    int parent;
    int rank;
}UFSTree; 
//初始化并查集
void MAKE_SET(UFSTree t[],int n)
{
    for(int i=0; i<n; i++)
    {
        t[i].data = i;
        t[i].parent = i;
        t[i].rank = 0;    
    }    
} 
//查找一个元素所在的集合
int FIND_SET(UFSTree t[],int x)
{
    if(x != t[x].parent)
        return FIND_SET(t,t[x].parent);
    else
        return x;    
} 
//将两个元素所在的集合合并
void UNION(UFSTree t[],int x,int y)
{
    x = FIND_SET(t,x);
    y = FIND_SET(t,y);
    if(t[x].rank > t[y].rank)
        t[y].parent = x;
    else
    {
        t[x].parent = y;
        if(t[x].rank == t[y].rank)
            t[y].rank++;    
    }    
}