嵌入式课程设计学习日志3

姓名：杨青 日期： 2018年9月12日

今日学习任务
了解队列：（先进先出）线性结构：顺序存储（数组） 链式存储

今日任务完成情况
在课堂上基本上可以跟上老师的节奏，在敲代码时还会犯一些小错误，需要更细心的加强自己的学习，总的来说今天的完成情况还不错。

今日开发收获
在今天的学习中，了解了顺序存储 、循环队列， 队头front、队尾rear； 队尾指针等等。指向最后一个元素的后一个，空对：队头队尾重合；
循环队列长度：（rear-front + MAXSIZE）%MAXSIZE
判断队列是否满：（rear+1）%MAXSIZE==front
节点分为数据域和指针域。
结构体：struct node
{
int data；
struct node *next；
}

队列：struct queue
{
Node *front；
Node *rear
}；

     struct node
     {
     }；

自我评价
今天学习了队列的结构知识，但还会出现各种错误，以后在学习时还要更细心点。

其他
老师很有耐心教着我们。

课堂练习：
main.c

#include"queue.h"
#include"stdio.h"

int main()
{
    int ret,i;
   Q *queue;

   ret=InitQueue(&queue);
   if(ret==SUCCESS)
      {
     printf("Init Sucess!\n");
      }
   else
      {
    printf("Init Failure!\n");
      }
    for(i=0;i<10;i++)
     {
      ret=EnterQueue(queue,i+1);
       if(ret==SUCCESS)
     {
        printf("Enter %d Success!\n",i+1);
      }
   else 
       {
     printf("Enter Failure!\n");
        } 
      } 


      for(i=0;i<6;i++)
       {
          ret=DeleteQueue(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=LengthQueue(queue);
     printf("length is %d\n",ret);

    ret=EmptyQueue(queue);
     if(SUCCESS==ret)
      {
       printf("queue is empty!\n");
        }
      else
       {
        printf("queue is not empty!\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