C和C++实现数据结构队列

C语言实现数据结构队列

c语言实现顺序循环队列

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

#define OK 1
#define ERROR 0
#define MAXSIZE 10

typedef int Status;
typedef int ElemType;
// 循环队列的顺序存储结构
typedef struct SqQueue {
	ElemType array[MAXSIZE];
	// 头指针
	int front;
	// 尾指针
	int rear;
	int size;
}SqQueue;

// 初始化空队列
SqQueue* InitQueue() {
	SqQueue* s = NULL;
	s = (SqQueue*)malloc(sizeof(SqQueue) * MAXSIZE);
	if (s != NULL) {
		s->front = s->rear = 0;
		s->size = 0;
		return s;
	}
	return NULL;
}

// 元素入队
Status EnQueue(SqQueue* s, ElemType e) {
	// 首先判断是否队满
	if ((s->rear + 1) % MAXSIZE == s->front)
		return ERROR;
	else {
		s->array[s->rear] = e;
		// 尾指针后移
		s->rear = (s->rear + 1) % MAXSIZE;
		s->size++;
		return OK;
	}
}

// 队头元素出队
Status DeQueue(SqQueue* s) {
	// 首先判断队是否为空
	if (s->rear == s->front)
		return ERROR;
	else {
		// 头指针后移
		s->front = (s->front + 1) % MAXSIZE;
		s->size--;
		return OK;
	}
}

// 取出队头元素
ElemType getFront(SqQueue* s, ElemType* e) {
	if (s->rear == s->front)
		return ERROR;
	else {
		*e = s->array[s->front];
		return *e;
	}
}

int size(SqQueue* s) {
	return s->size;
}

int main()
{
	SqQueue* s = InitQueue();
	int value = 0;
	int i = 0;

	for (i = 0; i < 8; i++)
		EnQueue(s, i);

	printf("此时队列中元素个数为：%d\n", size(s));

	for (i = 0; i < 8; i++) {
		printf ("此时队头元素为: %d\n", getFront(s, &value));
		DeQueue(s);
	}
	
	printf("此时队列中元素个数为: %d\n", size(s));

	return 0;
}

c语言实现链式队列

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

#define OK 1
#define ERROR 0

typedef int Status;
typedef int ElemType;
// 结点结构
typedef struct QNode
{
	ElemType value;
	struct QNode* next;
}QNode, *QueuePtr;

// 队列的链表结构
typedef struct
{
	// 队头队尾指针
	QueuePtr front, rear;
}LinkQueue;

// 初始化队列
Status InitQueue(LinkQueue* q) {
	QueuePtr Node = (QueuePtr)malloc(sizeof(QNode));
	if (Node != NULL) {
		q->front = q->rear = Node;
		q->front->next = NULL;
		return OK;
	} else {
		return ERROR;
	}
}

Status EnQueue(LinkQueue* q, ElemType e) {
	// 从堆空间申请一个结点
	QueuePtr node = (QueuePtr)malloc(sizeof(QNode));
	if (node != NULL) {
		node->value = e;
		node->next = NULL;
		// 把拥有元素e的新节点赋值给原队尾结点的后继
		q->rear->next = node;
		// 尾指针后移
		q->rear = node;
		return OK;
	} else {
		return ERROR;
	}
}

Status DeQueue(LinkQueue* q) {
	// 首先判断队元素是否为空
	if (q->front == q->rear)
		return ERROR;
	// 将欲删除的队头结点暂存给toDel
	QueuePtr toDel = q->front->next;
	// 将原队头结点后继赋值给头节点后继
	q->front->next = toDel->next;
	
	// 若队头是队尾则删除后将rear指向头节点
	if (q->rear == toDel)
		q->rear = q->front;

	free(toDel);
	return OK;
}

int size(LinkQueue* q) {
	int ret = 0;
	QueuePtr slider = q->front->next;
	while (slider != NULL) {
		ret++;
		slider = slider->next;
	}
	return ret;
}

// 获取队头元素
ElemType getFront(LinkQueue* q, ElemType* e) {
	if (q->front == q->rear)
		return ERROR;
	*e = q->front->next->value;
	
	return *e;
}

int main()
{
	LinkQueue s;
	int value = 0;
	int i;
	InitQueue(&s);
	for (i = 0; i < 10; i++)
		EnQueue(&s, i);

	printf("完成入队之后元素个数为： %d\n", size(&s));

	for (i = 0; i < 10; i++) {
		printf("此时队头元素为： %d\n", getFront(&s, &value));
		DeQueue(&s);
	}
	printf("完成出队之后元素个数为:  %d\n", size(&s));
	return 0;
}

c++实现数据结构队列

c++实现顺序循环队列

#include <iostream>
using namespace std;

template <typename T, int N>
class Queue
{
private:
	T m_space[N];
	// 头指针
	int m_front;
	// 尾指针
	int m_rear;
	// 元素个数
	int m_size;
public:
	Queue() {
		m_front = m_rear = m_size = 0;
	}
	
	// 元素入队操作
	bool EnQueue(const T& e) {
		// 首先判断是否队满
		if ((m_rear + 1) % N == m_front)
			return false;
		else {
			m_space[m_rear] = e;
			m_rear = (m_rear + 1) % N;
			m_size++;
			return true;
		}
	}
	
	// 元素出队操作
	bool DeQueue() {
		// 首先判断队是否为空
		if (m_front == m_rear)
			return false;
		else {
			// 头指针后移
			m_front = (m_front + 1) % N;
			m_size--;
			return true;
		}
	}
	
	// 获取队头元素
	T getFront(T& e) {
		if (m_front == m_rear)
			return -1;
		else {
			e = m_space[m_front];
			return e;
		}
	}

	int size() const {
		return m_size;
	}

};

int main() 
{
	Queue<int, 11> q;
	int e = 0;
	for (int i = 0; i < 10; i++)
		q.EnQueue(i);
	cout << "入队完成之后元素个数： " << q.size() << endl;

	for (int i = 0; i < 10; i++) {
		cout << "此时队头元素为: " << q.getFront(e) << endl;
		q.DeQueue();
	}
	cout << "出队完成之后元素个数: " << q.size() << endl;
}

C++实现链式队列

#include <iostream>
using namespace std;

template <typename T>
// 结点
struct Node
{
	T value;
	Node<T>* next;
	Node() {}
	Node(const T& val, Node<T>* theNext):value(val),next(theNext) {}
};

template <typename T>
class Queue
{
private:
	Node<T>* m_front;
	Node<T>* m_rear;
	int m_size;
public:
	Queue() {
		m_front = m_rear = NULL;
		m_size = 0;
	}
	
	// 向队中加入元素
	void EnQueue(const T& e) {
		// 从堆空间申请一个结点并初始化
		Node<T>* node = new Node<T>(e, NULL);
		
		if (node != NULL) {
			// 如果此时队为空
			if (m_size == 0)
				m_front = node;
			else
				m_rear->next = node;
			m_rear = node;
			m_size++;
		}
	}

	// 删除队头元素
	bool DeQueue() {
		if (m_front == NULL)
			return false;
		else {
			Node<T>* toDel = m_front->next;
			delete m_front;
			// 队头指针后移
			m_front = toDel;
			m_size--;
			return true;
		}
	}
	
	T front() {
		if (m_front == NULL)
			return -1;
		else
			return m_front->value;
	}

	bool empty() const {
		return m_size == 0;
	}

	int size() const {
		return m_size;
	}

};

int main()
{
	Queue<int> q;
	for (int i = 0; i < 10; i++)
		q.EnQueue(i);

	cout << "入队完成之后元素个数为： " << q.size() << endl;
	for (int i = 0; i < 10; i++) {
		cout << "此时队头元素为: " << q.front() << endl;
		q.DeQueue();
	}
	cout << "出队完成之后元素个数为:  " << q.size() << endl;
	return 0;
}

参考资料：

大话数据结构 c语言版
数据结构、算法与应用 c++语言描述