数据结构---顺序表实现(源码)

最新推荐文章于 2023-01-12 18:11:47 发布
最新推荐文章于 2023-01-12 18:11:47 发布
阅读量1.5k 收藏
点赞数 1
分类专栏： Data Structure 文章标签： 数据结构 存储 list date 出版 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sevenhu/article/details/3124625
版权

复习一下数据结构，希望以后每周能坚持发一章。

第一章   顺序表

  1. /*****************************SqList**********************************
  2. Date:2008.10.22
  3. Author:ZORO
  4. WebSite:http://blog.csdn.net/sevenhu
  6. ======================================================================
  8. 参考资料：
  9. BOOK:数据结构(C语言版)     严蔚敏     清华大学出版社
  10. Page:19
  12. ======================================================================
  13. ADT SqList  {
  14.     InitList(&L)
  15.     DestroyList(&L)
  16.     ListPush(&L,i)
  17.     ClearList(&L)
  18.     ListEmpty(L)
  19.     ListLength(L)
  20.     GetElem(L,i,&e)
  21.     LocateElem(L,e)
  22.     PriorElem(L,cur_e,&pre_e)
  23.     NextElem(L,cur_e,&next_e)
  24.     ListInsert(&L, i, e)
  25.     ListDelete(&L, i, e)
  26.     ListTraverse(L)
  27. }ADT SqList
  28. ======================================================================
  29. note:VC++ 6.0测试通过。
  30. *********************************************************************/
  33. #include <iostream>
  35. #define     OK                  1
  36. #define     FALSE               0
  37. #define     ERROR               0
  38. #define     OVERFLOW            -1
  39. #define     NULL                0
  42. #define     LIST_INIT_SIZE      100     //顺序表存储空间的初始分配量
  43. #define     LISTINCREMENT       10      //顺序表存储空间的分配增量
  46. using namespace std;
  47. typedef int Status;
  48. typedef bool BOOL;
  50. typedef struct SQ{
  51.     int * elem;
  52.     int length;                         //顺序表当前大小
  53.     int listsize;                       //顺序表容量
  54. } SqList;
  56. Status InitList(SqList &L)
  57. {
  58.     //构造表
  59.     L.elem = (int *)malloc(LIST_INIT_SIZE * sizeof(int));
  60.     
  61.     if (!L.elem)  {                     //空间分配失败
  62.         return OVERFLOW;
  63.     }
  64.     
  65.     L.length = 0;                       //初始化长度为0
  66.     L.listsize = LIST_INIT_SIZE;        //初始存储容量
  67.     return OK;
  68. } //InitList_Sq
  70. Status ListPush(SqList &L, int i)
  71. {
  72.     //增加元素
  73.     if (!L.elem)  {
  74.         return ERROR;                   //表不存在
  75.     }
  77.     if (L.length == L.listsize)  {      //空间不足，重新分配
  78.         L.elem = (int *)realloc(L.elem,sizeof(int) * (LISTINCREMENT + L.listsize));
  79.         if (!L.elem)  {
  80.             return OVERFLOW;            //分配失败
  81.         }
  82.         L.listsize += LISTINCREMENT;    //新空间容量
  83.     }
  85.     L.elem [L.length] = i;
  86.     ++L.length;
  88.     return OK;
  89. }
  92. Status ListInsert(SqList &L, int i, int e)
  93. {
  94.     //在顺序表L中第i个位置前插入元素e
  95.     if (!L.elem)  {
  96.         return ERROR;                   //表不存在
  97.     }
  98.     
  99.     if (i > L.length - 1 || i < 1)  {   //i值不合法
  100.         return ERROR;
  101.     }
  103.     if (L.length == L.listsize)  {
  104.         int * newbase;                  //空间不足，重新分配
  105.         newbase = (int *)realloc(L.elem,sizeof(int) * (LISTINCREMENT + L.listsize));
  106.         L.elem = newbase;
  108.         if (!L.elem)  {
  109.             return OVERFLOW;            //分配失败
  110.         }
  111.         L.listsize += LISTINCREMENT;    //新空间容量
  112.     }
  114.     int * q = &L.elem[i-1];             //标记插入位置
  116.     for (int * p = &L.elem[L.length-1]; p >= q; --p)  {
  117.         *(p+1) = *p;                    //插入位置及其后元素后移一位
  118.     }
  120.     *q = e;                             //插入e
  121.     ++L.length;                         //长度加1
  122.     q = p = NULL;
  123.     return OK;
  124. }//ListInsert
  126. Status ListDelete(SqList &L, int i, int &e)
  127. {
  128.     //在顺序表L中删除第i个值并用e返回这个值
  129.     if (!L.elem)  {
  130.         return ERROR;                   //表不存在
  131.     }
  132.     
  133.     if (i < 1 || i > L.length - 1)  {
  134.         return ERROR;                   //i值不合法
  135.     }
  137.     int *p = &L.elem[i-1];              //i位置的元素地址
  138.     e = *p;                             
  139.     int *q = L.elem + L.length - 1;     //L的最后一个元素地址
  140.     for (++p ; p <= q; ++p)  {
  141.         *(p-1) = *p;                    //把i位置后的元素向前移一位
  142.     }
  144.     --L.length;                         //L的长度减1
  146.     return OK;
  147. }//ListDelete
  149. Status DestroyList(SqList &L)
  150. {
  151.     //销毁L表
  152.     if (!L.elem)  {
  153.         return ERROR;                   //表不存在
  154.     }
  156.     free(L.elem);                       //释放内存
  157.     return OK;
  158. }//DestroyList
  160. Status ClearList(SqList &L)
  161. {
  162.     //清空表
  163.     if (!L.elem)  {
  164.         return ERROR;                   //表不存在
  165.     }
  167.     L.length = 0;                       //表长清零
  168.     return OK;
  169. }//ClearList
  171. BOOL ListEmpty(SqList L)
  172. {
  173.     //判断表是否为空
  174.     if (!L.elem)  {
  175.         return ERROR;                   //表不存在
  176.     }
  178.     if (L.length == 0)  {
  179.         return true;
  180.     }
  181.     
  182.     return false;
  183. }//ListEmpty
  185. int ListLength(SqList L)
  186. {
  187.     //表元素的个数
  188.     if (!L.elem)  {
  189.         return ERROR;                   //表不存在
  190.     }
  192.     return L.length;
  193. }//ListLength
  195. Status GetElem(SqList L, int i, int &e)
  196. {
  197.     //用e返回L表中第i个元素
  198.     if (!L.elem)  {
  199.         return ERROR;                   //表不存在
  200.     }
  202.     if (i < 1 || i > L.length - 1)  {
  203.         return ERROR;                   //i值不合法
  204.     }
  206.     int * q = L.elem ;
  207.     e = *(q + i -1);                    //把第i个元素给e
  208.     
  209.     return OK;
  210. }//GetElem
  213. int LocateElem(SqList L, int e)
  214. {
  215.     //返回与e相等的第一个元素的位置
  216.     if (!L.elem)  {
  217.         return ERROR;                   //表不存在
  218.     }
  220.     int i = 1;
  221.     int * p = L.elem ;
  222.     while (i < L.length && *p++ != e ) {//查找与e相等的值的位置
  223.         ++i;
  224.     }
  225.     
  226.     if (i <= L.length )  {
  227.         return i;
  228.     }
  230.     return 0;
  231. }
  233. Status PriorElem(SqList L, int cur_e, int & pre_e)
  234. {
  235.     //若cur_e是L的数据元素，且不是第一个，用pre_e返回它的前驱，否则操作失败，pre_e无定义
  236.     if (!L.elem)  {
  237.         return ERROR;                   //表不存在
  238.     }
  239.     int i = LocateElem(L,cur_e);
  240.     if (i == 1)  {
  241.         return FALSE;
  242.     }
  243.     else if(i == 0)  {
  244.         return FALSE;
  245.     }
  247.     pre_e = L.elem [i-2];               //前驱值给pre_e
  249.     return OK;
  250. }//PriorElem
  252. Status NextElem(SqList L, int cur_e, int & next_e)
  253. {
  254.     //若cur_e是L的数据元素，且不是最后一个，用next_e返回它的后继，否则操作失败，next_e无定义
  255.     if (!L.elem)  {
  256.         return ERROR;                   //表不存在
  257.     }
  258.     int i = LocateElem(L,cur_e);
  260.     if (i == L.length )  {
  261.         return FALSE;
  262.     }
  263.     else if (i == 0)  {
  264.         return FALSE;
  265.     }
  267.     next_e = L.elem [i];                //后继值给next_e
  269.     return OK;
  270. }//NextElem
  272. Status ListTraverse(SqList L)
  273. {
  274.     //遍历L表
  275.     if (!L.elem)  {
  276.         return ERROR;                   //表不存在
  277.     }
  279.     for (int i = 0 ; i < L.length ; ++i)  {
  280.         cout << L.elem[i] << " ";       //输出
  281.     }
  282.     cout << endl;
  284.     return OK;
  285. }//ListTraverse
  288. int main()
  289. {
  290.     SqList L;
  291.     if (InitList(L) == OK)  {
  292.         cout << "成功创建顺序表!" << endl;
  293.     }
  294.     else  {
  295.         cout << "创建顺序表失败!" << endl;
  296.         return FALSE;
  297.     }
  299.     for (int i = 0; i < 15; ++i)  {
  300.         if (ListPush(L,i) != OK)  {
  301.             cout << "录入数据失败!" << endl;
  302.             return FALSE;
  303.         }
  304.     }
  306.     cout << "成功录入数据!" << endl;
  309.     cout << "遍历顺序表!" << endl;
  310.     ListTraverse(L);
  312.     cout << "共" << ListLength(L) << "个元素" << endl;
  314.     cout << "清空顺序表!" << endl;
  315.     ClearList(L);
  317.     cout << "是否是空表?" << endl;   
  318.     cout << ListEmpty(L) << endl;
  320.     for (i = 15; i > 0; --i)  {
  321.         if (ListPush(L,i) != OK)  {
  322.             cout << "录入数据失败!" << endl;
  323.             return FALSE;
  324.         }
  325.     }
  327.     cout << "成功录入数据!" << endl;
  328.     cout << "遍历顺序表!" << endl;
  329.     ListTraverse(L);
  331.     int e;
  332.     GetElem(L,6,e);
  334.     cout << "第6个元素的值:"<< e << endl; 
  336.     PriorElem(L,7,e);
  337.     cout << "元素7的前驱元素:" << e << endl;
  339.     NextElem(L,7,e);
  340.     cout << "元素7的后继元素:" << e << endl;
  342.     cout << "在第4个位置插入元素100" << endl;
  343.     ListInsert(L,4,100);
  344.     ListTraverse(L);
  346.     cout << "删除第6个位置的元素" << endl;
  347.     ListDelete(L,6,e);
  348.     cout << "删除的元素为:" << e << endl;
  349.     ListTraverse(L);
  351.     cout << "元素4的位置是" << LocateElem(L,4) << endl;
  352.     
  353.     if (DestroyList(L)  == OK)  {
  354.         cout << "成功销毁顺序表!" << endl;
  355.         return 0;
  356.     }
  357.     else
  358.     {
  359.         cout << "销毁顺序表失败!" << endl;
  360.         return FALSE;
  361.     }
  362. }

sevenhu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
顺序表源码
09-26
顺序表源码顺序表源码顺序表源码顺序表源码顺序表源码
顺序表的源码
12-07
顺序表的源码，已测试，可以直接在VC++6.0中用
顺序表实现的源码
weixin_34007020的博客
02-20 197
2019独角兽企业重金招聘Python工程师标准>>> ...
【数据结构之顺序表】附源码【收藏】
哆啦A梦_PJYA的博客
10-29 1469
文章目录????引言1️⃣静态顺序表静态 VS 动态2️⃣动态顺序表????实现接口目录????初始化????打印数据????空间销毁????尾部插入????尾部删除????头部插入????头部删除????任意位置插入????任意位置删除????查找数据????查找某数据并插入数据????查找某数据并将其删除????头部插入（调用任意位置插入接口实现）????尾部插入 （调用任意位置插入接口实现）????头部删除（调用任意位置删除接口实现）????尾部删除（调用任意位置删除接口实现）????自动扩容????
C语言顺序表（源码）
m0_65190367的博客
08-09 480
C语言顺序表（源码）动态和静态
数据结构-顺序表结构的实现C语言（全代码）
m0_58441715的博客
01-10 6113
这是数据结构和算法设计课程设计一个选题。实践了顺序表的基本操作的封装，及实践中的调用。特别的对顺序表上的插入和删除操作做出详细的介绍。课设采用静态存储，按值查找。希望能够对其他同学有所帮助
数据结构-顺序表-C语言实现顺序表相关功能-数据结构学习
05-22
C语言实现的数据结构中的顺序表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习 对顺序表边界操作的判定 实现了以下功能： 创建顺序表 向顺序表中插入元素(尾插法，...
数据结构试验1-链表和顺序表
03-08
数据结构链表和顺序表实验源码，没有实验报告，需要下载。
数据结构-C语言实现单链表-数据结构学习
最新发布
05-26
C语言实现的数据结构中的单链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对链表边界的判定 实现了以下功能： 创建单链表 向顺序表中插入元素(头插法，尾插...
线性表顺序表-源码.cpp
05-09
文章：https://blog.csdn.net/2201_75425839/article/details/138611613?spm=1001.2014.3001.5501 的源码。 有需要的自取。
数据结构 顺序表 源码
10-14
本人正在学习中，小小的坐笔记，自己起后备用的哈哈，其实不完整 ，只是小小的实现下功能，认识下顺序表的结构
数据结构顺序表源码，能直接运行，供参考
11-16
本程序是数据结构顺序表的相关源码，能够直接在VC上运行，帮助那些面对一堆伪代码，比从入手的数据结构初学者
顺序表代码
10-24
顺序表的创建，插入，修改，查找以及删除。
严蔚敏《数据结构》源码 顺序表——二叉树
06-08
目前写在了图，之后的内容会在github上持续更新，数据结构系列更新完之后，可能会更新算法的教程（参考屈婉玲版《算法设计与分析》）希望可以帮到各位！！ InitList.cpp------顺序表 LinkList.cpp------链表 ...
顺序表的建立（源码）
qq_50679120的博客
04-02 480
#include<algorithm> #include<iostream> #include<cmath> #include<cstdlib> #include<cstring> #include<cstdio> #define MaxSize 100 using namespace std; typedef struct{ int data[MaxSize]; int length; }SqList; //.
顺序表堆栈的操作实现源码
Rob-Code
05-12 1027
//堆栈的实现，顺序表的实现 //编写一个C源程序，其中包含顺序表示的空栈的创建、判断栈是否为空、进栈、出栈、取栈顶元素等操作 #include #include #define MaxSize 20  using namespace std; typedef int DataType; typedef struct {      int stack[MaxSize]; in
顺序表实现代码
weixin_34126557的博客
03-12 1231
#include<iostream>using namespace std; typedef int ElemType; const int N = 80; struct SqList { ElemType *elem; int length; void Init(); void Clear(); ...
『初阶数据结构 • C语言』⑦ - 静态顺序表详解（附完整源码）
花想云的博客
01-12 1435
线性表（linear list）是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串...线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。
顺序表与链表源码之数据结构
peien3382的专栏
04-14 493
顺序表 #include #include #define elemtype int #define list_size 100 #define listcrecent 10 typedef  struct {  elemtype *base;  int length;  int listsize; }list; //初始化 int  inist (list *L)
redis数据结构跳表
07-27
跳表（Skip List）是一种有序数据结构，它允许快速地查找、插入和删除...总结一下，Redis 中的跳表数据结构是一种高效的有序集合实现方式，它通过增加多层索引来提高查找效率，适用于需要快速查找和有序遍历的场景。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值