//链表基本操作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=http://www.mamicode.com/ch;>
数据结构算法总结