环形队列——C语言实现、python实现

环形队列

环形队列是一种常用的数据机构，其结构示意图如下

它的首尾相连，其中head指向队列的首元素，tail指向队列的尾元素，数据从队列尾部入队，从队列的头部出队；

其具体的实现方式常用的有环形链表和数组；下面的代码采用数组来实现，将下标对数组长度求余而实现环形入队和出队；

与上图不同的一点是，下面的实现中，使用 front 代表 队列头元素的下标，而用 rear 代表 队列尾元素的下一个元素的下标；

C语言实现：

#include 
#include 
#include 

typedef struct queue_type queue_t;
struct queue_type {
	int capacity; /*环形队列的容量*/
	int size;	/*队列中当前元素的个数*/
	int front, rear; /*分别表示队列头和尾的下标*/
	int *qarray;
};
/*队列操作*/
queue_t *create_queue(int capacity);
void destroy_queue(queue_t *q);
void enqueue(queue_t *q, int element);
void dequeue(queue_t *q);
int front(queue_t *q);
int isempty(queue_t *q);
int isfull(queue_t *q);

int main(int argc, char *argv[])
{
	queue_t *q = NULL;

	int capacity;
	printf("input capacity:");
	scanf("%d", &capacity);
	q = create_queue(capacity);
	printf("op:\n\
	1 for enqueue\n\
	2 for front\n\
	3 for dequeue\n\
	0 for quit\n");

	int i = 1;
	int element;
	while (i != 0) {
		scanf("%d", &i);
		switch (i) {
			case 1:
				printf("insert element: ");
				scanf("%d", &element);
				enqueue(q, element);
				break;
			case 2:
				if (!isempty(q))
					printf("front: %d\n", front(q));
				else
					printf("queue empty.\n");
				break;
			case 3:
				printf("dequeue\n");
				dequeue(q);
				break;
			case 4:
				printf("destroy queue.\n");
				destroy_queue(q);
				i = 0;
				break;
			default:
				break;
		}
	}

	return 0;
}

queue_t *create_queue(int capacity)
{
	if (capacity < 1)
		return NULL;

	queue_t *q = (queue_t *)malloc(sizeof(queue_t));
	assert(q != NULL);

	q->capacity = capacity;
	q->size = 0;
	q->front = q->rear = 0;
	q->qarray = (int *)malloc(sizeof(int) * capacity);
	assert(q->qarray != NULL);

	return q;
}

void destroy_queue(queue_t *q)
{
	if (NULL == q)
		return;
	free(q->qarray);
	free(q);
}

int isempty(queue_t *q)
{
	return (q->size <= 0);
}

int isfull(queue_t *q)
{
	return (q->size >= q->capacity);
}

void enqueue(queue_t *q, int element)
{
	if (NULL == q)
		return;
	if (isfull(q)) {
		printf("queue is full\n");
		return;
	}
	q->qarray[q->rear] = element;
	q->size ++;
	q->rear = (q->rear + 1) % q->capacity;
}

int front(queue_t *q)
{
	return q->qarray[q->front];
}

void dequeue(queue_t *q)
{
	if (NULL == q)
		return;
	if (isempty(q)) {
		printf("queue is empty.\n");
		return;
	}
	q->size --;
	q->front = (q->front + 1) % q->capacity;
}

python实现：

class queue:
    def __init__(self, capacity = 10):
        self.capacity = capacity
        self.size = 0
        self.front = 0
        self.rear = 0
        self.array = [0]*capacity

    def is_empty(self):
        return 0 == self.size

    def is_full(self):
        return self.size == self.capacity

    def enqueue(self, element):
        if self.is_full():
            raise Exception('queue is full')

        self.array[self.rear] = element
        self.size += 1
        self.rear = (self.rear + 1) % self.capacity

    def dequeue(self):
        if self.is_empty():
            raise Exception('queue is empty')

        self.size -= 1
        self.front = (self.front + 1) % self.capacity

    def get_front(self):
        return self.array[self.front]

def main():
    q = queue(3)

    for i in range(3):
        q.enqueue(i)
    #q.enqueue(10)
    q.dequeue()
    q.dequeue()
    q.enqueue(333)
    
    while False == q.is_empty():
        print q.get_front(),
        q.dequeue()
    #q.dequeue()

if __name__ == '__main__':
    main()