广工anyview数据结构-03（乱码不贴）

/**********
【题目】试写一算法，实现顺序栈的判空操作
StackEmpty_Sq(SqStack S)。
顺序栈的类型定义为：
typedef struct {
  ElemType *elem; // 存储空间的基址
  int top;        // 栈顶元素的下一个位置，简称栈顶位标
  int size;       // 当前分配的存储容量
  int increment;  // 扩容时，增加的存储容量
} SqStack;        // 顺序栈
***********/
Status StackEmpty_Sq(SqStack S)
/* 对顺序栈S判空。                      */ 
/* 若S是空栈，则返回TRUE；否则返回FALSE */
{
   if(!S.top)return TRUE;
   else return FALSE;

}

/**********
【题目】试写一算法，实现顺序栈的取栈顶元素操作
GetTop_Sq(SqStack S, ElemType &e)。
顺序栈的类型定义为：
typedef struct {
  ElemType *elem;  // 存储空间的基址
  int top;         // 栈顶元素的下一个位置，简称栈顶位标
  int size;        // 当前分配的存储容量
  int increment;   // 扩容时，增加的存储容量
} SqStack;         // 顺序栈
***********/
Status GetTop_Sq(SqStack S, ElemType &e) 
/* 取顺序栈S的栈顶元素到e，并返回OK； */ 
/* 若失败，则返回ERROR。              */
{    
     e=S.elem[S.top-1];
     if(e!='\0')return OK;
     return ERROR; 
}

/**********
【题目】试写一算法，实现顺序栈的出栈操作
Pop_Sq(SqStack &S, ElemType &e)。
顺序栈的类型定义为：
typedef struct {
  ElemType *elem;  // 存储空间的基址
  int top;         // 栈顶元素的下一个位置，简称栈顶位标
  int size;        // 当前分配的存储容量
  int increment;   // 扩容时，增加的存储容量
} SqStack;         // 顺序栈
***********/
Status Pop_Sq(SqStack &S, ElemType &e) 
/* 顺序栈S的栈顶元素出栈到e，并返回OK；*/ 
/* 若失败，则返回ERROR。               */
{
  e=S.elem[S.top-1];
  S.top--;
  if(e!='\0')return OK;
  else return ERROR;
}

/**********
【题目】若顺序栈的类型重新定义如下。试编写算法，
构建初始容量和扩容增量分别为size和inc的空顺序栈S。
typedef struct {
  ElemType *elem; // 存储空间的基址
  ElemType *top;  // 栈顶元素的下一个位置
  int size;       // 当前分配的存储容量
  int increment;  // 扩容时，增加的存储容量
} SqStack2;
***********/
Status InitStack_Sq2(SqStack2 &S, int size, int inc)
/* 构建初始容量和扩容增量分别为size和inc的空顺序栈S。*/ 
/* 若成功，则返回OK；否则返回ERROR。                 */
{
    if(size<=0||inc<=0) return ERROR;
   ElemType* base;
   base = (ElemType*)malloc(size*sizeof(ElemType));
   if(base == NULL)  return ERROR;
   S.elem = base;
   S.top = base;
   S.size = size;
   S.increment = inc;
   return OK;
}

/**********
【题目】若顺序栈的类型重新定义如下。试编写算法，
实现顺序栈的判空操作。
typedef struct {
  ElemType *elem; // 存储空间的基址
  ElemType *top;  // 栈顶元素的下一个位置
  int size;       // 当前分配的存储容量
  int increment;  // 扩容时，增加的存储容量
} SqStack2;
***********/
Status StackEmpty_Sq2(SqStack2 S)
/* 对顺序栈S判空。                      */ 
/* 若S是空栈，则返回TRUE；否则返回FALSE */
{
   if(S.elem==S.top) return TRUE;
   else return FALSE;
}

/**********
【题目】若顺序栈的类型重新定义如下。试编写算法，
实现顺序栈的入栈操作。
typedef struct {
  ElemType *elem; // 存储空间的基址
  ElemType *top;  // 栈顶元素的下一个位置
  int size;       // 当前分配的存储容量
  int increment;  // 扩容时，增加的存储容量
} SqStack2;
***********/
Status Push_Sq2(SqStack2 &S, ElemType e)
/* 若顺序栈S是满的，则扩容，若失败则返回ERROR。*/
/* 将e压入S，返回OK。                          */
{
   ElemType *newbase;
   if(S.top>=S.size){
     int t=S.top-S.elem;
     newbase=(ElemType*)realloc(S.elem,(S.size+S.increment)*sizeof(ElemType));
     if(NULL==newbase)return ERROR;
     S.elem=newbase;
     S.top=S.elem+t;
    }
   *S.top++=e;
   return OK;  
}

/**********
【题目】若顺序栈的类型重新定义如下。试编写算法，
实现顺序栈的出栈操作。
typedef struct {
  ElemType *elem; // 存储空间的基址
  ElemType *top;  // 栈顶元素的下一个位置
  int size;       // 当前分配的存储容量
  int increment;  // 扩容时，增加的存储容量
} SqStack2;
***********/
Status Pop_Sq2(SqStack2 &S, ElemType &e) 
/* 若顺序栈S是空的，则返回ERROR；    */ 
/* 否则将S的栈顶元素出栈到e，返回OK。*/
{
  if(S.elem==S.top)return ERROR;
  e=*(--S.top);
  return OK;
}

/**********
【题目】试写一算法，借助辅助栈，复制顺序栈S1得到S2。
顺序栈的类型定义为：
typedef struct {
  ElemType *elem; // 存储空间的基址
  int top;        // 栈顶元素的下一个位置，简称栈顶位标
  int size;       // 当前分配的存储容量
  int increment;  // 扩容时，增加的存储容量
} SqStack;        // 顺序栈
可调用顺序栈接口中下列函数：
Status InitStack_Sq(SqStack &S, int size, int inc); // 初始化顺序栈S
Status DestroyStack_Sq(SqStack &S); // 销毁顺序栈S
Status StackEmpty_Sq(SqStack S);    // 栈S判空，若空则返回TRUE，否则FALSE
Status Push_Sq(SqStack &S, ElemType e); // 将元素e压入栈S
Status Pop_Sq(SqStack &S, ElemType &e); // 栈S的栈顶元素出栈到e
***********/
Status CopyStack_Sq(SqStack S1, SqStack &S2) 
/* 借助辅助栈，复制顺序栈S1得到S2。    */ 
/* 若复制成功，则返回TRUE；否则FALSE。 */
{
    int i;
    if(InitStack_Sq(S2,S1.size,S1.increment)!=OK)
      return FALSE;
    for(i=0;i<S1.top;i++)
      Push_Sq(S2,S1.elem[i]);
    return TRUE;
}

/**********
【题目】试写一算法，求循环队列的长度。
循环队列的类型定义为：
typedef struct {
  ElemType *base;  // 存储空间的基址
  int front;       // 队头位标
  int rear;        // 队尾位标，指示队尾元素的下一位置
  int maxSize;     // 最大长度
} SqQueue;
***********/
int QueueLength_Sq(SqQueue Q)
/* 返回队列Q中元素个数，即队列的长度。 */ 
{
  int length;
  length = Q.rear - Q.front;
  if(length < 0 ) length += Q.maxSize;
  return length;
}

/**********
【题目】如果希望循环队列中的元素都能得到利用，
则可设置一个标志域tag，并以tag值为0或1来区分尾
指针和头指针值相同时的队列状态是"空"还是"满"。
试编写与此结构相应的入队列和出队列的算法。
本题的循环队列CTagQueue的类型定义如下：
typedef struct {
  ElemType elem[MAXQSIZE];
  int tag;
  int front;
  int rear;
} CTagQueue;
**********/
Status EnCQueue(CTagQueue &Q, ElemType x)
/* 将元素x加入队列Q，并返回OK；*/
/* 若失败，则返回ERROR。       */
{
      if(Q.tag&&(Q.rear == Q.front))
        return ERROR;
        Q.rear %= MAXQSIZE;
      Q.elem[Q.rear] = x;  
      Q.rear = (Q.rear+1)%MAXSIZE;
      if(Q.rear == Q.front)
         Q.tag = 1;
      return OK;
      
}


Status DeCQueue(CTagQueue &Q, ElemType &x)
/* 将队列Q的队头元素退队到x，并返回OK；*/
/* 若失败，则返回ERROR。               */
{
      if(!Q.tag&&(Q.rear == Q.front)) 
        return ERROR;
      Q.front %= MAXQSIZE;
      x = Q.elem[Q.front];  
        Q.front = (Q.front+1)%10; 
      if(Q.front == Q.rear)
         Q.tag = 0;
      return OK;  
}

/**********
【题目】假设将循环队列定义为：以域变量rear
和length分别指示循环队列中队尾元素的位置和内
含元素的个数。试给出此循环队列的队满条件，并
写出相应的入队列和出队列的算法（在出队列的算
法中要返回队头元素）。
本题的循环队列CLenQueue的类型定义如下：
typedef struct {
  ElemType elem[MAXQSIZE];
  int length;
  int rear;
} CLenQueue;
**********/
Status EnCQueue(CLenQueue &Q, ElemType x)
  /* 将元素x加入队列Q，并返回OK；*/
  /* 若失败，则返回ERROR。       */
{
      if(Q.length == MAXQSIZE)
         return ERROR;     
      Q.rear = (Q.rear+1)%MAXQSIZE;
      Q.elem[Q.rear] = x;
      Q.length++;
      return OK;
}
Status DeCQueue(CLenQueue &Q, ElemType &x)
  /* 将队列Q的队头元素退队到x，并返回OK；*/
  /* 若失败，则返回ERROR。               */
{
     if(Q.length == 0)
       return ERROR;
     int front;
       front = Q.rear - Q.length + 1;
       if(front < 0)
         front += MAXQSIZE ;
     x = Q.elem[front];    
     Q.length--;
     return OK;
}

/**********
【题目】已知k阶斐波那契序列的定义为:
    f0=0,  f1=0,  …,  fk-2=0,  fk-1=1;
    fn=fn-1+fn-2+…+fn-k,  n=k,k+1,…
试利用循环队列编写求k阶斐波那契序列中第
n+1项fn的算法。


本题的循环队列的类型定义如下：
typedef struct {
  ElemType *base; // 存储空间的基址
  int front;      // 队头位标
  int rear;       // 队尾位标，指示队尾元素的下一位置
  int maxSize;    // 最大长度
} SqQueue;
**********/


long Fib(int k, int n)
/* 求k阶斐波那契序列的第n+1项fn */
{
    int x;
    int i,j;  
    long p[100];
    if(k<1||n<k||!p)
        return 0;
    for(i=0;i<k+1;i++)
    {    
       if(i<k-1)
         p[i]=0; 
       else p[i]=1;
     }   
    for(i=k+1;i<n+1;i++)
    {    
         x=p[0];   
         for(j=0;j<k;j++)
         p[j]=p[j+1];  
         p[k]=2*p[k-1]-x; 
     }    
    return p[k];
}

/**********
【题目】设A=(a1,…,am)和B=(b1,…,bn)均为有序顺序表，
A'和B'分别为A和B中除去最大共同前缀后的子表（例如，
A=(x,y,y,z,x,z)，B=(x,y,y,z,y,x,x,z)，则两者中最大
的共同前缀为(x,y,y,z)， 在两表中除去最大共同前缀后
的子表分别为A'=(x,z)和B'=(y,x,x,z)）。若A'=B'=空表，
则A=B；若A'=空表，而B'≠ 空表，或者两者均不为空表，
且A'的首元小于B'的首元，则A<B；否则A>B。试写一个比
较A和B大小的算法。（注意：在算法中，不要破坏原表A
和B，也不一定先求得A'和B'才进行比较）。
顺序表类型定义如下：
typedef struct {
  ElemType *elem;
  int       length;
  int       size;
  int       increment;
} SqList;
**********/
char Compare(SqList A, SqList B)
/* 比较顺序表A和B,      */
/*   返回'<', 若A<B;    */
/*       '=', 若A=B;    */
/*       '>', 若A>B     */
{
        int Iteator=0;
        while(Iteator<=A.length&&Iteator<=B.length)
        {
           if(A.elem[Iteator] != B.elem[Iteator])
             {
                  break;
             }
             Iteator++;
        }
        if(Iteator > A.length && Iteator <= B.length)
        {
            return '<';
        }else if(Iteator <= A.length && Iteator > B.length)
        {
           return '>';
        }
        else  if(Iteator > A.length && Iteator > B.length)
        {
           return '=';
        }
        else
        {
            if(A.elem[Iteator]>B.elem[Iteator])
              return '>';
            else if(A.elem[Iteator]==B.elem[Iteator])
              return '=';
            else 
              return '<';  
        }
        
        
}

/**********
【题目】试写一算法，实现顺序表的就地逆置，
即利用原表的存储空间将线性表(a1,a2,…,an)
逆置为(an,an-1,…,a1)。
顺序表类型定义如下：
typedef struct {
  ElemType *elem;
  int       length;
  int       size;
  int       increment;
} SqList;
**********/
void Inverse(SqList &L)
{
       int Iteator;
       ElemType temp;
       for(Iteator=0;Iteator<L.length/2;Iteator++)
       {
            temp=L.elem[Iteator];
            L.elem[Iteator]=L.elem[L.length-Iteator-1];
            L.elem[L.length-Iteator-1]=temp;
       }
}

/**********
【题目】试对一元稀疏多项式Pn(x)采用存储量同多项式
项数m成正比的顺序存储结构，编写求Pn(x0)的算法（x0
为给定值）。


一元稀疏多项式的顺序存储结构:
typedef struct {
  int  coef;  // 系数
  int   exp;  // 指数
} Term;


typedef struct {
  Term  *elem;   // 存储空间基址
  int    length; // 长度（项数）
} Poly;
**********/
float Evaluate(Poly P, float x)
/* P.elem[i].coef 存放ai，                        */
/* P.elem[i].exp存放ei (i=1,2,...,m)              */
/* 本算法计算并返回多项式的值。不判别溢出。       */
/* 入口时要求0≤e1<e2<...<em，算法内不对此再作验证 */
{
    int i=0,j=1,cur;
    float total=0,temp=1;      
    while(i<P.length){
        for(cur=P.elem[i].exp;j<=cur;++j){
            temp*=x;  
        }  
        total+=temp*(P.elem[i].coef);
        ++i;  
    }          
    return total;  
}

/**********
【题目】假设有两个集合A和B分别用两个线性表LA和LB
表示(即：线性表中的数据元素即为集合中的成员），
试写一算法，求并集A＝A∪B。
顺序表类型定义如下
typedef struct {
  ElemType *elem;     // 存储空间的基址
  int length;    // 当前长度
  int size;      // 存储容量 
  int increment; // 空间不够增加空间大小
} SqList;  // 顺序表
可调用顺序表的以下接口函数：   
Status InitList_Sq(SqList &L, int size, int inc); // 初始化顺序表L
int ListLength_Sq(SqList L);  // 返回顺序表L中元素个数
Status GetElem_Sq(SqList L, int i, ElemType &e); 
// 用e返回顺序表L中第i个元素的值
int Search_Sq(SqList L, ElemType e); 
// 在顺序表L顺序查找元素e，成功时返回该元素在表中第一次出现的位置，否则返回-1
Status Append_Sq(SqList &L, ElemType e);  // 在顺序表L表尾添加元素e
**********/
void Union(SqList &La, SqList Lb)
{
    int Iteator;
    ElemType elem='a';
    for(Iteator=0;Iteator<Lb.length;Iteator++)
    {
       elem=Lb.elem[Iteator];
       if(Search_Sq(La,elem) == -1)
         {
             if(La.length >= La.size)
             {
                 ElemType* newbase;
                 newbase = (ElemType*)realloc(La.elem,(La.size+La.increment)*sizeof(ElemType));
                 if(newbase == NULL) return;
                 La.size = La.size + La.increment;
                 La.elem=newbase;
             }
              Append_Sq(La,elem); 
                
         }
    }
}