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

链表的相关操作作业：

1】 按值修改

2】按值查找，返回当前节点的地址 （先不考虑重复，如果有重复，返回第一个）

3】 逆置(反转)

4】释放链表

main.c

#include "head.h"

int main(int argc, const char *argv[])
{
    //创建链表,头结点
    linklist_ptr p=create();
    //判断链表是否为空
    empty(p);
    //头插
    insert_head(p,10);
    insert_head(p,11);
    insert_head(p,12);
    //输出
    output(p);
    //尾插
    insert_tail(p,1);
    insert_tail(p,2);
    insert_tail(p,3);
    output(p);
    //任意位置插入
    insert_index(p,2,99);
    output(p);
    //头删
    del_head(p);
    output(p);
    //尾删除                             
    del_tail(p);
    output(p);
    //任意位置删除
    del_index(p,2);
    output(p);
    //按照所给位数修改值
    change_element(p,1,99);
    output(p);
    //按照所给的值查找
    find_element(p,1);

    output(p);
    //反转
    reversal(p);
    output(p);
    return 0;
}

head.h

#include <stdio.h>                                       
#include <stdlib.h>                                      
//定义节点数据的类型                                     
typedef int datatype;                                    
//定义链表结构体                                         
typedef struct node                                      
{                                                        
    union                                                
    {                                                    
        //表示节点的个数                                 
        int len;                                         
        //节点的数据                                     
        datatype data;                                   
    };                                                   
    //指针域                                             
    struct node *next;                                   
}linklist,*linklist_ptr;                                 
                                                         
                                                         
//1.链表的创建                                           
linklist_ptr create();                                   
//2.判断链表是否为空                                     
int  empty(linklist_ptr p);                              
//3.申请节点封装数据                                     
linklist_ptr node_create(datatype e);                    
//4.头插                                                 
int insert_head(linklist_ptr p,datatype e);              
//5.输出                                                 
void output(linklist_ptr p);                             
//6.尾插                                                 
int insert_tail(linklist_ptr p,datatype e);              
//7.任意位置插入                                         
int insert_index(linklist_ptr p,int index,datatype e);   
//8.头删                                                 
int del_head(linklist_ptr p);                            
//9.尾删除                                               
int del_tail(linklist_ptr p);                            
//10.任意位置删除                                        
int del_index(linklist_ptr p,int index);                 
//11.按照所给的值修改                                    
int change_element(linklist_ptr p,int index,datatype e); 
//12.按照所给的值查找                                    
linklist_ptr find_element(linklist_ptr p,datatype e);    
//13.反转                                                
int  reversal(linklist_ptr p);                           
#endif                                                   

fun.c

    {                                                                         
        q=q->next;                                                            
    }                                                                         
    q->next=p1;                                                               
    p->len++;                                                                 
    return 1;                                                                 
}                                                                             
                                                                              
                                                                              
//7.任意位置插入                                                              
int insert_index(linklist_ptr p,int index,datatype e)                         
{                                                                             
    if(NULL==p || index<1 || index>p->len+1)                                  
    {                                                                         
        printf("尾插失败\n");                                                 
        return -1;                                                            
    }                                                                         
    //申请节点                                                                
    linklist_ptr p1=node_create(e);                                           
    linklist_ptr q=p;                                                         
    for(int i=0;i<index;i++)                                                  
    {                                                                         
        q=q->next;                                                            
    }                                                                         
    p1->next=q->next;                                                         
    q->next=p1;                                                               
    p->len++;                                                                 
    return 1;                                                                 
}                                                                             
                                                                              
                                                                              
//8.头删                                                                      
int del_head(linklist_ptr p)                                                  
{                                                                             
    if(NULL==p || empty(p))                                                   
    {                                                                         
        printf("头删失败\n");                                                 
    }                                                                         
    //定义一个指针指向头指针指向的节点                                        
    linklist_ptr p1=p->next;                                                  
    p->next=p1->next;                                                         
    free(p1);                                                                 
    p1=NULL;                                                                  
                                                                              
    p->len--;                                                                 
    return 1;                                                                 
                                                                              
}                                                                             
                                                                              
                                                                              
//9.尾删除                                                                    
int del_tail(linklist_ptr p)                                                  
{                                                                             
    if(NULL==p || empty(p))                                                   
    {                                                                         
        printf("尾删失败\n");                                                 
        return 0;                                                             
    }                                                                         
    //定义一个指针指向头结点并让其循环到最后一个节点的前一个节点              
    linklist_ptr p1=p;                                                        
    for(int i=0;i<p->len-1;i++)                                               
    {                                                                         
        p1=p1->next;                                                          
    }                                                                         
    //指向需要删除最后一个节点                                                
    linklist_ptr p2=p1->next;                                                 
    p1->next=p1->next;                                                        
    //释放                                                                    
    free(p2);                                                                 
    p2=NULL;                                                                  
    p->len--;                                                                 
    return 1;                                                                 
}                                                                             
                                                                              
//10.任意位置删除                                                             
int del_index(linklist_ptr p,int index)                                       
{                                                                             
    if(NULL==p || empty(p) || index>p->len ||index<0)                         
    {                                                                         
        printf("任意位置删除失败\n");                                         
        return 0;                                                             
    }                                                                         
    //定义一个指针指向头结点用于循环到所需要                                  
    //的位置的上一个节点                                                      
    linklist_ptr p1=p;                                                        
    for(int i=0;i<index-1;i++)                                                
    {                                                                         
        p1=p1->next;                                                          
    }                                                                         
    //定义一个指针指向需要被删除的节点                                        
    linklist_ptr p2=p1->next;                                                 
    p1->next=p2->next;                                                        
    //释放                                                                    
    free(p2);                                                                 
    p2=NULL;                                                                  
    p->len--;                                                                 
    return 1;                                                                 
}                                                                             
                                                                              
                                                                              
//11.按照所给的值修改                                                         
int change_element(linklist_ptr p,int index,datatype e)                       
{                                                                             
    if(NULL==p || empty(p) || index>p->len || index<0)                        
    {                                                                         
        printf("任意位置修改失败\n");                                         
        return 0;                                                             
    }                                                                         
    //定义一个指针找到所需要的修改的节点                                      
    linklist_ptr p1=p;                                                        
    for(int i=0;i<index;i++)                                                  
    {                                                                         
        p1=p1->next;                                                          
    }                                                                         
    //修改其中的值                                                            
    p1->data=e;                                                               
                                                                              
}                                                                             
                                                                              
                                                                              
//12.按照所给的值查找                                                         
linklist_ptr find_element(linklist_ptr p,datatype e)                          
{                                                                             
    if(NULL==p || empty(p))                                                   
    {                                                                         
        printf("查找值失败\n");                                               
        return NULL;                                                          
    }                                                                         
    //记录相同的次数                                                          
    int flag=0;                                                               
    //循环查找                                                                
    linklist_ptr p1=p;                                                        
    for(int i=0;i<p->len;i++)                                                 
    {                                                                         
        p1=p1->next;                                                          
        if(p1->data==e)                                                       
        {                                                                     
            printf("第%d个元素的值相等\n",i+1);                               
            flag++;                                                           
        }                                                                     
        if(flag==1)                                                           
        {                                                                     
            return p1;                                                        
        }                                                                     
                                                                              
    }                                                                         
         if(flag==0)                                                          
        {                                                                     
            printf("未查找到相应的值\n");                                     
        }                                                                     
    return p;                                                                 
}                                                                             
                                                                              
                                                                              
//13.反转                                                                     
int  reversal(linklist_ptr p)                                                 
{                                                                             
    if(NULL == p || empty(p))                                                 
    {                                                                         
        printf("反转失败\n");                                                 
        return 0;                                                             
    }                                                                         
                                                                              
    linklist_ptr p1 = p->next; // 保存第1个节点的地址                         
    p->next = NULL; // 断开原头结点的连接（使其成为反转后的链表的尾节点）     
    linklist_ptr p2;                                                          
    while(p1->next!=NULL)                                                     
    {                                                                         
        p2 = p1; // 将当前节点保存到p2，以便将其插入到头部                    
        p1 = p1->next; // 移动到下一个节点                                    
        p2->next = p->next; // 将p2插入到p之前（使p2成为新的头结点）          
        p->next = p2; // 更新p为新插入的节点（更新头结点）                    
    }                                                                         
                                                                              
    return 1; // 返回反转后链表的新头结点                                     
}