devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

数据结构 | 顺序线性表_l->curnum-1

作者：你好赵伟 | 2024-05-14 20:34:10

赞

踩

l->curnum-1

一、数据结构定义

  1. typedef int SqlTableType;
  2.  
  3. typedef struct seqTable{
  4.     int MAXNUM;     // 最大元素个数   
  5.     int curNum;     // 元素的个数
  6.     SqlTableType* element;  // 连续空间的起始地址  
  7. }*SqlTable;

二、方法概览

  1. SqlTable CreateSqlTable(int max);   // 创建空顺序表
  2. int IsSqlListFull(SqlTable L);      // 判断顺序线性表是否已满
  3. int InsertSqlTable_P(SqlTable L, int p, SqlTableType x);     // 在下标p插入元素x
  4. int InsertSqlTable_Pre(SqlTable L, int p, SqlTableType x);   // 在下标p的前面插入元素x
  5. int InsertSqlTable_Post(SqlTable L, int p, SqlTableType x);  // 在下标p的后面插入元素x
  6. int FindElement(SqlTable L, SqlTableType x);        // 查找元素x首次出现的位置
  7. SqlTableType FindPostion(SqlTable L, int pos);      // 查找位置pos处的元素
  8. int DeletePostion(SqlTable L, int pos);             // 删除下标pos处的元素
  9. int DeleteElement(SqlTable L, SqlTableType x);      // 删除x值相同的数据元素
  10. int DestroySqlTable(SqlTable L);                    // 销毁线性表
  11. void PrintSqlTable(SqlTable L);     // 打印线性表

三、方法详解

  1. // 创建空顺序表，能存放的最大元素个数为max
  2. SqlTable CreateSqlTable(int max){
  3.     SqlTable L = (SqlTable)malloc(sizeof(struct seqTable));
  4.     if (L != NULL) {
  5.         L->element = (SqlTableType*)malloc(sizeof(SqlTableType) * max);
  6.         if (L->element) {
  7.             L->MAXNUM = max;
  8.             L->curNum = 0;
  9.             return L;
  10.         }
  11.         else free(L);
  12.     }
  13.     return NULL;
  14. }
  15.  
  16. // 判断顺序线性表是否已满
  17. // 若已满，返回值为1，否则返回值为0
  18. int IsSqlListFull(SqlTable L){
  19.     return (L->curNum == L->MAXNUM);
  20. }
  21.  
  22. // 在下标p插入元素x
  23. // 若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
  24. int InsertSqlTable_P(SqlTable L, int p, SqlTableType x){
  25.     if (L->curNum >= L->MAXNUM) {
  26.         printf("线性表已满");
  27.         return 0;
  28.     }
  29.     if (p < 0) {
  30.         printf("插入位置非法");
  31.         return 0;
  32.     }
  33.     L->element[p] = x;
  34.     L->curNum = L->curNum + 1;
  35.     return 1;
  36. }
  37.  
  38. // 在下标p的前面插入元素x
  39. // 若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
  40. int InsertSqlTable_Pre(SqlTable L, int p, SqlTableType x){
  41.     if (L->curNum >= L->MAXNUM) {
  42.         printf("线性表已满");
  43.         return 0;
  44.     }
  45.     if (p <= 0 || p > L->curNum) {
  46.         printf("插入位置非法");
  47.         return 0;
  48.     }
  49.     for (int i = L->curNum - 1; i >= p - 1; i--)
  50.         L->element[i + 1] = L->element[i];
  51.     L->element[p - 1] = x;
  52.     L->curNum = L->curNum + 1;
  53.     return 1;
  54. }
  55.  
  56. // 在下标p的后面插入元素x
  57. // 若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
  58. int InsertSqlTable_Post(SqlTable L, int p, SqlTableType x) {
  59.     if (L->curNum >= L->MAXNUM) {
  60.         printf("线性表已满");
  61.         return 0;
  62.     }
  63.     if (p < 0 || p >= L->curNum) {
  64.         printf("插入位置非法");
  65.         return 0;
  66.     }
  67.     for (int i = L->curNum - 1; i >= p + 1; i--)
  68.         L->element[i + 1] = L->element[i];
  69.     L->element[p + 1] = x;
  70.     L->curNum = L->curNum + 1;
  71.     return 1;
  72. }
  73.  
  74. // 打印线性表
  75. void PrintSqlTable(SqlTable L) {
  76.     for (int i = 0; i < L->curNum; i++)
  77.         printf("%d ", L->element[i]);
  78.     printf("\n");
  79. }
  80.  
  81. // 查找元素x首次出现的位置
  82. // 若待销毁的线性表不存在，则返回0
  83. int FindElement(SqlTable L, SqlTableType x){
  84.     for (int i = 0; i < L->curNum; i++) {
  85.         if (L->element[i] == x) return i;
  86.     }
  87.     return -1;
  88. }
  89.  
  90. // 查找位置pos处的元素
  91. // 若不存在给定值，则返回-1
  92. SqlTableType FindPostion(SqlTable L, int pos){
  93.     if (pos<0 || pos>L->curNum) return L->element[0];
  94.     else return L->element[pos];
  95. }
  96.  
  97. // 删除下标pos处的元素
  98. // 若pos非法，则返回-1；否则返回1
  99. int DeletePostion(SqlTable L, int pos) {
  100.     if (pos<0 || pos > L->curNum - 1) return -1;
  101.     for (int i = pos; i < L->curNum - 1; i++)
  102.         L->element[i] = L->element[i + 1];
  103.     L->curNum = L->curNum - 1;
  104.     return 1;
  105. }
  106.  
  107. // 删除x值相同的数据元素
  108. // 返回删除数据元素的个数
  109. int DeleteElement(SqlTable L, SqlTableType x){
  110.     int num = 0;
  111.     for (int i = 0; i < L->curNum; i++){
  112.         if (L->element[i] == x){
  113.             DeletePostion(L, i);
  114.             num++;
  115.         }
  116.     }
  117.     return num;
  118. }
  119.  
  120. // 销毁线性表
  121. // 返回销毁线性表元素的个数
  122. int DestroySqlTable(SqlTable L) {
  123.     int num = L->curNum;
  124.     free(L->element);
  125.     free(L);
  126.     return num;
  127. }

四、运行结果

        main方法代码如下：

  1. int main() {
  2.     int max = 10;
  3.     SqlTable table = CreateSqlTable(max);
  4.     for (int i = 0; i < max; i++) {
  5.         InsertSqlTable_P(table, i, i + 1);
  6.     }
  7.     PrintSqlTable(table);
  8.  
  9.     DeleteElement(table, 3);
  10.     PrintSqlTable(table);
  11.  
  12.     DeletePostion(table, 3);
  13.     PrintSqlTable(table);
  14.  
  15.     DestroySqlTable(table);
  16. }

       运行结果如下：

  五、源代码

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4.  
  5. typedef int SqlTableType;
  6.  
  7. typedef struct seqTable{
  8.     int MAXNUM;     // 最大元素个数   
  9.     int curNum;     // 元素的个数
  10.     SqlTableType* element;  // 连续空间的起始地址  
  11. }*SqlTable;
  12.  
  13. SqlTable CreateSqlTable(int max);   // 创建空顺序表
  14. int IsSqlListFull(SqlTable L);      // 判断顺序线性表是否已满
  15. int InsertSqlTable_P(SqlTable L, int p, SqlTableType x);     // 在下标p插入元素x
  16. int InsertSqlTable_Pre(SqlTable L, int p, SqlTableType x);   // 在下标p的前面插入元素x
  17. int InsertSqlTable_Post(SqlTable L, int p, SqlTableType x);  // 在下标p的后面插入元素x
  18. int FindElement(SqlTable L, SqlTableType x);        // 查找元素x首次出现的位置
  19. SqlTableType FindPostion(SqlTable L, int pos);      // 查找位置pos处的元素
  20. int DeletePostion(SqlTable L, int pos);             // 删除下标pos处的元素
  21. int DeleteElement(SqlTable L, SqlTableType x);      // 删除x值相同的数据元素
  22. int DestroySqlTable(SqlTable L);                    // 销毁线性表
  23. void PrintSqlTable(SqlTable L);     // 打印线性表
  24.  
  25.  
  26. // 创建空顺序表，能存放的最大元素个数为max
  27. SqlTable CreateSqlTable(int max){
  28.     SqlTable L = (SqlTable)malloc(sizeof(struct seqTable));
  29.     if (L != NULL) {
  30.         L->element = (SqlTableType*)malloc(sizeof(SqlTableType) * max);
  31.         if (L->element) {
  32.             L->MAXNUM = max;
  33.             L->curNum = 0;
  34.             return L;
  35.         }
  36.         else free(L);
  37.     }
  38.     return NULL;
  39. }
  40.  
  41. // 判断顺序线性表是否已满
  42. // 若已满，返回值为1，否则返回值为0
  43. int IsSqlListFull(SqlTable L){
  44.     return (L->curNum == L->MAXNUM);
  45. }
  46.  
  47. // 在下标p插入元素x
  48. // 若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
  49. int InsertSqlTable_P(SqlTable L, int p, SqlTableType x){
  50.     if (L->curNum >= L->MAXNUM) {
  51.         printf("线性表已满");
  52.         return 0;
  53.     }
  54.     if (p < 0) {
  55.         printf("插入位置非法");
  56.         return 0;
  57.     }
  58.     L->element[p] = x;
  59.     L->curNum = L->curNum + 1;
  60.     return 1;
  61. }
  62.  
  63. // 在下标p的前面插入元素x
  64. // 若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
  65. int InsertSqlTable_Pre(SqlTable L, int p, SqlTableType x){
  66.     if (L->curNum >= L->MAXNUM) {
  67.         printf("线性表已满");
  68.         return 0;
  69.     }
  70.     if (p <= 0 || p > L->curNum) {
  71.         printf("插入位置非法");
  72.         return 0;
  73.     }
  74.     for (int i = L->curNum - 1; i >= p - 1; i--)
  75.         L->element[i + 1] = L->element[i];
  76.     L->element[p - 1] = x;
  77.     L->curNum = L->curNum + 1;
  78.     return 1;
  79. }
  80.  
  81. // 在下标p的后面插入元素x
  82. // 若下标p非法或线性表已满无法插入数据，返回0；插入成功返回值为1
  83. int InsertSqlTable_Post(SqlTable L, int p, SqlTableType x) {
  84.     if (L->curNum >= L->MAXNUM) {
  85.         printf("线性表已满");
  86.         return 0;
  87.     }
  88.     if (p < 0 || p >= L->curNum) {
  89.         printf("插入位置非法");
  90.         return 0;
  91.     }
  92.     for (int i = L->curNum - 1; i >= p + 1; i--)
  93.         L->element[i + 1] = L->element[i];
  94.     L->element[p + 1] = x;
  95.     L->curNum = L->curNum + 1;
  96.     return 1;
  97. }
  98.  
  99. // 打印线性表
  100. void PrintSqlTable(SqlTable L) {
  101.     for (int i = 0; i < L->curNum; i++)
  102.         printf("%d ", L->element[i]);
  103.     printf("\n");
  104. }
  105.  
  106. // 查找元素x首次出现的位置
  107. // 若待销毁的线性表不存在，则返回0
  108. int FindElement(SqlTable L, SqlTableType x){
  109.     for (int i = 0; i < L->curNum; i++) {
  110.         if (L->element[i] == x) return i;
  111.     }
  112.     return -1;
  113. }
  114.  
  115. // 查找位置pos处的元素
  116. // 若不存在给定值，则返回-1
  117. SqlTableType FindPostion(SqlTable L, int pos){
  118.     if (pos<0 || pos>L->curNum) return L->element[0];
  119.     else return L->element[pos];
  120. }
  121.  
  122. // 删除下标pos处的元素
  123. // 若pos非法，则返回-1；否则返回1
  124. int DeletePostion(SqlTable L, int pos) {
  125.     if (pos<0 || pos > L->curNum - 1) return -1;
  126.     for (int i = pos; i < L->curNum - 1; i++)
  127.         L->element[i] = L->element[i + 1];
  128.     L->curNum = L->curNum - 1;
  129.     return 1;
  130. }
  131.  
  132. // 删除x值相同的数据元素
  133. // 返回删除数据元素的个数
  134. int DeleteElement(SqlTable L, SqlTableType x){
  135.     int num = 0;
  136.     for (int i = 0; i < L->curNum; i++){
  137.         if (L->element[i] == x){
  138.             DeletePostion(L, i);
  139.             num++;
  140.         }
  141.     }
  142.     return num;
  143. }
  144.  
  145. // 销毁线性表
  146. // 返回销毁线性表元素的个数
  147. int DestroySqlTable(SqlTable L) {
  148.     int num = L->curNum;
  149.     free(L->element);
  150.     free(L);
  151.     return num;
  152. }
  153.  
  154.  
  155. int main() {
  156.     int max = 10;
  157.     SqlTable table = CreateSqlTable(max);
  158.     for (int i = 0; i < max; i++) {
  159.         InsertSqlTable_P(table, i, i + 1);
  160.     }
  161.     PrintSqlTable(table);
  162.  
  163.     DeleteElement(table, 3);
  164.     PrintSqlTable(table);
  165.  
  166.     DeletePostion(table, 3);
  167.     PrintSqlTable(table);
  168.  
  169.     DestroySqlTable(table);
  170. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/570002
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号