数据结构 顺序队列 和 用队列实现杨辉三角形

一、队列的定义

1. 队列是特殊的线性表，仅在线性表两端进行操作；

    队头（Front）：取出数据的一端；

    队尾（Rear）：放入数据的一端；

2. 队列的性质：先进先出

二、队列常用公式

   一般使用循环队列（提高空间的利用率） 

    空队列：front == rear

    队列满时会空出一格

    判断队列满的条件：( rear + 1 ) % QueueSize == front;

    计算队列长度：( rear - front + QueueSize ) % QueueSize;

三、顺序队列

1. SequenceQueue.h

#ifndef _SEQUENCEQUEUE_H
#define _SEQUENCEQUEUE_H

#define SIZE     100
#define SUCCESS  10000
#define FAILURE  10001
#define TRUE     10002
#define FALSE    10003

struct queue
{
    int data[SIZE];
    int front;
    int rear;
};

typedef struct queue Queue;

int InitQueue(Queue *q);
int EmptyQueue(Queue q);
int EnterQueue(Queue *q, int e);
int GetFront(Queue q);
int LengthQueue(Queue q);
int DeleteQueue(Queue *q);
int ClearQueue(Queue *q);

#endif

2. SequenceQueue.c

#include "SequenceQueue.h"
#include 

/*初始化*/
int InitQueue(Queue *q)
{
    if(NULL == q)
    {
        return FAILURE;
    }

    q->rear = q->front = 0;

    return SUCCESS;
}

/*判断是否为空*/
int EmptyQueue(Queue q)
{
    return (q.front == q.rear) ? TRUE : FALSE;
}

/*进队列*/
int EnterQueue(Queue *q, int e) 
{
    if(NULL == q)
    {
        return FAILURE;
    }

    if((q->rear + 1) % SIZE == q->front)
    {
        return FAILURE;
    }

    q->data[q->rear] = e;
    q->rear = (q->rear + 1) % SIZE;

    return SUCCESS;
}

/*取队头元素*/
int GetFront(Queue q)
{
    if(q.rear == q.front)
    {
        return FAILURE;
    }

    return q.data[q.front];
}

/*队长*/
int LengthQueue(Queue q)
{
    return ((q.rear - q.front + SIZE) % SIZE);
}
/*出队*/
int DeleteQueue(Queue *q)
{
    if(q->rear == q->front)
    {
        return FAILURE;
    }

    int e = q->data[q->front];
    q->front = (q->front + 1) % SIZE;

    return e;
}

int ClearQueue(Queue *q)
{
    if(NULL == q)
    {
        return FAILURE;
    }

    q->front = q->rear;

    return SUCCESS;
}

3. TestSequenceQueue.c

#include "SequenceQueue.h"
#include 

int main()
{
    int ret, i;
    Queue queue;

    /*初始化*/
    ret = InitQueue(&queue);
    if(ret == SUCCESS)
    {
        printf("Init Success!\n");
    }
    else
    {
        printf("Init Failure!\n");
    }

    /*判断是否为空*/
    ret = EmptyQueue(queue);
    if(ret == TRUE)
    {
        printf("Queue is Empty!\n");
    }
    else
    {
        printf("Queue is not Empty!\n");
    }

    /*进队列*/
    for(i = 0; i < 10; i++)
    {
        ret = EnterQueue(&queue, i);
        if(FAILURE == ret)
        {
            printf("Enter %d Failure!\n", i);
        }
        else
        {
            printf("Enter %d Success!\n", i);
        }
    }

    /*取队头元素*/
    ret = GetFront(queue);
    if(FAILURE == ret)
    {
        printf("Get Front Failure!\n");
    }
    else
    {
        printf("Front is %d\n", ret);
    }

    /*队长*/
    ret = LengthQueue(queue);
    if(FAILURE == ret)
    {
        printf("QueueSize Error!\n");
    }
    else
    {
        printf("Length is %d\n", ret);
    }

    /*出队*/
    for(i = 0; i < 4; i++)
    {
        ret = DeleteQueue(&queue);
        if(FAILURE == ret)
        {
            printf("Delete Failure!\n");
        }
        else
        {
            printf("Delete %d Success!\n", ret);
        }
    }

    /*清空*/
    ret = ClearQueue(&queue);
    if(FAILURE == ret)
    {
        printf("Clear Failure!\n");
    }
    else
    {
        printf("Clear Success!\n");
    }

    return 0;
}

 

 

四、用队列实现杨辉三角形

主函数部分

#include "SequenceQueue.h"
#include 

int main()
{
    int ret, i, j, n, len;
    int Del1, Del2, num; //记录出队的两个数和两数之和
    Queue queue1, queue2;

    /*初始化*/
    if(InitQueue(&queue1) == FAILURE || InitQueue(&queue2) == FAILURE)
    {
        printf("Init Failure!\n");
    }

    printf("请输入杨辉三角形行数:\n");
    scanf("%d", &n);

    EnterQueue(&queue1, 0); //对队列1初始化
    EnterQueue(&queue1, 1);
    EnterQueue(&queue1, 0);

    printf("杨辉三角形如下:\n");
    printf("1\n");

    for(i = 0; i < n - 1; i++)
    {
        EnterQueue(&queue2, 0);
        len = LengthQueue(queue1);
        for(j = 0; (len != 1) ; j++) //队列1移动到队列2,直到队列1只剩最后一个元素0
        {
            Del1 = DeleteQueue(&queue1);
            Del2 = GetFront(queue1);
            num = Del1 + Del2;
            EnterQueue(&queue2, num);
            len--;
        }
        ClearQueue(&queue1); //清空队列1
        EnterQueue(&queue2, 0); //队列2中补0
        len = LengthQueue(queue2);
        for(j = 0; j < len; j++)  //输出队列2
        {
            ret = DeleteQueue(&queue2);
            if(ret != 0)
            {
                printf("%d ", ret);
            }
            EnterQueue(&queue1, ret);
        }
        printf("\n");

    }

    return 0;
}