devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

【C语言】顺序表的创建_顺序表编程

作者：我家自动化 | 2024-04-15 09:31:17

赞

踩

顺序表编程

一、代码实现部分：

        1、顺序表是线性表的基础部分，至于顺序表，在本人看来无异于数组。至于线性表的概念，在此不再赘述。接下来尝试利用C语言对线性表中的顺序表进行代码实现（此程序中规定用户输入的数据类型为int类型）：

  1. typedef struct{
  2.     int *p;
  3.     int length;
  4.     int ac;
  5. }S,*pS;

首先定义一个结构体，结构体中定义一个指针变量，两个int类型变量，之所以定义两个int类型变量length和ac是为了分别记录顺序表的规定长度（申请长度）和实际长度（已使用的长度，或者说已经存放了个元素个数）。

        2、在定义好结构体后，进行对顺序表的创建。在此利用函数void crate_s(pS s)；进行对顺序表的创建

  1. void crate_s(pS s){
  2.     int a;
  3.     printf("你想要存储多少个数据？\n");
  4.     scanf("%d",&a);
  5.     if(a<=0){
  6.         printf("你不想存储数据！\n");
  7.     }else{
  8.         s->p=(int *)malloc(sizeof(int)*a);
  9.         if(NULL==s->p){
  10.             printf("空间申请失败！\n");
  11.         }else{
  12.             s->length=a;
  13.             s->ac=-1;
  14.             printf("能够存储%d个元素的空间申请成功！\n",s->length);
  15.         }
  16.     }
  17. }

当结构体传入函数void crate_s(pS s);后，先判断用户是否想创建顺序表，要创建多长的顺序表。当用户想要创建顺序表后，向计算机申请相应空间，并且结构体中的length用于记录顺序表的规定（申请）长度，ac用于记录顺序表的实际长度。

        3、通过void insert_s(pS s);函数实现顺序表中添加数据，具体代码如下：

  1. void insert_s(pS s){
  2.     int a,b,c,d,e,i;
  3.     a=s->length;
  4.     b=s->ac;
  5.     c=a-(b+1);
  6.     if(a==0){
  7.         printf("你还没有创建顺序表！\n");
  8.     }else if(c==0){
  9.         printf("此表已满！\n");
  10.     }else{
  11.         printf("这个顺序表长度为%d，你还可以存%d个数据，你想存多少数据？\n",a,c);
  12.         scanf("%d",&d);
  13.         if(d==0){
  14.             printf("你不想存数据！\n");
  15.         }else if(c<d){
  16.             printf("此顺序表空间不足！\n");
  17.         }else{
  18.             for(i=0;i<d;i++){
  19.                 printf("请输入第%d个元素：\n",i+1);
  20.                 scanf("%d",&e);
  21.                 s->p[++(s->ac)]=e;
  22.                 printf("元素输入成功！\n");
  23.             }
  24.         }
  25.     }
  26. }

这个函数的编程思想是先判断是否已经创建顺序表，顺序表是否已经存满数据。然后判断用户想要输入的数据个数是否存在溢出情况，最后再存放用户想要存放的数据。

        4、通过void trave_s(pS s);函数实现顺序表数据的遍历，具体代码如下：

  1. void trave_s(pS s){
  2.     int a,b,c,i;
  3.     a=s->length;
  4.     b=s->ac;
  5.     if(a==0){
  6.         printf("你还没创建顺序表！\n");
  7.     }else{
  8.         if(b==-1){
  9.             printf("这是一个空表！\n");
  10.         }else{
  11.             printf("顺序表中数据是：\n");
  12.             for(i=0;i<=b;i++){
  13.                 printf("%4d",s->p[i]);
  14.             }
  15.             printf("\n");
  16.         }
  17.     }
  18. }

此函数的编程思想是先判断顺序表是否存在，是否为空，若都不是，那么遍历这个顺序表中实际存在的数据（这里注意区分顺序表的规定长度与实际长度）。

        5、通过void search_s(pS s);函数实现对顺序表元素的查询，具体代码如下：

  1. void search_s(pS s){
  2.     int a,b,c,i;
  3.     a=s->length;
  4.     b=s->ac;
  5.     if(a==0){
  6.         printf("你还没有创建顺序表！\n");
  7.     }else{
  8.         if(b==-1){
  9.             printf("这是一个空表！\n");
  10.         }else{
  11.             printf("此顺序表有%d个元素，你想查询几号元素？\n",b+1);
  12.             scanf("%d",&c);
  13.             if(c<=0||c>(b+1)){
  14.                 printf("你找的元素不在此顺序表中表中");
  15.             }else{
  16.                 printf("你要找的第%d号元素是%d \n",c,s->p[c-1]);
  17.             }
  18.         }
  19.     }
  20. }

在这里，仍然是先判断顺序表是否存在，是否为空，然后按照序号查找元素。若查找的方式是输入元素，查看其是否在顺序表中，那么本人的实现方法是利用最笨的遍历查找，将顺序表中的元素一一取出和输入元素相互比较以此找出此元素和次元素所在位置。

        6、利用void change_s(pS s);函数实现修改顺序表数据，具体代码如下：

  1. void change_s(pS s){
  2.     int a,b,c,d,i;
  3.     a=s->length;
  4.     b=s->ac;
  5.     if(a==0){
  6.         printf("你还没有创建顺序表！\n");
  7.     }else{
  8.         if(b==-1){
  9.             printf("这是一个空表！\n");
  10.         }else{
  11.             printf("此顺序表有%d个元素，你想修改几号元素？\n",b+1);
  12.             scanf("%d",&c);
  13.             if(c<=0||c>(b+1)){
  14.                 printf("你修改的元素不在此顺序表中表中\n");
  15.             }else{
  16.                 printf("你要修改的第%d号元素是%d,你想将其修改成什么数值？ \n",c,s->p[c-1]);
  17.                 scanf("%d",&d);
  18.                 s->p[c-1]=d;
  19.                 printf("元素修改成功！\n");
  20.             }
  21.         }
  22.     }
  23. }

先判断顺序表是否存在，顺序表是否为空，然后找到想要修改的元素下标，对对应的值进行修改。

        7、利用void empty_s(pS s);函数实现将顺序表置空：

  1. void empty_s(pS s){
  2.     int a,b,c;
  3.     a=s->length;
  4.     b=s->ac;
  5.     if(a==0){
  6.         printf("你还没有建表！\n");
  7.     }else{
  8.         if(b==-1){
  9.             printf("这是一个空表！\n");
  10.         }else{
  11.             s->ac=-1;
  12.             printf("此表已经置空！\n");
  13.         }
  14.     }
  15. }

同样先判断存在，判断是否为空，再进行置空。（小想法：这个置空倒是特别简单，将记录顺序表真实长度的ac变量值置为-1即可，那么在改变ac变量值之前已经在相应位置赋好的值怎么办？个人主观理解为，这些值会被其他（无论是否是人为操作）值覆盖，因此不用关心这些值的下场(无知的奸笑)）。

        8、利用void delete_s(pS s);函数实现删除顺序表中数据：

  1. void delete_s(pS s){
  2.     int a,b,c,d;
  3.     a=s->length;
  4.     b=s->ac;
  5.     if(a==0){
  6.         printf("你还没有建表！\n");
  7.     }else{
  8.         if(b==-1){
  9.             printf("这是一个空表！\n");
  10.         }else{
  11.             printf("你想要删除第几号元素？\n");
  12.             scanf("%d",&c);
  13.             if(c<=0||c>b+1){
  14.                 printf("你要删除的元素不在此顺序表中！\n");
  15.             }else{
  16.                 d=c-1;
  17.                 printf("你要删除的第%d号元素是%d\n",c,s->p[d]);
  18.                 for(d;d<=b;d++){
  19.                     s->p[d]=s->p[d+1];
  20.                 }
  21.                 s->ac--;
  22.                 printf("此元素删除成功！\n");
  23.             }
  24.         }
  25.     }
  26. }

同样，判存在，判空。因为此处是以元素在顺序表中的位置来定位元素，因此要判断要删除的元素是否在顺序表中。然后再做删除操作（指定元素的后面覆盖前面，ac-1）

        9、利用void init_s(pS s);函数实现向顺序表中插入数据，具体代码如下：

  1. void init_s(pS s){
  2.     int a,b,c,d,e,f;
  3.     a=s->length;
  4.     b=s->ac;
  5.     if(a==0){
  6.         printf("你还没有建立顺序表！\n");
  7.     }else{
  8.         if(b==-1){
  9.             printf("这是一个空表！\n");
  10.         }else{
  11.             if(a==b+1){
  12.                 printf("此表以满！\n");
  13.             }else{
  14.                 printf("你想在数据前面插入新数据还是想在数据后面插入新数据？选择前插请输入0，选择后插请输入1:\n");
  15.                 scanf("%d",&c);
  16.                 switch(c){
  17.                     case 0:
  18.                         printf("此顺序表一共可以存储%d个元素，目前已经存储了%d个元素，你想在几号元素前面插入数据？\n",a,b+1);
  19.                         scanf("%d",&d);
  20.                         e=d-1;
  21.                         if(d<=0||d>b+2){
  22.                             printf("此表中没有这号元素，你无法插入");
  23.                         }else{
  24.                             for(e;e<=b;b--){
  25.                                 s->p[b+1]=s->p[b];
  26.                             }
  27.                             printf("你想在%d号元素前面添加什么数值？\n",d);
  28.                             scanf("%d",&f);
  29.                             s->p[e]=f;
  30.                             s->ac++;
  31.                             printf("元素添加成功！\n");
  32.                         }
  33.                         break;
  34.  
  35.                      case 1:
  36.                         printf("此顺序表一共可以存储%d个元素，目前已经存储了%d个元素，你想在几号元素后面插入数据？\n",a,b+1);
  37.                         scanf("%d",&d);
  38.                         if(d<0||d>b+1){
  39.                             printf("此表中没有这号元素，你无法插入");
  40.                         }else{
  41.                             for(d;d<=b;b--){
  42.                                 s->p[b+1]=s->p[b];
  43.                             }
  44.                             printf("你想在%d号元素后面添加什么数值？\n",d);
  45.                             scanf("%d",&f);
  46.                             s->p[d]=f;
  47.                             s->ac++;
  48.                             printf("元素添加成功！\n");
  49.                         }
  50.                         break;
  51.  
  52.                      default:
  53.                         printf("你不想输入数据！\n");
  54.                         break;
  55.                 }
  56.             }
  57.         }
  58.     }
  59. }

判断表是否存在，是否为空。判断是要前插还是后插。保证插入数据后数据不会溢出。

        10、利用void thong_s(pS s);函数得到顺序表的长度，具体代码如下：

  1. void thong_s(pS s){
  2.     int a,b,c;
  3.     a=s->length;
  4.     b=s->ac;
  5.     if(a==0){
  6.         printf("你还没有建表！\n");
  7.     }else{
  8.         if(b==-1){
  9.             printf("这是一个空表！\n");
  10.         }else{
  11.             printf("此链表长度为%d",1+b);
  12.         }
  13.     }
  14. }

判断表是否存在，是否为空，返回结构体中真实记录顺序长度的ac+1值，因为ac初值是从-1开始。

        11、接下来就来实现应用一个基本框架将这些基本功能串联起来，构成一个简单的顺序表小程序。基本框架如下：

  1. #include<stdio.h>
  2. #include<malloc.h>
  3. #include<stdlib.h> //引入函数库                           
  4.  
  5. typedef struct{
  6.     int *p;
  7.     int length;
  8.     int ac;
  9. }S,*pS;          //定义结构体                            
  10.  
  11. //声明各个功能函数
  12.  
  13. void main(){
  14.     int a=1,b;
  15.     S s;
  16.     s.length=0;
  17.     while(a){
  18.         system("cls");
  19.         printf("\n\n\t\t顺序表基本操作\n");
  20.         printf("\t\t...1-n.顺序表的各种功能操作;  \n");
  21.         printf("\t\t...0.退出;  \n");
  22.         printf("\n\n");
  23.         printf("\t\t请选择[0,9]: ");
  24.         scanf("%d",&b);
  25.         printf("\n\n");
  26.         switch(b){
  27.             case 1-n:调用各种功能函数     ;break;
  28.             case 0:  a=0                 ;break;
  29.         }
  30.         if(b!=0){
  31.             printf("请输入任意键继续：\n");
  32.             getche();
  33.         }
  34.     }
  35.     system("cls");
  36.     printf("\t\t程序结束\n");
  37.     exit(-1);
  38. }
  39.  
  40. //具体的各种功能函数

这基本框架就是一个基本表单。

二、结果展示部分：

小程序运行结果如下：

1. 程序开始运行界面

2. 申请存储空间，即创建顺序表。

3. 向顺序表中添加元素。

4. 展示顺序表中元素。

5. 向顺序表中再次添加元素。

6.展示再次添加元素后的顺序表内容。

7.在已有顺序表中插入元素。

8.展示已经插入元素后的顺序表。

 9. 修改指定位置的元素内容

10. 展示已经修改好的顺序表内容。

        在此仅仅展示这几个简单功能，剩余功能也能正常实现。目前发现的不足之处在于，每次实现某一功能前总是要写出先判断顺序表是否存在、是否为空的代码，这些代码显得很冗余，因此可以尝试将这些代码写入一个新函数，在实现某一功能先调用此函数即可。

以上是本人对顺序表的C语言代码初步实现，不喜勿喷，感谢理解。

相关链接：

【C语言】单链表的创建_lixxkv的博客-CSDN博客

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/427058
推荐阅读