精华内容
下载资源
问答
  • 顺序表的基本操作代码实现

    千次阅读 2021-02-05 19:34:56
    顺序表顺序表是在计算机内存中以数组形式保存线性表,是指用一组地址连续存储单元依次存储数据元素线性结构。即线性表采用顺序存储方式存储就称之为顺序表。 下面直接上代码: //SeqList.h #include&...

    顺序表:顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。即线性表采用顺序存储的方式存储就称之为顺序表。

    下面直接上代码:

    
     //SeqList.h
    
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<assert.h>
    
    typedef int SLdatatype;
    
    typedef struct SeqList
    {
    	SLdatatype *a;//存储数据空间的指针
    	int capacity;//容量空间大小
    	int size;//有效数据个数
    }SeqList;
    
    void SeqListInit(SeqList *psl);//初始化
    void SeqListDestroy(SeqList *psl);//删除
    void SeqListPrint(SeqList *psl);//输出
    void SeqListPushBack(SeqList *psl, SLdatatype x);//尾插
    void SeqListPushFront(SeqList *psl, SLdatatype x);//头插
    void SeqListPopBack(SeqList *psl);//尾删
    void SeqListPopFront(SeqList *psl);//头删
    void SeqListInsert(SeqList *psl, int pos, SLdatatype x);//按位置插入元素
    void SeListErase(SeqList *psl, int pos);//按位置删除元素
    
    
     //SeqList.c
    
    #include"SeqList.h"
    
    void SeqListInit(SeqList *psl)
    {
    	psl->a = (SLdatatype*)malloc(sizeof(SLdatatype)*4);
    	if (psl->a == 0){
    		printf("malloc fail\n");
    		exit(-1);
    	}
    	memset(psl->a, 0, sizeof(SLdatatype) * 4);
    	psl->size = 0;
    	psl->capacity = 4;
    }
    
    void SeqListDestroy(SeqList *psl)
    {
    	free(psl->a);
    	psl->a = NULL;
    	psl->capacity = psl->size = 0;
    }
    
    void SeqListPrint(SeqList *psl)
    {
    	for (int i = 0; i < psl->size; i++){
    		printf("%d ", psl->a[i]);
    	}
    	printf("\n");
    }
    
    void CheckCapacity(SeqList* psl)
    {
    	if (psl->size == psl->capacity){
    		SLdatatype *b = (SLdatatype*)realloc(psl->a, sizeof(SLdatatype)*psl->capacity * 2);
    		if(b == NULL){
    			printf("malloc fail\n");
    			exit(-1);
    		}
    		psl->a = b;
    		psl->capacity = psl->capacity * 2;
    	}
    }
    
    void SeqListPushBack(SeqList *psl, SLdatatype x)
    {
    	    assert(psl);
    		CheckCapacity(psl);
            psl->a[psl->size] = x;
    	    psl->size++;
    
    }
    
    void SeqListPushFront(SeqList *psl, SLdatatype x)
    {
    	assert(psl);
    	CheckCapacity(psl);
    	for (int i = psl->size; i >0; i--){
    		psl->a[i] = psl->a[i - 1];
    	}
    	psl->a[0] = x;
    	psl->size++;
    }
    
    void SeqListPopBack(SeqList *psl)
    {
    	assert(psl);
    	assert(psl->size > 0);
    	psl->size--;
    }
    
    void SeqListPopFront(SeqList *psl)
    {
    	assert(psl);
    	assert(psl->size > 0);
    	for (int i = 0; i < psl->size; i++){
    		psl->a[i] = psl->a[i + 1];
    	}
    	psl->size--;
    }
    
    void SeqListInsert(SeqList *psl, int pos, SLdatatype x)
    {
    	assert(psl);
    	assert(pos >= 0 && pos <= psl->size);
    	CheckCapacity(psl);
    	int i;
    	for (i = psl->size; i>=pos; i--){
    		psl->a[i] = psl->a[i - 1];
    	}
    	psl->a[pos] = x;
    	psl->size++;
    }
    
    void SeListErase(SeqList *psl, int pos)
    {
    	assert(psl);
    	assert(pos >= 0 && pos <= psl->size);
    	for (int i = pos+1; i < psl->size; i++){
    		psl->a[i - 1] = psl->a[i];
    	}
    	psl->size--;
    }
    
    
     //test.c
    
    #include"SeqList.h"
    
    int main()
    {
    	SeqList s1;
    	SeqListInit(&s1);
    	SeqListPushBack(&s1, 1);
    	SeqListPushBack(&s1, 2);
    	SeqListPushBack(&s1, 3);
    	SeqListPushBack(&s1, 4);
    	SeqListPushBack(&s1, 5);
    	SeqListPrint(&s1);
    	SeqListPushFront(&s1, 0);
    	SeqListPrint(&s1);
    	SeqListPopBack(&s1);
    	SeqListPrint(&s1);
    	SeqListPopFront(&s1);
    	SeqListPrint(&s1);
    	SeqListInsert(&s1,2,10);
    	SeqListPrint(&s1);
    	SeListErase(&s1,2);
    	SeqListPrint(&s1);
    }
    
    展开全文
  • 一个数据结构的基本操作是指其最核心,最基本的操作。其他较复杂的操作可t通过调用其基本操作来实现。首先我们来了解一下线性表的基本操作:1.InitList(&L):初始化。构造一个空的线性表。2.Length(L):求长,...

    一个数据结构的基本操作是指其最核心,最基本的操作。其他较复杂的操作可t通过调用其基本操作来实现。首先我们来了解一下线性表的基本操作:

    1.InitList(&L):初始化表。构造一个空的线性表。

    2.Length(L):求表长,返回线性表的长度。

    3.LocateElement(L,e):按值查找。查找e在L中的位置。

    4.GetElement(L,i):按位置查找。返回下标为i的元素。

    5.ListInsert(&L,i,e):插入操作。在表中I位置插入元素e。

    6.ListDElete(&L,i,&e):删除操作。删除i位置的元素,并用e返回删除的值。

    7.PringList(L):输出操作。

    8.Empty(L):判空操作。判断线性表是否为空。

    9.DestroyLIst(&L):销毁操作。销毁线性表,并释放线性表L的所有元素值。

    69d04e1c19be66e96ff6e98eff182cd9.png

    注:

    1.具体的实现取决于采用哪种存储结构,存出结构也不同,算法的实现也不同。

    2.&表示C++中的引用。若传入的变量是指针型变量,且在函数体内要对传入的指针进行改变,则会用到指针变量的引用型。

    3.后边我会用C++来实现一下关于顺序表的几种基本操作,

    欢迎关注,留言,讨论,指正,共同学习呀。

    展开全文
  • 要想灵活使用数据结构,你需要先弄清楚数据在代码中被处理、加工的最小单位动作,也就是数据结构的基本操作,有了这些动作之后,你就可以基于此去选择更合适的数据结构了。1. 举个栗子:代码对数据处理例1:查找出一...
    b99b2656b62e7864a3f0319b8e69af0a.png点击上面“蓝字”关注我们  2c4d9fd761300e1173cd3b2d73fc6aea.png

    上一篇文章中,我们学习了 时空转换 的思想,而它的核心就是选择合适的数据结构,将时间复杂度向空间复杂度转换。那么该 如何选择合适的数据结构 呢?

    要想灵活使用数据结构,你需要先弄清楚数据在代码中被处理、加工的最小单位动作,也就是数据结构的 基本操作,有了这些动作之后,你就可以基于此去选择更合适的数据结构了。

    37a17b745de5c619c1ca703da051aaae.gif


    1. 举个栗子:代码对数据处理

    例1:查找出一个数组中,出现次数最多的那个元素的数值。例如,输入数组 a = [1,6,3,5,5,5,6 ] 中,查找出现次数最多的数值。

    这个例子我们在上一篇中已经分析过。使用 字典 的数据结构能使时间复杂度降低到O(n),那究竟是什么让我们选择字典呢?下面仔细来聊一聊。

    我们先看一下这个任务需要对数据进行哪些操作。我们在解这个题时,核心思路应该是:

    第一步,根据原始数组计算每个元素出现的次数;

    第二步,根据第一步的结果,找到出现次数最多的元素。

    (1)对于上面的第一步,可以提取出的基本数据操作有:

    查找:看能否在数据结构中查找到这个元素,也就是判断元素是否出现过。

    新增:针对没有出现过的情况,新增这个元素。

    改动:针对出现过的情况,需要对这个元素出现的次数加 1。

    (2)对于上面的第二步,可以提取出的基本数据操作有:

    查找:访问数据结构中的每个元素,找到次数最多的元素。

    由此可见,本任务会 重复使用到查找。而能在 O(1) 的时间复杂度内完成查找动作的数据结构,只有字典类型。因此选择字典结构可能会比其他数据结构效率更高,事实也是如此。

    注:此题解法可参考:【算法与数据结构 02】选择合适的数据结构——将昂贵的“时间”转换为廉价的“空间”

    2. 数据处理的基本操作

    设计合理的数据结构,要从问题本身出发,我们可以采用这样的思考顺序

    (1) 分析这段代码到底对数据先后进行了哪些操作。

    (2) 根据分析出来的数据操作,找到合理的数据结构。

    这样我们就把数据处理的基本操作梳理了出来。今后,即使你遇到更复杂的问题,无非就是这些 基本操作的叠加和组合。只要按照上述的逻辑进行思考,就可以 轻松设计出合理的数据结构!

    数据处理的操作就是找到需要处理的数据,计算结果,再把结果保存下来。这个过程总结为以下操作:

    (1) 找到要处理的数据。这就是按照某些条件进行查找。

    (2) 把结果存到一个新的内存空间中。这就是在现有数据上进行新增。

    (3) 把结果存到一个已使用的内存空间中。这需要先删除内存空间中的已有数据,再新增新的数据。

    3. 方法论

    经过对问题的拆解,你会发现即便是很复杂的代码,它对数据的处理也只有这 3 个基本操作,增、删、查。只要围绕这 3 个数据处理的操作进行分析,就能选择出合适的方案。总结下来,我们在思考代码优化时,可以从以下三个问题入手:

    (1) 这段代码对数据进行了哪些操作?

    (2) 这些操作中,哪个操作最影响效率,对时间复杂度的损耗最大?

    (3) 哪种数据结构最能帮助你提高数据操作的使用效率?

    对于前面两个问题,围绕数据处理的基本操作,这可以通过 刷题 加深我们的理解。对于第3个问题,就需要我们去掌握相应的数据结构 基础知识,这个我在后面也会逐渐整理出来。

    创作不易,点个在看再走吧 e7a1d8a28c102ad54ff3f8db5b5c6f3d.png
    展开全文
  • 顺序表操作基本代码

    2017-12-22 09:43:15
    顺序表操作基本代码。帮助顺序表的学习和代码的编写等。
  • 顺序表基本操作代码实现 初始化 静态分配方式 #include <stdio.h> #define MaxSize 10 //定义最大长度 typedef struct{ int data[MaxSize]; //存放数据元素 int length; //当前长度 }SqList; //顺序表...

    顺序表基本操作的代码实现

    初始化

    静态分配方式
    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    /**
    * 初始化函数 
    *
    * @param L 顺序表指针 
    */
    void InitList(SqList &L){
    	for(int i=0; i<MaxSize; i++)
    		L.data[i]=0; //初始化为0 
    	L.length=0; //初始长度为0 
    }
    
    
    int main(){
    	SqList L;
    	InitList(L);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    	
    	printf("length=%d", L.length);
    	
    	return 0;
    }
    

    输出

    0 0 0 0 0 0 0 0 0 0 length=0
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    
    动态分配方式
    #include <stdio.h>
    #include <stdlib.h>
    #define InitSize 10 //默认最大长度
    
    typedef struct{
    	int *data;	//指示动态分配数组的指针 
    	int MaxSize; //最大容量 
    	int length; //顺序表的当前长度 
    }SeqList; 
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针 
    */
    void InitList(SeqList &L){
    	//用 malloc 函数申请一片连续的存储空间 
    	L.data=(int *)malloc(InitSize*sizeof(int));
    	L.length=0;
    	L.MaxSize=InitSize;
    	
    	for(int i=0; i<InitSize; i++)
    		L.data[i]=0; //初始化为0 
    }
    
    /**
    * 动态增加数组长度 
    *
    * @param L 顺序表指针 
    * @param len 增加的长度
    */
    void IncreaseSize(SeqList &L, int len){
    	int *p=L.data;
    	L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));
    	
    	for(int i=0; i<L.length; i++){
    		L.data[i]=p[i];	//将数据复制到新区域 
    	}
    	
    	L.MaxSize=L.MaxSize+len; //扩大长度 
    	free(p); //释放原来的内存空间 
    } 
    
    int main(){
    	SeqList L;
    	InitList(L);
    	
    	for(int i=0; i<L.MaxSize; i++)
    		printf("%d ", L.data[i]);
    	printf("\n原来size=%d", L.MaxSize);
    	
    	IncreaseSize(L, 5);
    	printf("\n当前size=%d\n", L.MaxSize);
    	
    	return 0;
    }
    
    

    输出

    0 0 0 0 0 0 0 0 0 0
    原来size=10
    当前size=15
    
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    

    插入

    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素后移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    操作小记

    代码

    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针
    */
    void InitList(SqList &L){
    	for(int i=0; i<MaxSize; i++)
    		L.data[i]=0; //初始化为0 
    	L.length=0; //初始长度为0 
    }
    
    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素后移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    int main(){
    	SqList L;
    	InitList(L);
    	
    	ListInsert(L, 1, 3);
    	ListInsert(L, 1, 2);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    	
    	return 0;
    }
    
    

    效果:

    2 3 0 0 0 0 0 0 0 0
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    

    删除

    /**
    * 删除
    *
    * @param L 顺序表指针
    * @param i 输出的位置,即位序i 
    * @param e 删除的值 
    * @return 是否插入成功 
    */
    bool ListDelete(SqList &L, int i, int &e){
    	if(i<1 || i>L.length)
    		return false;
    		
    	e=L.data[i-1]; //将被删除的元素赋值给e 
    	
    	for(int j=i; j<L.length; j++) //将第i个位置后的元素前移 
    		L.data[j-1]=L.data[j];
    	L.length--;  //线性表长度减1 
    	
    	return true;
    }
    
    操作小记

    代码

    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针
    */
    void InitList(SqList &L){
    	for(int i=0; i<MaxSize; i++)
    		L.data[i]=0; //初始化为0 
    	L.length=0; //初始长度为0 
    }
    
    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素前移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    /**
    * 删除
    *
    * @param L 顺序表指针
    * @param i 输出的位置,即位序i 
    * @param e 删除的值 
    * @return 是否插入成功 
    */
    bool ListDelete(SqList &L, int i, int &e){
    	if(i<1 || i>L.length)
    		return false;
    		
    	e=L.data[i-1]; //将被删除的元素赋值给e 
    	
    	for(int j=i; j<L.length; j++) //将第i个位置后的元素前移 
    		L.data[j-1]=L.data[j];
    	L.length--;  //线性表长度减1 
    	
    	return true;
    }
    
    int main(){
    	SqList L;
    	InitList(L);
    	
    	ListInsert(L, 1, 3);
    	ListInsert(L, 1, 2);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    	
    	int e=-1;
    	ListDelete(L, 1, e);
    	printf("\nres=%d\n", e);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    	
    	return 0;
    }
    
    

    效果

    2 3 0 0 0 0 0 0 0 0
    res=2
    3 3 0 0 0 0 0 0 0 0
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    

    查找

    按位查找
    /**
    * 按位查找
    *
    * @param L 顺序表指针
    * @param i 位序i  
    * @return 该位置的值
    */
    int GetElem(SqList L, int i){
    	return L.data[i-1];
    }
    
    操作小记

    代码

    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针
    */
    void InitList(SqList &L){
    	for(int i=0; i<MaxSize; i++)
    		L.data[i]=0; //初始化为0 
    	L.length=0; //初始长度为0 
    }
    
    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素前移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    /**
    * 按位查找
    *
    * @param L 顺序表指针
    * @param i 位序i 
    * @return 该位置的值
    */
    int GetElem(SqList L, int i){
    	return L.data[i-1];
    }
    
    int main(){
    	SqList L;
    	InitList(L);
    	
    	ListInsert(L, 1, 3);
    	ListInsert(L, 1, 2);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    
    	printf("\n第一个值为:%d", GetElem(L, 1)); 
    	
    	return 0;
    }
    
    

    效果

    2 3 0 0 0 0 0 0 0 0
    第一个值为:2
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    
    按值查找
    /**
    * 按值查找
    *
    * @param L 顺序表指针
    * @param e 获取的值 
    * @return 该值的位序 
    */
    int LocateElem(SqList L, int e){
    	for(int i=0; i<L.length; i++)
    		if(L.data[i]==e)
    			return i+1;	//数组下标为i的元素值等于e,返回其位序i+1 
    	
    	return 0; //退出循环,说明查找失败 
    }
    
    操作小记

    代码

    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针
    */
    void InitList(SqList &L){
    	for(int i=0; i<MaxSize; i++)
    		L.data[i]=0; //初始化为0 
    	L.length=0; //初始长度为0 
    }
    
    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素前移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    /**
    * 按值查找
    *
    * @param L 顺序表指针
    * @param e 获取的值 
    * @return 该值的位序 
    */
    int LocateElem(SqList L, int e){
    	for(int i=0; i<L.length; i++)
    		if(L.data[i]==e)
    			return i+1;	//数组下标为i的元素值等于e,返回其位序i+1 
    	
    	return 0; //退出循环,说明查找失败 
    }
    
    int main(){
    	SqList L;
    	InitList(L);
    	
    	ListInsert(L, 1, 3);
    	ListInsert(L, 1, 2);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    
    	printf("\n元素值为3的位序:%d", LocateElem(L, 3)); 
    	
    	return 0;
    }
    
    

    效果

    2 3 0 0 0 0 0 0 0 0
    元素值为3的位序:2
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    
    
    展开全文
  • 数据结构-顺序表基本操作的实现(含全部代码

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天是线性表中的顺序表的实现,主要实现函数如下,读者有需要可以评论,我可以适当加几个。 CreatList(SqList &L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n) InitList...
  • 顺序表基本操作的代码实现
  • //1.创建一个顺序表 //2.遍历顺序表 ...获取顺序表的长度 //8.删除所有元素 //9.判断顺序表是否为空 //10.判断顺序表是否满 //11.根据数据删除节点 //12.在头部插入数据 //13.在头部删除数据 /...
  • C++实现顺序表的基本操作(含完整代码

    千次阅读 多人点赞 2020-03-27 10:00:22
    C++实现顺序表的基本操作(附完整代码) 1、顺序表的初始化 2、顺序表的长度 3、顺序表插入元素 4、删除顺序表元素 5、遍历顺序表 6、查找顺序表元素 完整代码: #include<iostream> using namespace std; #...
  • 顺序表的基本操作

    2015-03-30 19:02:35
    代码顺序表的基本操作,包括顺序表的初始化、长度、删除、插入、查找、显示所有元素。
  • 1,顺序表的定义及基本操作代码
  • 顺序表的基础操作代码 #include<iostream> #include<stdlib.h> #include<conio.h> using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREAMENT 10 #define TRUE 0 #define FALSE ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,663
精华内容 665
关键字:

顺序表的基本操作代码