线性表（特殊）-栈和队列练习题

1:算数表达式包含(),{},[]编写算法判断表达式括号是否配对，以'\0'作为算术表达式结束符----用栈

void ismatch(char *str)
{
    stack s;
    init(s);//初始化栈
    int i=0;while(str[i]!='\0')
    {
        //(2+4)+{(4+{7+8+(6+8)+9})+9}
        switch(str[i])
        {
            case '(':push(s,'(');break;
            case '{':push(s,'{');break;
            case '[':push(s,'[');break;
            case ')':pop(s,e);if(e!='(')return false;
            case '{':pop(s,e);if(e!='}')return false;
            case '[':pop(s,e);if(e!=']')return false;
            break;
            default:break;
        }
        i++;
    }
    if(!isempty(s))
    {
        printf("括号不匹配");
        return false;

    }
    else
    {
        printf("括号匹配");
        return true;
    }

}

2：用栈实现递归函数的非递归计算 栈用来保存n和对应Pn(x)值

Pn(x)
n=0 1
n=1 2x
n>1 2xPn-1(x)-2(n-1)Pn-2(x)

double P(int n,double x)
{
    struct stack
    {
        int no;
        double val;
    }st[max];
    int top=-1,i;
    double fv1=1,fv2=2*x;
    for(i=n;i>=2;i--)
    {
        top++;
        st[top].no=i;
    }
    while(top>=0)
    {
        st[top].val=2*x*fv2-2*(st[top].no-1)*fv1;
        fv1=fv2;
        fv2=st[top].val;
        top--;
    }
    if(n==0)
    {
        return fv1;
    }
    return fv2;
}

3：渡口管理

每次载10辆车过江（客车，货车）
同类先到先上船
客车先于货车 每上4辆客车，允许放一辆货车
等待客车不足4，一货车代替
无货车等待，允许客车都上

queue q;过江
queue q1;客车
queue q2;货车
void manage()
{
    int i=0,j=0;//j渡船上总车辆
    while(j<10)
    {
        if(!QueueEmpty(q1)&&i<4)//客车队列不空
        {
            DeQueue(q1,x);//客车队列出队
            EnQueue(q,x);
            i++;j++;//客车数加一，渡船上车辆加一
        }
        else if(!QueueEmpty(q2)&&i==4)//客车上足四辆
        {
            DeQueue(q2,x);//货车队列出队一个
            EnQueue(q,x);
            i=0;j++;//每上一辆货车，客车i重新计数
        }
        else//其他情况（客车队列空、货车队列空
        {
            while(j<10&&i<4&&!QueueEmpty(q2))//客车队列空
            {
                DeQueue(q2,x);
                EnQueue(q,x);
                i++;j++;//i》4退出循环
            }
            i=0;
        }
        if(QueueEmpty(q1)&&QueueEmpty(q2))//货车客车加起来不足10
        {
            j=11;
        }
    }
}

4：利用两个栈模拟队列

入队1 2 3 4 5 6出队1 2 3 4 5 6

入栈-》出栈-》入栈
6       1

5       2

4       3

3       4   

2       5

1---》6

出栈

//入队
int EnQueue(Stack &s1,Stack &s2, int e)
{
    if(!StackOverflow(s1))
    {
        Push(s1,e);
        return 1;
    }
    if(StackOverflow(s1)&&!StackEmpty(s2))
    {
        printf("队列满");
        return 0;
    }
    if(StackOverflow(s1)&&StackEmpty(s2))
    {
        while(!StackEmpty(s1))
        {
            Pop(s1,x);
            Push(s2,x);
        }
    }
    Push(s1,e);
    return 1;

}
//出队
void DeQueue(Stack &s1,Stack &s2,int &x)
{
    if(!StackEmpty(s2))
    {
        Pop(s2,x);
    }
    else if(StackEmpty(s1))
    {
        printf("队列为空");
    }
    else
    {
        while(!StackEmpty(s1))
        {
            Pop(S1,x);
            Push(S2,x);
        }
        Pop(s2,x);
    }

}

5：s1 s2采用顺序栈共享存储区，采用栈顶相向 迎面增长的存储方式，设计入栈出站的操作算法

typedef struct
{
    int data[N];//栈空间
    int top[2];//top为两个栈顶指针
}stk;
stk s;
int pushstk(int i,int x)//i栈号，i=0->s1 i=1->s2
{
    if(i<0||i>1)//站号不对
    {
        return 0;
    }
    if(s.top[1]-s.top[0]==1)//栈满
    {
        return 0
    }
    switch(i)
    {
        case 0:s.data[++s.top[0]]=x;return 1;break;
        case 1:s.data[--s.top[1]]=x;return 1;
    }
}
int popstk(int i)
{
    if(i<0||i>1)//站号不对
    {
        return 0;
    }
    switch(i)
    {
        case 0:
            if(s.top[0]==-1)//栈空
            {
                return -1;
            }
            else
            {
                return s.data[s.top[0]--];
            }
        case 1:

            if(s.top[1]==N)//栈空
            {
                return -1;
            }
            else
            {
                return s.data[s.top[1]++];
            }
    }
}

6：判断链表全部字符是否中心对称 让前一部分元素进栈，出栈与后一部分比较 若全部相等则对称

int dc(linklist L,int n)//L带头结点单链表
{
    int i;
    char s[n/2];//字符栈
    p=L->next;
    for(i=0;i<n/2;i++)
    {
        s[i]=p->data;
        p=p->next;
    }
    i--;
    if(n%2==1)
    {
        p=p->next;
    }
    while(p!=NULL&&s[i]==p->data)
    {
        i--;
        p=p->next;
    }
    if(i==-1)return 1 ;
    else return 0;
}