作业四：栈和队列

第三章：栈和队列
1. 编写一个方法，要求借助一个栈，把一个数组中的元素逆置。
2. 编写一个方法，判断一个字符串是否为回文序列。要求只使用栈完成
3. 设计链队列类，实现它的基本运算，要求采用带头结点和尾指针的单循环链表表示队列
4. 实现循环队列的入队和出队操作，要求采用设置计数器的方法区分循环队列的判空和判满。
5. 实现循环队列的入队和出队操作，要求采用设置标志位的方法区分循环队列的判空和判满。
1. //借助一个顺序栈将一个数组的数据元素逆置

public reverse(Object []a) throws Exception
{
    SqStack S = new SqStack(a.length);
    for(int i = 0;i < a.length;i++)
        S.push(a[i]);
    for(int i = 0;i < a.length;i++)
        a[i] = S.pop();
}

2.//判断字符序列是否为回文序列，若是则返回true,否则返回false;

public Boolean isPalindSeq(String str)
{
    LinkStack S = new LinkStack();
    int i = 0;
    for(i = 0;i< str.length;i++)
    {   S.push(str.charAt(i));
    char c = ((Character)S.pop().charValue();
    if(c!=str.charAt(i))
        return false;
    }
return true;
}

老师的答案：

第三章：栈和队列

//1、编写一个方法，要求借助一个栈，把一个数组中的元素逆置。
//提示：将数组的元素依次入栈；再将栈中的元素依次出栈保存在数组中

public void reverse(Object []elem)
 {
     Stack s = new Stack();
     int i;
     for(i=0  ; i<elem.length; i++）
     {
         s.push(elem[i]);
      }
     i = 0;
     while( !s.isEmpty() )
     {
        elem[i]= s.pop();
        i++;
     }     
 }

//2、编写一个方法，判断一个字符串是否为回文序列。要求只使用栈完成。
 // 方法一，将字符串的每个字符依次取出，放入栈，
//  再将栈中的字符依次出栈与字符串中的每个字符比较
   public boolean isPalindrome(String str )
   {
     Stack s = new Stack();
     int i;
     char ch ;
     for(i=0  ; i<str.length（）; i++）
     {
         ch =  str.charAt(i);
         s.push(ch);
      }
     for(i=0  ; i<str.length（）; i++）
     {
          ch = s.pop();
          if (ch != str.charAt（i）)
              return false;
      }
      return true;           
    }

 // 方法二，将字符串的一半字符放入栈，再从栈中依次出栈与字符串的后半部分字符串比较
   public boolean isPalindrome(String str )
   {
     Stack s = new Stack();
     int i;
     char ch ;
     for(i=0  ; i<str.length（）/2; i++）
     {
         ch =  str.charAt(i);
         s.push(ch);
      }
     if (str.length()%2==1)  //若字符串的个数为奇数，跳过中间的一个字符
           i++;
     for( ; i<str.length（）; i++）
     {
          ch = s.pop();
          if (ch != str.charAt（i）)
              return false;
      }
      return true;           
    }

//3、设计链队列类，实现它的基本运算，要求采用带头结点和尾指针的单循环链表表示队列。
// 提示，存储结构是单循环链表，条件是带有头结点和尾指针
//  尾指针表示队尾，入队在该结点之后，并需要修改尾指针
//  入队在首头结点后，即尾结点后继的后继
//  特别注意两个问题：（1）判断队空的条件
//          （2）  出队最后一个元素后，指针的变化
    class LinkQueue
    {
         Node rear;

         public LinkQueue()
         {
               rear = new Node();//带头结点
               rear.next = rear;
         }         

         public void offer(Object x)  //入队
         {
              Node s = new Node(x);
              s.next = rear.next;
              rear.next = s;
              rear = s;
          }

          public Object poll()  //出队
          {
               if (rear.next==rear)
                   return null;             

               Node p = rear.next.next;
               if (p==rear) //唯一的结点，出队后为空队
               {
                   rear = rear.next;
                   rear.next = rear;                
                }
               else
                {
                    rear.next.next = p.next;
                 }
               return p.data;        
           }

          public Object peek() //取队头元素
           {
              if (rear.next==rear)
                   return null;
              else
                   return rear.next.next.data;
            }

          public boolean isEmpty()
          {
              if (rear.next==rear)
                   return true;
              else
                   return false;
           }

    }

//4、实现循环队列的入队和出队操作，要求采用设置计数器的方法区分循环队列的判空和判满。
// 提示： 循环队列，是队列的顺序存储结构
// 要求：增设计数器，表示元素个数，该变量做为类的成员变量，初始化时值为0，入队时自增，出队时自减
//       该 计数器的值，就可以表示出队空和队满的不同状态。

    class SeqQueue
    {
         Object elem[];
         int front;
         int rear;
         int len ;  //长度计数

         public SeqQueue(int maxsize)
         {
               elem= new Ojbect[maxsize]; 
               front = 0;  //表示队首前一位置
               rear  = 0;  //表示队尾位置
               len  = 0;   //表示元素个数
         }         

         public void offer(Object x) throws Exception  //入队
         {
              if (len  == elem.length）
                 throw new Exception("溢出");
              else
              {
                  rear = (rear+1) % elem.length;
                  elem[rear]=x;
                  len++;
               }
          }

          public Object poll()  //出队
          {
               if (len==0)
                   return null;             
               else
               {
                   front = (front+1) % elem.length;
                   len--;
                   return (elem[front]);
                }    
           }

          public Object peek() //取队头元素
           {
               if (len==0)
                   return null;             
               else
                   return (elem[front+1]);

            }

          public boolean isEmpty()
          {
              if (len==0)
                   return true;
              else
                   return false;
           }
    }

//5、实现循环队列的入队和出队操作，要求采用设置标志位的方法区分循环队列的判空和判满。
// 提示：循环队列是队列的顺序存储结构
// 要求：增设标志位，区别队空和队满。该标志位的设置方法有多种，一是类型，可以为boolean类型，也
//       可以是int类型，用0和1。二是表示 的含义，可以用真值表示空，也可以用真值表示满。
// 以下参考答案，设full为标志位，类型为boolean，用真值表示满，假值表示非满。
// 基于此，full的初值为false；入队时，判断front==rear是否成立，若成立，表示满，full赋值为true；
// 出队时,full赋值为false；判断队满的条件是：(full==true)；判断队空的条件是：(full==false && front==rear)

    class SeqQueue
    {
         Object elem[];
         int front;
         int rear;
         boolean full;  // 队满为真，非满为假

         public SeqQueue(int maxsize)
         {
               elem= new Ojbect[maxsize]; 
               front = 0;  //表示队首前一位置
               rear  = 0;  //表示队尾位置
               full= false;    
         }         

         public void offer(Object x) throws Exception  //入队
         {
              if ( full）
                 throw new Exception("溢出");
              else
              {
                  rear = (rear+1) % elem.length;
                  elem[rear]=x;
                  if ( front == rear)
                    full = true;   
               }
          }

          public Object poll()  //出队
          {
               if (front==rear && !full)
                   return null;             
               else
               {
                   front = (front+1) % elem.length;
                   full = false;  
                   return (elem[front]);
                }    
           }

          public Object peek() //取队头元素
           {
               if (front==rear && !full)
                   return null;             
               else
                   return (elem[front+1]);

            }

          public boolean isEmpty()
          {
              if (front==rear && !full)
                   return true;
              else
                   return false;
           }
    }