嵌入式学习DAY19 --- 数据结构开始学习(时间复杂度,顺序表)

嵌入式100题(46):各种排序算法的时间空间复杂度、稳定性 各种排序算法的时间空间复杂度、稳定性 一、排序算法分类: 二、排序算法比较: 注: 1、归并排序可以通过手摇算法将空间复杂度降到O(1),但是时间复杂度会提高。 2、 基数排序时间复杂度为O(N*M),其中N为数据个数,M为数据位数。 三、 辅助记忆 1、时间复杂度记忆 冒泡、选择、直接 排序需要两个for循环,每次只关注一个元素,平均时间复杂度为O(n * n)O(n * n... 阅读详情

嵌入式入门学习笔记,遇到的问题以及心得体会!
DAY19

1、什么是数据结构
1、数据结构就是研究数据元素之间关系的一门计算机的基础学科
2、数据结构主要是研究非数值性程序设计中计算机操作的对象(数据)及其相互间关系和运算的学科
在这里插入图片描述
在这里插入图片描述

逻辑结构:
在这里插入图片描述

存储结构:
在这里插入图片描述
在这里插入图片描述

2、为什么要学习数据结构
以前我们在c语言程序,只需要想着我只要实现题目要求的功能就可以了,数据结构研究的是如何让程序运行起来更加高效,数据在内存中的操作更加流畅。
3、学习数据结构的方法
数据结构的特点:
1、比较抽象,对逻辑思维能力要求较高
2、代码量比较大

学习方法:
1、学会画图,将脑袋中抽象的东西画出来,变成具体的步骤
2、带着自己的思考敲代码
1、照着老师的代码敲(在敲的过程中,要思考每一行代码是在干什么,把对应注释写上)
2、自己尝试敲,重复,直到自己可以不看别人的代码,按照自己的思考敲出来
3、慢,自己的节奏,一点一点突破
4、什么是算法—时间复杂度
算法:解决问题的步骤的集合
算法的特点:1、可行性 2、有穷 3、与具体的计算机无关 3、确定性
程序=数据结构+算法

衡量一个算法的好坏:语句执行的次数(T(n))

int main()
{
Printf(“hello world”);      T(n) = 1   T(n) = O(1)
}

Int main()
{
Printf(“hello world”);
Printf(“hello world”);    T(n) = 2;   T(n) = O(1)

}

void fun(int n)
{
Int i;  1
For(i = 0; i < n; i++)   1  n+1  n
{
Printf(“hello world”);   n
    }
}
T(n) = 1+1+n+1+n+n = 3n+3   T(n) = 0(n)

在这里插入图片描述

5、顺序表 — 敲代码
1、顺序表的三个方面:
逻辑结构:线性结构—一对一
存储结构:顺序存储—数据元素和元素之间在内存中是连续的
运算:创建 增加 删除 查找 修改 排序 销毁

也就是:顺序表就是一块连续的内存空间,我们要实现的是对这块连续内存空间增删改查的操作

创建:就是申请一块连续的内存空间,然后将这块连续的内存空间的首地址返回

插入操作:
在这里插入图片描述

删除操作:
在这里插入图片描述

代码展示:
关于实现一个顺序表的功能步骤

第一步:首先编辑一个list.h文件

#ifndef _LIST_H_
#define _LIST_H_


typedef int data_t;
#define SIZE 5

/*
 * 创建一个顺序表
 * 增加一个元素
 * 删除一个元素
 * 修改元素的值
 * 查找
 * 排序
 * 销毁
 */

//通过该结构体来描述顺序表
typedef struct List
{
	data_t data[SIZE];
	int count; //当前顺序表的元素个数(插入了多少个元素)
}List;

enum LIST_OP
{
	LIST_ERROR = -1,
	LIST_OK,
	NOT_FOUND
};

List* createList();
int insertItemList(List *pList, int iOffset, data_t tData);
int deleteItemList(List *pList, int iOffset, data_t *pData);
int updateList(List *pList, data_t oldData, data_t newData);
int searchItemList(List *pList, data_t tData, int *pIndex);
int sortList(List *pList);
void destroyList(List **ppList);
void showList(List *pList);
#endif   //防止头文件重复包含

第二步:编辑一个list.c文件,用来具体编写各个功能如何实现

#include<stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"

/*功能:创建一个顺序表
 * 返回值:成功  顺序表的首地址
 * 失败:NULL
 */
List *createList()
{
	List *pList = (List *)malloc(sizeof(List));
	if(NULL == pList)
	{
		return NULL;
	}
	memset(pList, 0, sizeof(List));
	return pList;
}

/*
 * 功能:给顺序表插入一个元素
 * 参数:pList  顺序表的首地址
 *       iOffset  插入的位置
 *       tData  插入的值
 *返回值:成功  LIST_OK
         失败  LIST_ERROR
 */
int insertItemList(List *pList, int iOffset, data_t tData)
{
	if(NULL == pList || iOffset < 0 || iOffset >= SIZE || SIZE == pList->count)
	{
		return LIST_ERROR;
	}

	//根据iOffset将tData插入
	int i;
	for(i = pList->count-1; i >= iOffset; i--)
	{
		pList->data[i+1] = pList->data[i];
	}

	pList->data[iOffset] = tData;
	pList->count++;
	return LIST_OK;
}

/*
 * 功能:删除一个元素
 * 参数:pList  首地址
 *       iOffset 删除的位置
 *       pData  保存删除的元素
 *返回值:成功  LIST_OK
         失败  LIST_ERROR
 */
int deleteItemList(List *pList, int iOffset, data_t *pData)
{
	if(NULL == pList || iOffset < 0 || iOffset >= SIZE || NULL == pData || 0 == pList->count)
	{
		return LIST_ERROR;
	}

	//保存要删除的值 
	*pData = pList->data[iOffset];
    //删除:用后面的元素把前面的覆盖掉,count--
	int i;
	for(i = iOffset; i < pList->count-1; i++)
	{
		pList->data[i] = pList->data[i+1];
	}
	pList->count--;
	return LIST_OK;
}

int updateList(List *pList, data_t oldData, data_t newData)
{
	if(NULL == pList)
	{
		return LIST_ERROR;
	}

	//一旦发现顺序表中元素的值等于oldData就换成newData
	int i;
	for(i = 0; i < pList->count; i++)
	{
		if(pList->data[i] == oldData)
		{
			pList->data[i] = newData;
		}
	}
	return LIST_OK;
}

int searchItemList(List *pList, data_t tData, int *pIndex)
{
	//查找tData,如果找到了,就将这个元素的下标赋值给*iIndex
	//如果没有找到,就返回NOT_FOUND
	if(NULL == pList || NULL == pIndex)
	{
		return LIST_ERROR;
	}
	int i;
	for(i = 0; i < pList->count; i++)
	{
		if(pList->data[i] == tData)
		{
			*pIndex = i;
			return LIST_OK;
		}
	}
	return NOT_FOUND;
}
int sortList(List *pList)
{
}

void destroyList(List **ppList)
{
	if(NULL == ppList || NULL == *ppList)
	{
		return;
	}
	free(*ppList);
	*ppList = NULL;
}
void showList(List *pList)
{
	if(NULL == pList)
	{
		return;
	}
	int i;
	for(i = 0; i < pList->count; i++)
	{
		printf("%d  ", pList->data[i]);
	}
	printf("\n");
}

第三步:编辑一个main.c文件用来具体实现如何调用

#include<stdio.h>
#include "list.h"


int main()
{
	List *pList = createList();
	if(NULL == pList)
	{
		printf("创建失败!\n");
		return -1;
	}

	int i, ret;
	for(i = 0; i < 3; i++)
	{
		ret = insertItemList(pList, i, i+100);
		if(LIST_ERROR == ret)
		{
			printf("插入失败!\n");
			return -1;
		}
	}
	showList(pList);
    ret = insertItemList(pList, 0, 888);
	if(LIST_ERROR == ret)
	{
		printf("插入失败!\n");
		return -1;
	}
	showList(pList);

	data_t data;
	deleteItemList(pList, 2, &data);
	printf("删除的元素:%d\n", data);
	showList(pList);

	updateList(pList, 888, 999);
	showList(pList);

	printf("请输入要查找的数据:");
	scanf("%d", &data);
	int index;
	ret = searchItemList(pList, data, &index);
    if(NOT_FOUND == ret)
	{
		printf("没有找到!\n");
	}
	else
	{
		printf("查找的结果是:%d\n", index);
	}
	
	//destroy之后pList就变成了NULL
	destroyList(&pList);
	return 0;
}

扩展:
我们讲的顺序表的大小是固定的,最多只能是5个元素,那么能不能进行扩容呢?
也就是就算满了,我再继续插入也是可以的

顺序表的动态扩容
现在遇到的问题:原来的空间不够用了,会导致插入失败
解决办法:申请一块更大的空间,把原来小的空间的内容全部拷贝到新的空间,把要插入的数据插入到新的空间,将原来旧的空间给释放掉

Insert()
{
如果顺序表满了,就申请更大的空间
也就是data的大小变化了
}

回忆昨天的顺序表是如何定义的:

Struct List
{
Data_t data[SIZE];
Int count;
};

但是data_t data[SIZE];这个数组大小没办法改变,因为data是数组名,是常量,没办法修改
所以结构体需要重新定义

Struct List
{
Data_t *data;      //首地址
Int count;   //元素的个数
Int size;    //数组的容量
};

在这里插入图片描述
在这里插入图片描述

基础代码同上方差不多,我在这只贴出来list.c的代码

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"

List *createlist()
{
	List *pList = (List *)malloc(sizeof(List));
	if(NULL == pList)
	{
		return NULL;
	}
	memset(pList,0,sizeof(List));

	//给data赋值,让data指向一块连续的内存空间
	pList->size = SIZE;
	pList->data = (data_t *)malloc(sizeof(data_t)*pList->size);
	if(NULL == pList->data)
	{
		return NULL;
	}
	memset(pList->data, 0, sizeof(data_t)*pList->size);
	return pList;
}

int insert_list_item(List *pList,int ioffset,data_t tdata)
{
	if(NULL == pList || ioffset < 0 || ioffset > pList->size)
	{
		printf("1111\n");
		return LIST_ERROR;
	}
	
	//当表满的时候,需要实现扩容
	if(pList->size == pList->count)
	{
		//先保存一下原来的size
		int size = pList->size;
		//申请一块更大的空间
		pList->size += 5;
		data_t *pTmp = (data_t *)malloc(sizeof(data_t) * pList->size);
		if(NULL == pTmp)
		{
		    printf("222\n");
			return LIST_ERROR;
		}
		memset(pTmp, 0, sizeof(data_t)*pList->size);
        //将原来小的空间的内容拷贝到新的空间
		memcpy(pTmp, pList->data, sizeof(data_t)*size);

		//将原来的空间释放
		free(pList->data);
		//使得data指向新的空间
		pList->data = pTmp;
	}
	int i;
	for(i = pList->count-1;i >= ioffset;i--)
	{
		pList->data[i+1] = pList->data[i];
	}
	pList->data[ioffset] = tdata;
	pList->count++;
	return LIST_OK;
}

int delete_list_item(List *pList,int ioffset,data_t *pdata)
{
	if(NULL == pList || ioffset < 0 || ioffset > pList->count || NULL ==pdata || 0 == pList->count)
	{
		return LIST_ERROR;
	}
	*pdata = pList->data[ioffset];
	int i;
	for(i = ioffset;i < pList->count - 1;i++)
	{
		pList->data[i] = pList->data[i+1];
	}
	pList->count--;
	return LIST_OK;
}

int update_list_item(List *pList,data_t oldata,data_t newdata)
{
	if(NULL == pList)
	{
		return LIST_ERROR;
	}
	int i;
	for(i = 0;i < pList->count;i++)
	{
		if(pList->data[i] == oldata)
		{
			pList->data[i] = newdata;
		}
	}
	return LIST_OK;
}

int search_list_item(List *pList,data_t tdata,int *pindex)
{
	if(NULL == pList || NULL == pindex)
	{
		return LIST_ERROR;
	}
	int i;
	for(i = 0;i < pList->count;i++)
	{
		if(pList->data[i] == tdata)
		{
			*pindex = i;
			return LIST_OK;
		}
	}
	return NOT_FOUND;
}

int sort_list(List *pList)
{
	if(NULL == pList)
	{
		return LIST_ERROR;
	}
	int i, j;
	for(i = 0; i < pList->count-1; i++)
	{
		for(j = 0; j < pList->count-i-1; j++)
		{
			if(pList->data[j] > pList->data[j+1])
			{
				data_t tmp = pList->data[j];
				pList->data[j] = pList->data[j+1];
				pList->data[j+1] = tmp;
			}
		}
	}
	return LIST_OK;
}

void show_list(List *pList)
{
	if(NULL == pList)
	{
		return;
	}
	int i;
	for(i = 0;i < pList->count;i++)
	{
		printf("%d\t",pList->data[i]);
	}
	puts("");
}

void destroy_list(List **pplist)
{
	if(NULL == pplist || NULL == *pplist)
	{
		return;
	}
	free(*pplist);
	*pplist = NULL;
}

树莓派3-改装wifi外置天线 声明:本文只是技术性探讨,改装引起的产品损坏等后果,由用户自负! 改装主要有两种方法 方法一:直接替换原来的天线 1、移除原有的小陶瓷天线,就在Made in PRC(或UK)那边的那个 清理一下阻焊剂方便天线接地(图中PRC左侧) 2、焊接天线 天线的屏蔽层焊接到清理完阻焊剂的地方,中间的信号线焊接到PRC右侧焊盘。 3、最终的样子 阅读详情

相关推荐

ST-CNN实战:用Python实现交通流量预测(附完整代码)

本文详细介绍了如何利用时空卷积神经网络(ST-CNN)进行交通流量预测的实战过程。通过Python和PyTorch,从数据预处理、构建邻接矩阵,到ST-CNN核心模块的代码实现与模型训练,提供了完整的解决方案,帮助开发者掌握处理时空序列数据的核心算法。

rust6ferris的博客 930

通过构建一个顺序表——教你计算时间复杂度和空间复杂度(含递归)

算法效率分析分为两种:第一种是时间效率,第二种是空间效率。时间效率被称为时间复杂度,而空间效率被称作空间复杂度。 时间复杂度主要衡量的是一个算法的运行速度,而空间复杂度主要衡量一个算法所需要的额外空间。这篇博客将会手把手构建一个顺序表,在具体的代码中帮助理解一段代码的时间和空间复杂度。...

JDSZGLLL的博客 3692

接口操作MySQL跟MongoDB事务回滚问题

通常使用的事务注解:@Transactional 是不会对MongoDB生效的,但是在一些生产接口中无法避免同时使用MySQL跟MongoDB的操作。

weixin_45932023的博客 1579

数据结构:「顺序表基本操作」及其「时间复杂度分析」

顺序表定义 1,前言 线性表的顺序存储又称为顺序表。它是用一组地址连续的存储单元依次存储线性表中的数据元素,从而使得逻辑上相邻的两个元素在物理位置上也相邻。其最大的特点就是:元素的逻辑顺序与其物理顺序相同。 线性表的顺序存储结构中任一元素都可以随机存取,并且注意:线性表中元素的位序是从1 开始的,而数组中元素的下标是从0 开始的。假定线性表的元素类型为 EleType ,则线性表的顺序存储类型可以描述为: 2,动态实现 1,结构定义: 2,初始化顺序表: 3,增加动态数组的...

致力于C语言C++知识分享! 7467

10行代码搞定QMT实盘交易:手把手教你用Python自动化买卖股票(附完整源代码)

本文提供了一份详尽的QMT实盘交易教程,手把手教你使用Python构建自动化交易系统。内容涵盖环境配置、账户连接、查询与下单等核心代码,并附有完整的源代码示例,帮助开发者快速掌握从零到实盘的完整流程,实现安全可靠的股票自动化买卖。

weixin_29214335的博客 443

Oracle到金仓数据库信创改造迁移实施规划方案

**性能测试和优化**:对金仓数据库的性能进行测试,根据业务负载情况进行必要的调优,确保系统能够稳定高效运行。- **数据兼容性**:评估Oracle数据库中的数据结构和金仓数据库的兼容性,明确需要重构的数据模型。- **性能测试**:通过对金仓数据库的性能测试,预估在实际业务环境下的表现,是否能达到业务需求。- **工具选择**:选择适合的迁移工具,如金仓数据库提供的迁移工具,能够提升迁移效率和准确性。- **全面迁移**:在初步迁移成功后,进行全面数据迁移,确保所有数据完整迁移到金仓数据库上。

hdrhdrjdididrr的博客 482

【数据结构】顺序表

顺序表是一种线性表的数据结构,它的数据元素按照一定次序依次存储在计算机存储器中,使用连续的存储空间来存储。顺序表中每个数据元素的位置都有一个序号,这个序号也称为元素在顺序表中的下标。

nanguochenchuan的博客 1299

【笔记篇】Davinci Configurator OS模块(上)

主要讲解了AUTOSAR OS配置项和Vector MICROSAR OS的特性

weixin_47571898的博客 2274

顺序表的时间复杂度分析

1.顺序表的初始化中函数的应用: L.elem=new ElemType[MAIXSIZE];//为顺序表分配一个大小为MAIXSIZE的数组空间。 运用了C++中的new函数进行动态地址分配。 一般分配模式为:未知量=new 类型名 (列表初值)//列表初值可无。 例:int*p= new int;或int *p=new int (10); 每个new 都要对应一个delete,来释放分配的内存; L.elem=(int *)malloc(number *size of[MAIXSIZE])

qq_41169728的博客 6100

[STC32G144K246入门第一步]点亮LED

STC32G144K246是一款高性能32位8051单片机,集成了丰富外设资源,适用于工业控制和复杂算法处理。该芯片支持双模式内核,内置硬件加速器,提供246KB Flash和144KB SRAM存储空间。文章详细介绍了开发环境搭建步骤、寄存器配置方法,并给出了LED驱动示例代码,通过推挽输出控制P42口实现闪烁效果。虽然开发环境相比ARM存在不足,但通过合理配置仍可满足项目需求。该教程为开发者快速上手STC32G144K246提供了实用参考。

sinat_58149788的博客 800

实战!C#整合YOLO+Halcon做玻璃瓶口缺陷检测:裂纹识别+尺寸测量一步到位(附DLL交互代码)

AI擅长语义识别(裂纹、缺陷),传统机器视觉擅长精密测量(尺寸、位置),C#做整合层,才能满足工业生产的“精度+效率+稳定性”要求。这套方案不只是玻璃瓶检测能用,改改模型和测量逻辑,还能用到瓶盖缺陷检测、饮料瓶液位检测等场景。如果你们厂也有类似的质检痛点,评论区留个言,我帮你看看怎么调整算法参数。

这里只有干货:从 Modbus 通信到 MES 对接,从 YOLO 训练到工控机部署,带你搞定工业软件开发全流程。 873

嵌入式学习DAY19 --- 数据结构开始学习(时间复杂度,顺序表)(2)

对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。,朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》,可以扫描下方二维码领取(如遇扫码问题,可以在评论区留言领取哦)~//查找tData,如果找到了,就将这个元素的下标赋值给*iIndex。* 返回值:成功 顺序表的首地址。

2401_84264583的博客 958

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

2024年最新嵌入式学习DAY19 --- 数据结构开始学习(时间复杂度,顺序表),2024年最新干货精讲

以前我们在c语言程序,只需要想着我只要实现题目要求的功能就可以了,数据结构研究的是如何让程序运行起来更加高效,数据在内存中的操作更加流畅。也就是:顺序表就是一块连续的内存空间,我们要实现的是对这块连续内存空间增删改查的操作。1、照着老师的代码敲(在敲的过程中,要思考每一行代码是在干什么,把对应注释写上)2、自己尝试敲,重复,直到自己可以不看别人的代码,按照自己的思考敲出来。创建:就是申请一块连续的内存空间,然后将这块连续的内存空间的首地址返回。1、学会画图,将脑袋中抽象的东西画出来,变成具体的步骤。

2401_84520182的博客 381

IDEA的使用指南

IDEA基于java的使用手册,可以最快速的上手,在使用中不断的丰富自己的使用技巧.

廖雪峰Python教程[完整版]

廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白

【嵌入式学习】数据结构-Day2-顺序表

在链式存储结构中,线性表的元素在内存中可以是不连续的,通过指针来连接各个元素。:数据元素之间存在一对一的逻辑关系(数组,地铁的座位)头节点无直接前驱,尾节点无直接后继,中间节点存储在唯一的前驱唯一的后继。:数据元素之间存在一对多的逻辑关系(族谱,公司架构)头结点无直接前驱,尾节点无直接后继,中间节点存在唯一的直接前驱,多个后继。线性结构是一种元素之间存在一对一的关系,即每个元素都有唯一的直接前驱和直接后继。线性表:顺序表,链表,数组,栈,队列,字符串。数据类型(整数,小数,字符,字符串,汉字)

BH6AEV的博客 1694

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

嵌入式学习 day20:数据结构-顺序表

程序 = 数据结构 + 算法数据结构研究的是数据如何组织和存储,算法研究的是数据如何操作和处理,两者相辅相成。顺序表是用连续内存空间存储数据的线性结构。数组就是顺序表的一种实现。text首地址 末地址(物理地址连续)程序 = 数据结构 + 算法逻辑结构:线性(一对一)、树形(一对多)、图形(多对多)存储结构:顺序存储(连续)、链式存储(不连续)时间复杂度顺序表:用数组实现,随机访问快,插入删除慢今日感悟。

2401_85242990的博客 202

【学习嵌入式day16-数据结构】

一个链表就是节点,一个节点分为一个数据域和地址域* 链表存放数据的类型 *//* 链表节点类型 *///存放数据空间//存放下一个节点地址}linknode。

weixin_47152578的博客 781

嵌入式学习day15(顺序表)

顺序表

m0_37565374的博客 197

嵌入式开发学习日志(数据结构)Day18——顺序表(一)

数据结构是研究数据元素之间特定关系的学科,主要分为逻辑结构和物理结构。逻辑结构包括集合、线性、树和图,分别表示数据元素之间的平等、一对一、一对多和多对多关系。物理结构则涉及数据在内存中的存储方式,如顺序存储和链式存储。数据结构的基本概念包括数据、数据项、数据对象和数据类型,其中抽象数据类型(ADT)是数学模型和操作的集合。程序由数据和算法组成,算法具有输入输出特性、有穷性、确定性和可行性。算法的设计要求正确性、可读性、健壮性和高效性。时间复杂度是衡量算法执行时间的标准,通过简化计算步骤来评估。线性表是数据元

qq_63203532的博客 1316

自学嵌入式day20,顺序表

DATATYPE是通用数据类型,线性表,本质是一个容器,存储什么类型的数据,都是可以的,因为需要定义函数接口,通用数据类型作为参数,或者返回值使用。数据元素,描述一个相对完整的一个事物,就会有很多的属性,这里的属性被称为数据项。广义:如何把数据高效储存在计算机的内存中,方便后续使用,(增,删,改,查)。2.堆空间的生命周期,是由程序员控制的,需要的时候malloc,不需要的时候free。2.有穷性,执行的步骤会自动结束,不能是死循环,并且每一步是可以接收的时间内完成。数据对象,是数据元素的集合。

m0_62148706的博客 849

嵌入式Linux学习笔记 | 数据结构(Day02)顺序表核心功能实现 + 快速排序 + 折半查找 + 作业实战

本文完整实现了顺序表的核心功能,包括查找、修改和排序操作。采用泛型设计,通过void指针和元素大小参数支持任意数据类型。详细讲解了快速排序的分区递归算法和折半查找的二分思想,时间复杂度分别为O(nlogn)和O(logn)。实战部分实现顺序表倒序和极值查询功能,巩固指针操作和遍历技巧。所有代码可直接编译运行,配套测试用例验证功能正确性,适合数据结构学习和面试备考。

2301_76932294的博客 364

嵌入式系统学习Day19(数据结构)

算法的特性:输入输出特性(输入可省,输出必须有,数值的改变就可以称为输出),可读性(便于阅读), 可行性(可以用代码执行出来),有穷性(是有限的),确定性(同一个输入会是同一个输出)逻辑关系:集合,线性(1对1,中间位置的值有且仅有一个前驱,一个后继),树(1对多),图(多对多)特征: 支持随机访问 head+5 head[0] O(1)时间复杂度,时间的度量(事前分析法) ,大O 记法。相互之间存在一种或多种特定关系的数据元素的集合。顺序结构(类似于数组):存储空间连续,有序。衡量算法好坏的方法。

Zhangh___的博客 261

嵌入式学习Day 17 数据结构(1)

程序 == 数据结构 + 算法。

2501_91510279的博客 796

【数据结构入门 Day1】顺序表全解析 + 实战踩坑汇总

数据结构是嵌入式 / 后端开发的核心基础,第一天从线性表 —— 顺序表数据结构基本概念与分类顺序表的底层原理与结构体设计增、删、改、查、创建、销毁全套接口实现手写代码高频踩坑与避坑指南顺序表底层是连续数组,随机访问快,插入删除需挪动元素核心操作围绕clen展开,所有增删必须同步更新有效长度遍历类函数严禁在循环内提前 return,否则会终止遍历二级指针的核心作用:修改外部指针变量本身,常用于销毁置空边界判断是高频考点:插入位置、数组下标、空表空指针都要做防护。

2401_89475491的博客 451

嵌入式学习day17

1.概念:程序 == 数据结构 + 算法描述数据存储和操作的结构操作数据对象的方法2.衡量代码的质量和效率:1.时间复杂度:数据量的增长与程序运行时间的增长所呈现的比例函数关系,称为时间渐近复杂度函数,也简称时间复杂度常见的时间复杂度:(低 -> 高)O(1):程序运行时间维持恒定O(logn):程序刚开始运行时间可能增长较快,但经过一定数据量后,程序运行时间趋于恒定O(n):程序运行时间随数据量增长呈现固定的比例关系O(nlogn)O(n^2)O(n^3)O(2^n)

mysla的博客 628
上一篇: 统计自己Ubuntu系统中家目录下,一共敲了多少行代码。 要求:使用C语言实现
下一篇: 嵌入式学习DAY20 --- 数据结构(单链表)
南窗的雨
博客等级 码龄6年 687粉丝 97原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值