数据结构:【学习笔记】04 线性结构——队列

队列

1 队列及其实现

队列:具有一定操作约束的线性表。

  • 插入和删除操作:只能在一端查插入,而在另一端删除
  • 数据插入:入队列
  • 数据删除:出队列
  • 先来先服务
  • 先进先出:First In First Out (FIFO)

1、类型名称:队列

2、数据对象集:一个有0个或者多个元素的有穷线性表

3、操作集:长度为MaxSize的队列Q属于Queue,队列元素item属于ElementType

  • Queue CreateQueue(int MaxSize):生成长度为MaxSize的空队列
  • int IsFull(Queue Q, int MaxSize):判断队列Q是否已满
  • void AddQ(Queue Q, ElementType item):将元素item插入队列
  • int IsEmptyQ(Queue Q):判断队列Q是否为空
  • ElementType Delete(Queue Q):将队头数据元素从队列中删除并返回

2 队列的顺序存储实现

2.1 定义
# define MaxSize <MaxSizeNum>
struct QNode {
	ElementType Data[MaxSize];
	int rear;
	int front;
};

typedef struct QNode *Queue;

【问题】 若想加一个元素时,rear已经指向数组的末尾,而front在数组中间,那么怎么使得开头的空间得以更好的利用呢?

【解决方法】 我们可以使数组呈现循环结构,形成循环队列。

【问题】 使用循环队列怎么区分rear和front的相对位置关系呢?(即:队列到底是满还是空?)

【解决方法】

  • 使用额外标记:Size或者Tag域
  • 仅使用n-1个数组空间
2.2 入队列
void AddQ(Queue PtrQ, ElementType item)
{
	if ((PtrQ->rear + 1) % MaxSize == PtrQ->front) {
		printf("Queue Full!");
		return;
	}
	PtrQ->rear = (PtrQ->rear + 1) % MaxSize;
	PtrQ->Data[PtrQ->rear] = item;
}
2.3 出队列
ElementType DeleteQ(Queue PtrQ)
{
	if (PtrQ->front == PtrQ->rear) {
		printf("Queue Empty!");
		return ERROR;
	}
	else {
		PtrQ->front = (PtrQ->front + 1) % MaxSize;
		return PtrQ->Data[PtrQ->front];
	}
}

3 队列的链式存储实现

单向链表的插入和删除只能在表头实现,所以队列链表的front应该指向链表的表头。

3.1 具体的数据结构
struct Node {
	ElementType Data;
	struct Node *Next;
};
struct QNode {
	struct Node *rear;
	struct Node *front;
};
typedef struct QNode *Queue;
Queue PtrQ;
3.2 出队操作
ElementType DeleteQ(Queue PtrQ) {
	struct Node *FrontCell;
	ElementType FrontElem;
	if (PtrQ->front == NULL) {
		printf("Queue Empty!");
		return ERROR;
	}
	FrontCell = PtrQ->front;
	if (PtrQ->front == PtrQ->rear){
		PtrQ->front = PtrQ->rear = NULL;
	}
	else {
		PtrQ->front = PtrQ->front->Next;
	}
	FrontElem = FrontCell->Data;
	free(FrontCell);
	return FrontElem;
}
3.3 入队操作
void InsertQ(Queue PtrQ, ElementType item) {
	struct Node *TmpCell;
	TmpCell = (struct Node *)malloc(sizeof(struct Node));
	TmpCell->Data = item;
	TmpCell->Next = PtrQ->rear->Next;
	PtrQ->rear->Next = TmpCell;
	PtrQ->rear = TmpCell;
}

4 队列的实际运用

4.1 多项式加法运算

【分析过程】采用不带头结点的单向链表,按照指数递减的顺序排列各项

定义结构类型

struct PolyNode {
	int coef;
	int expon;
	struct PolyNode *link;
};
typedef struct PolyNode *Polynomial;
Polynomial P1, P2;

【算法思路】两个指针P1和P2分别指向这两个多项式第一个结点,不断循环:

  • 如果P1->expon == P2->expon:系数相加,同时P1和P2指向下一项。
  • 如果P1->expon > P2->expon:P1结果存入多项式结果,P1指向下一项。
  • 如果P1->expon < P2->expon:P2结果存入多项式结果,P2指向下一项。

【加法实现】

Polynomial PolyAdd(Polynomial P1, Polynomial P2) {
	Polynomial front, rear, temp;
	int sum;
	rear = (Polynomial)malloc(sizeof(struct PolyNode));
	front = rear;
	while (P1&&P2) {
		switch (Compare(P1->expon, P2->expon)) {
		case 1:
			Attach(P1->coef, P1->expon, &rear);
			P1 = P1->link;
			break;
		case -1:
			Attach(P2->coef, P2->expon, &rear);
			P2 = P2->link;
			break;
		case 0:
			sum = P1->coef + P2->coef;
			if(sum)
				Attach(P2->coef, P2->expon, &rear);
			P1 = P1->link;
			P2 = P2->link;
			break;
		}

	}
	for (;P1;P1 = P1->link)
		Attach(P1->coef, P1->expon, &rear);
	for (;P2;P2 = P2->link)
		Attach(P2->coef, P2->expon, &rear);
	rear->link = NULL;
	temp = front;
	front = front->link;
	free(temp);
	return front;
}

void Attach(int c, int e, Polynomial *pRear) {
	Polynomial P;
	P = (Polynomial)malloc(sizeof(struct PolyNode));
	P->coef = c;
	P->expon = e;
	P->link = NULL;
	(*pRear)->link = P;
	*pRear = P;
}

int Compare(int i1, int i2) {
	if (i1 == i2)
		return 0;
	else if (i1 > i2)
		return 1;
	else if (i1 < i2)
		return -1;
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值