【数据结构】队列

队列结构定义common.h

#ifndef __HI_COMM_H__
#define __HI_COMM_H__


#include <stdlib.h>
#include <stdio.h>
#include <malloc.h>
#include <string>

#define LIST_INIT_SIZE 100  /*线性表存储空间的初始分配量；*/
#define LIST_INCREMENT 10   /*线性表存储空间的分配增量；*/
#define ElemType int
//#define NULL (void*)0

/*线性表的顺序存储结构*/
typedef struct{
	ElemType *elem;  //线性表的基地址
	int length;      //当前长度
	int MaxSize;    //当前分配的存储容量
}sqlist;

/*线性表的链式存储结构*/
typedef struct frankLNode
{
	ElemType data;
	struct frankLNode* next; 
}LNode;   //


/*栈的顺序存储结构*/
typedef struct 
{
	ElemType* base;
	ElemType* top;
	int StackSize;
}FStack;
#define STACK_INIT_SIZE 100  /*栈存储空间的初始分配量；*/
#define STACK_INCREMENT 10   /*栈存储空间的分配增量；*/


/*队列的链式存储结构*/
typedef struct frankQNode
{
	ElemType data;
	struct frankQNode *next;
}QNode;

typedef struct frankQueueHeader
{
	QNode* front;
	QNode* rear;
}QueueHeader;

/*二叉树的存储结构*/

typedef struct frankBinTreeNode
{
	ElemType data;
	struct frankBinTreeNode *left;
	struct frankBinTreeNode *right;
}BinTreeNode;
typedef BinTreeNode* pBinTreeNode;


#endif

头文件FQueue.h

#pragma once
#include "common.h"
class FQueue
{
public:
	FQueue(void);
	~FQueue(void);



	void InitQueue(QueueHeader &QHeader);

	void DestroyQueue(QueueHeader &QHeader);

	void ClearQueue(QueueHeader &QHeader);

	bool isQueueEmpty(QueueHeader &QHeader);

	int getQueueLength(QueueHeader &QHeader);

	void EnQueue(QueueHeader &QHeader,ElemType e);

	ElemType DeQueue(QueueHeader &QHeader);
};

算法实现FQueue.cpp

#include "FQueue.h"


FQueue::FQueue(void)
{
}


FQueue::~FQueue(void)
{
}

void FQueue::InitQueue(QueueHeader &QHeader)
{
	QHeader.front = QHeader.rear = (QNode*)malloc(sizeof(QNode));
	if (!QHeader.front)
	{
		exit(1);
	}

	QHeader.front->next = 0;
}

void FQueue::DestroyQueue(QueueHeader &QHeader)
{
	while (QHeader.front)
	{
		QHeader.rear = QHeader.front->next;
		free(QHeader.front);
		QHeader.front = QHeader.rear;
	}

}

void FQueue::ClearQueue(QueueHeader &QHeader)
{

}

bool FQueue::isQueueEmpty(QueueHeader &QHeader)
{
	if (QHeader.front == QHeader.rear)
	{
		return true;
	}
	else
	{
		return false;
	}
}

int FQueue::getQueueLength(QueueHeader &QHeader)
{
	int i = 0;
	while (QHeader.rear != QHeader.front)
	{
		QHeader.rear = QHeader.rear->next;
	}
	return i;
}

void FQueue::EnQueue(QueueHeader &QHeader,ElemType e)
{
	QNode* node = (QNode*)malloc(sizeof(QNode));
	node->next = NULL;
	node->data = e;
	QHeader.rear->next = node;
	QHeader.rear = node;
}

ElemType FQueue::DeQueue(QueueHeader &QHeader)
{
	ElemType e;
	if (QHeader.front == QHeader.rear)
	{
		exit(1);
	}
	QNode* p = QHeader.front->next;
	e = p->data;

	 QHeader.front = p;
	 return e;
}

测试代码

void TEST_Queue()
{
	printf("-----------------------------------------------------\n");
	printf("-------Here is A Test For Queue----------------------\n");
	FQueue fQUEUE;
	QueueHeader QHeader ;
	QHeader.rear = (QNode*)malloc(sizeof(QNode));
	QHeader.front = (QNode*)malloc(sizeof(QNode));

	fQUEUE.InitQueue(QHeader);
	for (int i = 0;i<10;i++)
	{
		fQUEUE.EnQueue(QHeader,i);
	}
	for (int i = 0;i<10;i++)
	{
		printf("%d  ",fQUEUE.DeQueue(QHeader));
	}


}