习题课5

7.利用循环队列编写K阶Fabonacci数列中前n+1项（f0,f1,.....fn）的算法，要求:fn <=max,fn+1>max,其中max是某个约定的常数（注意：循环队列的最大容量是K，结束时队列应该存放时时数列的后k项）
  算法：初始化队列 Q.base;   Q.rear=0;
       f=Q.base[Q.rear-1]+Q.base[Q.rear-2]
       if f <=max  ，则f 入队
       0，1，1，2，3，5，8，13，21，34，55 假设max=50, K=8,则应该存放的是123----34其中的8项
       指针前移是否可以直接移动   -1对8求摸结果是7 -2对8求摸结果是6


       Status Fabonacci(int K,SqQueue &Q;Int MAX)
       {
        Q.base = (QElemtype*) malloc(K*sizeof(QElemType)); //申请K个存储空间
        if(！Q.base) exit(OVERFLOW);   
        Q.base[0] = 0; Q.base[1] =1; Q.rear =2;f=1; //初始化，rear指针指向第三个元素的下标
        while(f <= MAX) 
        {        
         Q.base[Q.rear] = f; //f入队列
         Q.rear = (Q.rear+1) % K; //指针往后移
         i= (Q.rear-1+K) % K;//再把前边两个指针计算出来  
         j= (Q.rear-2+K) % K; //0的前一个值是7，加一个K方便理解
         f= Q.base[i]+Q.base[j]; //计算数列
        }
       }

8.在顺序结构上实现输出受限的双端循环队列的入列和出列（只允许队头出列）算法，设每个元素表示一个待处理的作业，元素值表示作业的预算时间。入队列采取简化的短作业优先原则，若一个新提交的作业的预计执行时间小于对头和队尾作业的平均时间，则插入在对头，否则插入在队尾
  分析：用顺序队列实现
        出队列与普通队列没有区别
		入队：元素值<平均值，对头入队（优先考虑）
		      元素值>=平均值，队尾入队
  代码：//求模可以不加maxsize
       Status EnQueue(SqQueue &Q,QElemType e)
       {
	    //输出受限，小于平均时间入对头，否则入队尾
		if((Q.rear+1)%MAXSIZE == Q.front)//如果队列满，不能入队列
		return ERROR;
		t = (Q.base[Q.front]+Q.base[(Q.rear-1)% MAXSIZE])/2 //对头的元素和队尾的元素取出来平均值
		if(e<t){Q.front = (Q.front-1+MAXSIZE)%MAXSIZE;
                Q.base[Q.front]=e;}//队尾插入
		else{Q.base[Q.rear]=e;
		Q.rear=(Q.rear+1)% MAXSIZE;//对头插入，指针后移
		}
		return OK;
	   }	
   //实际上实现的就是在对头和队尾插元素   

9.假设以顺序结构实现一个双向栈，即在一个一维数组的存储空间中存在两个栈，他们的栈底分别设在数组的两个端点。试编写实现这个双向栈tws的三个操作：初始化inistack(tws)\入栈push(tws,i,x)和出栈pop(tws,i)的算法，其中i为0或1，用分别指示设在数组两端的两个栈
  定义双向栈：
  #define STACK_INIT_SIZE_100;
   typedef struct{
   SElemType *base;
   SElemTYpe *top0,*top1;
   int stacksize;
   }tws;
   其中stacksize表示栈当前可以使用的最大容量。base为栈底,top0/top1分别两个栈顶。
   正常情况top0<top1;
   top0的位置base,top1的位置是top+n-1的位置；
   初始化栈：
    Status InitStack(tws &S)
	{
	 //创造一个空栈
	 S.base = (SElemTYpe *)malloc(STACK_INIT_SIZE*sizeof(SElemTYpe));//申请存储空间
	 if(!S.base)exit(OVERFLOW);
	 S.stacksize = STACK_INIT_SIZE;//stacksize是申请到的存储空间的容量
	 S.top0 = S.base;//赋值 top0和top1
	 S.top1 = S.base+S.stacksize-1;
	 return OK;
	}//InitStack
	压栈：
	Status Push(tws &S,int I,SElemTYpe x)
	{
	if(S.top0>S.top1)//栈满
	           exit(OVERFLOW);
    if(i==0){S.base[S.top0]=x;S.top0++;}//栈不满，i是0，就在top0的位置上赋值，i=1就在top1的位置赋值
	else if(i==1){S.base[S.top1]=x;S.top1++;}
	else return ERROR;//误操作,i赋值为其他值  return ERROR
	return OK；
	}//Push
	出栈
	Status Pop(tws &S,int i,SElemTYpe &e)
	{
	 //从栈顶读取数据放入e内，栈中下一个元素所在位置成为新的栈顶
	 //出栈受限判断i是0还是1
	 if(i == 0)
	 {
	  if(S.top0==S.base) Exit(Empty);//判断书否为
	  e = *--S.top0;
	 }
	 else if(i==1)
	 {
	 if(S.top1 == S.base+S.stacksize-1)Exit(Empty);
	 e=*++S.top1;
	 }
	 else return ERROR;
	 return OK;
	}//Pop