精华内容
下载资源
问答
  • 属于顺序数据的是
    万次阅读
    2020-03-23 10:18:13

    1. 分类数据(categorical or nominal data)

    是只能归于某一类别的非数字型数据,它是对事物进行分类的结果,数据表现为类别,是用文字来描述的。例如:
    (1)人口按性别分为男、女两类;
    (2)企业按行业属性分为医药企业、家电企业、纺织品企业等;

    为了便于统计处理,对于分类数据可以用数字代码来表示各个类别,比如:
    用1表示“男性”,0表示“女性”;
    用1表示“医药企业”,2表示“家电企业”,3表示“纺织品企业”

    2. 顺序数据(Ordinal data)

    是只能归于某一有序类别的非数字型数据。顺序数据虽然也是类别,但这些类别是有序的。比如:
    (1)将产品分为一等品、二等品、三等品、次品等;
    (2)考试成绩可以分为优、良、中、及格、不及格等;
    (3)一个人的受教育程度可以分为小学、初中、高中、大学及以上
    (4)一个人对某一事物的态度可以分为非常同意、同意、保持中立、不同意、非常不同意,等

    同样,顺序数据也可以用数字代码来表示,比如:

    1—非常同意、2—同意、3—保持中立、4—不同意、5—非常不同意,等;

    3.数值型数据(Numerical attribute)

    是按数字尺度测量的观察值,其结果表现为具体的数值。现实中所处理的大多数都是数值型数据。

    4.小结

    分类数据和顺序数据说明的是事物的品质特征,通常是用文字来表述的,其结果均表现为类别,因而也可统称为定性数据或品质数据(qualitative data);

    数值型数据说明的是现象的数量特征,通常是用数值来表现的,因此也可以称为定量数据或数量数据(quantitative data)

    更多相关内容
  • 数据结构初阶——顺序

    千次阅读 多人点赞 2022-04-29 10:17:19
    博客写到这里,关于C语言的相关内容就告一段落了,从这篇开始,跟我一起进入一个全新的领域吧。把顺序表的代码放到了结尾。击鼓进军数据结构!!!

           博客写到这里,关于C语言的相关内容就告一段落了,从这篇开始,跟我一起进入一个全新的领域吧。

           前面也为大家介绍了通讯录应该怎样去实现,其实顺序表也与通讯录差不多。顺序表是一种线性表,线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的, 线性表在物理上存储时,通常以数组和链式结构的形式存储,关于线性表后面也会介绍很多。


    目录

    1. 顺序表的基本结构

    2. 接口实现

    3. 增加数据

            3.1 创建、初始化与销毁

            3.2 增加

                    3.2.1 尾插

                    3.2.2 头插

    4. 删除数据

            4.1 尾删

            4.2 头删

    5. 随机插入

    6. 随机删除

    7. 查找

    8. 修改

    结尾总结


    1. 顺序表的基本结构

           顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组上完成数据的增删查改。
    顺序表一般可以分为:
    1. 静态顺序表:使用定长数组存储元素

        像通讯录第一次实现时定义了1000个。

    2. 动态顺序表:使用动态开辟的数组存储。

        动态的通讯录


    2. 接口实现

           静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了,空间开多了浪费,开少了不够用。所以现实中基本都是使用动态顺序表,根据需要动态的分配空间大小。

           以后会经常用到typedef去对类型重命名,首先就要把顺序表的结构写出来,之后就来实现各种功能。


    3. 增加数据

            3.1 创建、初始化与销毁

           再增加数据之前,首先要在主函数创建一个顺序表,再对这个顺序表初始化。还是继续用模块化的方式。

     函数的参数是结构体指针,所以实参传入的时候要对结构体变量取地址。

            3.2 增加

    对于增加有两种形式,一种是头插,另一种是尾插。

                    3.2.1 尾插

    在开始插入时,我们要先对空间进行一个检查,检查空间是否足够我们插入数据。

    在检查时,先使用临时变量newcapacity和tmp,如果空间不够,我们直接扩容一倍,在开始的时候,size和capacity都是0,那开始直接先给4个空间,最后检查无误后再赋值。

    开始size是0,正好对应下标为0的位置,也就是第一个位置,之后size++,这时数据就可以存入了。

    为了检测我们插入的数据是否真的存到了顺序表中,再写一个打印函数 。

    之后就测试一下

     

                    3.2.2 头插

    头插不能在顺序表的头部插入,只能把所有的数据往后挪,再把数据插入。

    问题就是需要拿几次,和在存放时的越界问题,但这里应该不会出现这种问题,当size和capacity的值相等的时候就会扩容。

     

     


    4. 删除数据

            4.1 尾删

    尾删就简单很多,但还是得检查一下size,如果没用数据就不要删了,这种assert的方法比较“暴力”,但感觉方便。

    这样就尾删了三个数据。 

            4.2 头删

     

     

     

    可以看到什么都没有打印,前面一共有5个数据,尾删了三次,头删两次,所以最后什么也没有,可不是出错啊。


    5. 随机插入

       

     

    总之就是需要插入的时候就得判断需不需要扩容,既然pos是下标,就要判断pos的有效性。pos=0就是头插,pos=size就是尾插。之后也就可以复用。

    一个头插一个尾插测试一下。

     


    6. 随机删除

     

     

     

    和插入之前的数据一样。

    当然,随机删除也是可以复用的。

     

     一个头删一个尾删来测试一下。


    7. 查找

     

    找到了返回下标,找不到返回-1,毕竟下标没用负数。 


    8. 修改

    修改就可以使用查找函数,只有找到了才能修改,把SLFind的返回值传入再进行修改。


    结尾总结

    关于顺序表的大致实现就介绍到这里,数据结构介绍的还是数据存放的形式,顺序表是连续存放的,不存在空缺。Test.c文件中只是潦草的写了一些调试的代码,如果想变得更好,也可以像通讯录的时候写一个菜单,再写的时候一定要创建结构体变量再进行操作,最后把所有的代码放在下面。

    Seqlist.h文件

    #pragma once
    
    #include <stdio.h>
    #include <stdlib.h>
    #include <assert.h>
    
    typedef int SLDataType;
    
    typedef struct Seqlist
    {
    	SLDataType* a;//指向动态开辟的数组
    	int size;     //表中已存入数据的个数
    	int capacity; //容量空间的大小
    }SL;
    
    //初始化
    void SLInit(SL* ps);
    //销毁
    void SLDestory(SL* ps);
    //打印
    void SLPrint(SL* ps);
    
    //尾插/头插/尾删/头删
    void SLPushBack(SL* ps, SLDataType x);
    void SLPushFront(SL* ps, SLDataType x);
    void SLPopBack(SL* ps);
    void SLPopFront(SL* ps);
    
    //随机插入
    void SLInsert(SL* ps, int pos, SLDataType x);
    //随机删除
    void SLErase(SL* ps, int pos);
    
    //查找
    int SLFind(SL* ps, SLDataType x);
    
    //修改
    void SLModify(SL* ps, int pos, SLDataType x);

    Seqlist.c文件

    #define _CRT_SECURE_NO_WARNINGS 1
    
    #include "Seqlist.h"
    
    void SLPrint(SL* ps)
    {
    	assert(ps);
    	int i = 0;
    	for (i = 0; i < ps->size; i++)
    	{
    		printf("%d ", ps->a[i]);
    	}
    	printf("\n");
    }
    
    void SLInit(SL* ps)
    {
    	assert(ps);
    	ps->a = NULL;
    	ps->capacity = ps->size = 0;
    }
    
    void SLDestory(SL* ps)
    {
    	assert(ps);
    	if (ps->a)
    	{
    		free(ps->a);
    		ps->a = NULL;
    		ps->capacity = ps->size = 0;
    	}
    }
    
    void SLCheckCapacity(SL* ps)
    {
    	if (ps->capacity == ps->size)
    	{
    		int newCapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
    		SLDataType* tmp = (SLDataType*)realloc(ps->a, newCapacity * sizeof(SLDataType));
    		if (tmp == NULL)
    		{
    			printf("realloc fail\n");
    			return;
    		}
    		ps->capacity = newCapacity;
    		ps->a = tmp;
    	}
    }
    
    void SLPushBack(SL* ps, SLDataType x)
    {
    	//assert(ps);
    	//SLCheckCapacity(ps);
    
    	//ps->a[ps->size] = x;
    	//ps->size++;
    	SLInsert(ps, ps->size, x);
    }
    
    void SLPushFront(SL* ps, SLDataType x)
    {
    	//assert(ps);
    	//SLCheckCapacity(ps);
    
    	//int end = ps->size;
    	//while (end > 0)
    	//{
    	//	ps->a[end] = ps->a[end - 1];
    	//	end--;
    	//}
    	//ps->a[end] = x;
    	//ps->size++;
    	SLInsert(ps, 0, x);
    }
    
    void SLPopBack(SL* ps)
    {
    	//assert(ps);
    	//assert(ps->size > 0);
    	//ps->size--;
    	SLErase(ps, ps->size - 1);
    }
    
    void SLPopFront(SL* ps)
    {
    	//assert(ps);
    	//assert(ps->size > 0);
    
    	//int end = ps->size - 1;
    	//for (int i = 0; i < end; i++)
    	//{
    	//	ps->a[i] = ps->a[i + 1];
    	//}
    	//ps->size--;
    	SLErase(ps, 0);
    }
    
    void SLInsert(SL* ps, int pos, SLDataType x)
    {
    	assert(ps);
    	assert(pos >= 0 && pos <= ps->size);
    	SLCheckCapacity(ps);
    
    	//pos就是插入的下标
    	int end = ps->size;
    	while (end > pos)
    	{
    		ps->a[end] = ps->a[end - 1];
    		end--;
    	}
    	ps->a[pos] = x;
    	ps->size++;
    }
    
    void SLErase(SL* ps, int pos) 
    {
    	assert(ps);
    	assert(pos >= 0 && pos < ps->size);
    
    	for (int i = pos; i < ps->size - 1; i++)
    	{
    		ps->a[i] = ps->a[i + 1];
    	}
    	ps->size--;
    }
    
    int SLFind(SL* ps, SLDataType x)
    {
    	assert(ps);
    	for (int i = 0; i < ps->size; i++)
    	{
    		if (ps->a[i] == x)
    		{
    			return i;
    		}
    	}
    	return -1;
    }
    
    void SLModify(SL* ps, int pos, SLDataType x)
    {
    	assert(ps);
    	assert(pos >= 0 && pos < ps->size);
    
    	ps->a[pos] = x;
    }

    展开全文
  • 数据结构 - 顺序

    千次阅读 2020-05-30 16:55:22
    数据结构 - 顺序表基本实现思想

    顺序表

    在程序中,经常需要将一组(通常是同为某个类型的)数据元素作为整体管理和使用,需要创建这种元素组,用变量记录它们,传进传出函数等。一组数据中包含的元素个数可能发生变化(可以增加或删除元素)。

    对于这种需求,最简单的解决方案便是将这样一组元素看成一个序列,用元素在序列里的位置和顺序,表示实际应用中的某种有意义的信息,或者表示数据之间的某种关系。

    这样的一组序列元素的组织形式,我们可以将其抽象为 线性表。一个线性表是某类元素的一个集合,还记录着元素之间的一种顺序关系。线性表是最基本的数据结构之一,在实际程序中应用非常广泛,它还经常被用作更复杂的数据结构的实现基础。

    根据线性表的实际存储方式,分为两种实现模型:

    • 顺序表,将元素顺序地存放在一块连续的存储区里,元素间的顺序关系由它们的存储顺序自然表示。
    • 链表,将元素存放在通过链接构造起来的一系列存储块中。

    顺序表的基本形式

    顺序表的形式

    图a表示的是顺序表的基本形式,数据元素本身连续存储,每个元素所占的存储单元大小固定相同,元素的下标是其逻辑地址,而元素存储的物理地址(实际内存地址)可以通过存储区的起始地址 Loc (e0) 加上逻辑地址(第i个元素)与存储单元大小(c)的乘积计算而得,即:

    L o c ( e i ) = L o c ( e 0 ) + c ∗ i Loc(ei) = Loc(e0) + c*i Loc(ei)=Loc(e0)+ci

    故,访问指定元素时无需从头遍历,通过计算便可获得对应地址,其时间复杂度为O(1)。

    如果元素的大小不统一,则须采用图b的元素外置的形式,将实际数据元素另行存储,而顺序表中各单元位置保存对应元素的地址信息(即链接)。由于每个链接所需的存储量相同,通过上述公式,可以计算出元素链接的存储位置,而后顺着链接找到实际存储的数据元素。注意,图b中的c不再是数据元素的大小,而是存储一个链接地址所需的存储量,这个量通常很小。

    图b这样的顺序表也被称为对实际数据的索引,这是最简单的索引结构。


    顺序表的结构与实现

    ✍ 顺序表的结构

    顺序表结构

    一个顺序表的完整信息包括两部分,一部分是表中的元素集合,另一部分是为实现正确操作而需记录的信息,即有关表的整体情况的信息,这部分信息主要包括元素存储区的 容量 和当前表中已有的 元素个数 两项。


    ✍ 顺序表的两种基本实现方式

    顺序表的实现形式

    图a为一体式结构,存储表信息的单元与元素存储区以连续的方式安排在一块存储区里,两部分数据的整体形成一个完整的顺序表对象。

    一体式结构整体性强,易于管理。但是由于数据元素存储区域是表对象的一部分,顺序表创建后,元素存储区就固定了。

    图b为分离式结构,表对象里只保存与整个表有关的信息(即容量和元素个数),实际数据元素存放在另一个独立的元素存储区里,通过链接与基本表对象关联。


    ✍ 元素存储区替换

    一体式结构由于顺序表信息区与数据区连续存储在一起,所以若想更换数据区,则只能整体搬迁,即整个顺序表对象(指存储顺序表的结构信息的区域)改变了。

    分离式结构若想更换数据区,只需将表信息区中的数据区链接地址更新即可,而该顺序表对象不变。


    ✍ 元素存储区扩充

    采用分离式结构的顺序表,若将数据区更换为存储空间更大的区域,则可以在不改变表对象的前提下对其数据存储区进行了扩充,所有使用这个表的地方都不必修改。只要程序的运行环境(计算机系统)还有空闲存储,这种表结构就不会因为满了而导致操作无法进行。人们把采用这种技术实现的顺序表称为动态顺序表,因为其容量可以在使用中动态变化。

    扩充的两种策略

    • 每次扩充增加固定数目的存储位置,如每次扩充增加10个元素位置,这种策略可称为线性增长。

      特点:节省空间,但是扩充操作频繁,操作次数多。

    • 每次扩充容量加倍,如每次扩充增加一倍存储空间。

      特点:减少了扩充操作的执行次数,但可能会浪费空间资源。以空间换时间,推荐的方式。

    展开全文
  • 目录一、数据结构1.1 算法与数据结构的区别二、顺序表2.1 顺序表的基本形式【重点】2.2 顺序表的两种基本实现方式【重点】1、一体式结构:2、分离式结构:2.3 元素存储区替换与扩充1. 元素存储区的替换2. 元素存储区...

    一、数据结构

    • 数据结构指数据对象中数据元素之间的关系。
    • 计算机只有三种数据类型:int、float、char。在内存中,1个int占4个字节。

    1.1 算法与数据结构的区别

    • 程序 = 数据结构 + 算法
    • 算法是为了解决实际问题而设计的,数据结构是算法需要处理的问题载体。
    • 抽象数据类型(Abstract Data Type):抽象数据类型(ADT)的含义是指一个数学模型以及定义在此数学模型上的一组操作。即把数据类型和数据类型上的运算捆在一起,进行封装。引入抽象数据类型的目的是把数据类型的表示和数据类型上运算的实现与这些数据类型和运算在程序中的引用隔开,使它们相互独立。
    • 常用的数据运算有五种:插入、删除、修改、查找、排序

    二、顺序表

    • 线性表:将一组(通常是同为某个类型的)数据元素作为整体管理和使用,需要创建这种元素组,用变量记录它们,传进传出函数等。线性表是最基本的数据结构之一,根据线性表的实际存储方式,分为两种实现模型:顺序表、链表。

    • 顺序表:将元素顺序地存放在一块连续的存储区里,元素间的顺序关系由它们的存储顺序自然表示。

    • 顺序表的构建需要预先知道数据大小来申请连续的存储空间,而在进行扩充时又需要进行数据的搬迁。

    2.1 顺序表的基本形式【重点】

    在这里插入图片描述

    • 数据元素本身连续存储,每个元素所占的存储单元大小固定相同,元素的下标是其逻辑地址,而元素存储的物理地址(实际内存地址)可以通过存储区的起始地址Loc (e0)加上逻辑地址(第i个元素)与存储单元大小(c)的乘积计算而得,即:Loc(ei) = Loc(e0) + c*i
    • 查找的时间复杂度为O(1):
      顺序表的结构决定了访问指定元素时无需从头遍历,通过计算便可获得对应地址,其时间复杂度为O(1)。

    在这里插入图片描述

    • 元素外置的顺序表(被称为对实际数据的索引):
      元素的大小不统一,则须采用元素外置的形式,将实际数据元素另行存储,而顺序表中各单元位置保存对应元素的地址信息(即链接)。由于每个链接所需的存储量相同,通过上述公式,可以计算出元素链接的存储位置,而后顺着链接找到实际存储的数据元素。

    注意,图b中的c不再是数据元素的大小,而是存储一个链接地址所需的存储量,这个量通常很小。

    • 一个顺序表的完整信息包括两部分:一部分是表中的元素集合,另一部分是为实现正确操作而需记录的信息,即有关表的整体情况的信息(主要包括元素存储区的容量和当前表中已有的元素个数两项)。
      在这里插入图片描述

    2.2 顺序表的两种基本实现方式【重点】

    1、一体式结构:

    在这里插入图片描述

    • 存储表信息的单元与元素存储区以连续的方式安排在一块存储区里,两部分数据的整体形成一个完整的顺序表对概念:象。

    一体式结构整体性强,易于管理。但是由于数据元素存储区域是表对象的一部分,顺序表创建后,元素存储区就固定了。

    2、分离式结构:

    在这里插入图片描述

    • 概念:表对象里只保存与整个表有关的信息(即容量和元素个数),实际数据元素存放在另一个独立的元素存储区里,通过链接与基本表对象关联。

    2.3 元素存储区替换与扩充

    1. 元素存储区的替换
    • 一体式结构由于顺序表信息区与数据区连续存储在一起,所以若想更换数据区,则只能整体搬迁,即整个顺序表对象(指存储顺序表的结构信息的区域)改变了。

    • 分离式结构若想更换数据区,只需将表信息区中的数据区链接地址更新即可,而该顺序表对象不变。

    2. 元素存储区的扩充
    • 采用分离式结构的顺序表,若将数据区更换为存储空间更大的区域,则可以在不改变表对象的前提下对其数据存储区进行了扩充,所有使用这个表的地方都不必修改。把采用这种技术实现的顺序表称为动态顺序表,因为其容量可以在使用中动态变化。

    • 扩充的两种策略:
      1、线性增长:每次扩充增加固定数目的存储位置,如每次扩充增加10个元素位置。
      特点:节省空间,但是扩充操作频繁,操作次数多。

      2、每次扩充容量加倍,如每次扩充增加一倍存储空间。
      特点:减少了扩充操作的执行次数,但可能会浪费空间资源。以空间换时间,推荐的方式。

    2.4 顺序表的操作

    1. 增加元素

    在这里插入图片描述

    1. 尾端加入元素:直接在尾部加入即可,时间复杂度为O(1);
    2. 非保序加入元素:将插入位置的原元素调换到末尾,时间复杂度为O(1);
    3. 保序的加入元素:在某一位置插入元素后,原位置的元素依次后移。时间复杂度为O(n)。
    2. 删除元素

    在这里插入图片描述

    1. 删除末尾元素:直接删除,时间复杂度为O(1);
    2. 非保序的删除元素:元素删除后,直接将末尾的元素插入到删除位置。时间复杂度为O(1);
    3. 保序的元素删除:元素删除后,删除位置后面的元素依次前移。时间复杂度为O(n)。

    2.5 Python中的顺序表

    • Python中的顺序表:list、tuple

    • list就是一种采用分离式技术实现的动态顺序表。

    • list为什么采用分离式顺序表?

      list的特征是:允许任意加入元素,而且在不断加入元素的过程中,表对象的标识(函数id得到的值)不变。
      为满足该特征,就必须能更换元素存储区,并且为保证更换存储区时list对象的标识id不变,只能采用分离式实现技术。

    • list的实现策略:
      在建立空表(或者很小的表)时,系统分配一块能容纳8个元素的存储区;在执行插入操作(insert或append)时,如果元素存储区满就换一块4倍大的存储区。但如果此时的表已经很大(目前的阀值为50000),则改变策略,采用加一倍的方法。引入这种改变策略的方式,是为了避免出现过多空闲的存储位置。

    展开全文
  • 数据结构—顺序表详解

    千次阅读 多人点赞 2019-04-05 21:03:57
    线性表是一种在实际中广泛使用的数据结构,常见的线性表:顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物理上存储时,通常...
  • 数据结构--线性表与顺序

    千次阅读 2020-12-08 11:24:31
    1 线性表 线性表(linear list)是n个具有相同特性的数据元素的有限序列。...顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储,在数组上完成数据的增删查改。
  • 数据结构之顺序存储与链式存储

    千次阅读 2020-11-25 19:27:43
    线性表是n个数据特性相同的元素的组成有限序列,是最基本且常用的一种线性结构(线性表,栈,队列,串和数组都是线性结构),同时也是其他数据结构的基础。具有“一对一”逻辑关系的数据,最佳的存储方式是使用线性表...
  • 数据结构-顺序表基本操作的实现(含全部代码)

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表的实现,主要实现函数如下,读者有需要可以评论,我可以适当加几个。...
  • 《画解数据结构》九张动图,画解顺序

    万次阅读 多人点赞 2021-08-25 08:32:05
    本文已收录于专栏 《画解数据结构》 零、前言   目前本专栏正在进行优惠活动,在博主主页添加博主好友(好友位没有满的话),可以获取 付费专栏优惠券。   这篇文章,作者将用 「 七张动图 」 来阐述一种最基础...
  • excel表格同一个单元格数据顺序颠倒?要在excel的中输入一列为随意的文信息。2.然后进行选中已在输入的列表中A列,然后进行”右键““插入”。3.在列表中插入空白的一列,在进行一列中输入一列的有序的数字信息。4...
  • 数据结构——顺序表的逆置

    千次阅读 多人点赞 2021-03-20 22:58:31
    题目:请写一个算法将顺序存储结构的线性表(a1...an)逆置为(an...a1),要求使用最少的附加空间。 解析:可以理解为一个线性表内的交换问题。当n为奇数时,将第一个元素与最后一个元素进行交换,第二个元素与倒数...
  • 数据结构-两个顺序表合并

    千次阅读 2019-10-10 18:54:32
    #include <stdio.h> #define MaxSize 100 typedef struct { int data[MaxSize];... * 初始化顺序表 * @param L 顺序表L */ void Init_SeqList(SeqList& L) { L.length = 0; } /**...
  • 二叉树的存储结构有两种,分别为顺序存储和链式存储
  • 数据结构——顺序表的合并

    千次阅读 多人点赞 2021-02-02 20:34:47
    数据结构——顺序表的合并 具体要求:写一个函数,其函数的功能是将非递增顺序表LA和LB合并到非递增顺序表LC中 数据结构—顺序表的操作之合并顺序表 一、顺序表的结构 首先要定义的是顺序表的结构体,只有先定义了...
  • 顺序表的操作实验(数据结构)

    千次阅读 2021-02-21 21:48:47
    顺序表的操作实验 一、实验名称和性质 二、实验目的 1.掌握线性表的顺序存储结构的表示和实现方法。 2.掌握顺序表基本操作的算法实现。 3.了解顺序表的应用。 三、实验内容 1.建立顺序表。 2.在顺序表上...
  • 数据源kafka接收到多个topic(多种类型的)数据,(比如某个商品goods 的交易订单trade,交易金额数据broker,交易店铺order,交易历史stock情况) 然后将数据收集,再由多线程使用websocket实时推送给客户端 ...
  • 数据结构》实验报告(一)顺序表基本操作

    千次阅读 多人点赞 2021-04-04 02:51:00
    #define MAXSIZE 100 //顺序表的最大长度; int k=0;//全局变量,用于循环; typedef int elemtype;//元素类型; typedef struct{ elemtype data[MAXSIZE];//用数组存储线性表的元素; int length;//顺序表的长度...
  • 数据结构:线性表的顺序存储与链式存储

    千次阅读 多人点赞 2020-02-23 11:27:37
    文章目录一、线性表的基本概念二、动态数组(顺序表)的实现与测试 一、线性表的基本概念 线性表:线性表是零个或者多个数据元素的有限序列,是最常用且最简单的一种数据结构。 特点: (1)存在惟一的一个被称做“第一...
  • 在给出一组初始数据的情况下,实现顺序表的定义、创建、查找、插入、删除。 算法 顺序表的定义:一维数组、最大长度、实际长度 顺序表的创建:初始化顺序顺序表的查找:给出位置 i 的数据 顺序表的插入:位置 i ...
  • 数据结构-顺序表(动态分配存储空间)

    千次阅读 多人点赞 2019-10-10 18:52:47
    数据结构-顺序表(动态分配存储空间) (1)顺序表的结构定义: 结构型定义:(动态分配存储空间) /** * 动态分配存储空间 */ #define InitSize 100 //动态分配存储空间时,不限制最大,只给定一个初始值 #define ...
  • 好进行增容3、顺序表尾插4、顺序表尾删5、顺序表头插6、顺序表头删7、打印顺序表8、在顺序表中查找指定值9、在顺序表指定下标位置插入数据10、在顺序表中删除指定下标位置的数据11、查看顺序表中有效数据个数12、...
  • 队列中没有数据元素时称为空队列。 队列的操作是按照先进先出(first in first out)或后进后出(last in last out)的原则进行的。因此,队列又被称为FIFO表。它的实现方式主要有顺序队列、链队列两种。   队列...
  • 数据结构——C语言实现顺序

    千次阅读 2019-09-11 23:03:34
    数据结构——C语言实现顺序顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下顺序表是以数组为基础,结构体为框架来实现的。数组存储。在数组上完成数据的增删查改,而结构体中包含...
  • 数据结构:顺序表的基本操作

    万次阅读 多人点赞 2018-05-03 22:50:05
     线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素,使得线性表在逻辑结构上相邻的元素存储在连续的物理存储单元中,即:通过数据元素物理存储的连续性来反应元素之间逻辑上的相邻关系。...
  • MATLAB顺序读取文件夹数据

    千次阅读 2020-07-29 15:58:12
    通过顺序读取文件夹内的数据,可以实现matlab对不同数据进行批量处理分析,可以极高的提高效率。 具体方法: filedir=uigetdir(); %通过UI界面获取文件夹位置 list=dir(fullfile(filedir)); %将文件夹中的文件信息...
  • 数据结构学习心得——顺序

    千次阅读 2017-08-16 23:07:06
    一、线性表的定义线性表是具有相同特性数据元素的一个有限序列。该序列中所含元素的个数叫做线性表的长度,用n(n>0)表示。二、线性表的存储结构线性表的存储结构有顺序存储和链式存储两种。前者称为顺序表,后者...
  • 数据结构顺序表基本操作(C/C++实现)

    万次阅读 多人点赞 2019-10-22 23:23:01
    数据结构顺序表基本操作(C/C++实现) 涉及基本运算 初始化顺序表L 依次插入abcde元素 输出顺序表L 输出顺序表L的长度 判断顺序表L是否为空 输出顺序表L的第3个元素 输出元素a的位置 在第4个元素位置上插入f元素 ...
  • 数据结构——顺序表-删除算法

    千次阅读 2020-08-09 22:40:01
    #include #include #define SIZE 100 #define INCREMENT_SIZE 10 typedef struct{ int *elem; int length; int listsize;... printf("请输入输入数据的个数:"); scanf("%d",&sql.length); for(int i=0;i
  • 数据结构顺序表的指针(C语言)简单实现 思来想去决定向嵌入式系统方向靠拢。虽然本科是电子信息科学与技术,但是从未学过数据结构、操作系统等计算机方面的专业课。故最近开始学习数据结构,使用严蔚敏老师的第二版...
  • 数据结构】顺序查找和折半查找

    千次阅读 多人点赞 2021-04-03 08:07:36
    摘要:在本篇文章中,主要讲述了在数据结构中所涉及的几大查找算法,包括:顺序查找、折半查找、分块查找和散列表查找。这些查找方式都是数据结构中最基本的查找方式,并且在数据结构中运用广泛。在查找算法中,最为...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,746,259
精华内容 1,098,503
关键字:

属于顺序数据的是