1.有效的括号

char pairs(char a)
{
    if(a=='}')return '{';
    if(a==']')return '[';
    if(a==')')return '(';
    return 0;
}
bool isValid(char* s) {
    char* stack=(char*)malloc(sizeof(char)*10000);
    int top=0;
    int len=strlen(s);
    if(len%2==1)return false;
    for(int i=0;s[i];i++)
    {
        char ch=pairs(s[i]);
        if(ch)
        {
            if(top==0||stack[top-1]!=ch)return false;  
            top--;
        }
        else 
        {
            stack[top++]=s[i];
        }
        
    }
    return top==0;
}

      这个题为什么能想到用栈来解决呢？因为括号匹配的问题本质上涉及到”最近匹配原则“，就是最后出现的左括号应该与最先出现的右括号匹配。栈是一种后进先出的数据结构，非常适合用于处理最近匹配的问题，当我们遍历每个字符时，遇到左括号就将其压入栈中，而在遇到右括号时，就从栈中弹出最近遇到的左括号并检查是否匹配·。如果匹配就继续遍历；如果不匹配，或者栈为空而无法弹出，则说明括号不匹配。

2.逆波兰表达式求值

int evalRPN(char ** tokens, int tokensSize){
    int stack[tokensSize];
    int top=0;
    for(int i=0;i<tokensSize;i++)
    {
        char* c=tokens[i];
        int n=strlen(c);
        if(n>1||isdigit(c[0]))
    {
        stack[top++]=atoi(c);
    }
    else
    {
        int num1=stack[--top];
        int num2=stack[--top];
        switch(c[0])
        {
            case '+':
               stack[top++]=num2+num1;
               break;
            case '-':
               stack[top++]=num2-num1;
               break;
            case '*':
                stack[top++]=num2*num1;
                break;
            case '/':
                stack[top++]=num2/num1;
                break;
        }
    }
    }
    return stack[top-1];
}

     什么是逆波兰表示法？ 一个表达式E的后缀形式可以如下定义：（1）如果E是一个变量或常量，则E的后缀式是E本身。（2）如果E是E1 op E2形式的表达式，这里op是任何二元操作符，则E的后缀式为E1'E2' op，这里E1'和E2'分别为E1和E2的后缀式。（3)如果E是（E1）形式的表达式，则E1的后缀式就是E的后缀式。如：我们平时写a+b，这是中缀表达式，写成后缀表达式就是：

ab+(a+b)*c-(a+b)/e的后缀表达式为：
(a+b)*c-(a+b)/e
→((a+b)*c)((a+b)/e)-
→((a+b)c*)((a+b)e/)-
→(ab+c*)(ab+e/)-
→ab+c*ab+e/-

 

      就是不断把中缀表达式的二元运算符放到后缀上，有括号的最后再放，因为括号运算优先级最高，那把逆波兰表达式转化为中缀表达式，就是逆过程，我们也可以看到，每遇到一个运算符，我们总是把与这个运算符距离最近的两个数拿来运算，也是最近匹配的问题，所以我们想到用栈来解决问题，首先定义一个栈，然后就遇到了一个问题，我们遍历tokens时，怎么判断是不是数字呢，只有数字我们才能入栈，有三种情况：一位数，多位数，负数，对于负数我们可以计算这个字符的长度，如果长度大于1，就是数字；对于一位数乃至多位数，我们可以使用isdigit函数进行判断，isdigit函数用于判断数字字符(0-9)，参数为字符，如果不是返回0，是的话返回非0，如果返回非0，我们就把压入栈中，这里还用到了atoi函数，atoi函数用于把数字字符转化为数字，参数为字符串，这样我们就把数字压入栈中了，如果遇到了运算符，用switch语句判断是什么运算符，然后对最近的两个数字进行运算，把运算的结果压入栈中，直到遇到下一个运算符继续进行运算，最后返回栈顶的值即可。

3.反转链表

struct ListNode* reverseList(struct ListNode* head){
    if(head == NULL || head->next == NULL){
        return head;
    }
    int *stack = (int *)malloc(sizeof(int) * 5001);
    int top = 0;
    struct ListNode* now = head;
    while(now){
        stack[top++] = now->val;
        now = now->next;
    }
    struct ListNode* ret = malloc(sizeof(struct ListNode));
    struct ListNode* retHead = ret;
    while(top--){
        head->val = stack[top]; 
        ret->next = head;
        ret = ret->next;
        head = head->next;
    }
    return retHead->next;
}

     之前我们反转链表时是把next指针不断进行修改，而反转链表像不像先进后出的问题，我们同样可以使用栈数据结构来解决问题，首先判断链表是否为空或者是否只有一个结点，因为这种情况下我们不需要进行反转，直接返回head即可。

     接下来我们定义一个栈stack，和头指针now指向head，把链表各个结点的值存入栈中，接着我们再定义一个ret作为反转后的链表的虚拟头结点，以及返回的结点，接着就是栈中的元素出栈，将链表的值进行更新，ret和head不断向右走，最后返回retHead->next;

4.回文链表

bool isPalindrome(struct ListNode* head){
      int* stack=(int*)malloc(sizeof(int)*100000);
      int top=0;
      struct ListNode* cur=head;
      while(cur)
      {
          stack[top++]=cur->val;
          cur=cur->next;
      }
      while(top--)
      {
          if(stack[top]!=head->val)return false;
          head=head->next;
      }
      return true;
}

      这个题也很精彩，我们只需要值进行判断即可，回文就是前后对应相同，从后和从前看都是一样的链表就是回文链表，也就是说我们只需要判断末尾的值是否和开头的值是否相等即可，我们可以用栈来解决，毕竟栈是先进后出，末尾的值会先出栈。

     我们先定义一个栈，遍历链表，将值压入栈中，然后从栈顶开始遍历，如果遍历到的栈顶的值和从head开始遍历的值不相等，就不是回文链表，否则就是回文链表。