苏嵌日志3

学习日志
姓名：申胜男 日期：2018.9.12

今日学习任务 :
1、队列先进先出
2、队列的链式存储 和顺序存储
3、空队：队头队尾重合
4、队尾指针：指向最后一个元素的后一个
5、自定义函数来实现初始化，清空，输入，输出，删除，销毁等操作

今日任务完成情况:
1、按照课上老师的要求已经全部完成了所有的任务，并且实现了调试。
2、今天的代码开发量已经达到500多行。

今日开发中出现的问题:
编写程序时不够细心，会出现一些小错误。

今日开发收获：
学会了如何初始化，清空，输入，输出，删除，销毁等一系列程序编写。
队列特点：先进先出
队头front（取出数据） 队尾rear（存放数据）
进队：操作队尾
出队：操作对头
类型：顺序存储 （连续）链式存储 （不连续）
队列的顺序存储用 循环队列
空队：队头 队尾重合
队尾指针指向最后一个元素的后一个
循环队列长度：（rear - front + MAXSIZE）% MAXSIZE
判断队列是否已满：(rear + 1) % MAXSIZE == front
清除队列：q->rear = q->front
释放队列：free(q->data); q->data = NULL

自我评价:
每天都能学到一些新的知识，在老师的带领下分别用顺序存储方式和链式存储方式编写了队列的代码，但是经常出现细节上的小错误导致程序报错，日后还需提高自己的水平，打字速度还需加强。

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 =DestroyQueue(&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;
     }

     (*q)=(Q*)malloc(sizeof(Q));
    if(NULL==(*q))
        {
      return FAILURE;
        }

     Node *p=(Node *)malloc(sizeof(Node));
     if(NULL==p)
         {
       return FAILURE;
         }

     (*q)->front=(*q)->rear=p;

       return SUCCESS;
  }

int EnterQueue(Q *q,int e)
{
     if(NULL==q)
       {
     return FAILURE;
       }

    Node *p=(Node *)malloc(sizeof(Node));
     if(NULL==p)
       {
     return FAILURE;
       }
       p->next=NULL;
       p->data=e;

      q->rear->next=p;
       q->rear=p;

     return SUCCESS;
}

int DeleteQueue(Q *q)
{
    if(NULL==q)
     {
      return FAILURE;
      }

    if(q->rear==q->front)
      {
       return FAILURE;
      }

     Node *p=q->front->next;
     int e=p->data;
     q->front->next=p->next;
     free(p);

    if(q->rear==p)
      {
        q->rear=q->front;
       }

      return e;
}   

int LengthQueue(Q *q)
{
      if(NULL==q)
       {
           return FAILURE;
        }

     int length=0;

     Node *p=q->front->next;
      while(p)
     {
      length++;
       p=p->next;
     }

      return length;
}

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

     Node *p=q->front->next;

      while(p)
       { 
         q->front->next=p->next;
           free(p);
          p=q->front->next;
       }

        q->rear=q->front;

 return SUCCESS;
}

int EmptyQueue(Q *q)
{
    if(NULL==q)
      {
       return FAILURE;
       }

    return(q->front==q->rear)?SUCCESS:FAILURE;
}


int DestroyQueue(Q **q)
{
    if(NULL==q)
    {
     return FAILURE;
    }

    free((*q)->front);
      free(*q);
      *q=NULL;
      return SUCCESS;
}

queue.h

#ifndef QUEUE_H
#define QUEUE_H

#define SUCCESS 1000
#define FAILURE 1001

struct node
{
int data;
struct node *next;
};
typedef struct node Node;

struct queue
{
    Node *front;
      Node *rear;
};
typedef struct queue Q;

int InitQueue(Q **q);
int EnterQueue(Q *q,int e);
int DeleteQueue(Q *q);
int LengthQueue(Q *q);
int ClearQueue(Q *q);
int EmptyQueue(Q *q);
int DestroyQueue(Q **q);
#endif