1. 回文是指正读反读均相同的字符序列，如“abba”和“abdba”均是回文，但 “good”不是回文。试写一个算法判断给定字符序列是否是回文。（提示：将一般字符入栈。）
    【算法思想】
    将字符串前一半入栈，然后，栈中元素和字符串后一半比较。即将第一个出栈元素和后一半串中第一个字符比较，若相等，则再出栈一个元素与后一个字符比较，依次类推，直至栈空，在这种情况下可判断该字符序列是回文。 如果出栈元素与串中的字符进行比较时出现不等的情况，则可判断该字符序列不是回文。

    1. #define maxsize 100
    2. typedef struct{
    3.     char data[maxsize];
    4.     int top;
    5. }Stack;
    6. int isPalindrome(char *t){
    7.     Stack S;
    8.     InitStack(S);
    9.     int len=strlen(t);//获得字符串长度
    10.     for(int i=0;i<len/2;i++)//长度为奇数时跳过中间的字符
    11.         Push(S,t[i]);
    12.     if(len%2!=0)
    13.         i++;
    14.     while(!EmptyStack(S)){
    15.         char temp=Pop(S);
    16.         if(temp!=t[i])
    17.             return 0;
    18.         else
    19.             i++;
    20.     }
    21.     return 1;
    22. }

    2. 假设以数组 Q[m]存放循环队列的元素，同时设置一个标志域名 tag，以 tag == 0 和 tag == 1 来区别队头指针（front）和队尾指针（rear）相等时，队列状态为 “空”还是“满”。试编写与此结构相应的插入（EnQueue）和删除（DeQueue） 算法
    【算法思想】
    在循环队列中，增设一个 tag 类型的整型变量，进队时置 tag 为 1，出队时置 tag 为 0（因为入队操作可能导致队满，只有出队操作可能会导致队空）。队列 Q 初始时，置 tag == 0，front == rear == 0。这样队列的 4 要素如下：
    队空条件：Q.front == Q.rear && Q.tag == 0
    队满条件：Q.front == Q.rear && Q.tag == 1
    进队操作：Q.data[Q.rear] = x; Q.rear = (Q.rear+1)%MaxSize; Q.tag = 1 。
    出队操作：x = Q.data[Q.front]；Q.front = (Q.front+1)%MaxSize ; Q.tag = 0; 

    1. #define MaxSize 100
    2. typedef struct{
    3.     ElemType data[MaxSize];
    4.     int front,rear;
    5.     int tag;
    6. }SqQueue;
    7. //入队   
    8. int EnQuene(SqQueue &Q,ElemType x){
    9.     if(Q.front==Q.rear&&Q.tag=1)
    10.         return 0;
    11.     Q.data[Q.rear]=x;
    12.     Q.rear=(Q.rear+1)%MaxSize;
    13.     Q.tag=1;
    14.     return 1;
    15. }
    16. //出队
    17. int DeQuene(SqQueue &Q,ElemType &x){
    18.     if(Q.front==Q.rear&&Q.tag==0)
    19.         return 0;
    20.     x=Q.data[Q.front];
    21.     Q.front=(Q.front+1)%MaxSize;
    22.     Q.tag=0;
    23.     return 1;
    24. }

    3. 设计一个算法判断输入的表达式中括号是否配对（假设只含有左、右圆括号）
    【算法思想】
    该算法在表达式括号匹配时返回真，否则返回假。设置一个栈 st，扫描表达式 exp，遇到左括号时进栈；遇到右括号时，若栈顶为左括号，则出栈，否则返回假。当表达式扫描完毕且栈为空时返回真；否则返回假。算法如下：

    1. typedef struct Stack{
    2.     char data[MaxSize];
    3.     int top;
    4. }Stack;
    5. bool Match(char s[],int n){
    6.     int i=0;
    7.     char e;
    8.     bool match=true;
    9.     Stack S;
    10.     InitStack(S);
    11.     while(i<n&&match){
    12.         if(s[i]=='(')
    13.             Push(S,s[i]);
    14.         else if(s[i]==')'){
    15.             if(GetTop(S,e)==true){//成功取得栈顶元素
    16.                 if(e!='(')
    17.                     match=false;
    18.                 else
    19.                     Pop(S,e);
    20.             }
    21.             else
    22.                 match=false;//无法取栈顶元素时表示不匹配
    23.         }
    24.         i++;
    25.     }
    26.     if(!StackEmpty(S))//栈不空时不匹配
    27.         match=false;
    28.     return match;
    29. }