• 对顺序表的基本操作(增删查改),并编写makefile进行编

    1.定义顺序表结构体

    2.创建顺序表

    3.从尾部插入数据

    4.遍历顺序表

    5.从尾部删除数据

    6.按下标插入数据

    7.按下标删除数据

    8.按下标修改数据

    9.按下标查找数据

    10.按数据修改数据

    11..按数据查找位置

    12.顺序表去重

            删除重复数据

            (提示：将先出现的数据与后面的数据对比，如果有重复的将后面的数据删除）

            提示：可以直接使用按位置删除的函数

            顺序表中原有:1 2 2 1 1 3 4 3 2 4 5 3 4 5 4 1

            ......

            顺序表中存储:1 2 3 4 5

    SeqList.c

    1. #include "./SeqList.h"                                      
    2. #include                                      
    3. #include                                     
    4. //创建顺序表                                           
    5. SeqList* create_seqList()                              
    6. {                                                      
    7.                                                        
    8.     SeqList *list = (SeqList*)malloc(sizeof(SeqList)); 
    9.                                                        
    10.     if(NULL == list)                                   
    11.     {                                                  
    12.         return NULL;                                   
    13.     }                                                  
    14.     list -> pos = 0;//初始化要操作的位置为0            
    15.                                                        
    16.                                                        
    17.     return list;                                       
    18. }                                                      
    19.                                                        
    20. //插入数据                                             
    21. void insert_SeqList(SeqList* list,datatype num)        
    22. {                                                      
    23.     //判断顺序表是否为满                               
    24.     if(list->pos >= N)                                 
    25.     {                                                  
    26.         printf("%d顺序表为满,插入失败!\n",num);        
    27.         return;                                        
    28.     }                                                  
    29.                                                        
    30.     list->data[list->pos] = num;                       
    31.     (list->pos)++;                                     
    32.     printf("%d插入成功!\n",num);                       
    33.     return;                                            
    34. }                                                        
    35.                                                          
    36. //遍历顺序表                                             
    37. void show_SeqList(SeqList* list)                         
    38. {                                                        
    39.     for(int i=0;list->pos>i;i++)                         
    40.     {                                                    
    41.                                                          
    42.         printf("%d ",list->data[i]);                     
    43.                                                          
    44.     }                                                    
    45.     printf("\n");                                        
    46.     return;                                              
    47. }                                                        
    48.                                                          
    49. //从尾部删除                                             
    50.                                                          
    51. datatype del_SeqList(SeqList *list)                      
    52. {                                                        
    53.     int num;                                             
    54.     if(0 == list->pos)                                   
    55.     {                                                    
    56.         printf("顺序表为空!\n");                         
    57.         return 0;                                        
    58.     }                                                    
    59.     (list->pos)--;                                       
    60.     num = list->data[list->pos];                         
    61.                                                          
    62.                                                          
    63.     return num;                                          
    64. }                                                                        
    65.                                                                          
    66. //按位插入                                                               
    67. void insert_location_SeqList(SeqList* list,datatype index,datatype num)  
    68.                                                                          
    69. {                                                                        
    70.     if(list->pos >= N)                                                   
    71.     {                                                                    
    72.         printf("顺序表为满,插入失败!\n");                                
    73.         return;                                                          
    74.     }                                                                    
    75.     if(index<0 || index>list->pos)                                       
    76.     {                                                                    
    77.         printf("index=%d属于非法插入!\n",index);                         
    78.         return;                                                          
    79.     }                                                                    
    80.     int i=0;                                                             
    81.     for( i=list->pos;i>index;i--)                                        
    82.     {                                                                    
    83.         list->data[i] = list->data[i-1];                                 
    84.     }                                                                    
    85.     list->data[i] = num;                                                 
    86.     (list->pos)++;                                                       
    87.     printf("%d成功插入到下标为%d的位置!\n",num,index);                   
    88.     return;                                                              
    89.                                                                          
    90.                                                                          
    91. }                                                                        
    92. //按位删除                                                               
    93. datatype del_location_SeqList(SeqList* list,datatype index)              
    94. {                                                                        
    95.     int i;                                                               
    96.     if(0 == list->pos)                                                   
    97.     {                                                                    
    98.         printf("顺序表为空!\n");                                         
    99.         return 0;                                                        
    100.     }                                                                    
    101.                                                                          
    102.     for( i=index;i<(list->pos)-1;i++)                                    
    103.     {                                                                    
    104.         list->data[i] = list->data[i+1];                                 
    105.     }                                                                    
    106.     (list->pos)--;                                                       
    107.     printf("下标为%d的数据删除成功!\n",index);                           
    108.     return index;                                                        
    109. }                                                                        
    110. //按位修改                                                                             
    111. void rm_location_SeqList(SeqList* list,datatype index,datatype num)                    
    112. {                                                                                      
    113.     if(index<0 || index>list->pos)                                                     
    114.     {                                                                                  
    115.         printf("index=%d属于非法修改!\n",index);                                       
    116.         return;                                                                        
    117.     }                                                                                  
    118.     list->data[index] = num;                                                           
    119.     printf("下标为%d的数据修改成功!\n",index);                                         
    120.                                                                                        
    121.     return;                                                                            
    122.                                                                                        
    123. }                                                                                      
    124.                                                                                        
    125. //按位查找                                                                             
    126. void find_location_SeqList(SeqList* list,datatype index)                               
    127. {                                                                                      
    128.     if(0 == list->pos)                                                                 
    129.     {                                                                                  
    130.         printf("顺序表为空!\n");                                                       
    131.         return;                                                                        
    132.     }                                                                                  
    133.     printf("下标为%d是数据是%d\n",index,list->data[index]);                            
    134.     return;                                                                            
    135.                                                                                        
    136. }                                                                                      
    137.                                                                                        
    138. //按数据修改                                                                           
    139. void update_SeqList(SeqList* list,datatype oldNum,datatype newNum)                     
    140. {                                                                                      
    141.     int i=0;                                                                           
    142.     for(i=0;ipos;i++)                                                           
    143.     {                                                                                  
    144.         if(list->data[i] == oldNum)                                                    
    145.         {                                                                              
    146.             list->data[i] == newNum;                                                   
    147.         }                                                                              
    148.     }                                                                                  
    149.     printf("数据修改完成!\n");                                                         
    150.     return;                                                                            
    151. }                                                                                      
    152.                                                                                        
    153.                                                                                        
    154.                                                                                        
    155. //按数据查找                                                                           
    156. int select_SelqList(SeqList* list,datatype num)                                        
    157. {                                                                                      
    158.     int i=0;                                                                           
    159.     for(i=0;ipos;i++)                    
    160.     {                                           
    161.         if(list->data[i] == num)                
    162.         {                                       
    163.             return i;                           
    164.         }                                       
    165.     }                                           
    166.     return -1;                                  
    167. }                                               
    168.                                                 
    169.                                                 
    170. //顺序表去重                                    
    171. //1221134324534541                              
    172. //12345                                         
    173. void delrepeat_SeqList(SeqList* list)           
    174. {                                               
    175.     if(0 == list->pos)                          
    176.     {                                           
    177.         printf("顺序表为空!\n");                
    178.         return ;                                
    179.     }                                           
    180.                                                 
    181.     int i,j;                                    
    182.     for(i=0;i<(list->pos);i++)                  
    183.     {                                           
    184.         for(j=i+1;j<(list->pos);j++)            
    185.         {                                       
    186.             if(list->data[i] == list->data[j])  
    187.             {                                   
    188.                 del_location_SeqList(list,j);   
    189.                 j--;                            
    190.             }                                   
    191.                                                 
    192.         }                                       
    193.     }                                           
    194.     printf("去重成功!\n");                      
    195.                                                 
    196.     return;                                     
    197.                                                 
    198. }                                               
    199. //释放顺序表
    200. void free_SeqList(SeqList* list)
    201. {                                
    202.     free(list);
    203.     list = NULL;
    204.     printf("释放成功!");
    205.     return;
    206. }

    mian.c

    1. #include 
    2. #include "./SeqList.h"
    3. int main(int argc, const char *argv[])
    4. {   
    5.     SeqList * list = create_seqList();
    6.  
    7.  /*
    8.   insert_SeqList(list,10);
    9.     insert_SeqList(list,100);
    10.     insert_SeqList(list,1000);
    11.     insert_SeqList(list,10000);
    12.     insert_SeqList(list,100000);
    13.     
    14.     show_SeqList(list);                              
    15.     del_SeqList(list);
    16.     show_SeqList(list);
    17.     del_SeqList(list);
    18.     show_SeqList(list);
    19.     del_SeqList(list);
    20.     show_SeqList(list);
    21.     del_SeqList(list);
    22.     show_SeqList(list);
    23.     del_SeqList(list);
    24.     show_SeqList(list);
    26.     insert_location_SeqList(list,2,222);
    27.     show_SeqList(list);
    29.     del_location_SeqList(list,2);
    30.     show_SeqList(list);
    32.     rm_location_SeqList(list,2,222);
    33.     show_SeqList(list);
    35.     find_location_SeqList(list,2);
    36.     
    37.     update_SeqList(list, 11, 111);
    38.     show_seqList(list); 
    40.     int index = select_SelqList(list, 2222);
    41.     printf("index=%d\n", index);
    43. */ 
    44.     insert_SeqList(list,1);
    45.     insert_SeqList(list,2);
    46.     insert_SeqList(list,2);
    47.     insert_SeqList(list,1);
    48.     insert_SeqList(list,1);
    49.     insert_SeqList(list,3);
    50.     insert_SeqList(list,4);
    51.     insert_SeqList(list,3);      
    52.     insert_SeqList(list,2);      
    53.     insert_SeqList(list,4);      
    54.     insert_SeqList(list,5);      
    55.     insert_SeqList(list,3);      
    56.     insert_SeqList(list,4);      
    57.     insert_SeqList(list,5);      
    58.     insert_SeqList(list,4);      
    59.     insert_SeqList(list,1);      
    60.                                  
    61.     delrepeat_SeqList(list);     
    62.     show_SeqList(list);          
    63.     free_SeqList(list);                    
    64.                                  
    65.     return 0;                    
    66. }

    SeqList.h

    1. #ifndef __01_H__                                                         
    2. #define __01_H__                                                         
    3. #define N 17 //顺序表容量                                                
    4. typedef int datatype;                                                    
    5. typedef struct                                                           
    6. {                                                                        
    7.     datatype data[N];                                                    
    8.     int pos;                                                             
    9. }SeqList;                                                                
    10.                                                                          
    11. SeqList* create_seqList();                                               
    12. void insert_SeqList(SeqList* list,datatype num);                         
    13.                                                                          
    14. void show_SeqList(SeqList* list);                                        
    15. datatype del_SeqList(SeqList *list);                                     
    16. void insert_location_SeqList(SeqList* list,datatype index,datatype num); 
    17. datatype del_location_SeqList(SeqList* list,datatype index);             
    18. void rm_location_SeqList(SeqList* list,datatype index,datatype num);     
    19. void find_location_SeqList(SeqList* list,datatype index);                
    20. void update_SeqList(SeqList* list,datatype oldNum,datatype newNum);      
    21.                                                                          
    22. int select_SelqList(SeqList* list,datatype num);                         
    23.                                                                          
    24. void delrepeat_SeqList(SeqList* list); 
    25. void free_SeqList(SeqList* list);                                  
    26. #endif

    makefile.cfg

    1. Target:=a.out                   
    2. obj:=SeqList.o main.o           
    3. CAN:=-c -o                      
    4. CC:=gcc

    makefile

    1. -include ./makefile.cfg
    2. $(Target):$(obj)
    3.     $(CC) $^ -o $@
    4. %.o:%.c
    5.     $(CC) $< $(CAN) $@
    6. .PHONY:clean
    7.  
    8. clean:
    9.     rm $(obj) $(Target)

  • 相关阅读:
    【Python】使用 Python 中的 aioredis 实现后进先出队列
    8月19日PMP出成绩时间，公布了！
    C++ Reference: Standard C++ Library reference: C Library: cerrno
    图像增强及运算篇之图像掩膜直方图和HS直方图
    多旋翼无人机组合导航系统-多源信息融合算法（Matlab代码实现）
    Python中lambda函数&eval()函数&递归的详细用法
    大数据指标 透视50个DeFi头部协议
    android开发教程视频，android组件化和插件化
    【配置vscode编写python代码并输出到外部控制台】
    构造方法的私有化和枚举enum
  • 原文地址：https://blog.csdn.net/weixin_51949422/article/details/136176717