//_DataStructure_C_Impl:链式队列

//_DataStructure_C_Impl:链式队列
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
typedef int DataType;
typedef struct QNode{
	DataType data;
	struct QNode *next;
}LQNode,*QueuePtr;
typedef struct{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

//将带头结点的链式队列初始化为空队列需要把头结点的指针域置为0
void InitQueue(LinkQueue *LQ){
	LQ->front=LQ->rear=(LQNode *)malloc(sizeof(LQNode));
	if(LQ->front==NULL)
		exit(-1);
	LQ->front->next=NULL;	//把头结点的指针域置为为0
	LQ->rear=LQ->front;
}
//判断链式队列是否为空,队列为空返回1,否则返回0
int QueueEmpty(LinkQueue LQ){
	if(LQ.rear->next==NULL)
		return 1;
	else
		return 0;
}
//将元素e插入到链式队列LQ中,插入成功返回1
int EnterQueue(LinkQueue *LQ,DataType e){
	LQNode *s;
	s=(LQNode *)malloc(sizeof(LQNode));	//为将要入队的元素申请一个结点的空间
	if(!s)		//如果申请空间失败,则退出并返回参数-1
		exit(-1);
	s->data=e;		//将元素值赋值给结点的数据域
	s->next=NULL;	//将结点的指针域置为空
	LQ->rear->next=s;	//将原来队列的队尾指针指向s
	LQ->rear=s;	//将队尾指针指向s
	return 1;
}
//取链式队列中的队头元素,并将该元素赋值给e,取元素成功返回1,否则返回0
int GetHead(LinkQueue LQ,DataType *e){
	LQNode *s;
	if(LQ.front==LQ.rear)	//在取队头元素之前,判断链式队列是否为空
		return 0;
	else{
		s=LQ.front->next;	//将指针s指向队列的第一个元素即队头元素
		*e=s->data;		//将队头元素赋值给e,取出队头元素
		return 1;
	}
}
//将队列Q的队头元素出队,并存放到x所指的存储空间中
int DeleteQueue(LinkQueue *Q,DataType *x){
	LQNode *p;
	if(Q->front==Q->rear)
		return 0;
	p=Q->front->next;
	Q->front->next=p->next;	//队头元素p出队
	if(Q->front==NULL)	//如果队中只有一个元素p,则p出队后成为空队
		Q->rear=Q->front;
	*x=p->data;
	free(p);	//释放存储空间
	return 1;
}
//清空队列
void ClearQueue(LinkQueue *LQ){
	while(LQ->front!=NULL){
		LQ->rear=LQ->front->next;
		free(LQ->front);
		LQ->front=LQ->rear;
	}
}
//*********************************
void PrintArray(int a[],int n,int N){
	int i;
	static int count=0;	//记录输出的行
	for(i=0;i<N-count;i++)		//打印空格
		printf(" ");
	count++;
	for(i=0;i<n;i++)		//打印数组中的元素
		printf("%6d",a[i]);
	printf("\n");
}
//链式队列实现打印杨辉三角
void YangHuiTriangle(int N){
	int i,j,k,n;
	DataType e,t;
	int temp[MaxSize];
	LinkQueue Q;
	k=0;
	InitQueue(&Q);
	EnterQueue(&Q,1);
	for(n=2;n<=N;n++){
		k=0;
		EnterQueue(&Q,1);
		for(i=1;i<=n-2;i++){
			DeleteQueue(&Q,&t);
			temp[k++]=t;
			GetHead(Q,&e);
			t=t+e;
			EnterQueue(&Q,t);
		}
		DeleteQueue(&Q,&t);
		temp[k++]=t;
		PrintArray(temp,k,N);
		EnterQueue(&Q,1);
	}
	k=0;
	while(!QueueEmpty(Q)){
		DeleteQueue(&Q,&t);
		temp[k++]=t;
		if(QueueEmpty(Q))
			PrintArray(temp,k,N);
	}
}
void main(){
	int n;
	printf("请输入要打印的行数:n=:");
	scanf("%d",&n);
	YangHuiTriangle(n);
	system("pause");
}

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

时间: 2024-10-06 23:15:14

//_DataStructure_C_Impl:链式队列的相关文章

数据结构Java实现07----队列:顺序队列&amp;顺序循环队列、链式队列、顺序优先队列

数据结构Java实现07----队列:顺序队列&顺序循环队列.链式队列.顺序优先队列 一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其另一端进行删除操作. 队列中允许进行插入操作的一端称为队尾,允许进行删除操作的一端称为队头.队列的插入操作通常称作入队列,队列的删除操作通常称作出队列. 下图是一个依次向队列中插入数据元素a0,a1,...,an-

数据结构之---C语言实现链式队列

//链式队列的存储 //杨鑫 #include <stdio.h> #include <stdlib.h> typedef int QElemType; //定义节点 typedef struct QNode { QElemType data; struct QNode *next; }QNode, *QueuePtr; //定义指针 typedef struct { QueuePtr front; QueuePtr rear; }LinkQueue; //插入元素e进入队列 vo

【数据结构-队列】链式队列

关于链式队列 链式队列又称为链队,是使用单链表实现的,需要一个头指针一个尾指针 结构图: 链队需要的元素组成 /*链式队列的每一个节点*/ struct node{ int data;//存储数据 struct node *next;//指向下一个节点的指针 }; /*链式队列*/ typedef struct{ struct node *head;//头指针 struct node *tail;//尾指针 }LinkedQueue; 创建一个带头节点的空队列 创建一个节点p 将p节点的next

有序链式队列

  编写头文件 struct queue { int num;            //代表数据 int high;           //优先级1111 struct queue *pNext;//存储下一个节点的地址 }; typedef  struct queue Queue;                           //简化队列 Queue * init(Queue *queueHead);                        //初始化 Queue *

C++链式队列

LinkQueue: //链式队列 #include<iostream> using namespace std; typedef int elemType; struct QNode { elemType data; QNode *next; }; struct LinkQueue { QNode *front; QNode *rear; }; //初始化 void InitQueue(LinkQueue *q) { q->front = q->rear = new QNode;

数据结构基础(14) --链式队列的设计与实现

链式队列是基于单链表的一种存储表示, 其形状如下图所示: (队列的队头指针指向单链表的第一个结点, 队尾指针指向单链表的最后一个结点, 注意没有无用的空[头/尾]节点) 用单链表表示的链式队列特别适合于数据元素变动比较大的情况, 而且不存在队列满而产生溢出的情况; 链式队列结点构造: [这次我们将节点构造成了类LinkQueue的嵌套类] struct ChainNode { ChainNode(const Type &_data, ChainNode *_next = NULL) :data(

链式队列的实现

链式队列数据结构如下: typedef struct qnode{ ElemType data; struct qnode* next; //指向下一节点指针 }QNode; typedef struct{ QNode* front; //队首指针 QNode* rear; //队尾指针 }ListQueue; 实现以下函数: void InitQueue(ListQueue* &q); //初始化队列 void ClearQueue(ListQueue* &q); //清空队列 int

不带头结点的链式队列进出队操作

/* 不带头结点的链式队列进出队操作 */ #include <stdio.h> #include <stdlib.h> #define ElementType int typedef struct QNode *Queue; typedef struct Node{ ElementType Data; struct Node *Next; }; typedef struct QNode{ struct Node *front; struct Node *rear; }; void

顺序队列和链式队列的实现

队列是一种常用的数据结构,它跟栈一样,操作都受到限制,队列只允许从一端进数据,另一端出数据.队列跟栈不同,栈是一种"后进先出"的模式,而队列是一种"先进先出"的操作模式.就好比日常排队一样,先排队的先出,后排队的后出.例如,进入队列的顺序是1,2,3,4,5则出队列的顺序是1,2,3,4,5(只考虑一次性出列的情况). 队列也分顺序队列和链式队列,跟顺序栈和链表栈一样,顺序队列同样是基于数组实现,链式队列则是基于链表实现. 顺序队列: //顺序队列 #include