嵌入式数据结构—学习笔记 顺序表

已于 2024-07-09 22:27:17 修改
阅读量977 收藏 16
点赞数 28
分类专栏： 嵌入式数据结构 文章标签： 学习 笔记 数据结构
于 2024-07-06 08:43:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_58277444/article/details/140211613
版权

本文知识点来源：

01线性表之顺序表_哔哩哔哩_bilibiliicon-default.png?t=N7T8https://www.bilibili.com/video/BV1ee4y1q77b?p=3&vd_source=01c0a0b4e215da5cc9a422b60e2ca405

一.线性表相关概念

线性表：线性表是包含若干数据元素的一个线性序列

线性表L可用二元组形式描述：L= （D，R）

1.1 线性表特征：

  1. 有序性：线性表中的数据元素按照一定的顺序排列，每个元素都有一个前驱（除第一个元素）和/或后继（除最后一个元素）。

  2. 有限性：线性表由有限个数据元素组成，这意味着可以确切地计算出表中元素的数量。

  3. 数据类型一致性：线性表中所有元素都属于同一数据类型，或者说是同质的。

  4. 灵活性：线性表可以为空（即不含任何元素），也可以根据需要动态地增加或删除元素（在动态数组或链表等实现方式中）。

  5. 访问方式：线性表支持两种基本的访问操作，即按位置（索引）访问和顺序访问。具体实现时，数组支持快速的随机访问，而链表更适合顺序访问。

  6. 操作集：常见的线性表操作包括但不限于初始化、判断是否为空、查找、插入、删除、遍历等。

  7. 两种主要实现形式：线性表可以通过数组或链表来实现。数组实现的线性表称为静态数组或顺序表，特点是随机访问快但插入删除效率较低；链表实现的线性表则便于插入删除操作，但随机访问效率相对较低。

二.顺序表相关函数实现

2.1定义顺序表

// 定义一种整型数据类型，命名为data_t，方便后续使用及表示数据元素
typedef int data_t;

// 定义常量N，其值为128，作为静态数组的默认大小
#define N 128

// 定义一个结构体sqlist，包含两个成员：
// data：一个大小为N的数据元素数组，数组元素类型为data_t
// last：记录当前线性表中最后一个元素的实际位置（索引），初始化时应为-1表示空表
typedef struct{
    data_t data[N];
    int last;
} sqlist;

// 定义sqlink为指向sqlist结构体的指针类型，便于通过指针操作线性表
typedef sqlist *sqlink;

2.2 初始化顺序表

/**
 * 初始化一个sqlink列表。
 *
 * 该函数动态分配内存以创建一个sqlink列表，并对其进行初始化。
 * 列表初始化后，最后一个元素的索引被设置为-1，表示列表为空。
 *
 * @return 初始化后的sqlink列表指针。如果内存分配失败，返回NULL。
 */
sqlink list_init()
{
    sqlink L;
    // 为sqlink列表分配内存
    L = (sqlink)malloc(sizeof(sqlist));
    // 检查内存分配是否成功
    if (L = NULL)
    {
        printf("list malloc error\n");
        return NULL;
    }
    // 清零列表内存，确保所有字段都被初始化为0
    memset(L, 0, sizeof(sqlist));
    // 初始化列表的last字段为-1，表示列表为空
    L->last = -1;
    return L;
}

该函数用于初始化一个sqlink类型的链表。首先通过malloc函数为链表结构体sqlist分配内存空间，并将指针赋值给L。然后检查内存分配是否成功，如果失败则输出错误信息并返回NULL。接着使用memset函数将链表内存清零，确保所有字段都被初始化为0。最后将链表的last字段初始化为-1，表示链表为空，然后返回链表指针L。

2.3 清空顺序表

/**
 * 清空链表
 *
 * 本函数用于清空一个链表，将链表的所有元素置为空，并将链表的尾指针重置为-1。
 * 如果链表为空，则函数会打印提示信息并返回-1；否则，函数会成功清空链表并返回0。
 *
 * @param L 链表的头指针
 * @return 如果链表为空，则返回-1；否则返回0。
 */
int list_clear(sqlink L)
{
    /* 检查链表是否为空 */
    if (L == NULL)
    {
        /* 如果链表为空，则打印提示信息并返回错误码 */
        printf("list is null\n");
        return -1;
    }
    /* 将链表头部结构体的所有字节置为0，以清空链表 */
    memset(L, 0, sizeof(sqlist));
    /* 将链表的尾指针重置为-1，表示链表为空 */
    L->last = -1;

    /* 清空操作成功，返回0 */
    return 0;
}

该函数用于清空一个链表。首先检查链表是否为空，如果为空则打印提示信息并返回错误码-1。如果链表不为空，则将链表头部结构体的所有字节置为0，以清空链表，并将链表的尾指针重置为-1，表示链表为空。最后返回0，表示清空操作成功。

2.4 判断链表是否为空

/**
 * 检查链表是否为空
 *
 * 本函数通过检查链表头指针是否为NULL来确定链表是否为空。如果链表为空，即头指针为NULL，
 * 则函数会打印一条消息并返回-1；如果链表不为空，则返回0。
 *
 * @param L 链表的头指针
 * @return 如果链表为空，则返回-1；否则返回0。
 */
int list_empty(sqlink L)
{
    // 检查链表头指针是否为NULL
    if (L == NULL)
    {
        // 打印消息并返回，表示链表为空
        printf("list is null\n");
        return -1;
    }
    // 返回0，表示链表不为空
    return 0;
}

2.5  链表长度

/**
 * 求链表长度
 *
 * @param L 链表的首节点指针
 * @return 如果链表为空，则返回-1；否则返回L->last+1
 */
int list_length(sqlink L)
{
    if (L == NULL)
    {
        printf("list is null\n");
        return -1;
    }
    return (L->last + 1);
}

2.6 查找表中元素

/**
 * 在有序链表中定位元素的位置。
 *
 * 本函数通过遍历链表寻找给定元素，如果找到，则返回其位置；如果链表为空，或未找到元素，则返回-1。
 * 请注意，这个函数假设链表是按照数据值的顺序排列的。
 *
 * @param L 链表的头指针，类型为sqlink。
 * @param e 需要查找的元素，类型为data_t。
 * @return 如果找到元素，则返回其在链表中的位置（从0开始）；如果链表为空或未找到元素，则返回-1。
 */
int list_locate(sqlink L, data_t e)
{
    /* 检查链表是否为空 */
    if (L == NULL)
    {
        printf("list is null\n");
        return -1;
    }

    /* 初始化索引变量 */
    int i = 0;

    /* 遍历链表，查找元素 */
    for (i = 0; i <= L->last; i++)
    {
        /* 如果找到匹配的元素，则返回其位置 */
        if (L->data[i] == e)
        {
            return i;
        }
    }

    /* 如果遍历结束仍未找到元素，则返回-1 */
    return -1;
}

 2.7 插入元素

/**
 * 在单向链表中插入一个元素
 * @param L 链表的头指针
 * @param pos 插入位置的索引
 * @param e 要插入的元素
 * @return 如果插入成功，返回0；如果链表已满，返回-1；如果位置错误，返回-1。
 */
int list_insert(sqlink L, int pos, data_t e)
{
    /* 检查链表是否已满 */
    if (L->last == N - 1)
    {
        printf("list is full");
        return -1;
    }

    /* 检查插入位置是否有效 */
    if (0 <= pos && pos <= L->last)
    {
        /* 将插入位置之后的元素向后移动 */
        for (int i = L->last; i >= pos; i--)
        {
            L->data[i + 1] = L->data[i];
        }

        /* 在指定位置插入新元素 */
        L->data[pos] = e;
        L->last++;
    }
    else
    {
        printf("pos is error");
        return -1;
    }
    return 0;
}

 2.8 打印链表

/**
 * 函数功能：显示链表中的所有元素
 * 参数 L：链表的头指针
 * 返回值：如果链表为空或未初始化，则返回-1；否则返回0。
 */
int list_show(sqlink L)
{
    /* 检查链表是否为空或未初始化 */
    if (L == NULL || L->last == -1)
    {
        /* 如果是，则输出提示信息并返回-1 */
        printf("list is null\n");
        return -1;
    }
    /* 遍历链表，打印每个元素 */
    for (int i = 0; i <= L->last; i++)
    {
        printf("%d ", L->data[i]);
    }
    puts("");
    return 0;
}

 2.9 删除链表

/**
 * 删除单链表中指定位置的元素
 *
 * @param L 单链表的头指针
 * @param pos 要删除的元素的位置
 * @return 如果删除成功返回0，如果链表为空或位置不正确返回-1。
 *
 * 该函数首先检查链表是否为空，然后检查指定的位置是否有效。
 * 如果位置有效，它会通过移动元素将指定位置的元素删除。
 * 最后，它会更新链表的长度。
 */
int list_delete(sqlink L, int pos)
{
    /* 检查链表是否为空 */
    if (L->last == -1)
    {
        printf("list is null\n");
        return -1;
    }
    /* 检查指定的位置是否有效 */
    if (pos < 0 || pos > L->last)
    {
        printf("pos is error\n");
        return -1;
    }
    /* 将指定位置后的元素向前移动以覆盖删除的元素 */
    for (int i = pos; i < L->last; i++)
    {
        L->data[i] = L->data[i + 1];
    }
    /* 减少链表的长度 */
    L->last--;

    return 0;
}

 2.10 合并两个顺序表

/**
 * 合并两个有序链表
 * @param L1 第一个有序链表的头结点
 * @param L2 第二个有序链表的头结点
 * @return 返回0，表示合并操作完成
 *
 * 该函数的目的是将第二个有序链表L2中的所有元素合并到第一个有序链表L1中。
 * 合并过程中，保证L1仍然保持有序。函数通过遍历L2中的每个元素，然后在L1中查找
 * 相同的元素。如果L1中不存在相同的元素，则将该元素插入到L1的末尾。
 */
int list_merge(sqlink L1, sqlink L2)
{
    int i = 0; // 初始化索引变量i，用于遍历L2链表中的元素

    // 遍历L2链表，直到最后一个元素
    while (i <= L2->last)
    {
        // 在L1中查找当前元素是否存在
        int ret = list_locate(L1, L2->data[i]);

        // 如果L1中不存在当前元素，则将其插入到L1的末尾
        if (ret == -1)
        {
            list_insert(L1, L2->data[i], L1->last + 1);
        }
        i++; // 移动到下一个元素
    }
    return 0; // 合并操作完成，返回0
}

该函数用于将链表L2中的所有元素合并到链表L1中，如果L1中已经存在该元素，则不进行任何操作；如果L1中不存在该元素，则将其插入到L1的末尾。函数首先初始化一个索引变量i，用于遍历L2链表中的元素。然后通过循环遍历L2链表，对于每个元素，使用list_locate函数在L1中查找是否存在相同的元素。如果L1中不存在该元素，则使用list_insert函数将其插入到L1的末尾。最后，函数返回0，表示合并操作完成。

2.11 清除顺序表中重复元素

/**
 * 清理列表中重复的元素。
 *
 * 该函数遍历列表，如果发现有重复的元素，则删除重复元素，保持列表中元素的唯一性。
 *
 * @param L 指向sqlink列表的指针。
 * @return 始终返回0，目前未使用返回值来指示函数执行状态。
 */
int list_purge(sqlink L)
{
    // 如果列表为空，则直接返回，无需进行清理。
    if (L->last == 0)
        return 0;

    // 双重循环遍历列表，外层循环遍历每个元素，内层循环比较该元素与后面元素的重复情况。
    for (int i = 0; i < L->last; i++)
    {
        for (int j = i + 1; j < L->last; j++)
        {
            // 如果发现重复元素，则删除重复元素，并调整内层循环的索引。
            if (L->data[i] == L->data[j])
            {
                list_delete(L, j);
                j--;
            }
        }
    }
    return 0;
}

该函数用于清除列表中的重复元素。它通过双重循环遍历列表，外层循环遍历每个元素，内层循环比较该元素与后面元素的重复情况。如果发现重复元素，则删除重复元素，并调整内层循环的索引。如果列表为空，则直接返回。函数返回0，表示操作完成。

 2.12 修改指定元素

/**
 * 修改列表中指定位置的元素
 *
 * 本函数用于修改单向链表中指定位置的元素。如果位置无效（小于0或大于链表长度），函数将不进行任何修改并返回-1。
 * 否则，函数将用新的元素e替换链表中索引为i的元素，并返回0表示修改成功。
 *
 * @param L 链表的头指针，类型为sqlink。
 * @param i 需要修改的元素的位置索引，从0开始计数。
 * @param e 新的元素值，类型为data_t。
 * @return 如果修改成功，返回0；如果位置索引无效，返回-1。
 */
int list_alter(sqlink L, int i, data_t e)
{
    /* 检查索引是否有效 */
    if (i < 0 || i > L->last)
        return -1;
    /* 替换链表中指定位置的元素 */
    L->data[i] = e;
    return 0;
}

三 sqlist.h sqlist.c

sqlist.h:

#ifndef _SQLIST_H_
#define _SQLIST_H_

typedef int data_t;
#define N 128

typedef struct{
	data_t data[N];
	int last;
}sqlist, *sqlink;


sqlink list_init();
int list_clear(sqlink L);
int list_empty(sqlink L);
int list_length(sqlink L);
int list_locate(sqlink L, data_t e);
int list_insert(sqlink L, int i, data_t e);
int list_show(sqlink L);
int list_free(sqlink L);
int list_delete(sqlink L, int pos);
int list_merge(sqlink L1, sqlink L2);
int list_purge(sqlink L);
int list_locate_(sqlink L, data_t e);
int list_alter(sqlink L, int i, data_t e);

#endif

 sqlist.c

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

/**
 * 初始化一个sqlink列表。
 *
 * 该函数动态分配内存以创建一个sqlink列表，并对其进行初始化。
 * 列表初始化后，最后一个元素的索引被设置为-1，表示列表为空。
 *
 * @return 初始化后的sqlink列表指针。如果内存分配失败，返回NULL。
 */
sqlink list_init()
{
    sqlink L;
    // 为sqlink列表分配内存
    L = (sqlink)malloc(sizeof(sqlist));
    // 检查内存分配是否成功
    if (L = NULL)
    {
        printf("list malloc error\n");
        return NULL;
    }
    // 清零列表内存，确保所有字段都被初始化为0
    memset(L, 0, sizeof(sqlist));
    // 初始化列表的last字段为-1，表示列表为空
    L->last = -1;
    return L;
}
/**
 * 清空链表
 *
 * 本函数用于清空一个链表，将链表的所有元素置为空，并将链表的尾指针重置为-1。
 * 如果链表为空，则函数会打印提示信息并返回-1；否则，函数会成功清空链表并返回0。
 *
 * @param L 链表的头指针
 * @return 如果链表为空，则返回-1；否则返回0。
 */
int list_clear(sqlink L)
{
    /* 检查链表是否为空 */
    if (L == NULL)
    {
        /* 如果链表为空，则打印提示信息并返回错误码 */
        printf("list is null\n");
        return -1;
    }
    /* 将链表头部结构体的所有字节置为0，以清空链表 */
    memset(L, 0, sizeof(sqlist));
    /* 将链表的尾指针重置为-1，表示链表为空 */
    L->last = -1;

    /* 清空操作成功，返回0 */
    return 0;
}

/**
 * 检查链表是否为空
 *
 * 本函数通过检查链表头指针是否为NULL来确定链表是否为空。如果链表为空，即头指针为NULL，
 * 则函数会打印一条消息并返回-1；如果链表不为空，则返回0。
 *
 * @param L 链表的头指针
 * @return 如果链表为空，则返回-1；否则返回0。
 */
int list_empty(sqlink L)
{
    // 检查链表头指针是否为NULL
    if (L == NULL)
    {
        // 打印消息并返回，表示链表为空
        printf("list is null\n");
        return -1;
    }
    // 返回0，表示链表不为空
    return 0;
}

/**
 * 求链表长度
 *
 * @param L 链表的首节点指针
 * @return 如果链表为空，则返回-1；否则返回L->last+1
 */
int list_length(sqlink L)
{
    if (L == NULL)
    {
        printf("list is null\n");
        return -1;
    }
    return (L->last + 1);
}
/**
 * 在有序链表中定位元素的位置。
 *
 * 本函数通过遍历链表寻找给定元素，如果找到，则返回其位置；如果链表为空，或未找到元素，则返回-1。
 * 请注意，这个函数假设链表是按照数据值的顺序排列的。
 *
 * @param L 链表的头指针，类型为sqlink。
 * @param e 需要查找的元素，类型为data_t。
 * @return 如果找到元素，则返回其在链表中的位置（从0开始）；如果链表为空或未找到元素，则返回-1。
 */
int list_locate(sqlink L, data_t e)
{
    /* 检查链表是否为空 */
    if (L == NULL)
    {
        printf("list is null\n");
        return -1;
    }

    /* 遍历链表，查找元素 */
    for (int i = 0; i <= L->last; i++)
    {
        /* 如果找到匹配的元素，则返回其位置 */
        if (L->data[i] == e)
        {
            return i;
        }
    }

    /* 如果遍历结束仍未找到元素，则返回-1 */
    return -1;
}

/**
 * 在单向链表中插入一个元素
 * @param L 链表的头指针
 * @param pos 插入位置的索引
 * @param e 要插入的元素
 * @return 如果插入成功，返回0；如果链表已满，返回-1；如果位置错误，返回-1。
 */
int list_insert(sqlink L, int pos, data_t e)
{
    /* 检查链表是否已满 */
    if (L->last == N - 1)
    {
        printf("list is full");
        return -1;
    }

    /* 检查插入位置是否有效 */
    if (0 <= pos && pos <= L->last)
    {
        /* 将插入位置之后的元素向后移动 */
        for (int i = L->last; i >= pos; i--)
        {
            L->data[i + 1] = L->data[i];
        }

        /* 在指定位置插入新元素 */
        L->data[pos] = e;
        L->last++;
    }
    else
    {
        printf("pos is error");
        return -1;
    }
    return 0;
}

/**
 * 函数功能：显示链表中的所有元素
 * 参数 L：链表的头指针
 * 返回值：如果链表为空或未初始化，则返回-1；否则返回0。
 */
int list_show(sqlink L)
{
    /* 检查链表是否为空或未初始化 */
    if (L == NULL || L->last == -1)
    {
        /* 如果是，则输出提示信息并返回-1 */
        printf("list is null\n");
        return -1;
    }
    /* 遍历链表，打印每个元素 */
    for (int i = 0; i <= L->last; i++)
    {
        printf("%d ", L->data[i]);
    }
    puts("");
    return 0;
}

/**
 * 删除链表
 *
 * 本函数用于删除一个链表。链表的头指针通过参数 L 传递进来。
 * 如果链表不存在（即 L 为 NULL），则函数不进行任何操作并返回 -1。
 * 如果链表存在，则释放链表的内存空间，并将 L 设置为 NULL，表示链表已被删除。
 *
 * @param L 链表的头指针
 * @return 如果链表不存在返回 -1，否则返回 0 表示删除成功。
 */
int list_free(sqlink L)
{
    if (L == NULL)
    {
        return -1;
    }
    free(L);
    L = NULL;
    return 0;
}

/**
 * 删除单链表中指定位置的元素
 *
 * @param L 单链表的头指针
 * @param pos 要删除的元素的位置
 * @return 如果删除成功返回0，如果链表为空或位置不正确返回-1。
 *
 * 该函数首先检查链表是否为空，然后检查指定的位置是否有效。
 * 如果位置有效，它会通过移动元素将指定位置的元素删除。
 * 最后，它会更新链表的长度。
 */
int list_delete(sqlink L, int pos)
{
    /* 检查链表是否为空 */
    if (L->last == -1)
    {
        printf("list is null\n");
        return -1;
    }
    /* 检查指定的位置是否有效 */
    if (pos < 0 || pos > L->last)
    {
        printf("pos is error\n");
        return -1;
    }
    /* 将指定位置后的元素向前移动以覆盖删除的元素 */
    for (int i = pos; i < L->last; i++)
    {
        L->data[i] = L->data[i + 1];
    }
    /* 减少链表的长度 */
    L->last--;

    return 0;
}

/**
 * 合并两个有序链表
 * @param L1 第一个有序链表的头结点
 * @param L2 第二个有序链表的头结点
 * @return 返回0，表示合并操作完成
 *
 * 该函数的目的是将第二个有序链表L2中的所有元素合并到第一个有序链表L1中。
 * 合并过程中，保证L1仍然保持有序。函数通过遍历L2中的每个元素，然后在L1中查找
 * 相同的元素。如果L1中不存在相同的元素，则将该元素插入到L1的末尾。
 */
int list_merge(sqlink L1, sqlink L2)
{
    int i = 0; // 初始化索引变量i，用于遍历L2链表中的元素

    // 遍历L2链表，直到最后一个元素
    while (i <= L2->last)
    {
        // 在L1中查找当前元素是否存在
        int ret = list_locate(L1, L2->data[i]);

        // 如果L1中不存在当前元素，则将其插入到L1的末尾
        if (ret == -1)
        {
            list_insert(L1, L2->data[i], L1->last + 1);
        }
        i++; // 移动到下一个元素
    }
    return 0; // 合并操作完成，返回0
}

/**
 * 清理列表中重复的元素。
 *
 * 该函数遍历列表，如果发现有重复的元素，则删除重复元素，保持列表中元素的唯一性。
 *
 * @param L 指向sqlink列表的指针。
 * @return 始终返回0，目前未使用返回值来指示函数执行状态。
 */
int list_purge(sqlink L)
{
    // 如果列表为空，则直接返回，无需进行清理。
    if (L->last == 0)
        return 0;

    // 双重循环遍历列表，外层循环遍历每个元素，内层循环比较该元素与后面元素的重复情况。
    for (int i = 0; i < L->last; i++)
    {
        for (int j = i + 1; j < L->last; j++)
        {
            // 如果发现重复元素，则删除重复元素，并调整内层循环的索引。
            if (L->data[i] == L->data[j])
            {
                list_delete(L, j);
                j--;
            }
        }
    }
    return 0;
}

/**
 * 修改列表中指定位置的元素
 *
 * 本函数用于修改单向链表中指定位置的元素。如果位置无效（小于0或大于链表长度），函数将不进行任何修改并返回-1。
 * 否则，函数将用新的元素e替换链表中索引为i的元素，并返回0表示修改成功。
 *
 * @param L 链表的头指针，类型为sqlink。
 * @param i 需要修改的元素的位置索引，从0开始计数。
 * @param e 新的元素值，类型为data_t。
 * @return 如果修改成功，返回0；如果位置索引无效，返回-1。
 */
int list_alter(sqlink L, int i, data_t e)
{
    /* 检查索引是否有效 */
    if (i < 0 || i > L->last)
        return -1;
    /* 替换链表中指定位置的元素 */
    L->data[i] = e;
    return 0;
}

忘山君
关注
  • 28
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构学习笔记.zip
06-17
本压缩包"数据结构学习笔记.zip"包含了丰富的资源，对于大学生来说，是深入理解数据结构的重要参考资料。 在数据结构的学习中，我们首先会接触到线性数据结构，如数组、链表、栈和队列。数组是最基础的数据结构，它...
算法数据结构学习笔记-C语言.zip
06-16
"算法数据结构学习笔记-C语言.zip"这个压缩包很可能是为大学生提供的一份详细的学习资源，涵盖了数据结构的基础知识、常见算法以及相关的实践练习。 首先，我们要理解数据结构的基本概念，如数组、链表、栈、队列、...
嵌入式数据结构 —学习笔记 单链表
qq_58277444的博客
07-06 1006
01单链表_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1ee4y1q77b?p=9&vd_source=01c0a0b4e215da5cc9a422b60e2ca405线性表的链式存储结构是一种用于存储线性表数据结构的方法，它通过一系列的节点来表示线性表中的元素，每个节点包含两部分：链式存储结构的特点如下：链式存储结构可以根据节点之间的连接方式进一步细分为以下几种类型：在链式存储结构中，通常会有一个头指针，它指向链表的第一个节点，如果链表有头结点，则头指针指
嵌入式数据结构—学习笔记 二叉树
qq_58277444的博客
07-10 777
二叉树是计算机科学中的一种重要的数据结构，
嵌入式全栈开发学习笔记---数据结构（顺序表）
xiaobaivera的博客
08-04 1051
顺序表应该支持以下操作： 初始化操作，建立一个空的顺序表 InitList(*L); 判断顺序表是否为空 ListEmpty(L); 清空顺序表 ClearList(*L); 获取第i个位置的元素，存放在e中 GetElem(L, i, *e); 查找于e相等的元素，返回元素的位置 LocateElem(L, e); 在第i个位置插入元素e ListInsert(*L, i, e); 删除第i个位置的元素，保存在e中 ListDel(*L, i, *e); 获
嵌入式全栈开发学习笔记---数据结构（顺序栈）
xiaobaivera的博客
08-09 684
当我们初始化一个空栈的时候，栈顶指针（下标）应该设置为-1，如果设置为0的话就还不能表示空栈。 我们在程序上如果来表示一个栈呢？ 我们还是用结构体来表示： 只要知道栈顶在哪了，就知道这个栈的容量有多大了。
数据结构与算法知识总结（嵌入式系列学习4）
2303_78453210的博客
03-29 949
嵌入式学习系列来到数据结构与算法部分，本篇主要讲述了数据结构与算法常用主要知识总结，用于嵌入式基础巩固，开篇首先回顾带入结构体等关键字用法，另着重从数据结构和算法两者进行知识总结，分别从线性表（顺序表、链式表）、栈、队列、树（二叉树、最优二叉树）、图、查找和排序带着示例代码一起即学即用，活学活用，巩固自己编程基础，编译环境Ubuntu。
嵌入式全栈开发学习笔记---数据结构概述
xiaobaivera的博客
08-04 841
入门级概念 什么是数据结构？ 我们以往都是把数据存放在数组中，数组占用的是连续的内存。这种形式大部分都是没有问题的，90%的情况下数组都是能解决需求的，但是数据量特别大时，比如4亿个整型数据，你如何进行排序呢？我们不可能把这么多个数据放在内存中，也不会有这么多的内存。因此，我们就要想办法如何来排布这些数据才能放入内存中，以及如何排布才能让操作的效率最高。所以，数据的结构形式就是我们所说的数据结构。 什么是算法？算法和数据结构有什么联系？ 我们提到数据结构时一般都会涉及到算法。之前我们学过冒泡排序就算是一种常
嵌入式全栈开发学习笔记---数据结构（链表的分类）
xiaobaivera的博客
08-06 173
常见的链表有：静态链表（用的很少，有点类似于顺序表）、单链表、双向链表、循环链表、双向循环链表（效率最高）
数据结构学习笔记-杭电
Challfate的博客
12-30 1571
在这里插入代码片# 数据结构 时间复杂度 数的清为O（1） 线性结构定义： 若结构是非空有限集，则有且仅有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前趋和一个直接后继。 顺序存储，链式存储 C语言动态分配函数（<stdlib.h>) malloc(m)开辟m字节长的地址空间 sizeof（x）计算变量的长度 free（p）释放指针p所指变量的存储空间，彻底删除一个变量 C++ new +类型名 int *p=new int; 或int *p =new int(10); dele
【从零开始的嵌入式生活】数据结构2——线性表及顺序表
XingleiGao的博客
02-15 5085
前言 今天开了个新正式进入数据结构的学习，这两天颈椎病需要治一治所以有些拖更，治好我就满血复活0.0大家注意身体呀！ 另外今天竟然接到了第一个实习的面试邀请，惊喜，这两天也会加油更新的同时看看面经，相关的过程记录我也想更新，如果大家想看的话（疯狂暗示）。 三连即可提高学习效率0.0 ????????作者简介：一个学嵌入式的年轻人 ✨联系方式：2201891280(QQ) ????源码地址：https://gitee.com/xingleigao/study_qianrushi ⏳全文大约阅读时间： 60m
数据结构（C语言描述）学习笔记.zip
06-17
本压缩包“数据结构（C语言描述）学习笔记.zip”提供了大学生深入理解数据结构的重要资源，特别适合正在学习这门课程的学生。 在C语言中描述数据结构，主要是通过指针、结构体等概念来实现的，这使得C语言成为理解...
《数据结构与算法之美》的学习笔记和python代码实现.zip
06-16
《数据结构与算法之美》的学习笔记和Python代码实现提供了一条深入理解这些概念的途径，尤其适合大学生以及初学者，无论你是C/C++/JAVA还是Python的爱好者。 一、数据结构 数据结构是组织和管理大量数据的方式，它...
【学习笔记】卫星通信NTN 3GPP标准化进展分析（六）- 参考标准
u011376987的博客
09-01 1153
本文总结了NTN标准化进程以及后续的研究计划，是学习NTN协议的入门。本文来自3GPP Joern Krause, 3GPP MCC。
java重点学习-spring
qq_40453972的博客
09-03 861
AOP称为面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”(Aspect)，减少系统中的重复代码，降低了模块间的耦合度，同时提高了系统的可维护性。常见的AOP使用场景记录操作日志、●缓存处理Spring中内置的事务处理什么是AOP面向切面编程，用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取公共模块复用，降低耦合你们项目中有没有使用到AOP。
iomuxc、pinctrl子系统、gpio子系统（学习总结）
最新发布
weixin_61385844的博客
09-04 919
IOMUXC是SOC设计中实现引脚复用的关键组件，它通过动态切换引脚功能，提高了IO资源的利用率，满足了不同外设和功能的IO需求。在配置和使用IOMUXC时，需要参考芯片使用手册和设备树文档，确保引脚功能的正确设置。
学习项目1
m0_62803606的博客
09-03 1605
这篇文章主要记录你最近入手的无线串口模块的配置情况，这是个很好的习惯，尤其是在你以后需要重复操作或排查问题时，会非常有帮助。- **DL_20无线串口模块**：这是一个常见的无线串口通信模块，通常基于nRF24L01+等无线通信芯片，支持点对点或多点通信，适合短距离的无线数据传输。是的，如果你按照步骤成功配置了两个模块并将它们连接到单机和电脑，当你在上位机软件（如SSCOM）上能稳定地接收到从单片机发送的数据（例如每秒输出的T值），就说明两个无线模块之间的通信已经配置成功。
假期学习-- iOS runtime的简单了解
m0_74217598的博客
09-04 881
（Runtime字典转模型，数据的接受取决于模型的属性）首先需要了解，属性定义在类里面，那么类里面就有一个属性列表，属性列表以数组的形式存在，根据属性列表就可以获得类里面的所有属性名，所以遍历属性列表，也就可以遍历模型中的所有属性名。所以RunTime字典转模型过程就很清晰了。
嵌入式Linux开发：从C语言到数据结构与算法
在数据结构与算法部分，笔记涉及了顺序表、链表、图、哈希表、队列、查找和排序算法、栈以及C语言实现的树。最后，笔记介绍了嵌入式Linux项目开发的整个流程，包括开发环境搭建、项目开发流程、需求分析、硬件平台...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值