快速把握C语言——数据结构【创建次序表】多文件编译 ...

打印 上一主题 下一主题

主题 1049|帖子 1049|积分 3147

 1.数据结构脑图(未完)


2.次序表其他操作 


 3.功能函数封装

 


 4 完整代码
1>头文件test.h

  1. #ifndef __TEST_H__
  2. #define __TEST_H__
  3. #include<stdlib.h>
  4. #include<stdio.h>
  5. #include<string.h>
  6. //宏定义 线性表的最大容量
  7. #define MAX 30
  8. //类型重定义 表示要存放的数据的类型
  9. //typedef  int  datatype;
  10. //定义顺序表的结构图类型
  11. typedef struct sequence
  12. {
  13.         int data[MAX];
  14.         int len;
  15. }seqlist,*seqlistPtr;
  16. //创建顺序表
  17. seqlistPtr seq_create();
  18. //判空
  19. int empty(seqlistPtr S);
  20. //判满
  21. int fill(seqlistPtr S);
  22. //尾部插入数据
  23. int seq_add(seqlistPtr S,int e);
  24. //遍历
  25. void show(seqlistPtr S);
  26. //任意位置插入1
  27. int insert(seqlistPtr S,int index,int value);
  28. //任意位置插入2
  29. int index_add(seqlistPtr S,int index,int e);
  30. //任意位置删除
  31. int index_del(seqlistPtr S,int index);
  32. //任意位置修改
  33. void index_change(seqlistPtr S,int index,int e);
  34. //按值查找
  35. int value_index(seqlistPtr S, int e);
  36. //去重
  37. void repeat(seqlistPtr S);
  38. //销毁
  39. void my_free(seqlistPtr *S);
  40. #endif
复制代码
2.>源文件test.c

  1. #include "test.h"
  2. //1.
  3. //    创建一个顺序表
  4. seqlistPtr seq_create()
  5. {//在堆区申请顺序表的大小空间,返回主程序使用
  6.         seqlistPtr S=(seqlistPtr)malloc(sizeof(seqlist));
  7. //判断申请空间是否合法
  8.         if (NULL==S)
  9.         {
  10.                 printf("创建失败\n");
  11.                 return NULL;
  12.         }
  13.         printf("创建成功\n");
  14. //顺序表长度置零
  15.         S->len=0;
  16. //数组清空
  17.         memset(S->data,0,sizeof(S->data));
  18.         return S;
  19. }
  20. //2
  21. //   判空
  22. int empty(seqlistPtr S)
  23. {
  24.         //判断接受的顺序表是否为空
  25.         if (NULL==S)
  26.         {
  27.                 printf("判空失败\n");
  28.                 return -1;
  29.         }
  30.         //判断顺序表长度是否为0
  31.         return S->len==0;
  32. }
  33. //3.
  34. //   判满
  35. int fill(seqlistPtr S)
  36. {
  37.         if (NULL==S)
  38.         {
  39.                 printf("判满失败\n");
  40.                 return -1;
  41.         }
  42. //判断顺序表的长度和顺序表长度最大容量是否相等
  43.         return S->len==MAX;
  44. }
  45. //4.
  46. //    顺序表的增加
  47. int seq_add(seqlistPtr S,int e)
  48. {
  49.         //判断接受的顺序表是否合法
  50.         //判满
  51.         if (NULL==S ||fill(S))
  52.         {
  53.                 printf("增加失败\n");
  54.                 return 0;
  55.         }
  56.         //放入数据
  57.         S->data[S->len]=e;
  58.         //增加成功  顺序表长度自增
  59.         S->len++;
  60.         return 1;
  61. }
  62. //5
  63. //   顺序表的遍历
  64. void show(seqlistPtr S)
  65. {
  66.         //判断接受的顺序表是否合法
  67.         //判空       
  68.         if (NULL==S ||empty(S))
  69.         {
  70.                 printf("遍历失败\n");
  71.                 return ;
  72.         }
  73.         for (int i=0;i<S->len;i++)
  74.         {
  75.                 printf("%d ",S->data [i]);
  76.         }
  77.         printf("\n");
  78. }
  79. //6
  80. //     在顺序表插入一个数
  81. int insert(seqlistPtr S,int index,int value)
  82. {
  83.         if (index <0||index>S->len||S->len>=MAX)
  84.         {
  85.                 printf("插入位置不合法\n");
  86.                 return 0;
  87.         }
  88.         for (int i=S->len;i>index;i--)
  89.         {
  90.                 S->data[i]=S->data[i-1];
  91.         }
  92.         S->data[index]=value;
  93.         S->len++;
  94.         return 1 ;
  95. }
  96. //7.
  97. //在顺序表插入一个数方法2
  98. int index_add(seqlistPtr S,int index,int e)
  99. {
  100.         if (NULL==S||fill(S)||index<=0||index>S->len+1)
  101.         {
  102.                 printf("插入失败\n");
  103.                 return 0;
  104.         }
  105.         //        插入位置对应下标
  106.         index= index-1;
  107.         for(int i=0;i<S->len-index;i++)
  108.         {
  109.                 S->data[S->len-i]=S->data[S->len-1-i];
  110.         }
  111.         S->data[index]=e;
  112.         S->len++;
  113.         return 1;
  114. }
  115. //8.
  116. //   任意位置删除
  117. int index_del(seqlistPtr S,int index)
  118. {
  119.         if (NULL==S||empty(S)||index<0||index>S->len)
  120.         {
  121.                 printf("删除失败\n");
  122.                 return 0;
  123.         }
  124.         //        index-=1;
  125.         for(int i= index;i<S->len;i++)
  126.         {
  127.                 S->data[i]=S->data[i+1];
  128.         }
  129.         S->len--;
  130.         return 1;
  131. }
  132. //9.
  133. //  通过位置修改
  134. void index_change(seqlistPtr S,int index,int e)
  135. {
  136.         if (NULL==S||empty(S)||index<0||index>S->len)
  137.         {
  138.                 printf("修改失败\n");
  139.                 return ;
  140.         }
  141.         //修改
  142.         //        S->data[index-1]=e;
  143.         S->data[index]=e;
  144. }
  145. //10
  146. //  根据值查找下标
  147. int value_index(seqlistPtr S, int e)
  148. {
  149.         if (NULL==S||empty(S))
  150.         {
  151.                 printf("查找失败");
  152.                 return -1;
  153.         }
  154.         for (int i=0;i<S->len;i++)
  155.         {
  156.                 if (S->data[i]==e)
  157.                 {
  158.                         printf("%d \n",i);
  159.                         return i;
  160.                 }
  161.         }
  162.         printf("查无此数");
  163.         return -1;
  164. }
  165. //11
  166. //    去除重复数据
  167. void repeat(seqlistPtr S)
  168. {
  169.         if (NULL==S||S->len<=1)
  170.         {        printf("去重失败");
  171.                 return;
  172.         }
  173.         for (int i=0;i<S->len;i++)
  174.         {
  175.                 for(int j=i+1;j<S->len;j++)
  176.                         if (S->data[i]==S->data[j])
  177.                         {
  178.                                 index_del (S,j);
  179.                                 j--;
  180.                         }
  181.         }
  182. }
  183. // 12
  184. //   释放内存
  185. void my_free(seqlistPtr *S)
  186. {
  187.         if(NULL==*S)
  188.         {
  189.                 printf("销毁失败");
  190.                 return ;
  191.         }
  192.         free (*S);
  193.         S=NULL ;
  194.         printf("销毁成功");
  195. }
复制代码
3>测试文件main.c

  1. #include "test.h"
  2. int main(int argc, const char *argv[])
  3. {
  4.         //创建顺序表
  5.    seqlistPtr S=seq_create();
  6. //顺序表的增加(尾插)
  7.    seq_add(S,10);
  8.    seq_add(S,20);
  9.    seq_add(S,30);
  10.    seq_add(S,40);
  11.    seq_add(S,50);
  12.    show(S);
  13. //任意位置插入数据1方法
  14.    insert(S,0,1);
  15.    insert(S,1,2);
  16.    insert(S,2,3);
  17.    show(S);
  18. //任意位置插入数据2方法
  19.    index_add(S,5,666);
  20.    show(S);
  21. //删除指定位置的数据
  22.         index_del(S,0);
  23.         show(S);
  24. //修改指定位置数据
  25.         index_change(S,0,99);
  26.         show(S);
  27. //按值查找   
  28.         value_index(S,666);
  29.         show(S);
  30. //按值查找并删除
  31.         index_del(S,value_index(S,666));
  32.         show(S);
  33. //尾部插入多个数据
  34.    seq_add(S,10);
  35.    seq_add(S,20);
  36.    seq_add(S,30);
  37.    seq_add(S,10);
  38.    seq_add(S,10);
  39.    seq_add(S,20);
  40.    seq_add(S,20);
  41.    seq_add(S,40);
  42.    seq_add(S,30);
  43.    seq_add(S,50);
  44.    show(S);
  45. //去重
  46.    repeat(S);
  47.    show(S);
  48.   
  49.         return 0;
  50. }
复制代码
后续→c语言——数据结构【链表:单向链表】-CSDN博客



免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览

快速回复

您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

傲渊山岳

论坛元老
这个人很懒什么都没写!
快速回复 返回顶部 返回列表