精华内容
下载资源
问答
  • 适合初学数据结构,不明白如何通过代码实现顺序表。 超简洁代码如下: # include <stdio.h> # define initsize 10 //表长度的初始定义 # define maxsize 50 //定义线性表的最大...//初始化顺序表 initlist

    适合初学数据结构,不明白如何通过代码实现顺序表。

    超简洁代码如下:

    /****************************************
    2020/10/16 第一次修改,顺序表结构定义的data是数组类型,应采用静态分配,模糊了静态分配与动态分配,已修改,错误程序L->data[10]=(int*)malloc(sizeof(int)*initsize);。
    ****************************************/
    
    #include <stdio.h>
    # define maxsize 50    //定义线性表的最大长度
    //顺序表结构的头文件(静态分配)
    typedef struct   //定义结构体
    {
    int data[maxsize];
    int length;
    }Sqlist;     //定义结构体变量名
    
    //初始化顺序表
    initlist(Sqlist* L)     //(sqlist &l)程序会报错
    {
    L->data[maxsize];       //顺序表的元素
    L->length =0;           //顺序表的当前长度
    }
    
    //自定义创建顺序表
    creatlist(Sqlist* L)
    {
    int i=0,c;
    printf("请输入顺序表元素:\n");
    while((scanf("%d",&c))!=EOF)  //不知道输入个数使用(scanf())!=EOF),输入后换行,ctrl+z,在换行
        L->data[i++]=c;
    L->length=i;
    printf("输入的顺序表元素:\n");
    for(i=0;i<L->length;i++)
        printf("%d ",L->data[i]);
    }
    
    void main()
    {
        Sqlist L;
        if(!initlist(&L))
            printf("初始化顺序表失败!");
        creatlist(&L);
        return 0;
    }
    

     

    展开全文
  • 顺序表作为线性表最基本的一种结构。本文介绍了顺序表的定义和特点,然后给出了顺序表的常见各种操作和代码,包括了初始化、查找、插入、删除和归并(合并),并分析了程序的复杂度。


    在计算机的三大逻辑结构中,线性表是一种典型的线性结构。而顺序表又是一种最基础、最简单的线性表。

    一、顺序表的基本概念

    1.定义:顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系,采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。

    2.特点:将表中元素一个接一个的存入一组连续的存储单元中,这种存储结构是顺序结构。

    采用顺序存储结构的线性表简称为“== 顺序表==”。顺序表的存储特点是:只要确定了起始位置,表中任一元素的地址都通过下列公式得到:LOC(ai)=LOC(a1)+(i1)L 1inLOC(ai)=LOC(a1)+(i-1)*L  1≤i≤n 其中,LL是元素占用存储单元的长度。

    顺序表采用数组来存储线性表的元素,在C/C++语言中,静态数组需要先指定大小,但也可以动态地分配数组的大小(通过指针来引用数组中的元素,称为动态数组),严蔚敏的《数据结构》就是采用这种方式。

    二、顺序表算法

    2.1.顺序表的结构定义:

    设 MaxSize为一个整形常量,如果一个顺序表不会超过100个元素,则可以把 MaxSize定义为100:

    #define MaxSize   100
    

    在定义顺序表的顺序存储结构时,需要定义一个数组来存储线性表中的所有元素和定义一个整型变量来存储线性表的长度。假定数组用data[MaxSize]表示,长度整形变量用length表示,并采用结构体的形式表示,则元素类型为通用类型标识符ElemType的线性表的顺序存储类型可描述如下:

    //线性表的顺序储存结构
    
    typedef int ElemType;		   //定义ElemType为int类型
    
    typedef struct{
    	ElemType data[MaxSize];		//存放顺序表中的元素
    	int 	 length;					//存放顺序表当前的长度
    }SqList;						//声明顺序表的类型
    
    

    声明顺序表类型变量:

    SqList L;
    

    存储结构要体现数据的逻辑结构,顺序表的存储结构中,内存中物理地址相邻的结点一定具有顺序表中的逻辑关系。

    2.2顺序表的基本运算

    (1)初始化顺序表算法

    构造一个空的顺序表L。实际上只需要你将 length域设置为0即可。对应算法如下:

    //初始化当前顺序表长度为0
    void InitList(SqList &L){      //L回传给实参,用引用类型
    	L.length = 0;			   
    }
    
    

    本算法的时间复杂度为O(1)。

    (2)求顺序表中指定位置元素值的算法

    用e返回L中第i(1<=i<=L.length)的元素的值。对应算法如下:

    //返回L中第i个元素的值
    int GetElem(Sqlist L, int i, ElemType &e){
    	if(i<1 || i>L.length)                         //参数i错误时返回0
    		return 0;
    	else{
    		e = L.data[i-1];  
    		return 1;
    	}
    }
    

    本算法的时间复杂度为O(1)。

    (3)按元素值查找算法

    顺序查找第一个元素值等于e的元素的逻辑序号。若这样的元素不存在,则返回值为0.对应算法如下:

    //从顺序表中找到与给定的元素x相等的元素,若找到则返回序号,否则返回0
    int Locate(SqList L, ElemType e){
    	int i=0;
    	for(i=0;i<L.length, ++i){
    		if(L.data[i] =e)
    			return i+1;
    	}
    

    本算法的时间复杂度为O(n),空间复杂度为O(1),其中n为顺序表L的长度。

    (4)插入数据元素算法

    在顺序表L的第i(1<=i<=L.length+1)个位置上插入新的元素x。如果i值不正确,则返回0;否则将顺序表原来第i个元素以及以后的元素均后移一个位置,腾出一个空插入新元素,顺序表的长度加1.对应算法如下:

    //在顺序表中的第i-1个数据和第i个元素之间插入一个新的元素
    //在顺序表L中第i个元素之前插入新的元素x
    int ListInsert(SqList &L, int i, ElemType x){
    	int j=0;
    	if(i<1||i>L.length)
    		return 0;
    	for(j=L.length; j>i; j--)
    		L.data[j] = L.data[j-1];       //将i后面的元素向后移动一位
    	L.data[i-1] = x;                      //加入元素x
    	L.length++;                         //长度加一
    	return 1;
    }
    

    本算法的时间复杂度为O(n),空间复杂度为O(1),其中n为顺序表L的长度。

    (5)删除数据元素算法

    删除顺序表L的第i(1<=i<=L.length)个元素。如果i值不正确,则返回0;否则将顺序表第i个元素及以后的元素均前移动一个位置,这样就覆盖了原来的第i个元素,达到删除元素的目的,最后顺序表的长度减1.对应算法如下:

    //将顺序表的第i个元素ai删除,顺序表的长度减一
    //参数L需要回代,用引用的方式&,i为要删除元素的额位置
    int ListDelete(Sqlist &L, int i){
    	int j=0;
    	if(i<1||i>L.length)
    		return 0;
    	for(j=i; j<L.length; j++)
    		L.data[j-1] = L.data[j];
    	L.length--;
    	return 1;
    }
    
    

    本算法的时间复杂度为O(n),空间复杂度为O(1),其中n为顺序表L的长度。

    2.2 有序顺序表的归并算法

    当一个有序表(这里假设从小到大排列)采用顺序表存储时,称为有序顺序表。假设每个顺序表中元素不同,将两个具有相同次序的有序表归并为一个有序表的过程称为有序顺序表的归并,过程如下:
    在这里插入图片描述
    上图中,即为将顺序表A和B归并成C的结果。两个顺序表归并成一个顺序表称为二路归并,3个顺序表归并成一个顺序表称为三路归并,一次类推,这种思路应用于外排序中称为多路归并

    算法如下:

    //顺序表A和B按照非递减有序排列,将A和B合并到新的顺序表C中,且为非递减有序排列
    void merge(Sqlist A, Sqlist B, Sqlist &C){
    	int i,j,k=0;   //K记录c中元素的个数,i为A,j为B
    	while(i<A.length && j<B.length){		//是否有其中一个加入完成
    		if(A.data[i]<B.data[i]){
    			C.data[k] = A.data[i];
    			i++; k++;
    		}
    		else if(A.data[i]>B.data[j]){
    			C.data[k] = B.data[j];
    			j++; k++;
    		}
    		else{							//A.data[i] = B.data[i]
    			C.data[k] = A.data[i];
    			i++; k++;
    			C.data[k] = B.data[j];
    			j++; k++;
    		}	
    	}
    	while(i<A.length){				//B全部加入到C了,剩余的A中元素全部往C后面加入即可
    		C.data[k] = A.data[i];
    		i++;k++;
    	}
    	while(j<B.length){				//A全部加入到C了,同上
    		C.data[k] = B.data[i];
    		j++;k++;
    	}
    	C.length = k;		//C的长度
    }	
    

    本算法的时间复杂度为O(n+m),其中n、m分别为顺序表L1、L2的长度。空间复杂度为O(1),其中n为顺序表L的长度。将两个长度分别为m、n的递增有序顺序表合并成一个有序顺序表,最少的的比较次数为MIN(m,n)

    [下一篇]:数据结构之单链表的建立、删除、查找、插入、删除和归并(合并)(附C++程序)

    展开全文
  • 数据结构-顺序表初始化

    万次阅读 多人点赞 2014-09-24 17:12:44
    //顺序表初始化 #include #include // #define OK 1; #define OVERFLOW -2 #define MAXSIZE 100//顺序表可能达到的最大长度  typedef int Status;//Status是函数的类型,其值是函数结果状态代码,如OK等 typedef...


    //顺序表的初始化
    #include <stdio.h>
    #include <stdlib.h>//
    #define OK 1;
    #define OVERFLOW -2
    #define MAXSIZE 100//顺序表可能达到的最大长度 
    typedef int Status;//Status是函数的类型,其值是函数结果状态代码,如OK等  
    typedef int ElemType;//ElemType是线性表中数据元素的类型,此处用int
    typedef struct
    {
    	ElemType *elem;//存储空间的基地址 
    	int length;//当前长度 
    	int listsize;//当前分配的存储容量 
    }SqList;
    Status InitList_Sq(SqList &L)//构造一个空的顺序表 
    {
    	L.elem=new ElemType[MAXSIZE];//为顺序表分配一个大小为MAXSIZE的数组空间 
    	if(!L.elem) exit(OVERFLOW);//存储失败 
    	L.length=0;//空表长度为零 
    	L.listsize=MAXSIZE;
    	return OK;
    }
    Status ListTraverse(SqList L)//  初始条件:顺序线性表L已存在  
    {
    	ElemType *p;
    	p=L.elem;
    	int i;
    	printf("线性表当前容量为:%d\n",L.listsize);
    	if(L.length>0)
    	{
    		printf("当前线性表有%d个元素,分别是\n",L.length);
    		for(i=1;i<=L.length;i++)
    		{
    			printf("%d ",*p++);
    		}
    	}
    	else 
    	{
    		printf("目前还是空线性表.\n");
    	}
    }
    int main()
    {
    	SqList la;
    	InitList_Sq(la);
    	ListTraverse(la);
    }
    
    
    Exit()
    函数名: exit()
    所在头文件:stdlib.h
    功 能: 关闭所有文件,终止正在执行的程序。
    exit(1)表示异常退出.这个1是返回给操作系统的不过在DOS好像不需要这个返回值
    exit(x)(x不为0)都表示异常退出
    exit(0)表示正常退出
    用 法: void exit(int status);
    参 数 : status //程序退出的返回值.
    程序例:
    #include <stdlib.h>
    #include <conio.h>
    #include <stdio.h>
    int main(void)
    {
    int status;
    printf("Enter either 1 or 2\n");
    status = getch();
    /* Sets DOS errorlevel */
    exit(status - '0');
    /* Note: this line is never reached */
    return 0;
    }
    exit()和return的区别:
    按照ANSI C,在最初调用的main()中使用return和exit()的效果相同。
    但要注意这里所说的是“最初调用”。如果main()在一个递归程序中,exit()仍然会终止程序;但return将
    控制权移交给递归的前一级,直到最初的那一级,此时return才会终止程序。return和exit()的另一个区别
    在于,即使在除main()之外的函数中调用exit(),它也将终止程序。



    展开全文
  •  2) 这种代码块就是初始化代码块,用于给数据成员初始化,里面可以调用方法,使用if、for等Java语句,也就是说初始化块本质上和普通方法没有区别;  3) 初始化块会构造器之前执行,对数据成员初始

    1. 初始化块:

        1) 在类中可以定义和方法平行的代码块,例如:public class A { { /* 初始化块 */ } ... },即直接用花括号括起来的代码块;

        2) 这种代码块就是初始化代码块,用于给数据成员初始化,里面可以调用方法,使用if、for等Java语句,也就是说初始化块本质上和普通方法没有区别;

        3) 初始化块会在构造器之前执行,对数据成员初始化,但它跟构造器和其它普通方法有区别的地方是,初始化块不能传入参数!这是非常明显的一个特征;

             i. 这是个非常聪明的设计,如果需要对所有的对象全部进行完全相同的初始化处理那么初始化块就再合适不过了;

             ii. 因为初始化块不接受任何参数,这就意味着初始化块中的代码永远是固定的,任何对象的初始化结果都是相同的,初始化块就是为了满足这样的需求;

             iii. 初始化块是使编程更加简洁方便:

                 a. 不难看出初始化块完成的工作就是无参构造器的任务,那为什么不直接使用无参构造器还要设计一个初始化块呢?会不会多此一举呢?

                 b. 其实不是,考虑到如下情形:所有构造器都要先执行一段相同的无参初始化行为,为了防止代码冗余,在没有初始化块的情况下会把所有无参初始化行为都写在无参构造器中,然后在其它构造器的开始处调用这个无参构造器版本this();就行了;

    !!但是现在有了初始化块,而初始化块都是在构造器之前执行的,因此现在就可以省略各个构造器开始的this()了;

    !!跟何况有些构造器可能还想调用非无参版本的其它构造器,比如this(5, "lala");之类的,但是每个构造器最多只能用一次this调用其它构造器,对于这种情况就又麻烦了,可能需要将无参初始化行为写在另外一个单独的方法中,然后再调用它了!

    !!所以初始化块是一个非常非常成功的设计;

                  c. 有了初始化块就只要提供给一个空的无参构造器即可!虽然初始化块可以完全取代无参构造器,但是养成良好的习惯,还是要提供一个的!


    2. 初始化代码:

        1) 还记得在定义数据成员的时候可以直接提供一个默认值吗?例如:private int m_data = 5;这种直接提供默认值其实也是一种初始化;

        2) 直接默认值和初始化块合并属于初始化代码,而构造器不属于初始化代码,构造器和初始化代码是两个平行的概念;

        3) 初始化代码的特性:

             i. 在构造器之前执行;

             ii. 初始化代码按照在源代码中的定义顺序依次执行(初始化块可以有多个),例如:

    { a = 6; }
    private int a = 9;
    private int b = 10;
    { a = 7; b = 11; }
    !这个顺序很奇怪,初始化块有多个,并且初始化块可以放在数据成员定义之前(Java不像C++,需要前向引用声明,编译时会先识别所有的数据成员符号,然后再执行初始化代码);

    !!实际初始化时会按照从上到下的顺序一条条执行,这里a先是6,再是9,最后再是7,因此最终结果是7,而b最终结果是11;

    !!这里只是演示一下极端情况,为了说明初始化代码执行是按从上到下的顺序的,但实际编程中初始化代码只需要一个就行了,并且都是放在数据定义之后的,这样逻辑清晰并且美观;

        4) 初始化代码的编写规范:

             i. 具有显而易见的默认初始值的数据用直接默认值给出,例如刚创建的银行账号,余额必定是0,因此应该选择直接默认值初始化:private double account = 0.0;

             ii. 对于需要使用一定逻辑(可以是非常复杂的逻辑、算法,特别是通过一个方法调用产生一个初始值)计算出初始值的数据则应该放在初始化块中:例如用随机数产生一个初始值;

    !!由于某些方法可能会抛出异常,如果用这类方法产生初始值那就只能放在初始化块了,因为初始化块中可以加入异常处理逻辑,而直接默认值初始化显然不能解决抛出异常的问题,所以直接默认值初始化一般都是直接给出一个常量,很少使用一个方法来给定直接默认值的!

             iii. 使用直接默认值初始化的数据就不要再在初始化块中重复初始化了,即两者不要重复,各自的分工是明确的!


    3. 静态初始化块:

        1) 就是在普通初始化块之前加一个static,即static { /* 静态初始化代码 */ }

        2) 专门用来初始化静态数据成员的,而普通初始化块是用来初始化对象成员的;

        3) 同样,普通初始化块隐藏着一个this引用,所有的非局部变量默认使用this.引导,而静态初始化块没有隐藏的this引用,因此静态初始化块不能访问非静态成员!

        4) 静态初始化块和静态成员的直接默认初始化合并称为静态初始化代码,静态初始化代码会在类第一次加载时执行,会在所有对象创建之前执行,并且只执行一次;


    4. 一个完整的初始化过程的伪代码描述:

    static_init() { // 静态成员初始化
    	if (当前类有父类) {
    		当前类的父类.static_init();
    	}
    	if (!当前类加载过) {
    		执行当前类的初始化代码;
    	}
    }
    
    init() { // 非静态成员初始化
    	static_init(); // 静态初始化最先执行
    
    	if (this有父类) {
    		super.init();
    	}
    	执行当前对象this的初始化代码;
    }
    !!这是一个递归的描述,因此下面示例:

    class A {
    	static { out.println("static A"); }
    	{ out.println("A"); }
    	public A() { out.println("cons A"); }
    }
    
    class B extends A {
    	static { out.println("static B"); }
    	{ out.println("B"); }
    	public B() { out.println("cons B"); }
    }
    
    class C extends B {
    	static { out.println("static C"); }
    	{ out.println("C"); }
    	public C() { out.println("cons C"); }
    }
    
    public class Test {
    	public static void main(String[] args) {
    		new C();		
    	}
    }
    !!结果是:

    static A
    static B
    static C
    A
    cons A
    B
    cons B
    C
    cons C
    !!Java还是和其它语言保持一致的,即对一个对象初始化时一定要先保证其父类部分初始化再初始化自己的部分;





    展开全文
  • 静态顺序表初始化以及插入删除操作 1. 首先是静态顺序表结构体的编写 typedef struct { int data[MaxSize]; int length; }Sqlist; 2. 初始化 void InitList(Sqlist *L) { L->length = 0; } 3....
  • 一、顺序表定义及特点 1.顺序表定义 2.顺序表特点 二、顺序表定义 三、顺序表插入运算 四、顺序表删除运算 五、顺序表元素查找 六、顺序表取元素数据 七、主函数定义 注1. typedef 解释 注2. 链表知识点...
  • 顺序表计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中逻辑结构上相邻的数据元素存储相邻的物理存储单元中,即通过数据元素...
  • 指针初始化顺序

    千次阅读 2019-04-07 18:30:05
    无继承时: 1、分配内存 2、初始化列表之前赋值虚指针...Q:虚指针在初始化列表之前被赋值,可以放在初始化列表之后赋值吗?即顺序是:列表初始化、虚指针赋值、构造函数体?? class B { public: virtual int...
  • 成员初始化顺序表

    2013-04-24 17:49:46
    1构造函数初始化列表的变量优先于构造函数(至少明显的写前面) (若都在初始化列表中初始化,则按声明顺序初始化,与初始化列表中的顺序无关) 2静态成员变量先于实例变量 3父类成员变量先于子类成员变量 4父类...
  • 顺序表,全名顺序存储结构,是线性表的一种。通过《线性表》一节的学习我们知道,线性表用于存储逻辑关系为“一对一”的数据,顺序表自然也不例外。 不仅如此,顺序表对数据的物理存储结构也有要求。顺序表存储数据...
  • 剧中Sheldon可以说是一个极品,真不知Leonard是如何忍受这位极品室友成天的唠叨。 你知道么?Sheldon有一个神秘的小本本,记录了所有他从小开始讨厌的人名。Stuart这位漫画店老板就是小本本的一员哦,谁叫他常常...
  • 数据结构—顺序表初始化

    千次阅读 2018-08-18 17:19:32
    #include <stdio.h> #include <stdlib.h> ... #define LIST_INIT_SIZE 10// 线性表存储空间的初始分配量 typedef int Status; //Status是函数数据类型 ,其值是函数结果状态,如OK ...
  • 顺序表,全名顺序存储结构,是线性表的一种。通过《什么是线性表》一节的学习我们知道,线性表用于存储逻辑关系为“一对一”的数据,顺序表自然也不例外。 不仅如此,顺序表对数据的物理存储结构也有要求。顺序表...
  • 该程序实现了一个顺序表的基本操作: ... //初始化线性表 void CreateSqList(); //创建线性表 void ListInsert(); //向线性表中插入值 void ListDelete(); //删除顺序表中的数据元素 void PrintList(); ...
  • 顺序表初始化(vc++6.0)

    千次阅读 2018-08-29 14:06:07
    // c1.h (程序名) #include #include #include<malloc.h> // malloc()等 ...// 函数结果状态代码 ..."初始化L后:L.elem=%u L.length=%d L.listsize=%d\n" ,L.elem,L.length,L.listsize); return 0 ;}
  • C++实现顺序表的创建、初始化、查找、插入、删除

    千次阅读 多人点赞 2020-05-24 23:14:52
    C++实现顺序表的创建、初始化、查找、插入、删除 学习了数据结构之后,对于顺序表的相关操作有了自己的启发,因此拿来敲个代码练练手,我选用的是C++语言,因为我觉得c++可以使用引用,比较方便(纯个人看法嘻嘻)...
  • 顺序表的表示和实现 顺序表的特点: 逻辑上相邻的元素物理上也是相邻 可以快速计算出任何一个数据元素的存储地址,即访问每个元素所花时间相等 算法实现(C语言) 这里插入代码片#include<stdio.h> #...
  • c语言 顺序表的基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出) 1、创建、申请空间 2、初始化顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、指定位置插入数据,后续数据...
  • 计算机中用一组地址连续的存储单元依次存储线性表的各个数据元素,称作线性表的顺序存储结构. 顺序存储结构是存储结构类型中的一种,该结构是把逻辑上相邻的节点存储物理位置上相邻的存储单元中,结点之间的逻辑...
  • #include <iostream> #include <cstdlib> using namespace std; #define ERROR 0 #define OK 1 ...#define LIST_INIT_SIZE 100 //根据实际情况,调整初始分配空间大小 #define LISTINC...
  • C语言实现顺序表初始化,插入,删除,查找

    万次阅读 多人点赞 2016-12-03 23:24:07
    #define LIST_INIT_SISE 100 // 线性表存储空间的初始分配量 #define LIST_INCREASE_SISE 20 // 线性表存储空间的分配增量 #define OK 0 #define ERROR -1 #define OVERFLOW -2 typedef int elementTy
  • #include using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 int OK=1; int OVERFLOW=0; int ERROR=0; /*线性表的定义*/ typedef struct { char *elem;.../*线性表的初始化*/ int
  • 数据结构-顺序表基本操作的实现(含全部代码

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构...L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n) InitList(SqList &...
  • 线性表 定义 #define MAXSIZE 20 //线性表最长长度 typedef int ElemType; //数据类型 typedef struct{ ElemType data[MAXSIZE]; int length;... * InitList(*L) 初始化 * ListEmpty(L) 若为空,返回tru
  • c++顺序表基本算法代码

    千次阅读 2016-11-02 09:50:24
    #define MAXLEN 100//定义顺序表的最大长度 /*************顺序表的定义部分*****************/ struct Data{//定义顺序表结点类型 string key;//节点关键字 string name; int age; }; struct SLtype{//定
  • //用顺序表实现堆栈 //包含printf与scanf函数 #include //包含malloc函数 #include //v是分配的内存空间的首地址,m是分配的空间的大小(代表了表的总长),n为表的实际长度 //n的初值较为重要。一定要获得栈顶...
  • 数据结构是计算机类学生基本上必修的一门课程,也是比较难得一门课程。对于初学shujujiegouderenlaishui最近写了个数据结构的顺序表,运行了一下感觉还可以,所以想拿出来和大家分享一下
  • 1.前言链表是一种非常基础也非常重要的数据结构,实际中使用非常广泛,也是各种面试里特别容易出现的类型。...链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是
  • 上一篇我们总结了什么是线性表,线性表的ADT类型,线性表的两种存储类型顺序存储结构和链式存储结构,今天正式进入线性表的顺序存储结构的总结和归纳,也就是数据结构的线性表的顺序表的讲解。 1、什么是顺序表? ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 314,685
精华内容 125,874
关键字:

在顺序表初始化代码