栈之扩展操作



栈的扩展操作：

（0）后进先出：逆序问题

（1）判断是否对称问题：symmetry ['sɪmɪtrɪ]

（1.1）问题：
有一个带表头的单链表L，用于存放整形数据，设计一个算法判断该链表是否是对称的。

（1.2）分析：
扫描L的所有节点并将节点值进栈，再次扫描L，和栈顶元素比较。

（1.3）代码实现：
   bool isSymmetry(LinkList* linkList){
      int stack[MaxSize];
      int top=-1;

      Node* pnode=linkList->next;/*获取第一个节点*/
      while(p!=NULL){

       top++;
       stack[top]=pnode->data;/*节点值进栈*/
       pnode=pnode->next;
      }

      pnode=linkList->next;
      while(pnode!=NULL){
       if(pnode->data==stack[top])
       top--;
       else return false;
       pnode=pnode->next;
      }

      return true;
   }

   -----------------------------

   （2）Catlan数问题（出栈顺序问题）

http://blog.csdn.net/legend050709/article/details/39078951（推荐）

   参见：http://blog.csdn.net/zqt520/article/details/8010485

 *
 * *
 * * *
 * * * *
 * * * * *
形如这样的直角三角形网格，从左上角开始，只能向右走和向下走，问总共有多少种走法？

 问题的由来：编号为 1 到 n 的 n 个元素，顺序的进入一个栈，则可能的出栈序列有多少种？

对问题的转化与思考：n 个元素进栈和出栈，总共要经历 n 次进栈和 n 次出栈。这就相当于对这 2n 步操作进行排列。

 一 个模型：一个 n*n 的正方形网格，从左上角顶点到右下角顶点，只能向右走和向下走。问共有多少种走法。如果将向右走对应上述问题的进栈，向下走对应上述问题的出栈，那么，可 以视此模型为对上述问题的具体描述。而解决此问题，只要在总共从左上角到右下角的2n步中，选定向右走的步数，即共有C(n 2n)中走法。

但是存在一个问题，如果走法越过了对角线，那么对应到上述问题是出栈数比入栈数多，这是不符合实际的。

 对以上模型进行处理，对角线将以上正方形网格分成两部分，只留下包含对角线在内的下半部分，那么就不会出现越过对角线的问题。而这问题就是开始提出的问题。
 -------------
 问题等价于：n个1和n个0组成一2n位的2进制数，要求从左到右扫描，1的累计数不小于0的累计数，试求满足这条件的数有多少？
 解答： 设P2n为这样所得的数的个数。在2n位上填入n个1的方案数为 C（n 2n）
 不填1的其余n位自动填以数0。从C（n 2n）中减去不符合要求的方案数即为所求。
 不合要求的数指的是从左而右扫描，出现0的累计数超过1的累计数的数。

 不合要求的数的特征是从左而右扫描时，必然在某一奇数2m+1位上首先出现m+1个的累计数，和m个1的累计数。
 此 后的2（n－m）－1位上有n－m个1，n－m－1个0。如若把后面这部分2（n－m）－1位，0与1交换，使之成为n－m个0，n－m－1个1，结果得 1个由n＋1个0和n－1个1组成的2n位数，即一个不合要求的数对应于一个由n－1个0和n＋1个1组成的一个排列。

 反过来，任何一个 由n＋1个0，n－1个1组成的2n位数，由于0的个数多2个，2n是偶数，故必在某一个奇数位上出现0的累计数超过1的累计数。同样在后面的部分，令0 和1互换，使之成为由n个0和n个1组成的2n位数。即n＋1个0和n－1个1组成的2n位数，必对应于一个不合要求的数。

 用上述方法建立了由n＋1个0和n－1个1组成的2n位数，与由n个0和n个1组成的2n位数中从左向右扫描出现0的累计数超过1的累计数的数一一对应。

 例如 10100101

是由4个0和4个1组成的8位2进制数。但从左而右扫描在第5位（显示为红色）出现0的累计数3超过1的累计数2，它对应于由3个1，5个0组成的10100010。

 反过来 10100010

对应于 10100101

因而不合要求的2n位数与n＋1个0，n－1个1组成的排列一一对应，故有

P2n ＝ C（n 2n）— C（n＋1 2n）

 这个结果是一个“卡塔兰数”Catalan，在组合数学中有介绍，可以参阅有关资料

   （2.1）问题：
   设以数字序列1,2,3,4作为栈S 的输入，利用push和pop操作，写出所有的可能的输出。

   （2.2）分析：

   （2.3）代码实现：

#include <iostream>
using namespace std;
/*问题：1,2,3,4进栈；
输出所有的出栈可能；*/
/*分析：
*/

#define MaxSize 10
typedef int sElemType ;
class stack{
      public:

      sElemType array[MaxSize];
      int top;

      stack(){
      top=-1;
      }

      void Push(sElemType elem ){
            if(top==MaxSize-1) return ;
      top++;
      array[top]=elem;
      }

      sElemType Pop(){
      if(top!=-1){
      sElemType elem=array[top];
      top--;
      return elem;
      }
      }

      int GetSize(){
      return top+1;
      }
};

 stack s1,s2;
 int path[4];

 void Solve(int step);
 void out();

 int main()
 {
         for(int i=4;i>0;i--)
                 s2.Push(i);
         Solve(0);
          return 0;
 }

 void Solve(int step)
 {
         int temp;
         if(s1.GetSize()==0&& s2.GetSize()==0)
         {
               out();
                 return;
         }
         if(s1.GetSize()!=0)
         {
               temp=s1.Pop();
               path[step]=temp;
                 Solve(step+1);
                 s1.Push(temp);
         }
         if(s2.GetSize()!=0)
         {
               s1.Push(s2.Pop());
               Solve(step);
                 s2.Push(s1.Pop());
         }
 }

 void out()
 {
         for(int i=0;i <4;i++)
                 cout <<path[i];
         cout <<endl;
 }

   （2.4）结论：

   设入栈序列为I(n):1,2,...,n
1，I(n)有C(2n,n)-C(2n,n-1)个出栈序列，或者C(2n,n)/(n+1);
2，L(n)是I(n)的一个出栈序列当且仅当：对于L(n)中的任意一位数M，其后面比它小的数降序排列。