顺序表增删改查(c语言)

main函数:

 #include <stdio.h>
 #include "./seq.h"
 int main(int argc, const char *argv[])
 {
     SeqList* list =  create_seqList();
     insert_seqList(list,10);
     insert_seqList(list,100);
     insert_seqList(list,12);
     insert_seqList(list,23);
     show_seqList(list);
     int res;
     res=delete_seqList(list);
     printf("%d\n",res);                                 
     insert_byid_seqList(list,66,1);
     show_seqList(list);
     int n=delete_byid_seqList(list,2);
     printf("被删除的数据为%d\n",n);
     show_seqList(list);
     updata_byid(list,1);
     show_seqList(list);
     int x=search_byid(list,1);
     printf("查找的数据为%d\n",x);
     int idx=selectidx_bydata_seqList(list,10);
     printf("%d\n",idx);
     return 0;
 }
                                                         

函数部分:

  1 #include <stdio.h>                                                                                                                                    
  2 #include <stdlib.h>                                                                                                                                   
  3 #include "./seq.h"                                                                                                                                    
  4                                                                                                                                                       
  5 /*                                                                                                                                                    
  6  * function:    创建顺序表                                                                                                                            
  7  * @param[ in]                                                                                                                                        
  8  * @param[out]                                                                                                                                        
  9  * @return                                                                                                                                            
 10  */                                                                                                                                                   
 11 //创建顺序表                                                                                                                                          
 12 SeqList* create_seqList()                                                                                                                             
 13 {                                                                                                                                                     
 14     SeqList *list=(SeqList *)malloc(sizeof(SeqList));//申请对空间在函数结束后不会被销毁                                                               
 15     if(NULL == list)//定义顺序表是否为空                                                                                                              
 16     {                                                                                                                                                 
 17         return NULL;                                                                                                                                  
 18     }                                                                                                                                                 
 19     list->pos=0;//初始化记录下标位置为0                                                                                                               
 20                                                                                                                                                       
 21     return list;                                                                                                                                      
 22 }                                                                                                                                                     
 23 //在顺序表尾部插入数据                                                                                                                                
 24 void insert_seqList(SeqList * list,datatype num)                                                                                                      
 25 {                                                                                                                                                     
 26     if(list->pos >= N)          //判断顺序表是否满了                                                                                                  
 27     {                                                                                                                                                 
 28         printf("顺序表已满,插入失败!\n");                                                                                                           
 29         return;                                                                                                                                       
 30     }                                                                                                                                                 
 31     list->data[list->pos] = num;//将要插入的数据给到末尾为的pos下标                                                                                   
 32     (list->pos)++;              //将pos后移                                                                                                           
 33     printf("插入成功!\n");                                                                                                                           
 34     return;                                                                                                                                           
 35 }                                                                                                                                                     
 36 //根据下标插入数据                                                                                                                                    
 37 void insert_byid_seqList(SeqList *list,datatype num,int n)//n为需要插入数据的下标                                                                     
 38 {                                                                                                                                                     
 39     int i;                                                                                                                                            
 40     if(n<0||n>list->pos)                                                                                                                              
 41     {                                                                                                                                                 
 42         printf("插入的位置非法!\n");                                                                                                                 
 43     }                                                                                                                                                 
 44                                                                                                                                                       
 45     if(n>list->pos || list->pos>=N)                                                                                                                   
 46     {                                                                                                                                                 
 47         printf("顺序表已满,插入失败!\n");                                                                                                           
 48         return;                                                                                                                                       
 49     }                                                                                                                                                 
 50         for(i=list->pos;i>n;i--)//先将顺序表中的数据后移                                                                                              
 51     {                                                                                                                                                 
 52         list->data[i]=list->data[i-1];                                                                                                                
 53     }                                                                                                                                                 
 54     list->data[n] = num;   //将目标数据赋给目标下标                                                                                                   
 55     (list->pos)++;         //将pos的值+1                                                                                                              
 56     printf("插入成功!\n");                                                                                                                           
 57                                                                                                                                                       
 58 }                                                                                                                                                     
 59 //根据下标删除数据                                                                                                                                    
 60 datatype delete_byid_seqList(SeqList* list,int x)                                                                                                     
 61 {                                                                                                                                                     
 62     int i;                                                                                                                                            
 63     datatype num;//先定义一个变量用来存储要被删除的数据,以免被覆盖                                                                                   
 64     if(x<0 || x>=list->pos)                                                                                                                           
 65     {                                                                                                                                                 
 66         printf("删除失败!\n");                                                                                                                       
 67     }                                                                                                                                                 
 68     num=list->data[x];                                                                                                                                
 69     for(i=x;i<list->pos-1;i++)//先找到要删除的下标位置,将后面的数据往前移                                                                            
 70     {                                                                                                                                                 
 71         list->data[i]=list->data[i+1];                                                                                                                
 72     }                                                                                                                                                 
 73     list->pos--;//数据被删除了,所以要将pos-1                                                                                                         
 74                                                                                                                                                       
 75     return num;                                                                                                                                       
 76 }                                                                                                                                                     
 77 //在顺序表尾部删除数据                                                                                                                                
 78 datatype delete_seqList(SeqList* list)                                                                                                                
 79 {                                                                                                                                                     
 80     if(list->pos<=0)                                                                                                                                  
 81     {                                                                                                                                                 
 82     printf("顺序表中没有数据,删除失败!\n");                                                                                                         
 83     }                                                                                                                                                 
 84     list->pos--;                                                                                                                                      
 85     return list->data[list->pos];                                                                                                                     
 86 }                                                                                                                                                     
 87 //根据下标修改数据                                                                                                                                    
 88 void updata_byid(SeqList* list,int x)                                                                                                                 
 89 {                                                                                                                                                     
 90     if(x>=list->pos||x<0)                                                                                                                             
 91     {                                                                                                                                                 
 92         printf("该下标非法,修改失败!\n");                                                                                                           
 93         return;                                                                                                                                       
 94     }                                                                                                                                                 
 95     printf("请输入数据>>>\n");                                                                                                                        
 96     scanf("%d",&list->data[x]);                                                                                                                       
 97     return;                                                                                                                                           
 98 }                                                                                                                                                     
 99 datatype search_byid(SeqList* list,int x)                                                                                                             
100 {                                                                                                                                                     
101     if(x>=list->pos||x<0)                                                                                                                             
102     {                                                                                                                                                 
103         printf("该下标越界!\n");                                                                                                                     
104     }                                                                                                                                                 
105     return list->data[x];                                                                                                                             
106 }                                                                                                                                                     
107 /*                                                                                                                                                    
108  * function:                                                                                                                                          
109  * @param [ in]                                                                                                                                       
110  * @param [out]                                                                                                                                       
111  * @return                                                                                                                                            
112  */                                                                                                                                                   
113 //遍历顺序表                                                                                                                                          
114 void show_seqList(SeqList* list)                                                                                                                      
115 {                                                                                                                                                     
116     int i;                                                                                                                                            
117     if(0==list->pos)                                                                                                                                  
118     {                                                                                                                                                 
119         printf("顺序表中没有数据!\n");                                                                                                               
120     }                                                                                                                                                 
121     for(i=0;i<list->pos;i++)                                                                                                                          
122     {                                                                                                                                                 
123         printf("%d ",list->data[i]);                                                                                                                  
124     }                                                                                                                                                 
125     putchar(10);                                                                                                                                      
126     return;                                                                                                                                           
127 }                                                                                                                                                     
128 void selectdata_seqList(SeqList* list,datatype oldNum,datatype newNum)                                                                                
129 {                                                                                                                                                     
130     int i=0;                                                                                                                                          
131     for(i=0;i<list->pos;i++)                                                                                                                          
132     {                                                                                                                                                 
133         if(list->data[oldNum]==list->data[i])                                                                                                         
134         {                                                                                                                                             
135             list->data[newNum]=list->data[oldNum];                                                                                                    
136         }                                                                                                                                             
137     }                                                                                                                                                 
138     printf("更新完成!\n");                                                                                                                           
139     return;                                                                                                                                           
140                                                                                                                                                       
141 }                                                                                                                                                     
142 int  selectidx_bydata_seqList(SeqList* list,datatype num)                                                                                             
143 {                                                                                                                                                     
144     int i=0;                                                                                                                                          
145     for(i=0;i<list->pos;i++)                                                                                                                          
146     {                                                                                                                                                 
147         if(num==list->data[i])                                                                                                                        
148         {                                                                                                                                             
149             return i;                                                                                                                                 
150         }                                                                                                                                             
151     }                                                                                                                                                 
152     return -1;                                                                                                                                        
153 }                                                                                                                                                     
                                                                                                                                                    

头文件:

 #ifndef __FUNC_H__                                                              
 #define __FUNC_H_                                                               
 #define N 100  //顺序表的容量                                                   
                                                                                 
 typedef int datatype;                                                           
 typedef struct//由于需要同时返回顺序表及其下标位置,所以定义一个结构体          
 {                                                                               
     datatype data[N];    //定义一个顺序表                                       
     int pos;        //记录下标位置                                              
 }SeqList;                                                                       
                                                                                 
 SeqList* create_seqList();                                                      
 void insert_seqList(SeqList* list,datatype num);                                
 void show_seqList(SeqList* list);                                               
 datatype delete_seqList(SeqList* list);                                         
 void insert_byid_seqList(SeqList *list,datatype num,int n);                     
 datatype delete_byid_seqList(SeqList* list,int x);                              
 void updata_byid(SeqList* list,int x);                                          
 datatype search_byid(SeqList* list,int x);                                      
 int  selectidx_bydata_seqList(SeqList* list,datatype num);                      
                                                                                 
 #endif                                                                          
                                                                                 
                                                                                 

  • 10
    点赞
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值