数据结构算法总结

//链表基本操作tatus ListOppose(LinkList &L){    linklist p,q;    p=L;    p=p->next;    L->next=NULL;    while(p){        q=p;        p=p->next;        q->next=L->next;        L->next=q;    }    return OK;}//两个有序链表合并成一个void MergeList(LinkList &la,LinkList &lb){    LinkList pa,pb,pc;    pc=la;    pa=la->next;pb=la->next;    while(pa&&pb)    {        if(pa->num<pb->num) {pc->next=pa;pc=pa;pa=pa->next;}         else         {pc->next=pb;pc=pb;pb=pb->next;}    }    if(pa)          pc->next=pa;     if(pb)          pc->next=pb;}//删去la中与lb相同的元素Status DelSame(LinkList &la,LinkList &lb ){    LinkList p,q,r;    p=la;q=p->next;    while(q!=NULL)    {        r=lb->next;        while(r!=NULL&&r->num!=q->num)            r=r->next;        if(r==NULL) p=q;        else     p->next=q->next;        q=q->next;    }}/*栈和队列常见算法*///进制转换void Conersion(int n){    Initstack(S);    while(n)    {        push(S,n%N);        n/=N;    }    /*十六进制      while(n){      if(n%16<=9) push(S,n%16+48);//存入字符      else push(S,n%16+55)      此时存入的是字符      }      */    while(!emptystack)    {        pop(S,e);        printf("%d",e);    }}//行编辑程序,存入文件void LineEdit(){    FILE *fp=fopen("file.txt","w");    InitStack(S);    ch=getchar();    while(ch!=EOF){        while(ch!=EOF&&ch!='\n')        {//全文未结束且未到行末            switch(ch)            {                case '#':pop(S,c);break;                case '@':clearstack(S);break;                default:push(S,ch) ;break;            }            ch=getchar();        }        StackTraverse(S,copy);//遇到'\n'或者EOF从栈底到栈顶的栈内字符传送至文件        fputc('\n',fp);//向文件传送一个换行符        clearstack(S);        if(ch!=EOF) ch=getchar();    }    destroystack(S);    fclose(fp);}//迷宫问题typedef struct{    int x;    int y;}PosType;//迷宫坐标位置类型typedef struct{    int ord; //通道块在路径上的序号    PosType seat;//通道块在迷宫中的坐标    int di;//走向下一个通道快的方向}SElemType;Mazetype  m;//迷宫数组void Print();//输出迷宫的解void Init(int k)//迷宫数组的初始化，墙值为0，通道值为k    Status Pass(PosType b);//当迷宫m的b点序号为1(可以通过),返回OK，否则，返回error    void FootPrint(Postype a)//a点变为足迹    PosType Nextpos(PosType&c,int di)//根据当前位置及移动方向，求下一位置    void Markprint(PosType b)//使b点序号变为-1(不能通过)Status MazePath(PosType start,PosType end)//算法{    InitStack(S);    curpos=start;    curstep=1;    SElemType e;    do{        if(Pass(curpos)){//当前位置可以通过            FootPrint(curpos);//留下足迹            e.ord=curstep;e.seat=curpos;e.di=0;            push(S,e);//加入路径            ++curstep;            if(curpos==end)  return true;            curpos=Nextpos(curpos,e.di);         }        else   //当前位置不能通过        {            if(!Stackempty(S))            {                pop(S,e);//退栈到前一位置                curstep--;//足迹减一                while(e.di==3&&!Stackempty(S))//前一位置处于最后一个方向                {                    markPrint(e.seat);//留下不能通过的标记(-1)                    pop(S,e);//继续回退                    curstep--;                }                if(e.di<3)                {                    e.di++;                    push(S,e);//push e into stack again                    curstep++;                    curpos=e.seat;//确定当前位置                    curpos=NeatPos(curpos,e.di);                }            }        }while(!Stackempty(S));        return FALSE;    }}//表达式求值    char Precede(SElemType t1,SElemtype t2)//判断t1,t2量符号的优先关系    Status In(Selemtype c)//判断c是否7种运算符之一SElemType Operate(SElemType a,SElemType theta,SElemtype b)    //做四则运算：a theta b,返回运算结果SElemtype EvaluateExpression()//算法{    Initstack(OPTR);push(OPTR,'#');    Initstack(OPND);    c=getchar();    while(c!='#'||Gettop(OPTR)!='#')    {        if(!In(c)) push(OPND,c);//不是运算符则进栈        else             switch(Precede(Gettop(OPTR),c)){                case '<':push(OPTR，c);c=getcahr();//栈顶元素优先权低                         break;                case '=':pop(OPTR,x);c=getchar();//脱括号，接受下一个字符                          break;                case '>':pop(OPTR,thea);// 退栈并将运算结果入栈                         pop(OPND,a);pop(OPND,b);                         push(OPND,Operate(a,theta,b));                         break;            }//switch        c=getchar();    }//while    return Gettop(OPND);}//八皇后问题typedef struct{    int i;    int j;}Pos;Pos pos[3]={{-1,-1},{-1,1},{-1,0}}//检测左上，右上，上,三个方向    void queenini(void)//初始化    void display(void)//打印出来int check(int i,int j)//检测board[i][j]是否能放皇后,返回1，可放{    int ni,nj,k,t;    t=1;    for(k=0;k<3;k++)    {        ni=i;nj=j;        while(t&&board[ni][nj]!='#')//未到达边界且未检测到皇后        {            ni+=pos[k].i;nj+=pos[k].j;            if(board[ni][nj]=='*') t=0//t=0表示遇到皇后，退出while，        }    }    return t;}void queenfind(int i,int j){//递归两个出口：1.i>N  2.回溯，重置board[i][k]=' '    int k;    if(i>N) {count++;display();}    else//j not used,just locate first position    {        for(k=1;k<=N;k++)               if(check(i,k))            {                board[i][k]='*';                queenfind(i+1,j);                board[i][k]=' ';            }    }}/*树中常见算法:遍历,判定*///二叉树的先序建立typedef struct BiNode{    ElemType data;    struct BiNode *lchild,*rchild;}BiNode,*Bitree;void CreatTree(Bitree &p)//先序建立二叉树{    if((ch=getchar())=='#') p=NULL;    else{        p=(Bitree)malloc(sizeof(BiNode));        p->data=ch;        Create(p->lchild);        Create(p->rchild);    }}//递归遍历Status Preorder(Bitree p){    if(!p)    {        visit(p);        preorder(p->lchild);        Preorder(p->rchild);    }}//其他类推//非递归遍历.利用栈//先序Status Preorder(Bitree p){    InitStack(S);    while(!emptyStack(S)||p)    {        if(p) {visit(p);push(S,p); p=p->lchild;}//访问根指针，进栈，遍历左子树        else {pop(S,p),p=p->rchild;}    }    return OK;}//中序Status Inorder(Bitree p){    InitStack(S);    while(!emptyStack(S)||p)    {        if(p){push(S,p);p=p->lchild;}        else { pop(S,p);visit(p); p=p->rchild; }    }    return OK;}//后序Status Postorder(Bitree p){    InitStack(S);    Bitree t,l;    t=p;l=NULL;    while(!emptyStack(S)||t)    {        if(t) {push(S,t);t=t->lchild;}//存在左孩子，入栈        else {t=gettopStack(S);t=t->rchild;}//否则，查找栈顶元素，定位到栈顶的右孩子        if(!t||t==l) {pop(S,l);visit(l);t=NULL;}//栈顶的右孩子为空或者上一次被访问，弹出栈顶，并访问    }    return OK;}//层次遍历.利用队列Status LevelOrder(Bitree p){    InitQueue(Q);    if(p) enqueue(Q);    while(!emptyQueue(Q))    {        dequeue(Q,p);visit(p);        if(p->lchild) enqueue(p->lchild);        if(p->rchild) enqueue(p->rchild);    }}//求二叉树深度,宽度非递归算法Status BitreeDepWid(Bitree p){    Initqueue(Q);    Bitree t,l;    l=t=p;    int n,wid,dep;    n=wid=dep=0;    if(p)   enqueue(Q,p);    while(!emptyQueue(Q))    {        dequeue(Q,t);n++;        if(t->lchild) enqueue(Q,t->lchild);        if(t->rchild) enqueue(Q,t->rchild);        if(t==l)        {            dep++;//换一层，深度加1，            if(!emptyQueue(Q)) l=Q.rear->bt;//队不空，l指向队尾节点            if(n>wid) wid=n;//某层节点比mid大则替换            n=0;        }        printf(dep,wid);    }}//判断一棵二叉树是否完全二叉树Status Iscomplete(Bitree p){    Initqueue(Q);    Bitree t;    if(!p) return FALSE;    else enqueue(Q,p);    while(!emptyQueue(Q))    {        dequeue(Q,t);        if(t) {enqueue(Q,t->lchild);enqueue(Q,t->rchild);}//节点不空，左右孩子均入队        else {            while(!emptyQueue(Q)) {dequeue(Q,t);if(t) return FALSE;}        }//出现了一个空节点，若再出现一个非空的节点，表明非完全二叉树    }    return OK;}//删除节点值为x的子树Status Delx(Bitree p,Elemtype x){    InitQueue(Q);    Bitree t=p;    if(p->data==x) {Deltree(p);return OK;}    enqueue(Q,t);    while(!emptyQueue(Q))    {        dequeue(Q,t);        if(t->lchild) {            if(t->lchild->data==x) {DelTree(t->lchild);t->lchild=NULL;}            else enqueue(Q,t->lchild);                  }        if(t->rchild){            if(t->rchild->data==x) {DelTree(t->rchild);t->rchild=NULL;}            else enqueue(Q,t->rchild);        }    }    //查找第一个以x值为节点的所有父节点    Status SearchParent(Bitree p,ElemType x)    {//利用二叉树的后序遍历思想        InitStack(s);        Bitree t,l;        t=p,l=NULL;        while(t||!empstack(S))        {            if(t) {                if(t->data==x) break;//入栈的时候检测看是否存在取值为x的点，其余跟后序遍历一样                else {push(Q,t);t=t->lchild;}            }            else  { t=gettopStack(Q);t=t->rchild; }            if(!t||t==l) {pop(Q,l);t=NULL;}        }        if(!empStack)//非空，输出父节点         {            while(!empStack) {pop(Q,t);visit(t);}            return OK;        }        else            return FALSE;    }    //二叉排序树的插入    Status BST_Insert(Bitree &p,ElemType x)//插入节点一定在叶子节点上    {        Bitree l,t,k;        l=(Bitree)malloc(sizeof(Binode));        l->lchild=l->rchild=NULL;        t=p;        if(t){//根节点非空            while(t)            {        k=t;                if(k->data>x) t=k->lchild;                else if(k->data<x) t=k->rchild;                else {free(t);break;}            }            if(k->data>x) k->lchild=l;            else k->rchild=l;        }        else             p=l;    }    //二叉排序树的判断：中序遍历 不能用层次遍历（切记）              Status Is_BST(Bitree p)        {            InitStack(S);            Bitree t=p;            l=NULL;            while(t||!empStack(S))            {                if(t){push(S,t);t=t->lchild;}                else {                    pop(Q,t);                    if(l&&l->data>t->data) return FALSE;//与上次出栈 的数做比较                    l=t;t=t->rchild;                }            }        }        //平衡二叉树的判定        Status IS_Balence(Bitree p)        {            if(!p) return OK;            if(abs(dep(p->lchild)-dep(p->rchild))>1) return FALSE;            else                 return (IS_Balence(p->lchild)&&IS_Balence(p->rchild));        }        //Huffman编码 Huffman树        typedef struct{            unsigned int weight;            unsigned int parent,lchild,rchild;        }HTNode,*HuffmanTree;        typedef char * * HuffmanCode;        Status Select(Huffman HT,int n,int &s1,int &s2);//数组HT[1...n]中查找parent         为0且weight最小的两个节点，s1权值小于s2            //求huffman编码的算法：            status HuffmanCoding(HuffmanTree &HT,HuffmanCode &HC,int *w,int n)            {                if(n<=1) return FALSE;                m=2*n-1;//一棵拥有n个叶节点的Huffman树拥有2*n-1个节点                HT=(HuffmanTree)malloc((m+1)*sizeof(HTNode));//0号单元未使用                for(p=HT,i=1;i<=n;++i) *p={*w,0,0,0};//初始化前n个节点                for(;i<=m;i++) *p={0,0,0,0};//初始化剩余节点                for(i=n+1;i<=m;i++)//建Huffman树                {                    Selecte(HT,i-1,s1,s2);                    HT[s1].parent=HT[s2].parent=i;                    HT[i].lchild=s1,HT[i].rchild=s2;                    Ht[i].weight=HT[s1].weight+HT[s2].weight;                }                //从叶子节点到根逆向求每个字符的Huffman编码                HC=(HuffmanCode)malloc((n+1)*sizeof(char *));//分配n个字符编码的头指针向量                cd=(char*)malloc(n*sizeof(char));//分配求编码的工作区间                cd[n-1]='\0';                for(i=1;i<=n;i++)//逐个字符求Huffman编码                {                    start=n-1;//编码结束符位置                    for(c=i,f=HT[i].parent;f!=0;c=f,f=HT[f].parent)//从叶子向根逆向求编码                    {                        if(c==HT[f].lchild) cd[--start]='0';//c是父节点f的左孩子                        else cd[--start]='1';                    }                    HC[i]=(char*)malloc((n-start)*sizeof(char));                    strcpy(HC[i],&cd[start]);                }            }        //遍历Huffman树求编码        Status Get_HuffmanCode(HuffmanTree HT,HuffmanCode &HC,int n)        {            HC=(HuffmanCode)malloc((n+1)*sizeof(char*));//分配指向编码的头指针空间            cd=(char*)malloc(n*sizeof(char));            int p=m;cdlen=0;            for(i=1;i<=m;i++) HT[i].weight=0;//遍历Huffman树时作节点状态标记            while(p)            {                if(HT[p].weight==0){//向左                    HT[p].weight=1;                    if(HT[p].lchild!=0) {p=HT[p].lchild;cd[cdlen++]='0';}                    else  if (HT[p].rchild==0) {//登记叶子节点的字符的编码                        HC[p]=(char*)malloc((cdlen+1)*sizeof(char));                        cd[cdlen]='\0';strcpy(HC[p],cd);//复制编码串                    }                }                else if(HT[p].weight==1) {//向右                    HT[p].weight=2;                    if(HT[p].rchild!=0) {p=HT[p].rchild;cd[cdlen++]='1';}                }                else {//HT[p].weight==2，退回                    HT[p].weight=0;p=HT[p].parent;--cdlen;//退到父节点，编码长度减1                }            }        }        /*图的基本算法*/        //DFS:递归 非递归        Status DFS(Graph G,VerType v)        {            visit(v);//访问v节点            visit[v]=TRUE;//做访问标记            for(w=FirstNeighbor(G,v);w>=0;w=NextNeighor(G,v,w))                if(!visit[w]) DFS(G,w);        }        Status DFS(Graph G)//非递归，利用栈        {            InitStack(Q);            for(v=0,v<G.vexnum;v++)                if(!visit[v])                {                    visit[v]=true;                    ArcNode *t;                    push(Q,v);                    while(!emptyStack(S))                    {                        pop(Q,t);                        visit(t);                        for(w=FirstNeighor(G,k);w>=0;w=NextNeighor(G,k,w))                            if(!visit[w])                            {push(Q,w);                                visit[v]=TRUE;                            }//if                    }//while                }//if        }        //BFS:非递归        Status BFS(Graph G)//BFS非递归算法，利用队列        {            InitQueue(Q);            for(v=0;v<G.vernum;v++)                if(!visit[v]){                    enqueue(Q,v);                    visit[v]=TRUE;//访问标记                    while(!empQueue(Q)){                        dequeue(Q,v);                        visit(v);                        for(w=FirstNeighor(G,v);w>=0;w=NextNeighor(G,v,w))                            if(!visit[w]) {visit[w]=TRUE;visit(w);enqueue(Q,w);}//访问v的关联点后入队                    }//while                }//if        }        //拓扑排序:邻接表存储的有向图        Status TopLogicalSort(Graph G)        {            InitStack(S);            FindInDegree(G,indegree);//对各顶点求入度indegree[0....vernum-1]            for(i=0;i<G.vernum;i++)                if(!indegree[i]) push(Q,i);//顶点为0的入栈            int count=0//计数，作最后的判断之用                while(!emptyStack(S))                {                    pop(S,i);visit(i);++count;//输出i号顶点并计数                    for(p=G.vertice[i].firstarc;p!=NULL;p=p->nextarc)                    {                        k=p->adjvex;//对i的每个邻接点的入度减1                        if(!(--indegree[k])) push(Q,k);//若度为0则入栈                    }                }            if(count==G.vexnum) return Ok;            else                 return FALSE;        }        //最短路径:Dijstra(1-n).floyd(n-n)        //floyd,求任意两顶点的最短路径        Status ShortestPath_floyd(Graph p)        {            int path[][][]//3维矩阵记录路径                int Distance[][]//二维矩阵记录两点间距离                for(v=0;v<G.vexnum;v++)//对各点初始已知距离和路径                    for(w=0;w<G.vexnum;w++)                    {                        d[v][w]=G.arc[v][w];//init the array                        for(u=0;u<G.vexnum;u++) p[v][w][u]=0;                        if(d[v][w]){//v到w之间有直接路径                            p[v][w][v]=p[v][w][w]=1;//v到w经过v和w                        }                    }            for(u=0;u<G.vexnum;u++)                for(v=0;v<G.vexnum;v++)                    for(w=0;w<G.vexnum;w++)                        if(d[v][u]+d[u][w]<d[v][w])//从v到w的一条路径更短                        {                            d[v][w]=d[v][u]+d[u][w];                            for(i=0;i<G.vexnum;i++) p[v][w][i]=p[v][[u][i]||p[u][w][i]//v到w经过v到u和u到w的所有路径                        }        }        //dijstra        Status ShortestPath_Dijstra(Graph G,int v0,pathmatrix p,shortpathtable d)        {            int v,w,i,j,min;            Status final[];//为真表示该顶点到v0最短距离已求出，初值为假            for(v=0;v<G.vexnum;v++)            {                final[v]=FALSE;                d[v]=G.arcs[v0][v].adj;//d[]存放v0到v的最短距离，初值为直接距离                for(w=0;w<G.vexnum;+=w)                    p[v][w]=FALSE;//初值为FALSE,表示没有路径                if(d[v]<INFINITY)//v0到v有直接路径                    p[v][v0]=p[v][v]=TRUE;//一维数组p[v][]表示v0到v最短路径通过的顶点            }//initial,v0 belongs to Set[s]            d[v0]=0;//v0到v0距离为0            final[v0]=TRUE;//v0并入S集            for(i=1;i<G.vexnum;++i)//其余G.vexnum-1个顶点            {//开始主循环，每次求得v0到某个顶点v的最短路径，并将v并入S集                min=INFINITY;                for(w=0;w<G.vexnum;++w)//对所有顶点检查                    if(!final[w]&&d[w]<min)//在S集之外的顶点中找离v0最近的顶点，赋值给v，距离赋值给min                    {v=w;min=d[w];}                final[v]=TRUE;//v并入S集                for(w=0;w<G.vexnum;++w)//根据新并入的顶点更新不在S集中的顶点到v0的距离和路径数组                    if(!final[w]&&min<INFINITY&&G.arcs[v][w].adj<INFINITY&&(min+G.arcs[v][w].adj<d[w]))                    {//w不属于S集且v0->v->w的距离<目前v0->w的距离                        d[w]=min+G.arcs[v][w].adj;//更新d[w]                        for(j=0;j<G.vexnum;++j)//修改p[w]，v0到w经过的顶点包括v0到v经过的顶点再加上顶点w                            p[w][j]=p[v][j];                        p[w][w]=TRUE;                    }//if            }//for        }        //最小生成树:prim kruskal        //prim算法        Status MiniSpanTree_Prim(MGraph G,VertexType u)        {            typedef struct{                VertexType adjvex;                int lowcost;            }closedge[MAX_VERTEXNUM];            int minivex(miniside sz,MGraph G);//求出sz数组中lowcost最小positive节点，返回其在sz中序号            k=Locate(G,u);//找出节点u在节点数组的位置            for(j=0;j<G.vexnum;++j)                if(j!=k&&G.arcs[k][j].adj)//辅助数组初始化                {                    closedge[j].adjvex=u;                    closedge[j].lowcost=G.arcs[k][j].adj;                }            closedge[k].lowcost=0;//已访问的节点置于u集中            for(i=1;i<G.vexnum;++i)//选择其余G.vexnum-1个顶点            {                k=minivex(closedge,G);//求出T的下一个顶点：第k顶点                printf(closedge[k].adjvex->G.vex[k]);//输出生成树的边                closedge[k].lowcost=0;//第k顶点并入u集                for(j=0;j<G.vexnum;++j)//加入G.vex[k]后有边权值比原来小                    if(G.arcs[k][j].adj>0&&G.arcs[k][j].adj<closedge[j].lowcost)                    {                        closedge[j].adjvex=G.vex[k];                        closedge[j].lowcost=G.arcs[k][j].adj;                    }            }        }        //kruskal算法        Status MiniSpanTree_Kruskal(MGraph G)        {            int set[MAX_VERTEX_NUM],i,j;            int k=0,a=0,b=0,min=G.arcs[a][b].adj;            for(i=0;i<G.vexnum;++i)                set[i]=i;//初态,各顶点分别属于各集合            while(k<G.vexnum-1)//最小生成树边数小于顶点树减1            {//寻找最小权值的边                for(i=0;i<G.vexnum;++i)                    for(j=i+1;j<G.vexnum;++j)                        if(G.arc[i][j]<min)                        {                            min=G.arcs[i][j];                            a=i;b=j;                        }                min=G.arcs[a][b].adj=INFINITY;//删除上三角中该边，下次不再查找                if(set[a]!=set[b])//边的两顶点不属于同一集合                {                    printf(G.vexs[a]-G.vexs[b]);//输出该边                    k++;//边数加一                    for(i=0;i<G.vexnum;i++)                        if(set[i]==set[b]) set[i]=set[a];                }            }        }        /*内部排序算法*/        typedef struct{            int key;            int otherinfo;        }redtype;        typedef struct{            redtype r[MAX+1];            int length;        }SqList;        /*1.插入排序*/        //直接插入排序        void InsertSort(SqList &l)        {            int i,j;            for(i=2;i<l.length;i++)                if(l.r[i]<l.r[i-1])                {                    l.r[0]=l.r[i];//复制为哨兵                    for(j=i-1;j>0&&l.r[j].key>l.r[0].key;j--)                        l.r[j+1]=l.r[j];//记录后移                    l.r[j+1]=l.r[0];//插入                }        }        //折半插入排序        void BInsertSort(SqList &l)        {            int i,j,mid,low,high;            for(i=2;i<l.length;i++)            {                l.r[0]=l.r[i];                low=1;high=i-1;//注意是插入排序,不是全部序列折半查找                while(low<=high)                {                    mid=low+(high-low)/2;                    if(l.r[mid].key>l.r[0].key) high=mid-1;                    else low=m+1;                }                for(j=i-1;j>=high+1;j--)                    l.r[j+1]=l.r[j];//记录后移                l.r[high+1]=l.r[0];            }        }        //希尔排序        void ShellSort(sqList &l)        {            int dk,i,j;            for(dk=l.length/2;dk>=1;dk/=2)                for(i=dk+1;i<=l.length;++i)                    if(l.r[i].key<l.r[i-dk].key)                    {                        l.r[0]=l.r[i];                        for(j=i-dk;j>0&&l.r[j].key<l.r[0].key;j-=dk;)                            l.r[j+dk]=l.r[j];//记录后移查找icharu位置                        l.r[j+dk]=l.r[0];//插入                    }        }        //交换排序：冒泡 快速        //快速        void QuickSort(SqList &l,int low,int high)        {            int pos;            if(low<high)            {                pos=Partion(l,low,high);                QuickSort(l,low,pos-1);                QuickSort(l,pos+1,high);            }        }        int Partion(SqList &l,int low,int high)        {            int piv=l.r[low].key;            l.r[0]=l.r[low];//以第一个元素为基准            while(low<high)            {                while(low<high&&l.r[high].key>piv) --high;                l.r[low]=l.r[high];                while(low<high&&l.r[low].key<piv) --low;                l.r[high]=l.r[low];            }            l.r[low]=l.r[[0];            return low;        }        //选择排序,堆排序.采用顺序结构存储待排元素        void HeapSort(SqList &l)         {            for(i=l.lenngth/2;i>0;i--)                HeapAdjust(l,i,l.length);//把l.r[1...l.length]建成大顶堆            for(i=l.length;i>1;i--)            {                t=l.r[1];                l.r[1]=l.r[i];                l.r[i]=t;                HeapAdjust(l,1,i-1);//将l.[1...i-1]从新调整为大顶堆            }        }        void HeapAdjust(SqList &l,int s,int m)//调整H.r[s]的关键字,使H.r[s...m]成大顶堆        {            int i;            t=l.r[s];            for(i=2*s;i<m;i*=2)//沿key较大的子节点向下筛选            {                if(i<m&&l.r[i].key<l.r[i+1].key) ++i;                if(t.key>=l.r[i].key) break;//筛选结束                else  {l.r[s]=l.r[i];//t应插在s上                    s=i;                }//修改s值，以便继续向下筛选             }            l.r[s]=t;//插入        }        //归并排序        void Merge(int a[],int b[],int low,int mid,int high)        {//将a[low..mid]和a[mid+1...high]合并，b是辅助数组            int i,j,k;            for(i=low;i<=high;i++) b[i++]=a[i++];a中所有元素复制到b中                i=low;j=mid+1;            k=low;            while(i<=mid&&j<=high)//类似于链表合并            {                if(b[i].key<b[j].key) a[k++]=b[i++];                else a[k++]=b[j++];            }            while(i<=mid) a[k++]=b[i++];            while(j<=high) a[k++]=b[j++];        }        void MergeSort(int a[],int b,int low,int high)        {            int mid;            if(low<high)            {                mid=(low+high)/2;                MergeSort(a,b,low,mid);                MergeSort(a,b,mid+1,high);                Merge(a,b,low,mid,high);            }        }        //两个升序序列求中位数        int search(int a[]，int b[],int n)        {            int a1,a2,m1,b1,b2,m2;            a1=b1=0;a2=b2=n-1;            while(a1!=a2&&b1!=b2)            {                m1=(a1+a2)/2;                m2=(b1+b2)/2;                if(a[m1]==b[m2]) return a[m1];                else if(a[m1]<b[m2])                {                    if((a1+a2)%2==0) {a1=m2;b2=m2;}                    else {a1=m1+1;b2=m2;}                }                else {                    if((a1+a2)%2==0) {a2=m1;b1=m2;}                    else {a2=m1;b1=m2+1;}                }                return a[a1]<b[b1]?a[a1]:b[b1];            }        }        //字符串匹配的kmp算法        void get_next(const char *str)        {            int i,j;            i=0;j=-1;            next[0]=-1;            while(*(str+i)!='\0')            {                if(j==-1||*(str+i)==*(str+j))                {                    i++;j++;                    if(str[i]!=str[j]) next[i]=j;                    else next[i]=next[j];                }                else  j=next[j];            }            int kmp_search(char *s1,char *s2)            {                int i,j;                i=0;j=0;                while(i!=trlen(s1)&&j!=strlen(s2))                {                    if(j==-1||s1[i]==s2[j]) {i++;j++;}                    else j=next[j];                }                if(j==strlen(s2)) return i-j+1;                else return 0;            }            //二分法求（A*B)%C            typedef unsigned _int64 llong;            llong Modle(llong a,llong b,llong c)            {                llong d=0;                while(b)                {                    if(b&1) d=(d+a)%c;                    a=(a+a)%c;                    b>>=1;                }                return  d;            }            //二分法求A^B%C            int mod_exp(int a,int b,int c)            {                int d=1;                while(b)                {                    if(b&1) d=(d*a)%c;                    a=(a*a)%c;                    b>>=1;                }                return d;            }