11月24号作业

于 2022-11-24 20:09:47 发布
阅读量96 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xiaocaiji0/article/details/128025603
这个博客展示了如何使用C语言实现顺序表的基本操作，包括按值修改元素、按位置查找元素、插入元素、删除元素、更新元素、按值查找元素、排序、获取最大值以及去重。代码中包含了一系列的函数，如`list_add`、`list_delete_pos`、`list_change`等，用于演示这些操作。在最后，代码运行并输出了相应操作的结果。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

题目：

完成顺序表的按值修改、按位置查找、排序、最值、去重

  

代码：
main.c
#include"seqlist.h"

int main(int argc, const char *argv[])
{
    seqlist *L=list_create();
    if(NULL==L) return -1;

    list_add(L,5);
    list_add(L,4);
    list_add(L,4);
    list_add(L,3);
    list_add(L,5);
    list_add(L,2);
    list_add(L,2);
    list_add(L,4);
    list_add(L,1);
    list_add(L,5);
    list_add(L,2);
    list_add(L,2);
    list_add(L,4);
    list_add(L,1);
    list_add(L,1);
    list_add(L,5);
    list_add(L,4);
    list_add(L,5);
    list_add(L,1);
    list_add(L,4);
    list_display(L);
    list_insert_pos(L,4,2);
    list_display(L);
    list_delete_pos(L,4);                                                       
    list_display(L);
    list_update_pos(L,0,3);
    list_display(L);
//  printf("%d下标为%d\n",3,list_search_value(L,3));
//  list_free(&L);
//  list_display(L);
    list_update_value(L,4,2);
    list_display(L);
    printf("%d\n",list_search_pos(L,-1));
    list_change(L);
    list_display(L);
    printf("%d\n",list_max(L));
    list_delete_repeat(L);
    list_display(L);
    return 0;
}

seqlist.c

#include"seqlist.h"                                                                                                                                                                                    
                                                                                                                                                                                                       
seqlist *list_create()                                                                                                                                                                                 
{                                                                                                                                                                                                      
    seqlist *L=(seqlist *)malloc(sizeof(seqlist));                                                                                                                                                     
    if(NULL==L)                                                                                                                                                                                        
    {                                                                                                                                                                                                  
        printf("创建失败\n");                                                                                                                                                                          
        return NULL;                                                                                                                                                                                   
    }                                                                                                                                                                                                  
    bzero(L,sizeof(seqlist));                                                                                                                                                                          
    printf("创建成功\n");                                                                                                                                                                              
    return L;                                                                                                                                                                                          
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
int list_empty(seqlist *L)                                                                                                                                                                             
{                                                                                                                                                                                                      
    return L->len==0 ? 1:0;                                                                                                                                                                            
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
int list_full(seqlist *L)                                                                                                                                                                              
{                                                                                                                                                                                                      
    return L->len==MAX ? 1:0;                                                                                                                                                                          
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
int list_add(seqlist *L,datatype e)                                                                                                                                                                    
{                                                                                                                                                                                                      
    if(list_full(L))                                                                                                                                                                                   
    {                                                                                                                                                                                                  
        printf("表满，添加失败\n");                                                                                                                                                                    
        return 0;                                                                                                                                                                                      
    }                                                                                                                                                                                                  
    L->data[L->len]=e;                                                                                                                                                                                 
    L->len++;                                                                                                                                                                                          
    printf("添加成功\n");                                                                                                                                                                              
    return 1;                                                                                                                                                                                          
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
void list_display(seqlist *L)                                                                                                                                                                          
{                                                                                                                                                                                                      
    if(NULL==L||list_empty(L))                                                                                                                                                                         
    {                                                                                                                                                                                                  
        printf("数组为空，遍历失败\n");                                                                                                                                                                
        return;                                                                                                                                                                                        
    }                                                                                                                                                                                                  
    printf("分别为：");                                                                                                                                                                                
    for(int i=0;i<L->len;i++)printf("%d\t",L->data[i]);                                                                                                                                                
    printf("\n");                                                                                                                                                                                      
                                                                                                                                                                                                       
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
int list_insert_pos(seqlist *L,int pos,datatype e)                                                                                                                                                     
{                                                                                                                                                                                                      
    if(list_full(L)||pos>L->len||pos<0)                                                                                                                                                                
    {                                                                                                                                                                                                  
        printf("插入失败\n");                                                                                                                                                                          
        return 0;                                                                                                                                                                                      
    }                                                                                                                                                                                                  
    for(int i=L->len-1;i>=pos;i--) L->data[i+1]=L->data[i];                                                                                                                                            
    L->data[pos]=e;                                                                                                                                                                                    
    L->len++;                                                                                                                                                                                          
    printf("插入成功\n");                                                                                                                                                                              
    return 1;                                                                                                                                                                                          
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
int list_delete_pos(seqlist *L,int pos)                                                                                                                                                                
{                                                                                                                                                                                                      
    if(list_empty(L)||pos>L->len||pos<0)                                                                                                                                                               
    {                                                                                                                                                                                                  
        printf("删除失败\n");                                                                                                                                                                          
        return 0;                                                                                                                                                                                      
    }                                                                                                                                                                                                  
    for(int i=pos+1;i<L->len;i++) L->data[i-1]=L->data[i];                                                                                                                                             
    L->len--;                                                                                                                                                                                          
    printf("删除成功\n");                                                                                                                                                                              
    return 1;                                                                                                                                                                                          
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
int list_update_pos(seqlist *L,int pos,datatype e)                                                                                                                                                     
{                                                                                                                                                                                                      
    if(list_empty(L)||pos<0||pos>=L->len)                                                                                                                                                              
    {                                                                                                                                                                                                  
        printf("修改失败\n");                                                                                                                                                                          
        return 0;                                                                                                                                                                                      
    }                                                                                                                                                                                                  
    L->data[pos]=e;                                                                                                                                                                                    
    printf("修改成功\n");                                                                                                                                                                              
    return 1;                                                                                                                                                                                          
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
int list_update_value(seqlist *L,datatype old_e,datatype new_e)                                                                                                                                        
{                                                                                                                                                                                                      
    int flag=0;                                                                                                                                                                                        
    if(list_empty(L))                                                                                                                                                                                  
    {                                                                                                                                                                                                  
        printf("修改失败\n");                                                                                                                                                                          
        return 0;                                                                                                                                                                                      
    }                                                                                                                                                                                                  
    for(int i=0;i<L->len;i++)                                                                                                                                                                          
    {                                                                                                                                                                                                  
        if(L->data[i]==old_e)                                                                                                                                                                          
        {                                                                                                                                                                                              
            L->data[i]=new_e;                                                                                                                                                                          
            flag=1;                                                                                                                                                                                    
        }                                                                                                                                                                                              
    }                                                                                                                                                                                                  
    if(flag==1)                                                                                                                                                                                        
    {                                                                                                                                                                                                  
        printf("修改成功\n");                                                                                                                                                                          
        return 1;                                                                                                                                                                                      
    }                                                                                                                                                                                                  
    printf("修改失败\n");                                                                                                                                                                              
    return 0;                                                                                                                                                                                          
}                                                                                                                                                                                                      
int list_search_pos(seqlist *L,int pos)                                                                                                                                                                
{                                                                                                                                                                                                      
    if(list_empty(L)||pos<0||pos>=L->len)                                                                                                                                                              
    {                                                                                                                                                                                                  
        printf("查找失败\n");                                                                                                                                                                          
        return -1;                                                                                                                                                                                     
    }                                                                                                                                                                                                  
    return L->data[pos];                                                                                                                                                                               
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
int list_search_value(seqlist *L,datatype e)                                                                                                                                                           
{                                                                                                                                                                                                      
    if(list_empty(L))                                                                                                                                                                                  
    {                                                                                                                                                                                                  
        printf("查找失败\n");                                                                                                                                                                          
        return -1;                                                                                                                                                                                     
    }                                                                                                                                                                                                  
    for(int i=0;i<L->len;i++)                                                                                                                                                                          
    {                                                                                                                                                                                                  
        if(L->data[i]==e) return i;                                                                                                                                                                    
    }                                                                                                                                                                                                  
    return -1;                                                                                                                                                                                         
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
void list_free(seqlist **L)                                                                                                                                                                            
{                                                                                                                                                                                                      
    if(L!=NULL)                                                                                                                                                                                        
    {                                                                                                                                                                                                  
        free(*L);                                                                                                                                                                                      
        *L=NULL;                                                                                                                                                                                       
        printf("销毁成功\n");                                                                                                                                                                          
    }                                                                                                                                                                                                  
}                                                                                                                                                                                                      
                                                                                                                                                                                                       
int list_change(seqlist *L)                                                                                                                                                                            
{                                                                                                                                                                                                      
    datatype temp;                                                                                                                                                                                     
    if(list_empty(L))                                                                                                                                                                                  
    {                                                                                                                                                                                                  
        printf("排序失败\n");                                                                                                                                                                          
        return -1;                                                                                                                                                                                     
    }                                                                                                                                                                                                  
    for(int i=0;i < L->len-1;i++)                                                                                                                                                                      
    {                                                                                                                                                                                                  
        for(int j=0;j < L->len-1-i;j++)                                                                                                                                                                
        {                                                                                                                                                                                              
            if(L->data[j] > L->data[j+1])                                                                                                                                                              
            {                                                                                                                                                                                          
                temp=L->data[j];                                                                                                                                                                       
                L->data[j]=L->data[j+1];                                                                                                                                                               
                L->data[j+1]=temp;                                                                                                                                                                     
            }                                                                                                                                                                                          
        }                                                                                                                                                                                              
    }                                                                                                                                                                                                  
    printf("排序成功\n");                                                                                                                                                                              
    return 0;                                                                                                                                                                                          
                                                                                                                                                                                                       
}                                                                                                                                                                                                      
int list_max(seqlist *L)                                                                                                                                                                               
{                                                                                                                                                                                                      
    datatype max=0;                                                                                                                                                                                    
    if(list_empty(L))                                                                                                                                                                                  
    {                                                                                                                                                                                                  
        printf("找最值失败\n");                                                                                                                                                                        
        return -1;                                                                                                                                                                                     
    }                                                                                                                                                                                                  
    for(int i=0;i<L->len;i++)                                                                                                                                                                          
    {                                                                                                                                                                                                  
        if(L->data[i]>L->data[max])max=i;                                                                                                                                                              
    }                                                                                                                                                                                                  
    return L->data[max];                                                                                                                                                                                        
                                                                                                                                                                                                       
}                                                                                                                                                                                                      
int list_delete_repeat(seqlist *L)                                                                                                                                                                     
{                                                                                                                                                                                                      
    int j=0;                                                                                                                                                                                           
    int k=0;                                                                                                                                                                                           
    if(list_empty(L))                                                                                                                                                                                  
    {                                                                                                                                                                                                  
        printf("找最值失败\n");                                                                                                                                                                        
        return -1;                                                                                                                                                                                     
    }                                                                                                                                                                                                  
    for(int i=0;i<L->len;i++)                                                                                                                                                                          
    {                                                                                                                                                                                                  
        j=i;                                                                                                                                                                                           
        k=i;                                                                                                                                                                                           
        while(k < L->len)                                                                                                                                                                              
        {                                                                                                                                                                                              
            if(L->data[i]!=L->data[k])                                                                                                                                                                 
            {                                                                                                                                                                                          
                j++;                                                                                                                                                                                   
                L->data[j]=L->data[k];                                                                                                                                                                 
            }                                                                                                                                                                                          
            k++;                                                                                                                                                                                       
        }                                                                                                                                                                                              
        L->len=j+1;                                                                                                                                                                                    
    }                                                                                                                                                                                                  
    return 0;                                                                                                                                                                                          
}

seqlist.h

 #ifndef __SEQLIST_H__                                                                                               
 #define __SEQLIST_H__                                                                                               
                                                                                                                     
 #include<stdio.h>                                                                                                   
 #include<stdlib.h>                                                                                                  
 #include<string.h>                                                                                                  
 #define MAX 20                                                                                                      
                                                                                                                     
 typedef int datatype;                                                                                               
 typedef struct                                                                                                      
 {                                                                                                                   
     datatype data[MAX];                                                                                             
     int len;                                                                                                        
 }seqlist;                                                                                                           
                                                                                                                     
 seqlist *list_create();                                                                                             
 int list_empty(seqlist *L);                                                                                         
 int list_full(seqlist *L);                                                                                          
 int list_add(seqlist *L,datatype e);                                                                                
 void list_display(seqlist *L);                                                                                      
 int list_insert_pos(seqlist *L,int pos,datatype e);                                                                 
 int list_delete_pos(seqlist *L,int pos);                                                                            
 int list_update_pos(seqlist *L,int pos,datatype e);                                                                 
 int list_search_value(seqlist *L,datatype e);                                                                       
 int list_update_value(seqlist *L,datatype old_e,datatype new_e);                                                    
 void list_free(seqlist **L);                                                                                        
 int list_search_pos(seqlist *L,int pos);                                                                            
 int list_change(seqlist *L);                                                                                        
 int list_max(seqlist *L);                                                                                           
 int list_delete_repeat(seqlist *L);                                                                                 
 #endif

运行结果：

ubuntu@ubuntu:~$ ./a.out
创建成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
添加成功
分别为：5	4	4	3	5	2	2	4	1	5	2	2	4	1	1	5	4	5	1	4	
插入失败
分别为：5	4	4	3	5	2	2	4	1	5	2	2	4	1	1	5	4	5	1	4	
删除成功
分别为：5	4	4	3	2	2	4	1	5	2	2	4	1	1	5	4	5	1	4	
修改成功
分别为：3	4	4	3	2	2	4	1	5	2	2	4	1	1	5	4	5	1	4	
修改成功
分别为：3	2	2	3	2	2	2	1	5	2	2	2	1	1	5	2	5	1	2	
查找失败
-1
排序成功
分别为：1	1	1	1	2	2	2	2	2	2	2	2	2	2	3	3	5	5	5	
5
分别为：1	2	3	5

 

xiaocaiji0
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值