【图解数据结构】顺序表实战指南:手把手教你详细实现(超详细解析)

在这里插入图片描述
🌈个人主页:聆风吟
🔥系列专栏:图解数据结构、算法模板
🔖少年有梦不应止于心动,更要付诸行动。


文章目录

  • 一. ⛳️线性表
    • 1.1 🔔线性表的定义
    • 1.2 🔔线性表的存储结构
  • 二. ⛳️顺序表
    • 2.1 🔔顺序表定义
    • 2.2 🔔顺序表的分类
      • 2.2.1 👻静态顺序表
      • 2.2.2 👻动态顺序表
  • 三. ⛳️顺序表的基本操作实现
    • 3.1 🔔动态顺序表结构体构建
    • 3.2 🔔初始化顺序表
    • 3.3 🔔销毁顺序表
    • 3.4 🔔打印顺序表
    • 3.4 🔔扩容
    • 3.5 🔔尾插
    • 3.6 🔔尾删
    • 3.7 🔔头插
    • 3.8 🔔头删
    • 3.9 🔔在下标为pos位置插入x
    • 3.10 🔔删除下标为pos位置的数据
    • 3.11 🔔查找某个值的下标
  • 四. ⛳️顺序表的完整源代码
    • 4.1 🔔SeqList.h 顺序表的函数声明
    • 4.2 🔔SeqList.c 顺序表的函数定义
    • 4.3 🔔test.c 顺序表功能测试
  • 📝总结

一. ⛳️线性表

1.1 🔔线性表的定义

线性表(linear list):线性表是一种数据结构,由n个具有相同数据类型的元素构成一个有限序列。线性表可以用数组、链表、栈等方式实现,常见的线性表有数组、链表、栈、队列等,也可以自定义实现。

这里需要强调一下几点:
    首先它是一个序列。也就是说,元素之间是有顺序的。线性表中的元素称为结点,相邻结点之间的关系称为邻接关系。除第一个结点无前驱和最后一个结点无后继外,其他每个结点有且仅有一个前驱和一个后继。图解如下:
在这里插入图片描述

注意:
线性表元素个数n (n >= 0)定义为线性表的长度,当n=0时,称为空表


1.2 🔔线性表的存储结构

     线性表的存储结构有顺序存储结构和链式存储结构两种。前者称为顺序表,后者称为链表:
在这里插入图片描述     其中,线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物理上存储时,通常以数组和链式结构的形式存储。
在这里插入图片描述
     本文主要详细讲解线性表的顺序存储结构 —— 顺序表。线性表的链式存储将在下期讲解,言归正传接下来让我们开始今天的 “主菜" 学习。



二. ⛳️顺序表

2.1 🔔顺序表定义

     顺序表(Sequential List):用一段物理地址连续的存储单元依次存储数据元素的线性结构。一般情况下采用数组存储。在数组上完成数据的增删查改。

在这里插入图片描述

2.2 🔔顺序表的分类

顺序表一般可以分为:静态顺序表动态顺序表

2.2.1 👻静态顺序表

     静态顺序表:指存储空间是固定的并且在程序运行前就已经确定大小的顺序表。它通常使用数组来实现,即通过定义一个固定长度的数组来存储数据元素。

静态顺序表的结构代码:

//静态顺序表 —— 使用定长数组存储元素(不实用)
#define MAXSIZE 7//存储单元初始分配量
typedef int SLDataType;//SLDataType类型根据实际情况而定,这里是inttypedef struct SeqList
{SLDataType data[MAXSIZE];//定长数组int size;//有效数据的个数
}SeqList;

我们可以发现描述静态顺序表需要三个属性:

  • 存储空间的起始位置:数组data,他的存储位置就是存储空间的存储位置;
  • 线性表的最大存储容量:数组长的MAXSIZE
  • 线性表的当前位置:size

在这里插入图片描述静态顺序表的优缺点:

  1. 由于静态顺序表大小是固定的,因此不支持动态插入和删除,但可以通过重新分配空间的方式来增加或减少容量;
  2. 静态顺序表的优点:访问数据快速,由于是连续存储,所以可以直接通过下标访问元素,效率高;
  3. 静态顺序表的缺点:空间利用率低,因为必须预留足够的空间,以防止溢出。

2.2.2 👻动态顺序表

     动态顺序表:通过动态分配内存空间,实现随着数据量的增加而不断扩容的效果。它的结构类似于一个数组,数据元素的存储是连续的,支持随机访问和顺序访问。

动态顺序表的结构代码:

//动态顺序表 —— 使用动态开辟的数组存储
typedef int SLDataType;//SLDataType类型根据实际情况而定,这里是inttypedef struct SeqList
{SLDataType* a;//指向动态开辟的数组int size;//有效数据的个数int capacity;//记录容量的空间大小
}SL;

我们可以发现描述动态顺序表也需要三个属性:

  • 存储空间的起始位置:指针a,他里面存储的地址就是存储空间的地址;
  • 线性表当前最大存储容量:capacity,可以通过动态分配的方式进行扩容;
  • 线性表的当前位置:size

在这里插入图片描述动态顺序表的优缺点:

  1. 动态顺序表的优点:可以使用指针动态地分配内存,具有高效的存储和访问效率;
  2. 动态顺序表的缺点:在插入和删除元素时需要移动大量的数据,效率较低。


三. ⛳️顺序表的基本操作实现

    通过上面的学习我们已经初步了解静态顺序表和动态顺序表,有同学估计要问了在日常生活中我们应该使用哪种呢?在这里作者推荐大家使用动态顺序表。因为动态顺序表可以使程序更加高效和灵活,可以根据实际数据量动态地调整表的大小,避免在创建静态顺序表时浪费内存空间或者当数据量超出静态顺序表容量时造成数据丢失或程序崩溃等问题。本文也将采用动态顺序表结合图文去实现顺序表的基本操作。

3.1 🔔动态顺序表结构体构建

//动态顺序表
#define SLCAPACITY 4
typedef int SLDataType;typedef struct SeqList
{SLDataType* a;//指向动态开辟的数组int size;//有效数据的个数int capacity;//记录容量的空间大小
}SL;

代码深剖:

  • 结构体中 a 指向的数组类型是我们重定义的SLDataType,这样当我们想创建其它类型的顺序表时只需要对 typedef 后面的类型进行需改即可;
  • size是用来计数的,统计当前顺序表一共有多少个有效元素;
  • capacity是用来表示当前顺序表的容量,当size==capacity时说明当前顺序表已经“装满了”,需要扩容;
  • 定义标识符SLCAPACITY,方便后文对顺寻表进行初始化可以方便改变capacity的初始值。

3.2 🔔初始化顺序表

//初始化顺序表
void SLInit(SL* ps)
{assert(ps);//使用malloc开辟空间ps->a = (SLDataType*)malloc(sizeof(SLDataType)*4);//判断空间是否开辟成功if (NULL == ps->a){perror("malloc failed");exit(-1);}ps->size = 0;ps->capacity = SLCAPACITY;
}

代码深剖:

  • 在这里我们需要使用assertps进行一下断言,以防传入空指针(后文在出现就不多做叙述了)。
  • 使用malloc开辟空间,一定要进行判断是否开辟成功,如果不进行判断直接使用可能会导致程序崩溃。

时间复杂度:

该程序没有循环,根据大O阶的推导方法很容易得出:初始化顺序表的时间复杂度为O(1)


3.3 🔔销毁顺序表

//销毁顺序表
void SLDestroy(SL* ps)
{assert(ps);free(ps->a);ps->a = NULL;ps->size = ps->capacity = 0;
}

代码深剖:
    为什么在这里要销毁顺序表呢?因为我们在这里使用的动态顺序表,a是通过malloc进行动态申请的空间,如果使用了malloc分配的内存空间后忘记释放,会导致内存泄漏,浪费系统资源甚至导致程序崩溃。

时间复杂度:

该程序没有循环,根据大O阶的推导方法很容易得出:销毁顺序表的时间复杂度为O(1)


3.4 🔔打印顺序表

//打印顺序表
void SLPrint(SL* ps)
{assert(ps);for (int i = 0; i < ps->size; i++){printf("%d ", ps->a[i]);}printf("\n");
}

代码深剖:
打印顺序表就是进行简单的遍历循环,此处不多做叙述。

时间复杂度:

该程序有单层循环,根据大O阶的推导方法很容易得出:打印顺序表的时间复杂度为O(n)


3.4 🔔扩容

    因为扩容在尾插、头插以及在pos位置插入都需要使用,因此我们可以把扩容单独封装成一个函数,可以降低代码的的冗余。整体思路图解:
在这里插入图片描述

//检查容量是否够,不够进行扩容
void SLCheckCapacity(SL* ps)
{assert(ps);//满了要扩容if (ps->size == ps->capacity){//使用realloc进行扩容SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * 2 * (ps->capacity));//检查是否扩容成功if (temp == NULL){perror("realloc failed");exit(-1);}ps->a = temp;ps->capacity *= 2;}
}

代码深剖:
    realloc是C语言中的一个函数,用于重新分配已经分配的内存空间的大小。它的原型是:

//头文件
#include<stdlib.h>
//原型
extern void *realloc(void *mem_address, unsigned int newsize)

其中,mem_address是指向已分配内存的指针,newsize是新的内存大小。如果内存分配失败,将会会返回NULL

时间复杂度:

该程序没有循环,根据大O阶的推导方法很容易得出:扩容的时间复杂度为O(1)


3.5 🔔尾插

    尾插时需要先判断顺序表是否满了,满了要先进行扩容才能继续进行扩容。size表示有效元素个数,同时也是顺序表中最后一个元素后一个位置的下标。成功插入后要对有效数据个数size进行加1操作。整体思路图解:
在这里插入图片描述

//尾插
void SLPushBack(SL* ps, SLDataType x)
{assert(ps);//检查是否需要扩容SLCheckCapacity(ps);ps->a[ps->size] = x;ps->size++;
}

时间复杂度:

该程序没有循环,根据大O阶的推导方法很容易得出:尾插的时间复杂度为O(1)


3.6 🔔尾删

整体思路图解:
在这里插入图片描述

//尾删
void SLPopBack(SL* ps)
{assert(ps);//温柔检查/*if (ps->size == 0)return;*///暴力检查assert(ps->size > 0);ps->size--;
}

代码深剖:
    在代码中我们提供两种检查顺序表是否为空的办法。第一种是比较温柔的检查,如果顺序表为空直接返回,返回之后仍然可以进行其他操作。第二种是比较暴力的检查方法,直接提示错误并打印出错误位置的行号。
在这里插入图片描述
时间复杂度:

该程序没有循环,根据大O阶的推导方法很容易得出:尾删的时间复杂度为O(1)


3.7 🔔头插

整体思路图解:
在这里插入图片描述

//头插
void SLPushFront(SL* ps, SLDataType x)
{assert(ps);//检查是否需要扩容SLCheckCapacity(ps);//挪动数据int end = ps->size - 1;while (end >= 0){ps->a[end + 1] = ps->a[end];--end;}ps->a[0] = x;ps->size++;
}

时间复杂度:

该程序需要执行单层循环,根据大O阶的推导方法很容易得出:头插的时间复杂度为O(n)


3.8 🔔头删

整体思路图解:
在这里插入图片描述

//头删
void SLPopFront(SL* ps)
{assert(ps);//判断顺序表是否为空assert(ps->size > 0);//挪动元素向前覆盖int begin = 1;while (begin < ps->size){ps->a[begin - 1] = ps->a[begin];++begin;}ps->size--;
}

时间复杂度:

该程序需要执行单层循环,根据大O阶的推导方法很容易得出:头插的时间复杂度为O(n)


3.9 🔔在下标为pos位置插入x

整体思路图解:
在这里插入图片描述

//在下标为pos的位置插入x
void SLInsert(SL* ps, int pos, SLDataType x)
{assert(ps);//检查pos是否在有效范围内assert(pos >= 0 && pos <= ps->size);//检查是否需要扩容SLCheckCapacity(ps);//挪动数据int end = ps->size - 1;while (end >= pos) {ps->a[end + 1] = ps->a[end];--end;}//插入元素ps->a[pos] = x;ps->size++;
}

时间复杂度:

该程序需要执行单层循环,根据大O阶的推导方法很容易得出:pos位置插入的时间复杂度为O(n)


3.10 🔔删除下标为pos位置的数据

整体思路图解:
在这里插入图片描述

//删除下标为pos位置的数据
void SLErase(SL* ps, int pos)
{assert(ps);//检查pos是否在有效范围内assert(pos >= 0 && pos < ps->size);//挪动元素向前覆盖int begin = pos + 1;while (begin < ps->size){ps->a[begin - 1] = ps->a[begin];++begin;}ps->size--;
}

时间复杂度:

该程序需要执行单层循环,根据大O阶的推导方法很容易得出:pos位置删除的时间复杂度为O(n)


3.11 🔔查找某个值的下标

//查找某个值的下标,没找到返回-1
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;
}

时间复杂度:

该程序需要执行单层循环,根据大O阶的推导方法很容易得出:查找的时间复杂度为O(n)



四. ⛳️顺序表的完整源代码

4.1 🔔SeqList.h 顺序表的函数声明

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>//动态顺序表
#define SLCAPACITY 4
typedef int SLDataType;typedef struct SeqList
{SLDataType* a;//指向动态开辟的数组int size;//有效数据的个数int capacity;//记录容量的空间大小
}SL;//管理数据 —— 增删查改//初始化
void SLInit(SL* ps);
//销毁顺序表
void SLDestroy(SL* ps);
//打印顺序表
void SLPrint(SL* ps);
//检查容量是否够,不够进行扩容
void SLCheckCapacity(SL* ps);//尾插尾删
void SLPushBack(SL* ps, SLDataType x);
void SLPopBack(SL* ps);//头插头删 
void SLPushFront(SL* ps, SLDataType x);
void SLPopFront(SL* ps);//查找某个值的下标,没找到返回-1
int SLFind(SL* ps, SLDataType x);//在pos位置插入x
void SLInsert(SL* ps, int pos, SLDataType x);
//删除pos位置的数据
void SLErase(SL* ps, int pos);

4.2 🔔SeqList.c 顺序表的函数定义

#include "SeqList.h"//初始化顺序表
void SLInit(SL* ps)
{assert(ps);//使用malloc开辟空间ps->a = (SLDataType*)malloc(sizeof(SLDataType)*4);//判断空间是否开辟成功if (NULL == ps->a){perror("malloc failed");exit(-1);}ps->size = 0;ps->capacity = SLCAPACITY;
}//销毁顺序表
void SLDestroy(SL* ps)
{assert(ps);//释放动态开辟的空间free(ps->a);ps->a = NULL;ps->size = ps->capacity = 0;
}//打印顺序表
void SLPrint(SL* ps)
{assert(ps);for (int i = 0; i < ps->size; i++){printf("%d ", ps->a[i]);}printf("\n");
}//检查容量是否够,不够进行扩容
void SLCheckCapacity(SL* ps)
{assert(ps);//满了要扩容if (ps->size == ps->capacity){//使用realloc进行扩容SLDataType* temp = (SLDataType*)realloc(ps->a, sizeof(SLDataType) * 2 * (ps->capacity));//检查是否扩容成功if (temp == NULL){perror("realloc failed");exit(-1);}ps->a = temp;ps->capacity *= 2;}
}//尾插
void SLPushBack(SL* ps, SLDataType x)
{assert(ps);//检查是否需要扩容SLCheckCapacity(ps);ps->a[ps->size] = x;ps->size++;
}//尾删
void SLPopBack(SL* ps)
{assert(ps);//暴力检查assert(ps->size > 0);ps->size--;
}//头插
void SLPushFront(SL* ps, SLDataType x)
{assert(ps);//检查是否需要扩容SLCheckCapacity(ps);//挪动数据int end = ps->size - 1;while (end >= 0){ps->a[end + 1] = ps->a[end];--end;}ps->a[0] = x;ps->size++;
}//头删
void SLPopFront(SL* ps)
{assert(ps);//判断顺序表是否为空assert(ps->size > 0);//挪动元素向前覆盖int begin = 1;while (begin < ps->size){ps->a[begin - 1] = ps->a[begin];++begin;}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;
}//在下标为pos的位置插入x
void SLInsert(SL* ps, int pos, SLDataType x)
{assert(ps);//检查pos是否在有效范围内assert(pos >= 0 && pos <= ps->size);//检查是否需要扩容SLCheckCapacity(ps);//挪动数据int end = ps->size - 1;while (end >= pos) {ps->a[end + 1] = ps->a[end];--end;}//插入元素ps->a[pos] = x;ps->size++;
}//删除下标为pos位置的数据
void SLErase(SL* ps, int pos)
{assert(ps);//检查pos是否在有效范围内assert(pos >= 0 && pos < ps->size);//挪动元素向前覆盖int begin = pos + 1;while (begin < ps->size){ps->a[begin - 1] = ps->a[begin];++begin;}ps->size--;
}

4.3 🔔test.c 顺序表功能测试

    在这里作者只给出头插头删这组测试样例,因为只需要调用前面的函数,所以就不给大家挨个测试了,下来之后大家可以自行尝试,多敲多练大家一块进步。

#include "SeqList.h"//尾插尾删检测
void TestSeqList1()
{SL s;//创建顺序表SLInit(&s);//初始化//尾插SLPushBack(&s, 1);SLPushBack(&s, 2);SLPushBack(&s, 3);SLPrint(&s);//打印//尾删SLPopBack(&s);SLPopBack(&s);SLPrint(&s);//打印//销毁顺序表SLDestroy(&s);
}int main()
{TestSeqList1();return 0;
}


📝总结

本文主要讲解:

  1. 线性表的定义:由n个具有相同数据类型的元素构成一个有限序列;
  2. 线性表的存储结构:顺序存储结构、链式存储结构;
  3. 顺序表的定义:用一段物理地址连续的存储单元依次存储数据元素的线性结构;
  4. 顺序表的分类:静态顺序表、动态顺序表;
  5. 顺序表的增删查改的实现。

     今天的干货分享到这里就结束啦!如果觉得文章还可以的话,希望能给个三连支持一下,聆风吟的主页还有很多有趣的文章,欢迎小伙伴们前去点评,您的支持就是作者前进的最大动力!
在这里插入图片描述

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/242333.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

web前端项目-金山打字游戏【附源码】

金山打字 【金山打字】这是一个练习打字的游戏&#xff0c;当游戏开始后&#xff0c;界面从顶部不断落下内容为随机字母的方块&#xff0c;当按下相对应的按键时&#xff0c;就会清除对应方块。游戏难度会随着落下的速度加快而提高。玩家每次成功清除字母方块&#xff0c;都会…

spawn_group | spawn_group_template | linked_respawn

字段介绍 spawn_group | spawn_group_template 用来记录与脚本事件或boss战斗有关的 creatures | gameobjects 的刷新数据linked_respawn 用来将 creatures | gameobjects 和 boss 联系起来&#xff0c;这样如果你杀死boss&#xff0c; creatures | gameobjects 在副本重置之前…

六、数组(1)一维数组

所谓数组&#xff0c;就是一个集合&#xff0c;里面存放了相同类型的数据元素 特点1&#xff1a;数组中每个数据元素都是相同的数据类型 特点2&#xff1a;数组是由连续的内存位置组成的 一、一维数组的定义方式 1、数据类型 数组名[数组长度]; 2、数据类型 数组名[数组长度…

【JavaEE】_基于UDP实现网络通信

目录 1. 服务器 1.1 实现逻辑 1.2 代码 1.3 部分代码解释 2. 客户端 2.1 实现逻辑 2.2 代码 2.3 客户端部分代码解释 3. 程序运行结果 4. 服务器客户端交互逻辑 此篇内容为实现UDP版本的回显服务器echo server&#xff1b; 普通服务器&#xff1a;收到请求&#xff…

《WebKit 技术内幕》之五(3): HTML解释器和DOM 模型

3 DOM的事件机制 基于 WebKit 的浏览器事件处理过程&#xff1a;首先检测事件发生处的元素有无监听者&#xff0c;如果网页的相关节点注册了事件的监听者则浏览器会将事件派发给 WebKit 内核来处理。另外浏览器可能也需要处理这样的事件&#xff08;浏览器对于有些事件必须响应…

【Linux】nc 网络诊断 | 文件传输 命令详解

目录 一、命令简介 二、命令使用 2.1 测试服务器 2.2 端口连通性测试 2.2.1tcp端口连通性测试 2.2.2udp端口连通性测试 2.3 文件及目录的传输 2.3.1 文件传输(TCP端口) 2.3.2 文件传输(UDP端口) 相关文章&#xff1a; 【网络】抓包工具Wireshark下载安装和基本使用教…

力扣343. 整数拆分(动态规划)

Problem: 343. 整数拆分 文章目录 题目描述思路解题方法复杂度Code 题目描述 思路 该题目可以抽象成动态规划中的爬楼梯模型&#xff0c;将整数的拆分类比为上台阶&#xff1a; 1.每个阶段可以从整数中划分出1、2、…k的一个整数 2.int dp[n 1] dp[i]表示为i的整数划分的最大…

怎么提升搜狗网站排名

在当今数字化时代&#xff0c;网站排名对于品牌、企业以及个人都至关重要。而对于许多网站来说&#xff0c;搜狗搜索引擎是一个重要的流量来源。为了在搜狗上取得更好的排名&#xff0c;不仅需要优化网站内容&#xff0c;还需要巧妙运用一些工具和技巧。在本文中&#xff0c;我…

Labview局部变量、全局变量、引用、属性节点、调用节点用法理解及精讲

写本章前想起题主初学Labview时面对一个位移台程序&#xff0c;傻傻搞不清局部变量和属性节点值有什么区别&#xff0c;概念很模糊。所以更新这篇文章让大家更具象和深刻的去理解这几个概念&#xff0c;看完记得点赞加关注喔~ 本文程序源代码附在后面&#xff0c;大家可以自行下…

C语言第四弹---printf和scanf详解

✨个人主页&#xff1a; 熬夜学编程的小林 &#x1f497;系列专栏&#xff1a; 【C语言详解】 【数据结构详解】 printf和scanf详解 1、printf和scanf详解介绍1.1 printf1.1.1 基本用法1.1.2 占位符1.1.3 占位符列举1.1.4 输出格式1.1.4.1 限定宽度1.1.4.2 总是显示正负号1.1…

Docker安装开源Blog(Typecho)

前言 首先这个镜像是centos7.9进行安装PHP环境&#xff0c;然后挂载目录去运行的&#xff0c;镜像大概300MB左右&#xff0c;没学过PHP&#xff0c;没办法给Dockerfile文件 参考文章&#xff1a;Docker安装Typecho | D-y Blog感知不强&#xff0c;图一乐https://www.wlul.top…

Vagrant创建Oracle RAC环境示例

利用Vagrant安装Oracle RAC&#xff08;默认为non-CDB模式&#xff09;&#xff0c;生成2台虚机&#xff0c;耗时约1小时。 node1: -----------------------------------------------------------------node1: INFO: 2024-01-11 18:25:54: Make create database commandnode1: …

SpringBoot 更新业务场景下,如何区分null是清空属性值 还是null为vo属性默认值?

先看歧义现象 值为null 未传递此属性 所以此时如何区分null 时传递进来的的null&#xff0c;还是属性的默认值null? 引入方案 引入过滤器&#xff0c;中间截获requestBodyData并保存到HttpServletRequest&#xff0c;业务层从HttpServletRequest 获取到requestBodyData辅…

C语言算法赛——蓝桥杯(省赛试题)

一、十四届C/C程序设计C组试题 十四届程序C组试题A#include <stdio.h> int main() {long long sum 0;int n 20230408;int i 0;// 累加从1到n的所有整数for (i 1; i < n; i){sum i;}// 输出结果printf("%lld\n", sum);return 0; }//十四届程序C组试题B…

Cortex-M3/M4内核中断及HAL库函数详解(1):中断相关寄存器

0 工具准备 Keil uVision5 Cortex M3权威指南&#xff08;中文&#xff09; Cortex M3与M4权威指南 stm32f407的HAL库工程 STM32F4xx中文参考手册 1 NVIC相关寄存器介绍 在Cortex-M3/M4内核上搭载了一个异常响应系统&#xff0c;支持为数众多的系统异常和外部中断。其中&#…

关于C语言整型提升的讲解

目录 1.什么是整型提升 2.整型提升的意义 3.整型提升是怎么提升的 4.整型提升的实例 1.什么是整型提升 C语言中的整型算术运算总是以缺省&#xff08;默认&#xff09;整型类型的精度来进行的。为了获得这个精度&#xff0c;表达式中的字符和短整型操作数在使用之前会被转换…

3d渲染软件有哪些?3d云渲染推荐

目前市面上的3D渲染软件非常多&#xff0c;不同的建模软件都有自己的渲染方式&#xff0c;根据所处行业的不同和项目需要&#xff0c;设计师可以选择不同的软件帮助展示最终效果。 主流的渲染软件有&#xff1a;VRay和Corona&#xff1a;一般用于室内效果图渲染&#xff0c;与3…

Git学习笔记(第5章):Git团队协作机制

目录 5.1 团队内协作 5.2 跨团队协作 Git进行版本控制都是在本地库操作的。若想使用Git进行团队协作&#xff0c;就必须借助代码托管中心。 5.1 团队内协作 问题引入&#xff1a;成员1&#xff08;大佬&#xff09;利用Git在宿主机上初始化本地库&#xff0c;完成代码的整体…

MFC 序列化机制

目录 文件操作相关类 序列化机制相关类 序列化机制使用 序列化机制执行过程 序列化类对象 文件操作相关类 CFile&#xff1a;文件操作类&#xff0c;封装了关于文件读写等操作&#xff0c;常见的方法&#xff1a; CFile::Open&#xff1a;打开或者创建文件CFile::Write/…

经典目标检测YOLO系列(二)YOLOV2的复现(1)总体网络架构及前向推理过程

经典目标检测YOLO系列(二)YOLOV2的复现(1)总体网络架构及前向推理过程 和之前实现的YOLOv1一样&#xff0c;根据《YOLO目标检测》(ISBN:9787115627094)一书&#xff0c;在不脱离YOLOv2的大部分核心理念的前提下&#xff0c;重构一款较新的YOLOv2检测器&#xff0c;来对YOLOV2有…