数据结构 循环队列、链队（C++描述）

循环队列

#define MAX 10

enum status {
	success,overflow,underflow
};

template <class T>
class SqQueue {
public:
	SqQueue() {
		front = rear = 0;
	}
	bool isEmpty()const;
	bool isFull()const;
	status enQueue(T x);
	status deQueue(T& x);
	status travQueue();
private:
	int front;
	int rear;
	T data[MAX];
};

template<class T>
bool SqQueue<T>::isEmpty()const {
	if (front == rear) return true;
	else return false;
}
template<class T>
bool SqQueue<T>::isFull()const {
	if ((rear + 1) % MAX == front) return true;
	else return false;
}
template<class T>
status SqQueue<T>::enQueue(T x) {
	if (isFull()) return overflow;
	else {
		data[rear] = x;
		rear=(rear+1)%MAX;
		return success;
	}
}
template<class T>
status SqQueue<T>::deQueue(T& x) {
	if (isEmpty()) exit(0); //return underflow;
	else {
		x = data[front];
		front = (front + 1) % MAX;

		return success;
	}
}

template<class T>
status SqQueue<T>::travQueue() {
	if (isEmpty()) return underflow;
	else {
		for (int i = front; i != (rear + 1) % MAX; i = (i + 1) % MAX) {
			cout << data[i];
		}
		cout << endl;
		return success;
	}
}

链队

enum status {
	success,failed
};
template<class T>
struct node {
	T data;
	node<T>* next;
};

template<class T>
class LinkedQueue {
public:
	LinkedQueue();
	~LinkedQueue();
	bool isEmpty();
	int getLength();
	status enQueue(T x);
	status deQueue(T& x);
	status travQueue();
private:
	node<T>* head;
	node<T>* rear;
	int count;
};

template<class T>
LinkedQueue<T>::LinkedQueue() {
	head = rear = new node<T>;
	head->next = nullptr;
	count = 0;
}
template<class T>
LinkedQueue<T>::~LinkedQueue() {
	while (!isEmpty()) {
		node<T>* cur = new node<T>;
		cur = head->next;
		head->next = cur->next;
		delete cur;
		count--;
	}
}
template<class T>
bool LinkedQueue<T>::isEmpty() {
	if (count == 0) return true;
	else return false;
}
template<class T>
int LinkedQueue<T>:: getLength() {
	return count;
}
template<class T>
status LinkedQueue<T>::enQueue(T x) {
	node<T>* cur = new node<T>;
	cur->data = x;
	cur->next = NULL;
	if (cur) {
		rear->next = cur;
		rear = cur;
		count++;
		return success;
	}
	else return failed;
}
template<class T>
status LinkedQueue<T>::deQueue(T& x) {
	if (isEmpty()) {
		exit(0);
		return failed;
	}
	else {
		node<T>* cur = new node<T>;
		cur = head->next;
		x = cur->data;
		head->next = cur->next;
		delete cur;
		count--;
		return success;
	}
}
template<class T>
status LinkedQueue<T>::travQueue() {
	if (head->next) {
		node<T>* cur = head->next;
		while (!cur->next) {
			std::cout << cur->data << " ";
			cur = cur->next;
		}
		std::cout << cur->data << std::endl;
	}
}