5-1动态内存分配，分配的是堆内存的空间

• 分配内存函数 (都集中在库函数 stdlib.h  中)

void *malloc (unsigned int num_bytes); //指定分配内存空间大小，大小为 num_bytes字节，其值是随机值。
void *calloc (unsigned num ,unsigned size);  //参数包含元素的数量和每个元素的字节数，内存空间为num*sie
void *realloc(void *ptr,size_t size);  //调用该函数对内存空间进行重新分配，ptr指向已有的内存空间，size用来指定重新分配后所得整个空间大小

　   在使用动态分配之前，首先要判断是否分配成功。

• 内存的释放函数原型:

void free(void *ptr);   //动态分配的内存使用结束后，要及时释放，

　　内存释放后建议把指针指向NULL

5-2队列（初始化，入队，出队，判断空，判断满）

• 单向队列

　　

• 循环队列  （队头和队尾有两种情况会指向同一位置，一是队列空了，二是队列满了）

#define QueueSize_UartLen 8
typedef struct
{
  int front;   //队头
  int rear;    //队尾
  int counter;   //记录队列元素的个数
  int uart_data[QueneSize_UartLen];  //定义数组用来存储队列的元素
}CIRQUEUE_UART;    //定义结构体，用typedef把结构体重新命名为CIRQUEUE_UART

void InitQueue(CIRQUEUE_UART *queue) //初始化形参，CIRQUEUE_UART类型的指针变量queue，队列的初始化
{
  queue->front=0;   //->与指向结构体变量的指针相连，表示指向结构体变量指针的成员（左边为指针，注意与 . 的区别）
  queue->rear=0;
  queue->counter=0;
}

int Inqueue(CIRQUEUE_UART *queue,int data)  //入队
{
  if(QueueFull(queue))   //队满判断
   { 
      return 0;         //输出队满提示
   }
   else
   {
      queue->uart_data[queue->rear]=data;    //queue->rear指向队尾待插入数据位置
      queue->counter++;                      //计数器加1
      queue->rear=(queue->rear+1)%QueueSize_UartLen;  //然后指queue->rear向下一个待插入数据的位置
      return 1;
   }
}

int OutQueue(CIRQUEUE_UART *queue,int *p_data)    //出队  通过指针p_data取出队的数据
{
  if(QueueEmpty(queue))
    {
     return 0;
     }
   else
     {
      *p_data=queue->data(front);         //先把出队的数据元素取出放在p_data
      queue->counter--;                   //计数器减1
      queue->front=(queue->front+1)%QueueSize_UartLen;   //然后指queue->front向下一个位置
      return 1;
      }
}

int QueueEmpty(CIRQUEUE_UART *queue)  //判断队空
{
  return queue->count==0;
}

int QueueFull(CIRQUEUE_UART *queue)   //判断队满
{
  return queue->counter==QueueSize_UartLen;
}

• 链式队列 

　　构成链表中的每一个存储节点都包括一个值域和一个指针域，而指针域指向的是下一个存储节点的，则称该链表为单链表，在一个单链表中第一个节点的指针称为表头指针，最后一个节点被称为表尾节点，表尾节点的指针域的值为空。

　　在一个单链表中，除表头节点外，每一个每个结点都由前一个结点的指针域所指向，第一个节点只能有另设的表头指针所指向。当访问一个单链表时候，只能从表头指针出发，首先访问第一个节点，然后由第一个节点的指针域指向第二个节点的地址。

　　空队列时，头指针front和尾指针rear都指向头结点。

　　

　　单链表只要头节点就可以访问所有的链表元素，融入队列的特性，一个指针是不不够的。队列删除（出队）在对头，插入（入队）在队尾。

　　头指针front指向链队的头结点，每个结点对应一个数据；尾指针rear指向终端结点。

typedef struct LinkNode_t       //队列结点结构
{
  int data;
  struct LinkNode_t *next;
}LinkNode;

typedef struct LinkPoint_t      //队列链表结构
{
  struct LinkNode_t *front;
  struct LinkNode_t *rear;
}LinkQueue;
LinkQueue *queue;
LinkNode *node;

LinkQueue LinkQueueInit()                       //初始化，建立一个带有队头的空队列
{
  queue_t=(LinkQueue)malloc(sizeof(LinkQueue)); //因为在LinkQueue中定义了一个结构体指针，必须对其进行分配内存。
  node=(LinkQueue)malloc(sizeof(LinkNode));     //同上
  node->next=NULL;
  queue_t->front=queue->rear=node;
  return queue_t;
}

void InlinkQueue(LinkQueue *queue,int data)  //入队
{
  node=(LinkNode)malloc(sizeof(LinkNode));
  node->data=data;
  node->next=queue->rear->next; //node->next指向data插入前、尾部指针指向的next的位置（queue->rear->next）。
  queue->rear->next=node;     //新插入的数据或结点成了新的队尾，队尾指针queue->rear->next指向新插入的node结点
  queue->rear=node;           //最后让新插入的数据或结点成为新的队尾。
}

void OutQueue(LinkQueue *queue)  //出队
{
  int data;
  if(!LQEmpty(queue))         //判空
  {
    node=queue->front->next;
    queue->front->next=node->next;
    data=