作业/数据结构/2023/7/10

1.实现单向链表队列的，创建，入队，出队，遍历，长度，销毁。

main.c

#include "head.h"int main(int argc, const char *argv[])
{//创建链式队列queue_ptr QL=create_queue();//入栈push(QL, 1000);push(QL, 1001);push(QL, 1002);push(QL, 1003);push(QL, 1004);//遍历 output(QL);//出队pop( QL);output(QL);//长度length(QL);//销毁 freedom(QL);return 0;
}                                     

head.h

#ifndef __HEAD_H__                
#define __HEAD_H__                #include <stdio.h>                
#include <stdlib.h>               
//定义节点中的数据类型            
typedef int datatype;             
//定义节点结构体                  
typedef struct node               
{                                 union                         {                             int len;                  datatype data;            };                            struct node*next;             
}Node;                            //定义链式队列结构体              
typedef struct seq                
{                                 Node *head;                   Node *tail;                   
}queue,*queue_ptr;                //1.创建链式队列                  
queue_ptr create_queue();         
//2.判断为空操作                  
int empty(queue_ptr QL);          
//3.链式队列入队                  
int push(queue_ptr QL,datatype e);
//4.链式队列的遍历                
void output(queue_ptr QL);        
//5,链式队列的出队只能从对头删除  
void pop(queue_ptr QL);           
//6.长度                          
void length(queue_ptr QL);        
//销毁                            
void freedom(queue_ptr QL);       
#endif                            

 fun.c

 #include "head.h"                                     //1.创建链式队列                                      queue_ptr create_queue()                              {                                                     //申请链式队列的结构体的大小空间                  queue_ptr QL=(queue_ptr)malloc(sizeof(queue));    //判断链式队列申请节点成功没有                    if(NULL==QL)                                      {                                                 printf("创建链式队列失败\n");                 return NULL;                                  }                                                 //申请节点结构体的大小空间                        QL->head=(Node*)malloc(sizeof(Node));             //判断链式队列节点申请有没有成功                  if(NULL==QL->head)                                {                                                 printf("节点创建失败\n");                     free(QL);                                     return NULL;                                  }                                                 //头节点创建成功                                  QL->head->len=0;//节点长度置0                     QL->head->next=NULL;//节点指针域指向NULL          //链式队列结构体里面的指针指向                    QL->tail=QL->head;                                printf("链式队列创建成功\n");                     return QL;                                        }                                                     //2.判断为空操作                                      int empty(queue_ptr QL)                               {                                                     if(QL==NULL)                                      {                                                 printf("判空操作失败\n");                     return -1;                                    }                                                 //当链式队列结构体的指针指向同一个节点            return QL->head==QL->tail;                    }                                                     //3.链式队列入队                                      int push(queue_ptr QL,datatype e)                     {                                                     if(QL==NULL)                                      {                                                 printf("入队失败\n");                         return 0;                                     }                                                 //申请普通节点                                    Node *p=(Node*)malloc(sizeof(Node));              if(NULL==p)                                       {                                                 printf("申请节点失败\n");                     return 0;                                     }                                                 p->data=e;                                        p->next=NULL;                                     //然后尾插                                        QL->tail->next=p;                                 QL->tail=p;                                       //长度自增                                        QL->head->len++;                                  return 1;                                         }                                                     //4.链式队列的遍历                                    void output(queue_ptr QL)                             {                                                     if(NULL==QL ||empty(QL))                          {                                                 printf("遍历失败\n");                         return ;                                      }                                                 //循环遍历的指向的指针                            Node* q=QL->head;                                 while(q->next!=NULL)                              {                                                 q=q->next;                                    printf("%d  ",q->data);                       }                                                 printf("\n");                                     }                                                     //5,链式队列的出队只能从对头删除                      void pop(queue_ptr QL)                                {                                                     if(NULL==QL ||empty(QL))                          {                                                 printf("出队失败\n");                         return ;                                      }                                                 //定义一个遍历指向队头指针                        Node*p=QL->head->next;                            //头指针指向下一节点                              QL->head->next=p->next;                           free(p);                                          p=NULL;                                           QL->head->len--;                                  }                                                     //6.长度                                              void length(queue_ptr QL)                             {                                                     if(NULL==QL)                                      {                                                 printf("输出长度失败\n");                     return ;                                      }                                                 int len=QL->head->len;                            printf("该顺序链式队列的长度为:%d\n",len);        return;                                           }                                                     //销毁                                                void freedom(queue_ptr QL)                            {                                                     if(NULL==QL)                                      {                                                 printf("销毁失败\n");                         return ;                                      }                                                 while(QL->head->next!=NULL)                       {                                                 pop(QL);                                      }                                                 free(QL->head);                                   QL->head=NULL;                                    printf("销毁成功\n");                             return;                                           
}