苏嵌学习日志day3

name:钱成杰 date:2018.9.12
今日学习任务
复习栈和队列的相关知识点，队列的顺序是先进先出，学习顺序存储和链式存储
今日任务完成情况
能跟上老师的编程节奏，对于链式与顺序存储有了初步的了解。
今日开发中出现的问题汇总
了解队列是从队尾存放数据，队头取出数据。
空队：对头队尾重合 队尾指针：指向最后一个元素的后一个（n-1）
循环队列的长度：（rear –front +MAXSIZE）%MAXSIZE
如：7%5 取整=1； 5%7取余=5；取整=0；
判断栈是否满：（rear+1）%MAXSIZE=front
注意：
在queue.c中所写的如下程序的头文件必须在queue.h中加上且必须加分号（；）
如：int InitQueue(Q *q); //queue中复制粘贴
int DelQueue(Q *q);
int lenthQueue(Q q);
int ClearQueue(Q *q);
int DestoryQueue(Q *q);
int EnterQueue(Q *q,int e);
最后编译代码为：gcc *.c -Wall

在虚拟机中创建：
计算机—>文件系统—>home文件夹—>创建文件夹（queue）—>创建文档—>文档编辑器（打开文档）
指针分为：数据域 + 指针域
今日未解决问题
对于栈与队列的编程还是模糊。
今日开发收获
学会了链式与顺序的编程方法，进栈，出栈，销毁，空栈，长度等的计算。
自我评价
跟上老师的节奏是最大的收获。

课堂训练：
顺序存储：
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);   //queue中复制粘贴
 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;