嵌入式软件--数据结构与算法 DAY 12

已于 2024-08-12 22:22:18 修改
阅读量763 收藏 9
点赞数 19
分类专栏： 嵌入式软件 文章标签： c语言 数据结构
于 2024-08-12 19:18:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zx18831955136/article/details/141057760
版权

数据结构和算法是程序的核心，虽然在嵌入式应用中很少会用到，但了解认知这种思维过程是非常有必要的。一个好的程序员应该把数据结构和算法看的比代码更重要。

1.数据结构是什么？

定义1(宏观)：数据结构是为了高效访问数据而设计出的一种数据的组织和存储方式。

定义2(微观)：数据结构是相互之间存在一种或多种特定关系的数据元素的集合。

简言之，数据结构是带结构的数据元素的集合，“结构”就是指数据元素之间存在的关系。

数据结构，关注的是对这些数据元素的操作和数据元素之间的关系，不关心具体的数据项内容。目的是为了高效的访问数据。

2.内存的理解

一般而言，数据结构针对的是内存中的数据。所以在学习数据结构之前，需要先对内存有一个简单的了解。

内存由许多存储单元组成，每个存储单元可以存储一个固定大小的数据块，通常以字节（Byte）为单位。每个存储单元都有一个唯一的地址，操作系统正是根据这一地址去访问内存中的数据的。

我们讨论的数据结构中的数据元素就保存在这些一个个的内存单元中，这些数据元素或存储在连续的内存单元中，或存储在分散的内存单元中。

3.线性结构之数组

C 语言中，数组是具有相同类型的数据元素的集合。在所有的数据结构中，数组算是最常见、最简单的一种数据结构。

C 语言中，数组的长度一旦确定就不可以再变了。

（1）数组优缺点

优点：

1》查找容易（通过下标），时间复杂度为O(1)。不需要额外申请或删除空间。

2》使用下标位置索引(index)十分高效的访问任意元素，修改快

缺点：

  • 插入、删除元素难，效率低。（需要移动大量元素以使元素空间连续）。
  • 插入操作平均需要移动n/2个元素。
  • 删除操作平均需要移动(n-1)/2个元素。
  • 扩展相对繁琐。一方面需要确保能提供更大区域的连续内存空间，另一方面需要将原有数据复制到新的顺序表中。

（2）功能定义

//初始化动态数组

void initDynamicArray(DynamicArray *array, size_t initialCapacity)

//释放动态数组内存

void destroyDynamicArray(DynamicArray *array)

//调整动态数组内存大小

void resizeDynamicArray(DynamicArray *array, size_t newCapacity)

//获取动态数组长度（元素个数）

size_t getLength(const DynamicArray *array)

//在指定位置插入新元素

void insertAt(DynamicArray *array, size_t index, int element)

//在末尾插入新元素

void insertEnd(DynamicArray *array, int element)

//删除指定位置的元素并返回被删除的元素

int deleteAt(DynamicArray *array, size_t index)

//删除末尾的元素并返回被删除的元素

int deleteEnd(DynamicArray *array)

//遍历所有的元素

void print(DynamicArray *array)

（3）实现原理

可变长的动态数组是一种数据结构，它允许在运行时根据需要动态地调整数组的大小，而不需要提前指定固定的大小。这种动态数组通常被称为动态数组、动态分配数组、动态增长数组或动态内存数组。int arr[10];   

C语言中是通过使用指针和内存分配函数来实现动态数组，常见的内存分配函数是malloc、realloc和free。下面是一些相关的概念和操作：

  1. 分配内存（malloc）： 在C语言中，可以使用malloc函数来分配一块指定大小的内存。例如，int *arr = (int *)malloc(n * sizeof(int)); 将分配能够存储n个整数的内存空间。
  2. 重新分配内存（realloc）： 如果需要改变动态数组的大小，可以使用realloc函数来重新分配内存。这允许你在保留原有数据的情况下扩展或缩小数组的大小。
  3. 释放内存（free）： 当不再需要动态数组时，应使用free函数释放之前分配的内存，以避免内存泄露。à  内存溢出

（4）代码实现

初始化动态数组

#include <stdio.h>
#include <stdlib.h>
typedef struct
{
    // 保存动态数组元素个数
    int size;
    // 保存指针变量动态数组开辟内存地址
    int *data;
    // 数组内部元素数量限制
    int maxsize;
} DynamicArray;
// 第一个参数结构体指针，第二个参数开辟元素个数
void initDynamicArray(DynamicArray *array, size_t maxsize)
{
    //动态开辟内存
    array->data=(int*)malloc(sizeof(int)*maxsize);
    //动态数组内部元素的个数
    array->size=0;
    //存储动态数组最大元素的个数
    array->maxsize=maxsize;
}
int main()
{
    // 创建结构体变量
    DynamicArray array;
    // 初始化动态数组
    initDynamicArray(&array, 10);
    return 0;
}

释放动态数组内存

#include <stdio.h>
#include <stdlib.h>
typedef struct
{
    // 保存动态数组元素个数
    int size;
    // 保存指针变量动态数组开辟内存地址
    int *data;
    // 数组内部元素数量限制
    int maxsize;
} DynamicArray;
// 第一个参数结构体指针，第二个参数开辟元素个数
void initDynamicArray(DynamicArray *array, size_t maxsize)
{
    //动态开辟内存
    array->data=(int*)malloc(sizeof(int)*maxsize);
    //动态数组内部元素的个数
    array->size=0;
    //存储动态数组最大元素的个数
    array->maxsize=maxsize;
}
//释放内存，传结构体指针
void destroyDynamicArray(DynamicArray *array)
{
free(array->data);//释放
//清空
array->size=0;
array->maxsize=0;
}
int main()
{
    // 创建结构体变量
    DynamicArray array;
    // 初始化动态数组
    initDynamicArray(&array, 10);
    destroyDynamicArray(&array);
    return 0;
}

调整动态数组内存大小

#include <stdio.h>
#include <stdlib.h>
typedef struct
{
    // 保存动态数组元素个数
    int size;
    // 保存指针变量动态数组开辟内存地址
    int *data;
    // 数组内部元素数量限制
    int maxsize;
} DynamicArray;
// 第一个参数结构体指针，第二个参数开辟元素个数
void initDynamicArray(DynamicArray *array, size_t maxsize)
{
    //动态开辟内存
    array->data=(int*)malloc(sizeof(int)*maxsize);
    //动态数组内部元素的个数
    array->size=0;
    //存储动态数组最大元素的个数
    array->maxsize=maxsize;
}
//释放内存，传结构体指针
void destroyDynamicArray(DynamicArray *array)
{
free(array->data);//释放
//清空
array->size=0;
array->maxsize=0;
}
void resizeDynamicArray(DynamicArray *array, size_t newMaxsize)
{
//判断数组需不需要扩充内存
if(array->size>=array->maxsize)
{
    //动态数组内存变大
array->data=realloc(array->data,sizeof(int)*newMaxsize);
}
//存储一下最新的最大元素个数
array->maxsize=newMaxsize;
}
int main()
{
    // 创建结构体变量
    DynamicArray array;
    // 初始化动态数组
    initDynamicArray(&array, 10);
    destroyDynamicArray(&array);
    
    return 0;
}

为节省时间，部分功能在代码内体现。

#include <stdio.h>
#include <stdlib.h>
// 结构体
typedef struct
{
    // 保存动态数组内部的元素个数
    int size;
    // 指针变量存储动态开辟内存地址
    int *data;
    // 保存数组内部元素的存储上限制
    int maxSize;
} DynamicArray;

// 初始化动态数组[占多少内层]
// 第一个参数:结构体指针   第二个参数:元素个数
void initDynamicArray(DynamicArray *array, int maxSize)
{
    // 动态开辟内存
    array->data = (int *)malloc(sizeof(int) * maxSize);
    // 动态数组内部的元素的个数
    array->size = 0;
    // 存储动态数组存储的元素的最大的个数
    array->maxSize = maxSize;
}

// 释放内存
void destroyDynamicArray(DynamicArray *array)
{
    // 释放
    free(array->data);
    // 清空size、maxSize
    array->size = 0;
    array->maxSize = 0;
}

// 调整内存大小
// 第一个参数:动态数组  第二参数:
void resizeDynamicArray(DynamicArray *array, int newMaxSize)
{
    // 判断动态数组是否需要拓展内层大小
    if (array->size >= array->maxSize)
    {
        // 动态数组内存变大
        array->data = realloc(array->data, sizeof(int) * newMaxSize);
    }
    // 存储一下最新的最大元素个数
    array->maxSize = newMaxSize;
}

// 获取动态数组内部元素的个数
int getLength(DynamicArray *array)
{
    return array->size;
}

// 动态数组指定位置插入元素
// 第一个参数:动态数组  第二个参数:插入元素的角标  第三个参数:插入的数据
void insertAt(DynamicArray *array, int index, int element)
{
    // 先判断角标是否合理
    if (index < 0 || index > array->maxSize)
    {
        return;
    }
    // 是否拓容
    if (array->size >= array->maxSize)
    {
        resizeDynamicArray(array, array->maxSize * 2);
    }

    // 插入元素 size = 4  index = 2
    for (int i = array->size; i > index; i--)
    {
        array->data[i] = array->data[i - 1];
    }
    // 将新的元素插入
    array->data[index] = element;
    // 元素的个数+1
    array->size++;
}

// 打印动态数组的数组
void print(DynamicArray *array)
{
    // 循环打印出动态数组内部的元素
    for (int i = 0; i < array->size; i++)
    {
        printf("%d\n", array->data[i]);
    }
}

int main()
{
    // 创建一个动态数组结构体变量
    DynamicArray array;
    // 初始化动态数组
    initDynamicArray(&array, 5);
    insertAt(&array, 0, 10);
    insertAt(&array, 1, 20);
    insertAt(&array, 2, 30);
    insertAt(&array, 3, 40);
    insertAt(&array, 4, 50);
    insertAt(&array, 5, 60);
    insertAt(&array, 6, 70);
    insertAt(&array, 7, 80);
    print(&array);

    return 0;
}

4.线性结构之链表

（1）链表优缺点

1》优点

  1. 插入和删除操作效率高。
  2. 动态扩展性能更好，链表不需要像数组那样预先指定固定的大小，而是可以随时动态的增长或缩小。链表是真正的动态数据结构，不需要处理固定容量的问题。

2》缺点

  1. 查找慢。由于链表中的结点不是连续存储的，无法像数组一样根据索引直接计算出每个结点的地址。必须从头结点开始遍历链表，直到找到目标结点，这导致了链表的随机访问效率较低。
  2. 额外的存储空间。链表的每个结点都需要存储指向下一个结点的指针，这会占用额外的存储空间。所以，相比于数组，链表需要更多的内存空间来存储相同数量的数据元素。

（2）功能定义

初始化链表

void initLinkedList(LinkedList *list)

返回链表的长度

size_t getLength(const LinkedList *list)

在指定位置插入元素

void insertAt(LinkedList *list, size_t index, int element)

在末尾插入元素

void insertEnd(LinkedList *list, int element)

删除指定位置的元素并返回被删除的元素

int deleteAt(LinkedList *list, size_t index)

删除末尾元素

int deleteEnd(LinkedList *list)

获取指定位置的元素

int getElementAt(const LinkedList *list, size_t index)

修改指定位置的元素

void modifyAt(LinkedList *list, size_t index, int newValue)

释放链表内存

void destroyLinkedList(LinkedList *list)

（3）代码实现

#include <stdio.h>
#include <stdlib.h>

// 定义一个结点
typedef struct Node
{
    // 结点保存数据的地方
    int data;
    // 指针保存下一个结点的地址
    struct Node *next;
} Node;

// 链表
typedef struct
{
    // 存储结点的个数
    int size;
    // 存储"头结点"
    Node *head;
} LinkedList;

// 初始化链表
void initLinkedList(LinkedList *list)
{
    // 链表的结点的个数
    list->size = 0;
    // 头结点指向NULL
    list->head = NULL;
}

// 返回结点的个数
int getLength(LinkedList *list)
{
    return list->size;
}

// 在指定位置插入元素
// 第一个参数:链表   第二个参数:插入这个数据角标  第三个参数:节点保存的数据
void insertAt(LinkedList *list, int index, int element)
{
    // 先判断插入的位置是不是合法的
    if (index < 0 || index > list->size)
    {
        return;
    }
    // 创建新的结点:动态开辟内存的,结点保存数据、保存下一个节点的地址
    Node *node = (Node *)malloc(sizeof(Node));
    // 创建新节点需要保存的数据
    node->data = element;
    // 第一个位置插入
    if (index == 0)
    {
        // 当前节点保存下一个节点的地址(暂时没有下一个)
        node->next = list->head;
        // 链表的头结点指向第一个节点的地址
        list->head = node;
    }
    else
    {
        // 先找到插入位置的上一个节点
        Node *prevNode = list->head;
        for (int i = 1; i < index; i++)
        {
            prevNode = prevNode->next;
        }
        // 找到上一个节点的位置
        node->next = prevNode->next;
        prevNode->next = node;
    }
    // 节点的个数+1
    list->size++;
}
// 在链表的末尾插入元素
void insertEnd(LinkedList *list, int element)
{
    insertAt(list, list->size, element);
}

// 封装一个函数,专门找链表的某一个位置的前一个节点

Node *findPrevNode(LinkedList *list, int index)
{
    // 从第一个结点向后找
    Node *prevNode = list->head;
    for (int i = 1; i < index; i++)
    {
        prevNode = prevNode->next;
    }
    // 返回不就是某一个位置前面的结点
    return prevNode;
}

// 删除指定的元素
// 返回结点保存data数据 第一个参数:链表 第二个参数:删除元素的角标
int deleteAt(LinkedList *list, int index)
{
    // 先判断给的角标对不对
    if (index < 0 || index > list->size - 1)
    {
        return -1;
    }
    // 准备一个节点-代表将来要删除节点
    Node *deleteNode = NULL;
    // 删除的第一个节点
    if (index == 0)
    {
        // 删除的结点
        deleteNode = list->head;
        // 修改头结点的地址
        list->head = deleteNode->next;
    }
    else
    {
        // 找到index这个位置的前面节点
        Node *prevNode = findPrevNode(list, index);
        // 确定删除的结点
        deleteNode = prevNode->next;
        prevNode->next = deleteNode->next;
    }
    // 执行到这里说明干掉的结点已经找到了
    // 取出结点的数据
    int deleteData = deleteNode->data;
    // 链表长度-1
    list->size--;
    // 节点空间free
    free(deleteNode);
    return deleteData;
}

// 删除末尾的元素
int deleteEnd(LinkedList *list)
{
    return deleteAt(list, list->size - 1);
}

// 获取指定位置的元素
int getElementAt(LinkedList *list, int index)
{
    // 先判断角标是否合法化
    if (index < 0 || index > list->size - 1)
    {
        return -1;
    }
    // 第一个
    if (index == 0)
    {
        return list->head->data;
    }
    else
    {
        // 获取上一个节点
        Node *prevNode = findPrevNode(list, index);
        return prevNode->next->data;
    }
}

// 修改指定的元素
void modifyAt(LinkedList *list, int index, int newValue)
{
    // 判断角标合法性
    if (index < 0 || index > list->size - 1)
    {
        return;
    }

    // 判断第一个元素
    if (index == 0)
    {
        list->head->data = newValue;
    }
    else
    {
        Node *prevNode = findPrevNode(list, index);
        prevNode->next->data = newValue;
    }
}

// 释放链表
void destroyLinkedList(LinkedList *list)
{
    // 释放全部节点
    Node *node = list->head;
    // 全部节点释放
    while (node != NULL)
    {
        Node *tmp = node;
        node = node->next;
        free(tmp);
    }
    // 节点的长度归零
    list->size = 0;
    // 头结点指向NULL
    list->head = NULL;
}

// 打印输出
void print(LinkedList *list)
{
    Node *node = list->head;
    while (node != NULL)
    {
        printf("%d\n", node->data);
        node = node->next;
    }
}
int main()
{
    // 进行初始化链表
    LinkedList list;
    initLinkedList(&list);
    insertAt(&list, 0, 10);
    insertAt(&list, 1, 20);
    insertAt(&list, 2, 30);
    insertAt(&list, 3, 40);
    insertAt(&list, 4, 50);
    insertAt(&list, 5, 150);
    insertAt(&list, 6, 250);
    // 尾巴插入一个350
    insertEnd(&list, 350);
    insertEnd(&list, 450);
    // 删除元素
    printf("干掉的====%d\n", deleteAt(&list, 4));
    printf("干掉的====%d\n", deleteAt(&list, -2));
    deleteEnd(&list);
    deleteEnd(&list);
    modifyAt(&list, 0, 12306);
    modifyAt(&list, 5, 6666);
    printf("0==%d\n", getElementAt(&list, 0));
    print(&list);
    destroyLinkedList(&list);
    return 0;
}

5.线性结构之栈

栈先进后出。

（1）功能定义

初始化栈

void initStack(Stack *stack, size_t capacity)

返回栈内元素个数

size_t getSize(const Stack *stack)

添加新元素

void push(Stack *stack, int element)

栈顶元素出栈并返回

int pop(Stack *stack)

释放栈内存

void destroyStack(Stack *stack)

（2）代码实现

#include <stdio.h>
#include <stdlib.h>
// 定义一个栈
typedef struct
{
    // 栈需要内存空间
    int *data;
    // 统计元素的个数
    int size;
    // 限制元素的上线个数
    int maxSize;
} Stack;

// 初始化栈
// 第一个参数:栈 结构体指针    第二个参数:首次创建的栈的最大容量
void initStack(Stack *stack, int maxSize)
{
    // 初始化栈
    stack->data = (int *)malloc(sizeof(int) * maxSize);
    // 元素个数为零
    stack->size = 0;
    // 首次初始化栈元素上限个数
    stack->maxSize = maxSize;
}

// 获取栈内元素的个数
int getSize(Stack *stack)
{
    return stack->size;
}

// 添加元素,向栈内压数据
void push(Stack *stack, int element)
{
    // 考虑是否拓容
    if (stack->size >= stack->maxSize)
    {
        // 上限修改为元素2倍
        stack->maxSize *= 2;
        // 拓容
        stack->data = (int *)realloc(stack->data, sizeof(int) * stack->maxSize);
    }
    // 栈压数据
    stack->data[stack->size] = element;
    stack->size++;
}

// 出栈
// 出栈:返回int,代表的是出栈的那个元素的数据
// 形参:栈
int pop(Stack *stack)
{
    // 先判断是不是空栈
    if (stack->size == 0)
    {
        return -1;
    }
    stack->size--;
    return stack->data[stack->size];
}
// 释放内存
void destroyStack(Stack *stack)
{
    // 释放内存
    free(stack->data);
    // 一切数据从头开始
    stack->data = NULL;
    stack->size = 0;
    stack->maxSize = 0;
}
int main()
{
    // 创建栈
    Stack stack;
    initStack(&stack, 5);
    push(&stack, 10);
    push(&stack, 20);
    push(&stack, 30);
    push(&stack, 40);
    push(&stack, 50);
    push(&stack, 60);
    printf("出栈了:%d\n", pop(&stack));
    printf("出栈了:%d\n", pop(&stack));
    printf("出栈了:%d\n", pop(&stack));
    printf("出栈了:%d\n", pop(&stack));
    printf("出栈了:%d\n", pop(&stack));
    printf("出栈了:%d\n", pop(&stack));
    printf("出栈了:%d\n", pop(&stack));
    printf("获取栈内的元素个数:%d\n", getSize(&stack));
    return 0;
}

6.线性结构之队列

先进先出

（1）出现的问题

顺序队列中存在“假溢出”现象：尽管队列中实际元素个数可能远远小于数组大小，但可能由于尾指针rear已超出向量空间的上界而不能做入队操作。

为充分利用空间，克服上述“假溢出”现象，有两种方法

方法1：使用数组实现，入队列时添加到队列的最后，出队列时移除第一个元素同时将右侧的元素左移。

方法2：为队列分配的向量空间看成是一个首尾相接的圆环，这种队列称为循环队列。

（2）功能定义

初始化队列

void initQueue(Queue *queue, size_t capacity)

返回队列内元素个数

size_t getSize(const Queue *queue)

添加新元素

void enqueue(Queue *queue, int element)

元素出队列

int dequeue(Queue *queue)

释放队列内存

void destroyQueue(Queue *queue)

遍历队列

void printQueue(Queue *queue)

7.代码实现

#include <stdio.h>
#include <stdlib.h>
// 结构体标识循环队列
typedef struct
{
    // 设置队列的所占空间
    int *data;
    // 当前队列有多少个元素
    int size;
    // 队列存储数据上限制
    int maxSize;
    // 队首的标记
    int front; // 数据出去的标记
    // 对尾的标记
    int rear; // 数据进来的标记
} Queue;
// 初始化队列
// 第一个队列空间    队列存储数据的上限
void initQueue(Queue *queue, int maxSize)
{
    // 初始化
    queue->data = (int *)malloc(sizeof(int) * maxSize);
    // 对列的元素的个数
    queue->size = 0;
    // 上限值
    queue->maxSize = maxSize;
    // 队首
    queue->front = 0;
    // 队尾
    queue->rear = 0;
}
// 返回队列的元素的个数
int getSize(Queue *queue)
{
    return queue->size;
}
// 添加元素->入队
void enqueue(Queue *queue, int element)
{
    // 先判断能否入队
    if (queue->size >= queue->maxSize)
    {
        printf("队列已满!你先等着\n");
        return;
    }

    // 入队
    queue->data[queue->rear] = element;

    queue->rear = (queue->rear + 1) % queue->maxSize;
    // 元素的个数+1
    queue->size++;
}
// 删除元素->离队
// int返回数据类型:出队的元素的数据
int dequeue(Queue *queue)
{
    // 合法,如果是空的队列
    if (queue->size == 0)
    {
        return -1;
    }
    // 出队
    int data = queue->data[queue->front];
    queue->front = (queue->front + 1) % queue->maxSize;
    queue->size--;
    return data;
}

// 遍历队列
void printQueue(Queue *queue)
{
    int index = queue->front;
    for (int i = 0; i < queue->size; i++)
    {
        printf("%d\n", queue->data[index]);
        index = (index + 1) % queue->maxSize;
    }
}

// 释放内存
void destroyQueue(Queue *queue)
{
    free(queue->data);
    queue->data = NULL;
    queue->size = 0;
    queue->maxSize = 0;
    queue->front = 0;
    queue->rear = 0;
}
int main()
{
    // 初始化队列
    Queue queue;
    initQueue(&queue, 6);
    enqueue(&queue, 10);
    enqueue(&queue, 20);
    enqueue(&queue, 30);
    enqueue(&queue, 40);
    enqueue(&queue, 50);
    enqueue(&queue, 60);
    enqueue(&queue, 9990); // 没有入队
    // 出队列
    printf("我%d数出去离开队伍\n", dequeue(&queue));
    printf("我%d数出去离开队伍\n", dequeue(&queue));
    enqueue(&queue, 70);
    enqueue(&queue, 80);
    printf("我%d数出去离开队伍\n", dequeue(&queue));

    // 获取队列的元素的个数
    printf("队列当前元素的个数:%d\n", getSize(&queue));
    printf("*********");
    printQueue(&queue);
    return 0;
}

阿川！
关注
专栏目录
论：嵌入式C语言是否需要数据结构？
liquid soul
11-27 2790
0x00：前记 前几天看到群组里面几个小伙伴讨论关于嵌入式软件C语言编程是否需要数据结构。有些小伙伴说，嵌入式嘛，代码很轻松，也就不需要数据结构了呀~当时我觉得很奇怪，当然我也不同意他的想法，所以写下了当前的文章用以佐证。 文章目录0x00：前记0x01：开头0x02：数据结构？0x03：数据结构应用0x04：举例0x14：智能家居系统0x24：FreeRTOS任务创建0x05 总结 0x01：...
【毕业季|进击的技术er】作为一名职场人，精心总结的嵌入式学习路线图
热门推荐
Donge's Blog
06-20 8万+
大学毕业，还在为选择工作迷茫吗？董哥带你一文领略嵌入式学习路线地图，送给刚毕业的你，祝你早日走出迷茫区
嵌入式学习-02_数据结构和算法 (链表)
路小飞
03-15 481
由于链表中的结点不是连续存储的，无法像数组一样根据索引直接计算出每个结点的地址。必须从头结点开始遍历链表，直到找到目标结点，这导致了链表的随机访问效率较低。物理结构：与数组不同，链表中的结点需要自行组织，向系统申请很多分散在内存各处的结点，每个结点都保存了当前结点的数据和下一个结点的地址(指针)，通过指针将结点串成一串。（2）额外的存储空间。链表的每个结点都需要存储指向下一个结点的指针，这会占用额外的存储空间。（2）动态扩展性能更好，链表不需要像数组那样预先指定固定的大小，而是可以随时动态的增长或缩小。
c++数据结构代码整理_嵌入式：经典数据结构
weixin_39721924的博客
11-25 232
1.什么是数据结构？如果我们现在要整理图书，有一堆书， 怎么整理呢？最简单一种一个挨着一个放；或者给图书分类，按照大分类再细分类整合；或者直接细分拆成很多类，每一类之间肯定会有很多的关系；但是有没有想过这个书是要放在哪里的？要在什么环境下保存？这就需要给每种整理方法换个角度考虑，是都放在一个书架的一层呢，还是放在不同的书架隔层，又或者是放在图书馆里不同的书架上；这个提到的整理图书讨论的东西，就是数...
嵌入式软件--数据结构与算法 DAY 13
zx18831955136的博客
08-13 507
算法是一个用于解决特定问题的有限指令序列（计算机可以执行的操作）。通俗的理解就是可以解决特定问题的方法。
嵌入式学习-数据结构
huang_caitou的博客
07-26 165
数据结构day6
嵌入式学习--C语言Day05
Xiaomo1536的博客
09-10 892
假设第一个元素最小，和后边每一个进行比较，比较过程中遇到了更小值，暂存下标位置，直到一轮比较结束，再把最小值和最左边位置交换；sizeof计算元素实际开辟的空间大小，strlen计算字符串实际元素个数。sizeof计算 包括'\0',strlen不包括'\0'int a[5]={6,5,4,3,2};访问：数组名[行下标][列下标] 下标从0开始。功能：计算字符串实际元素个数 不包括'\0'数据类型 数组名[行数][列数]
day-07嵌入式-循环结构and数组
2201_75286049的博客
07-29 664
do-while循环：至少执行一次循环体，适合用于那些需要在条件检查前先执行代码的场景。使用时注意：确保循环有终止条件，避免无限循环，并了解编程语言对do-while语法的支持情况。for循环：用于执行固定次数的迭代，是一种高效的循环控制结构。（while可以完成的for都可以完成）注意细节：了解并正确使用循环变量的作用域，防止无限循环，合理使用复合语句和多重循环，并确保条件和更新表达式正确。for（初始条件；循环条件；使循环趋于结束语句）其中这些语句可以不一定在这些位置，但在整个语句中必须存在。
嵌入式软件工程师笔试题--爱立信通讯软件研究开发(上海)有限公司
03-28
根据给定的文件信息，以下是对“嵌入式软件工程师笔试题--爱立信通讯软件研究开发(上海)有限公司”中的部分题目进行的详细解析，旨在深入探讨与嵌入式软件工程相关的专业知识点。 ### 第一题：宏定义与运算 代码...
华清远见嵌入式Linu长期就业班数据结构实验代码
12-31
在嵌入式系统开发中，数据结构的重要性不言而喻，因为资源有限，合理的数据结构设计能优化内存使用，提高程序运行效率。华清远见的嵌入式Linux长期就业班数据结构实验代码提供了对这一主题的实践性学习。 实验代码...
深圳MTK公司嵌入式软件工程师笔试真题.doc
12-21
嵌入式软件工程师笔试真题主要涵盖了C语言编程、数据结构、算法设计和软件设计模式等方面的知识点。下面将对每道题目进行逐一解析。 1. #define 指令和宏定义 该题目考查了define指令和宏定义的使用。在C语言中，#...
iommu-zero-day-labs/riscv-iommu
12-14
iommu-zero-day-labs/riscv-iommu项目是一个专注于RISC-V架构的IOMMU（Input/Output Memory Management Unit）研究与开发的资源库。RISC-V是一种开放源码的指令集架构，近年来在嵌入式计算、数据中心以及高性能计算...
c语言 数据结构与算法 嵌入式,第6讲 嵌入式C语言_常见数据结构与算法.ppt
weixin_39654823的博客
05-25 131
第6讲 嵌入式C语言_常见数据结构与算法嵌入式C语言编程——常见数据结构及算法;结构、联合、枚举用结构构成链表单向链表双向链表循环双向链表C语言中的常用算法; 一个学生的信息有学号、姓名、性别、年龄、住址、成绩等。 一本图书的信息有分类编号、书名、作者、出版社、出版日期、价格、库存量等。 如何描述这些类型不同的相关数据？; struct 结构体名 { 数据类型1 成员名1;...
嵌入式中C中常见的语法结构与实现
嵌入式技术开发
08-10 130
要区分。
【C语言】数据在内存中的存储
最新发布
2401_86272648的博客
09-11 865
内存中以一个字节为单元，超过一个字节的数据（short、int、long）在内存中存储，必然就有存储顺序的问题。另外，对于大于8位的处理器，例如16位、32位处理器，由于寄存器宽度大于一个字节，也会存在多个字节的存储顺序的问题。在内存中数据是以二进制存储的，这里为了方便书写和观察，用十六进制表示。
C语言位域详解：高效利用字节存储与MS-DOS日期结构示例
3. 功能强大：C语言支持丰富的数据结构和算法，提供了大量的编程灵活性。 4. 灵活：标准库和与Unix系统的紧密集成使得C语言成为许多系统开发的首选。 然而，C语言也存在一些缺点，比如容易隐藏错误、语法复杂可能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值