for(j=0;j<5;j++)
            if(((p+5*i+j)!=p) && ((p+5*i+j)!=(p+4)) && ((p+5*i+j)!=(p+20)) && (*pmin>*(p+5*i+j)))
                pmin = p+5*i+j;
    temp = *pmin;                           //将第四个最小值换给右下角元素
    *pmin = *(p+24);
    *(p+24) = temp;
}

（5）设A是有n个元素的整形数组（n>=1)，试写一个求A中n个整数的平均值的递归程序。
（本题20分）
参考解法：
#include<stdio.h>
float f(int a[],int n)
{
    float avg;
    if(n==1) avg=a[0];
    else
    {
        avg = (a[n-1] + f(a,n-1)*(n-1))/n;
    }
    return avg;
}

void main()
{
    int a[10] = {0,1,2,3,4,5,6,7,8,9};
    int sum;
    float avg;
    avg = f(a,10);
    printf("The avg = %f\n",avg);
}

（6）假设由终端输入集合元素，先建立表示集合X的静态链表P1，而后在输入集合Y的元素的
同时查找P1表，若存在和Y和相同的元素，则从表P1表中删除之，否则将此元素插入P1.
（本题20分）
参考解法：
//题目在清华大学出版社 严蔚敏《数据结构（C语言版）》课本33页
#define MAXSIZE 1000
typdef char ElemType;
typedef struct
{
    ElemType data;
    int cur;
}component,SLinkList[MAXSIZE];
//①将整个数组空间初始化成一个链表；
void InitSpace_SL(SLinkList space)
{
    int i;
    for(i=0;i<MAXSIZE;i++)
        space[i].cur = i+1;
    space[MAXSIZE-1].cur = 0;
}
//②从备用空间取得一个结点；
int Malloc_SL(SLinkList &space)
{
    int i;
    i = space[0].cur;
    if(space[0].cur)    space[0].cur = space[i].cur;
    return i;
}
//③将空闲结点链结到链表上。
void Free_SL(SLinkList space,int k)
{
    space[k].cur = space[0].cur;
    space[0].cur = k;
}
void difference(SLinkList space,int &S)
{
    int i,j,k,r,m,n,p;
    char b;
    InitSpace_SL(space);
    S = Malloc_SL(space);
    r = S;
    scanf("%d%d",&m,&n);
    for(j=1;j<=m;j++)
    {
        i = Malloc_SL(space);
        scanf("%c",&space[i].data);
        space[r].cur = i;
        r = i;
    }//for
    space[r].cur = 0;
    for(j=1;j<=n;j++)
    {
        scanf("%c",&b);
        p = S;
        k = space[S].cur;
        while(k!=space[r].cur && space[k].data!=b)
        {
            p = k;
            k = space[k].cur;
        }//while
        if(k == space[r].cur)
        {
            i = Malloc_SL(space);
            space[i].data = b;
            space[i].cur = space[r].cur;
            space[r].cur = i;
        }//if
        else
        {
            space[p].cur = space[k].cur;
            Free_SL(space,k);
            if(r==k)
                r = p;
        }//else
    }//for
}//difference

（7）请写出用二叉树计算英文文献中单词使用频度的算法。（本题20分）
                              该单词的使用次数
        单词的使用频度 ＝ －－－－－－－－－－－－－
                              文献中单词的总数

参考解法：
#include<stdio.h>
typedef struct BiNode
{
    char *data;
    int count;
    struct BiNode *lchild,*rchild;
}BiNode;

int sum(BiNode *b)          //返回二叉树单词的总数
{
    if(b==NULL) return 0;
    if((b->lchild==NULL)&&(b->rchild==NULL))
        return b->count;
    else
    {
        return ((b->count)+sum(b->lchild)+sum(b->rchild));
    }
}
void frequence(BiNode *b,int n)
{
    if(b!=NULL)
    {
        frequence(b->lchild,n);
        printf("Word:%s,Frequence:%f\n",b->data,1.0*b->count/n);
        frequence(b->rchild,n);
    }
}

void func(BiNode *b)
{
    int n;
    n = sum(b);
    frequence(b,n);
}

（8）请写出下图所代表的树向二叉数转换的算法，并用中序遍历给出转换后二叉树的节点
序列和树的深度。（本题20分）
A(B(E,F(K,L)),C(G,H(M,N),I),D(J))
中序遍历：EKLFBGMNHICJDA
深度:7
#include<stdio.h>
#include<stdlib.h>
#define MAX_TREE_SIZE 100
typedef struct CTNode
{
    int child;
    struct CTNode *next;
}CTNode,*ChildPtr;
typedef struct
{
    char data;
    ChildPtr firstchild;
}CTBox;
typedef struct
{
    CTBox nodes[MAX_TREE_SIZE];
    int n,r;
}CTree;
typedef struct CSNode
{
    char data;
    struct CSNode *firstchild,*nextsibling;
}CSNode,*CSTree;

void Convert(CTBox nodes[],int r,CSTree &root) //由孩子表示法存储的树向二叉树转换
{
    CTNode *ctn;
    CSNode *p;
    if(r==-1) root = NULL;
    else
    {
        root = (CSNode *)malloc(sizeof(CSNode));
        root->data = nodes[r].data;
        root->firstchild = NULL;
        root->nextsibling = NULL;
        if(nodes[r].firstchild)                //判断root结点是否存在第一个孩子
        {
            ctn = nodes[r].firstchild;         //处理root结点的第一个孩子
            r = ctn->child;
            Convert(nodes,r,root->firstchild);
            ctn = ctn->next;                   //处理root结点的其它孩子
            p = root->firstchild;
            while(ctn)
            {
                r = ctn->child;