广工anyview数据结构-03(乱码不贴)

原创 2015年07月10日 11:02:10
/**********
【题目】试写一算法,实现顺序栈的判空操作
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); 
                
         }
    }
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

Delphi7高级应用开发随书源码

  • 2003年04月30日 00:00
  • 676KB
  • 下载

2015广工数据结构anyview题库

/********** 【题目】试写一算法,如果三个整数a,b和c的值 不是依次非递增的,则通过交换,令其为非递增。 ***********/ void Descend(int &a, int &b,...

广工anyview数据结构-07~08(乱码不贴)

广工anyview数据结构
  • clr_lr
  • clr_lr
  • 2015年07月10日 11:52
  • 1752

广工数据结构anyview2015

  • 2015年07月10日 12:14
  • 698KB
  • 下载

0614广工数据结构anyview答案2015

  • 2015年06月16日 00:02
  • 43KB
  • 下载

(持续更新)造福GDUT计院的小伙伴们,数据结构anyview题目+答案,代码搓大牛们勿喷

GDUT数据结构anyview题目+答案,代码搓大牛们勿喷,大家随意就好!/********** 【题目】试写一算法,实现链栈的判空操作。 链栈的类型定义为: typedef struct LSNod...

广工Anyview数据结构答案

  • 2015年06月12日 19:06
  • 656KB
  • 下载

左程云_算法与数据结构 — 链表问题 — 03删除链表的中间节点和a/b处的节点

问题描述给定链表的头节点head,实现删除链表的中间节点的方法; 若为偶数个:比如1234则删除节点2; 给定链表的头节点head,实现删除链表的a/b处节点的方法;思路分析删除中间节点1个节点,...

广工Anyview数据结构答案

  • 2016年01月17日 00:07
  • 656KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:广工anyview数据结构-03(乱码不贴)
举报原因:
原因补充:

(最多只允许输入30个字)