数据结构作业/2024/7/9

2>实现双向循环链表的创建、判空、尾插、遍历、尾删、销毁

fun.c

 #include "head.h"                                                 
                                                                   
 //1.双向循环链表的创建                                            
 doubleloop_ptr create_list()                                      
 {                                                                 
     //头结点的创立                                                
     doubleloop_ptr H=(doubleloop_ptr)malloc(sizeof(doubleloop));  
     if(NULL==H)                                                   
     {                                                             
         printf("创建双向循环链表失败\n");                         
         return NULL;                                              
     }                                                             
                                                                   
     H->len=0;                                                     
     H->next=H;                                                    
     H->prior=H;                                                   
     printf("双向循环链表创建成功\n");                             
     return H;                                                     
 }                                                                 
                                                                   
                                                                   
 //2.双向循环链表的判空                                            
 int empty(doubleloop_ptr H)                                       
 {                                                                 
     if(NULL==H)                                                   
     {                                                             
         printf("双向循环链表判空失败\n");                         
         return -1;                                                
     }                                                             
                                                                   
     return H->len==0;                                             
 }                                                                 
                                                                   
                                                                   
 //3.双向循环链表节点的创建                                        
 doubleloop_ptr node(datatype e)                                   
 {                                                                 
                                                                   
     //创建节点,堆区申请空间                                       
     doubleloop_ptr p=(doubleloop_ptr)malloc(sizeof(doubleloop));  
     if(NULL==p)                                                   
     {                                                             
         printf("节点创建失败\n");                                 
         return NULL;                                              
     }                                                             
     p->data=e;                                                    
     p->next=NULL;                                                 
     p->prior=NULL;                                                
     return p;                                                     
                                                                   
 }                                                                 
                                                                   
 //4.尾插                                                          
 int insert_tail(doubleloop_ptr H,datatype e)                      
 {                                                                 
     if(NULL==H)                                                   
     {                                                             
         printf("尾部插入失败\n");                                 
         return -1;                                                
     }                                                             
     doubleloop_ptr p=node(e);                                     
     //判断双向循环链表的表头后面是否有元素                        
     if(H->next==H&&H->prior==H)                                   
     {                                                             
         p->next=H;//直接相连                                      
         p->prior=H;                                               
         H->next=p;                                                
         H->prior=p;                                               
     }                                                             
     else                                                          
     {                                                             
         //定义一个指针q指向头结点然后循环到最后一个               
         doubleloop_ptr q=H;                                       
         for(int i=0;i<H->len;i++)                                 
         {                                                         
             q=q->next;                                            
         }                                                         
         p->prior=q;                                               
         p->next=H;                                                
         q->next=p;                                                
         H->prior=p;                                               
     }                                                             
     H->len++;                                                     
     return 1;                                                     
 }                                                                 
                                                                   
                                                                   
 //5.遍历                                                          
 int output(doubleloop_ptr H)                                      
 {                                                                 
     if(NULL==H || empty(H))                                       
     {                                                             
         printf("遍历结果失败\n");                                 
         return-1;                                                 
     }                                                             
     doubleloop_ptr p=H;                                           
     while(p->next!=H)                                             
     {                                                             
         p=p->next;                                                
         printf("%d  ",p->data);                                   
     }                                                             
     printf("\n");                                                 
     return 1;                                                     
                                                                   
 }                                                                 
                                                                   
                                                                   
 //6.尾删                                                          
 int del_tail(doubleloop_ptr H)                                    
 {                                                                 
     if(NULL==H || empty(H))                                       
     {                                                             
         printf("尾删失败\n");                                     
         return -1;                                                
     }                                                             
     doubleloop_ptr q=H;                                           
     for(int i=0;i<H->len;i++)                                     
     {                                                             
         q=q->next;                                                
     }                                                             
     q->prior->next=H;                                             
     H->prior=q->prior;                                            
     free(q);                                                      
     q=NULL;                                                       
     H->len--;                                                     
     return 1;                                                     
 }                                                                 
                                                                   
                                                                   
 //7.销毁链表                                                      
 int destory(doubleloop_ptr H)                                     
 {                                                                 
     if(NULL==H ||empty(H))                                        
     {                                                             
         printf("销毁双向链表失败\n");                             
     }                                                             
     //循环尾删链表                                                
     while(H->next!=H)                                             
     {                                                             
         del_tail(H);                                              
     }                                                             
     free(H);                                                      
     H=NULL;                                                       
     printf("链表已删除\n");                                       
     return 1;                                                     
 }                                                                 

main.c

#ifndef __HEAD_H__                                                  
#define __HEAD_H__                                                  
                                                                    
#include <stdio.h>                                                  
#include <stdlib.h>                                                 
                                                                    
//对结构体内部的数据类型重定义                                      
typedef int datatype;                                               
                                                                    
//定义双向循环链表结构体                                            
typedef struct node                                                 
{                                                                   
    union//结构体内的共用体储存数据和长度                           
    {                                                               
        datatype data;//普通节点存储的数据                          
        int len;//头结点存储的长度数据                              
    };                                                              
    struct node* next;//定义结构体类型的指针                        
    struct node* prior;                                             
}doubleloop,*doubleloop_ptr;//双线循环链表类型重命名,及其指针重命名 
                                                                    
                                                                    
                                                                    
//1.双向循环链表的创建                                              
doubleloop_ptr create_list();                                       
//2.双向循环链表的判空                                              
int empty(doubleloop_ptr H);                                        
//3.双向循环链表节点的创建                                          
doubleloop_ptr node(datatype e);                                    
//4.尾插                                                            
int insert_tail(doubleloop_ptr H,datatype e);                       
//5.遍历                                                            
int output(doubleloop_ptr H);                                       
//6.尾删                                                            
int del_tail(doubleloop_ptr H);                                     
//7.销毁链表                                                        
int destory(doubleloop_ptr H);                                      
#endif                                                              
                                                                    

 head.h

#include "head.h"

int main(int argc, const char *argv[]
{
    //双向循环链表的创建
    doubleloop_ptr H=create_list();
    //尾插
    insert_tail(H,1000);
    insert_tail(H,1001);
    insert_tail(H,1003);
    insert_tail(H,1004);
    insert_tail(H,1005);
    insert_tail(H,1006);
    insert_tail(H,1007);
    insert_tail(H,1008);
    //遍历
    output(H);
    //尾删 
    del_tail(H);
    del_tail(H);
    del_tail(H);
    output(H);
    //释放
    destory(H);                      
    H=NULL;
    output(H);
    return 0;
}