学习日志3 姓名：蒋康 日期： 2018 9 12

今日学习任务 ：
学习数据结构中的队列，通过队列进一步了解线性结构，学习线性结构的顺序存储（储存空间连续）队列和链式存储（存储空间不连续）队列。

今日任务完成情况：
突破了300+的代码量，实现了功能。

今日开发中出现的问题汇总 ：
对于细节方面把握的不是很好，老是犯一些低级的错误。

今日收获：
学习线性结构的顺序存储（数组）和链式存储 。
学习队列的特点先进先出，存放数据在 队尾(rear)，队头（front）取出数据。
1) 队列的顺序存储一般用循环队列。
2) 队列的链式存储。
3) 空队：队头和队尾重合（队尾指针：指向最后一个元素的后一个。
4) 循环队列长度：{rear – front + MAXSIZE(容量) } % MAXSIZE 。
5) 判断队列是否已满：(rear + 1)% MACSIZE =front 。

自我评价 ：
通过今天的学习，学习了队列的相关知识与操作。
队列是一种线性表，特点是先进先出，插入在一端，删除在另一端。就像排队一样，先进来的数据入队要排在队尾(rear)，每次出队的都是队首(front)的数据。
明天继续努力！

今日程序编写；
main.c

#include<stdio.h>
#include"queue.h"

int main()
{   
    int ret, i;
    Q queue;            //定义队列
    ret = InitQueue(&queue);    //初始化
    if (SUCCESS == ret)
    {
        printf("Init Success!\n");
    }   
    else
    {
        printf("Init Failure!\n");  
    }

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

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

    }

    ret = LengthQueue(queue);   //求队列长度
    printf("Length is %d\n",ret);

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

    ret = DestoryQueue(&queue); //释放队列
    if(ret == SUCCESS)
    {
        printf("Destroy Success!\n");
    }
    else
    {
        printf("Destroy Failure!\n");
    }


    return 0;
}

queue.c

#include"queue.h"
  #include<stdlib.h>

  int InitQueue(Q *q)
  {
      if (NULL == q)  //入参判断
      {
          return FAILURE;
      }

      //申请一块内存空间，并且让data指针指向这块空间
      q->data = (int *)malloc(sizeof(int) * MAXSIZE);
      if (NULL == q->data)    //返回值判断（如果申请失败）
      {
          return FAILURE;
      }

      q->rear = q->front = 0；//队头队尾指针指向同一个 
      return SUCCESS;
  }

  int EnterQueue(Q *q, int e) //进队
  {
      if (NULL == q)
      {
          return FAILURE;
      }
      if((q->rear + 1) % MAXSIZE == q->front) //队满
      {
          return FAILURE;
      }
      q->data[q->rear] = e;
      q->rear = (q->rear +1) % MAXSIZE;
      return SUCCESS;
  }

  int DelQueue(Q *q)  //出队
  {
      if (NULL == q)
      {
          return FAILURE;
      }
      if (q->rear == q->front)    //空队
      {
          return FAILURE;
      }

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

  int LengthQueue(Q q)    //求队列长度
  {
      return (q.rear - q.front + MAXSIZE) % MAXSIZE;
  }

  int ClearQueue(Q *q)    //清理队列
  {
      if (NULL == q)
      {
          return FAILURE;
      }
      q->rear = q->front;
      return SUCCESS;
  }

  int DestoryQueue(Q *q)
  {
      if(NULL == q)
      {
          return FAILURE;
      }
      free(q->data);  //释放空间
      q->data = NULL;
      return SUCCESS;
 }

queue.h

#ifndef QUEUE_H
#define QUEUE_H

#define MAXSIZE 10      //队列容量  

//标志位（成功或者失败）
#define SUCCESS 1000        
#define FAILURE 1001

struct queue
{
    int *data;              //向队列的存储空间
    int front;              //队头指针
    int rear;               //队尾指针
};
typedef struct queue Q;

int InitQueue(Q *q);        //初始化
int EnterQueue(Q *q, int e);    //入队
int DelQueue(Q *q);     //出队
int LengthQueue(Q q);       //求队列长度
int ClearQueue(Q *q);       //清空队列
int DestoryQueue(Q *q);     //释放队列

#endif