西工大NOJ数据结构理论——010.k阶斐波那契数列（严3.32）

k阶斐波那契序列定义：第k和k+1项为1，前k - 1项为0，从k项之后每一项都是前k项的和

k=2时，斐波那契序列为：0,1,1,2,3,5,8,13...

k=3时，斐波那契序列为：0,0,1,1,2,4,7,13,24...

k=4时，斐波那契数列为：0,0,0,1,1,2,4,8,15,29...

#include
#include
typedef struct NODE{
	int n;
	struct NODE* next;
}NODE;
//结构体类型 

typedef struct Queue{
	struct NODE* front;
	struct NODE* rear;
}Queue;
//队列对头和队尾指针 

int IsQueueEmpty(Queue* qptr){
	int flag=0;
	if(qptr->front==NULL){
		flag=1;
	}
	return flag;
}
//判断队列中是否为空 

Queue* CreateEmptyQueue(){
	Queue* qptr=(Queue*)malloc(sizeof(Queue));
	if(qptr!=NULL){
		qptr->front=qptr->rear=NULL;
	}
	else{
		printf("Out of space!n");
	}
	return qptr;
}
//创建一个空队列 

void InsertQueue(Queue* qptr,int x){
	NODE* p=(NODE*)malloc(sizeof(NODE));
	if(p==NULL){
		printf("Out of space!n");
	}
	else{
		p->n=x;
		p->next=NULL;
		if(IsQueueEmpty(qptr)){
			qptr->front=qptr->rear=p;
			qptr->rear->next=qptr->front;
		}
		else{
			qptr->rear->next=p;
			qptr->rear=p;
			qptr->rear->next=qptr->front;
		}
	}
}
//向循环队列中插入一个新元素 

int DeleteQueue(Queue* qptr){
	NODE* p;
	int x;
	if(qptr->front==NULL){
		printf("Empty queue.n");
		return 0;
	}
	else{
		p=qptr->front;
		qptr->front=qptr->front->next;
		qptr->rear->next=qptr->front;
		x=p->n;
		free(p);
		return x;
	}
}
//删除队头元素 

int GetQueuevalue(Queue* qptr){
	int x=qptr->front->n;
	return x;
}
//获取队头元素 
 
void OutputQueuevalue(Queue* qptr){
	NODE* p;
	p=qptr->front;
	while(1){
		printf("%d ",p->n);
		p=p->next;
		if(p==qptr->front) break;
	}
}
//输出循环队列中所有元素 

void FibonacciArray(Queue* qptr,int max,int k){
	for(int i=k;i>1;i--){
		InsertQueue(qptr,0);
	}
	InsertQueue(qptr,1);
	//k阶斐波那契数列的初始化：
	//前k-1项都为1，第k项为1
	NODE* p=qptr->front;
	while(p->next->n==0) p=p->next;
	while(1){
		int x=0;
		NODE* q=p;
		for(int i=k;i>0;i--){
			x+=q->n;
			q=q->next;
		}
		if(x>max) break;
		InsertQueue(qptr,x);
		p=p->next;
		DeleteQueue(qptr);
	}
}
//完成斐波那契数列的复杂功能 

int main(){
	int max,k;
	scanf("%d%d",&max,&k);
	Queue* qptr=CreateEmptyQueue();
	FibonacciArray(qptr,max,k);
	OutputQueuevalue(qptr);
	return 0; 
}