苏嵌日志3

学习日志3
姓名：崔宇 日期：2018.9.12
今日学习任务：
学习了解队列的顺序存储和链式存储知识。
队列的顺序存储结构：循环队列。
空队：队头和队尾重合
队尾指针：指向最后一个元素的后一个。
循环队列长度：（rear-front+MAXSIZE）% MAXSIZE
判断队列是否满：（rear+1）% MAXSIZE=front
今日任务完成情况：
完成老师布置的任务，课上基本能跟上，开发代码数量500行。
今日开发中出现的问题汇总：
暂无。
今日开发收获：
学习了栈的知识，顺序存储以及链式存储结构的知识，以及用顺序存储、链式存储编写队列的程序。
自我评价：
能跟上老师的进度，还算可以，对于结构体以及指针方面的内容有了进一步的认识。

顺序存储：
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 DelQueue(Q *q);
 int lenthQueue(Q q);
  int ClearQueue(Q *q);
 int DestoryQueue(Q *q);
 int EnterQueue(Q *q,int e);   
  #endif

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 =lenthQueue(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("Destory  Success!\n");
     }
     else
     {
     printf("Destory 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 lenthQueue(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 SUCCESS 1000

define FAILURE 1001

struct mode //结点的信息
{
int data; //数据域
struct mode *next; //指针域
};
typedef struct mode 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 EmptQueue(Q *q);
int DestoryQueue(Q **q);

endif

Main.c

include”queue.h”

include”stdio.h”

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

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

for(i=0;i<5;i++)
{
  ret=EnterQueue(queue,i+1);
   if(ret ==SUCCESS)
   {
      printf("Enter %d Success!\n");

   }
   else
   {
      printf("Enter Failure!\n");
   }

}

for(i=0;i<10;i++)
{
  ret=DeleteQueue(queue);
  if(ret==FAILURE)
  {
     printf("Delete Failure!\n");

  }
  else
  {
     printf("Delete %d Success!\n");
  }

}

ret=lengthQueue(queue);
printf("length is %d\n",ret);


 ret =ClearQueue(queue);
 if(ret==SUCCESS)
  {
     printf("Clear %d Success!\n");

  }
 else
 {
     printf("Clear Failure!\n");

 }


   ret=lengthQueue(queue);
   printf("length is %d\n",ret);

   ret =EmptQueue(queue);
    if(SUCCESS==ret)
    {
       printf("queue is empty !\n");

    }
    else
     {
        printf("queue is not empty!\n");

     }

     ret=DestoryQueue(&queue);
     if(ret==SUCCESS)
     {
        printf("Destory Success!\n");

     }
     else
     {
        printf("Destory 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) //while(p!=NULL)
{
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 EmptQueue(Q *q)
{
if(NULL==q) //清空队列
{
return FAILURE;

}

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

}

int DestoryQueue(Q **q) //销毁
{
if(NULL==q)
{
return FAILURE;
}

free((*q)->front);
free (*q);
*q=NULL;

return SUCCESS;

}