作业/数据结构/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;                                           
}