嵌入式养成计划-17-数据结构之顺序表

已于 2023-08-26 14:30:44 修改
阅读量105 收藏
点赞数
分类专栏： C/C++ 数据结构与算法 文章标签： 数据结构 c++ c语言
于 2023-08-25 19:43:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52625576/article/details/132501386
版权

四十七、 数据结构

47.1 什么是数据结构

数据结构是计算机存储、组织数据的方式
是指相互之间存在一种或多种特定关系的数据元素的集合

  • 数据: 整数、文件、视频、图片，能够被计算机存储和识别的
  • 结构: 数据与数据间的关系
  • 算法: 解决问题的求解方法

数据结构和编程语言无关
使用数据结构为了能够更好对数据进行处理

47.2 数据结构的三要素

  • 存储结构
  • 逻辑结构
  • 算法

存储结构:

存储结构	:	
	顺序存储				可以类比数组，计算机中一般都是顺序存储
  	链式存储				想想自行车链条，或者谁谁谁的大金链子，这一环扣着下一环
  	散列存储/索引存储		哈希表，不连续的，建议搜百度

逻辑结构:

逻辑结构:
	一对一	:	线性的，比如大金链子，这一环扣下一环，不乱扣
				除第一个数据结点外，每一个数据结点都有一个唯一前驱结点
				除最后一个数据结点外，每一个数据结点都有一个直接后继结点
	
	一对多	:	树形，一个根有好几个树杈，一个树杈又有好几个子树杈
				第一个元素结点无前驱结点，最后一个元素结点无后继结点
				其他的元素结点，只有唯一前驱结点，没有唯一后继结点
	
	多对多	:	图,想想地图上的车站
				这个车站可以直接去好几个其他车站
				好几个其他车站也能直接到这个车站
				一个结点可以有很多后继结点，也可以有很多个前驱结点

算法:

进行运算或操作的方法
	算法(Algorithm)是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令
	算法代表着用系统的方法描述解决问题的策略机制。
	能够对一定规范的输入，在有限时间内获得所要求的输出。

算法五要素:

  • 有穷性: 算法必须能在执行有限个步骤之后终止
  • 确定性: 算法的每一步骤必须有确定的意义
  • 可行性: 算法中执行的任何计算步骤都可以被分解为基本的可执行的操作步骤，每个计算步骤都可以在有限时间内完成（也称之为有效性）
  • 输入: 一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输入是指算法本身定出了初始条件
  • 输出: 一个算法有一个或多个输出，以反映对输入数据加工后的结果，没有结果的算法是毫无意义的

47.3 数据，数据元素，数据项，数据对象

  • 数据: 客观事物的符号表示，是所有能输入计算机中并被计算机程序处理的符号的总称
  • 数据元素: 数据的基本单位，在计算机中通常作为一个整体进行考虑和处理。（有“原子型”，不可分割的；“由多个款项构成”，每个款项成为一个数据项）
  • 数据项: 组成数据元素的、有独立含义的、不可分割的最小单位
  • 数据对象: 性质相同的数据元素的集合，是数据的一个子集

在这里插入图片描述
不清楚的可以看下这个链接的讲解:

https://codebuilding.blog.csdn.net/article/details/79868242?spm=1001.2101.3001.6650.5&utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-5-79868242-blog-117795840.235%5Ev38%5Epc_relevant_sort_base2&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7ECTRLIST%7ERate-5-79868242-blog-117795840.235%5Ev38%5Epc_relevant_sort_base2&utm_relevant_index=4

四十八、线性表浅谈（特别浅的谈）

48.1 线性表概念

  • 多个同一特征的数据元素组成的线性结构，就叫做线性表

48.2 线性表分类

线性表根据具体实现的不同，可以分为:

  1. 顺序表
  2. 链表
  3. 栈 (操作受限的线性表)
  4. 队列 (操作受限的线性表)

48.3 线性表特点

  1. 同一特征的多个数据类型
  2. 数据之间是一对一的关系

四十九、顺序表

49.1 顺序表概念

  • 顺序存储的数据之间是一对一关系的，多个同一特征元素的结构
  • 逻辑结构上连续的元素之间物理存储结构上也连续

49.2 顺序表实现思路

  1. 可以直接通过数组实现，可以直接分配在栈区，也可以手动分配在堆区
  2. 由于涉及到对顺序表元素的，增删改查，所以需要记录顺序表的实际长度
    在这里插入图片描述

49.3 顺序表的实现

49.3.1 顺序表的结构体

  • 需要一个数组
  • 以及一个实际长度
typedef int datatype;

typedef struct SeqList
{
    datatype arr[MAX];
    int len;
}Seq,*Seqptr;

Seq		:	结构体类型
Seqptr	:	结构体指针类型

49.3.2 需要实现的顺序表的功能

顺序表的结构体声明:

//	顺序表最多十个结点
#define MAX 10
//	给int类型起个别名为data
typedef int data;
//	顺序表结构体声明，并起别名为list
typedef struct mylist
{
    data arr[MAX];	//	存放数据的数组
    int index;		//	实际存放的个数
}list;
  • 增删改查(CURD)
// 创建顺序表
list *init();
// 顺序表的判满
int is_full(list *L);
// 顺序表的判空
int is_empty(list *L);
// 顺序表的尾插
int tail_insert(list *L, data number);
// 顺序表的头插
int head_insert(list *L, data number);
//  指定下标插入
int inset_by_index(list *l, int index, data value);
//  指定下标删除
int del_by_index(list *l, int index);
// 顺序表的按值查找，返回下标
int find_by_value(list *l, data value);
// 顺序表的按值修改,返回下标
int change_by_value(list *l, data old_value, data new_value);
// 顺序表的按位置查找，返回对应的值
data find_by_index(list *l, int i);
// 顺序表的选择排序
int select_sort(list *l);
// 顺序表的冒泡排序
int bubble_sort(list *l);
//  输出顺序表
int output(list *l);
//  头删
int head_del(list *l);
//  尾删
int tail_del(list *l);
//  顺序表去重
int remove_duplicates(list *l);
//  释放顺序表
int free_list(list **l);

49.4 顺序表功能函数的实现分析

  • 创建顺序表
// 创建顺序表
list *init();
//	在堆区申请list这么大的空间
list *p = (list *)malloc(sizeof(list));
//  将顺序表的内容清零
memset(p->arr, 0, sizeof(p->arr));
//  实际存放数清零
p->index = 0;
  • 顺序表的判满
// 顺序表的判满
int is_full(list *L);
//	实际存放数量小于最大存放数量时未满
if (L->index < MAX)
    return 0;	//	未满返回0
else
    return 1;	//	满返回1
  • 顺序表的判空
// 顺序表的判空
int is_empty(list *L);
//	实际存放数量为0时为空
if (0 == L->index)
    return 1;	//	空则返回1
else
    return 0;	//	不空则返回0
  • 顺序表的尾插
// 顺序表的尾插
int tail_insert(list *L, data number);
//  以实际存储数量为下标进行插入
//  实际存储数量会比里面存放的最后一个数据的下标多1
L->arr[L->index] = number;
//  插入后实际存放数量+1
L->index++;
  • 顺序表的头插
// 顺序表的头插
int head_insert(list *L, data number);
//  实际存放的最后一个数据到第一个数据都向后移动一位   
for (int i = L->index; i > 0; i--)
{
    //  逐位覆盖后移，将 头部位置 空出
    L->arr[i] = L->arr[i - 1];
    //  其实第一位还有之前的数据，只是在第二位复制了一份
    //	所以第一位的数据可以进行修改了
}
//  在头部插入，即下标为0的位置
L->arr[0] = number;
//  插入后实际存放数量+1
L->index++;
  • 指定下标插入
//  指定下标插入
int inset_by_index(list *l, int index, data value);
//  从实际存储的最后一个位置的下一位开始
//  到指定的下标位置，逐个往后移动一位
for (int i = l->index; i > index - 1; i--)
{   
    //  前一位覆盖后一位
    l->arr[i] = l->arr[i - 1];
}
//  将数据存入指定下标位置
l->arr[index] = value;
//  实际存放数据数+1
l->index++;
  • 指定下标删除
//  指定下标删除
int del_by_index(list *l, int index);
//  从指定下标开始，到实际存入数据最后位置的前一位
//  后一位覆盖当前位置
//  若删除最后一位的元素,则不会进入此循环,会直接将 L.index 减1
for (int i = index; i < l->index - 1; i++)
{
    //  后一位覆盖当前位
    l->arr[i] = l->arr[i + 1];
}
//  实际存放数据数-1
l->index--;
  • 顺序表的按值查找，返回下
// 顺序表的按值查找，返回下标
int find_by_value(list *l, data value);
//  从第一个循环向最后一个找
//  i < l->index 可以取到最后一个
for (int i = 0; i < l->index; i++)
{
    //  如果当前下标上的值与要找的值相同，则返回下标
    if (value == l->arr[i])
    {
        return i;   //  返回下标
    }
}
//  没找到就提示没找到，并返回-1，代表函数异常退出
printf("没找到这个值\n");
return -1;
  • 顺序表的按值修改,返回下标
// 顺序表的按值修改,返回下标
int change_by_value(list *l, data old_value, data new_value);
//  找到这个值对应的下标
int i = find_by_value(l, old_value);
//  将这个下标上的值修改为新的值
l->arr[i] = new_value;
//  返回下标
return i;
  • 顺序表的按位置查找，返回对应的值
// 顺序表的按位置查找，返回对应的值
data find_by_index(list *l, int i);
//  返回对应下标的值，数组这点很方便
return l->arr[i];
  • 顺序表的简单选择排序
// 顺序表的简单选择排序
int select_sort(list *l);
//  从第一位开始，往后逐个找最值，找到最值后进行交换
for (int i = 0; i < l->index - 1; i++)
{
    //  假设当前下标是最大值所在的下标
    int max = i;
    //  从当前的下一个位置开始比较
    for (int j = i + 1; j < l->index; j++)
    {
        //  如果后面某个值比记录的最大值下标对应的值还大，那就更新最大值下标
        if (l->arr[max] < l->arr[j])
        {
            max = j;    //  更新最大值下标
        }
    }
    //  将最大值与当前值进行交换
    //  也可以先判断记录的最大值所在下标是不是更新过，更新过再换
    data temp = l->arr[max];
    l->arr[max] = l->arr[i];
    l->arr[i] = temp;
}
  • 顺序表的冒泡排序
// 顺序表的冒泡排序
int bubble_sort(list *l);
//  循环实际存入数量-1次
for (int i = 0; i < l->index; i++)
{
    //  每相邻的两位都要进行比较
    
    for (int j = 0; j < l->index - i - 1; j++)
    {
        //  如果当前位置数据大于后一位，那么就交换
        if (l->arr[j] > l->arr[j + 1])
        {
            data temp = l->arr[j];
            l->arr[j] = l->arr[j + 1];
            l->arr[j + 1] = temp;
        }
    }
}
  • 输出顺序表
//  输出顺序表
int output(list *l);
//  从下标0开始，循环到实际存入的最后一个数据
for (int i = 0; i < l->index; i++)
{
    //  输出数据
    printf("L->arr[%d]=%d\n", i, l->arr[i]);
}
  • 头删
//  头删
int head_del(list *l);
//  从第一个数据开始，后一个将当前覆盖
//  至倒数第二个实际存入的数据
//  因为倒数第二个也是后一位覆盖当前
for (int i = 0; i < l->index - 1; i++)
{
    //  后一个覆盖当前
    l->arr[i] = l->arr[i + 1];
}
//  实际存入数据数-1
l->index--;
  • 尾删
//  尾删
int tail_del(list *l);
//  实际存入数-1就够了，这样就无法正常访问到原来最后的数据了
//  不放心可以按照下标将最后的数据清空
l->index--;
  • 顺序表去重
//  顺序表去重
int remove_duplicates(list *l);
//  从第一个数据开始为当前位置，到实际存入的倒数第二个数据
for (int i = 0; i < l->index - 1; i++)
{
    //  从当前位置的下一位开始，至最后一位数据，逐位比较
    for (int j = i + 1; j < l->index; j++)
    {
        //  如果有重复的，那么以这个地方为下标
        if (l->arr[i] == l->arr[j])
        {
            //  根据这个地方的下标删除这个地方的数据
            del_by_index(l, j);
            //  被比较的往前挪一下，因为一会还要+1，-1+1相当于没动
            j--;
        }
    }
}
  • 释放顺序表
//  释放顺序表
int free_list(list **l);
//  根据传入的顺序表的地址
//  将其指向的地址(*l)的空间释放
free(*l);
//  根据传入的顺序表的地址
//  让其指向(*l)NULL
*l = NULL;

49.5 顺序表功能函数、接口及测试代码

直接上代码:

接口 : head.h

#ifndef __HEAD_H__
#define __HEAD_H__

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

//	顺序表最多放十个数据
#define MAX 10

//	int 类型重定义为 data
typedef int data;

//	结构体声明并重定义为 list
typedef struct mylist
{
    data arr[MAX];
    int index;
}list;

// 创建顺序表
list *init();

// 顺序表的判满
int is_full(list *L);

// 顺序表的判空
int is_empty(list *L);

// 顺序表的尾插
int tail_insert(list *L, data number);

// 顺序表的头插
int head_insert(list *L, data number);

//  指定下标插入
int inset_by_index(list *l, int index, data value);

//  指定下标删除
int del_by_index(list *l, int index);

// 顺序表的按值查找，返回下标
int find_by_value(list *l, data value);

// 顺序表的按值修改,返回下标
int change_by_value(list *l, data old_value, data new_value);

// 顺序表的按位置查找，返回对应的值
data find_by_index(list *l, int i);

// 顺序表的选择排序
int select_sort(list *l);

// 顺序表的冒泡排序
int bubble_sort(list *l);

//  输出顺序表
int output(list *l);

//  头删
int head_del(list *l);

//  尾删
int tail_del(list *l);

//  顺序表去重
int remove_duplicates(list *l);

int free_list(list **l);

#endif

功能实现 : list.c

#include "head.h"

// 创建顺序表
list *init()
{
    list *p = (list *)malloc(sizeof(list));
    if (NULL == p)
    {
        printf("创建顺序表失败\n");
        return NULL;
    }
    //  将顺序表的内容清零
    memset(p->arr, 0, sizeof(p->arr));
    //  下标清零
    p->index = 0;
    return p;
}

// 顺序表的判满 满则返回1
int is_full(list *L)
{
    if (NULL == L)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (L->index < MAX)
        return 0;
    else
        return 1;
}

// 顺序表的判空 空则返回1
int is_empty(list *L)
{
    if (NULL == L)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (0 == L->index)
        return 1;
    else
        return 0;
}

// 顺序表的尾插
int tail_insert(list *L, data number)
{
    if (NULL == L)
    {
        printf("传入参数为空\n");
        return -1;
    }
    else if (is_full(L))
    {
        printf("这个顺序表满了,无法继续插入\n");
        return -1;
    }
    //  进行插入
    L->arr[L->index] = number;
    L->index++;

    return 0;
}

// 顺序表的头插
int head_insert(list *L, data number)
{
    if (NULL == L)
    {
        printf("传入参数为空\n");
        return -1;
    }
    else if (is_full(L))
    {
        printf("这个顺序表满了,无法继续插入\n");
        return -1;
    }

    //  后移 将 头部 空出
    for (int i = L->index; i > 0; i--)
    {
        L->arr[i] = L->arr[i - 1];
    }
    //  在头部插入
    L->arr[0] = number;
    L->index++;

    return 0;
}

// 顺序表的按值查找，返回下标
int find_by_value(list *l, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    for (int i = 0; i < l->index; i++)
    {
        if (value == l->arr[i])
        {
            return i;
        }
    }
    printf("没找到这个值\n");
    return -1;
}

// 顺序表的按值修改,返回下标
int change_by_value(list *l, data old_value, data new_value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    int i = find_by_value(l, old_value);
    l->arr[i] = new_value;
    return 0;
}

// 顺序表的按位置查找，返回对应的值
data find_by_index(list *l, int i)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    else if (i < 0 || i >= l->index)
    {
        printf("传入的位置不在合法区间\n");
        return -1;
    }
    return l->arr[i];
}

// 顺序表的选择排序
int select_sort(list *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }

    for (int i = 0; i < l->index - 1; i++)
    {
        int max = i;
        for (int j = i; j < l->index; j++)
        {
            if (l->arr[max] < l->arr[j])
            {
                max = j;
            }
        }
        data temp = l->arr[max];
        l->arr[max] = l->arr[i];
        l->arr[i] = temp;
    }
    return 0;
}

// 顺序表的冒泡排序
int bubble_sort(list *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    for (int i = 0; i < l->index; i++)
    {
        for (int j = 0; j < l->index - i - 1; j++)
        {
            if (l->arr[j] > l->arr[j + 1])
            {
                data temp = l->arr[j];
                l->arr[j] = l->arr[j + 1];
                l->arr[j + 1] = temp;
            }
        }
    }
    return 0;
}

//  输出顺序表
int output(list *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("是个空表,没有输出\n");
        return -1;
    }
    for (int i = 0; i < l->index; i++)
    {
        printf("L->arr[%d]=%d\n", i, l->arr[i]);
    }
    return 0;
}

//  头删
int head_del(list *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("是个空表,无法删除\n");
        return -1;
    }
    for (int i = 0; i < l->index - 1; i++)
    {
        l->arr[i] = l->arr[i + 1];
    }
    l->index--;
    return 0;
}

//  尾删
int tail_del(list *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("是个空表,无法删除\n");
        return -1;
    }
    l->index--;
    return 0;
}

//  指定下标插入
int inset_by_index(list *l, int index, data value)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    else if (is_full(l))
    {
        printf("这个顺序表满了,无法继续插入\n");
        return -1;
    }
    //  此处的 "index > l->index-1" 表示不能插到最后面，只能在最后一个数的前面插入
    if (index <= 0 || index > l->index - 1)
    {
        printf("传入的位置不在合法区间\n");
        return -1;
    }

    for (int i = l->index; i > index - 1; i--)
    {
        l->arr[i] = l->arr[i - 1];
    }
    l->arr[index] = value;
    l->index++;

    return 0;
}

//  指定下标删除
int del_by_index(list *l, int index)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    else if (is_empty(l))
    {
        printf("这个是个空顺序表,无法进行删除\n");
        return -1;
    }
    if (index < 0 || index > l->index - 1)
    {
        printf("传入的位置不在合法区间\n");
        return -1;
    }
    //  若删除最后一位的元素,则不会进入此循环,会直接将 L.index 减1
    for (int i = index; i < l->index - 1; i++)
    {
        l->arr[i] = l->arr[i + 1];
    }
    l->index--;
    return 0;
}

//  顺序表去重
int remove_duplicates(list *l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    if (is_empty(l))
    {
        printf("是个空表,无法操作\n");
        return -1;
    }
    for (int i = 0; i < l->index - 1; i++)
    {
        for (int j = i + 1; j < l->index; j++)
        {
            if (l->arr[i] == l->arr[j])
            {
                del_by_index(l, j);
                j--;
            }
        }
    }
    return 0;
}

//  释放顺序表的空间并将其指向NULL
int free_list(list **l)
{
    if (NULL == l)
    {
        printf("传入参数为空\n");
        return -1;
    }
    free(*l);
    *l = NULL;
    return 0;
}

测试函数 : main.c

#include "head.h"

int main()
{
    list *L = init();

    head_insert(L, 20);

    tail_insert(L, 22);

    head_insert(L, 25);

    tail_insert(L, 21);

    head_insert(L, 20);

    tail_insert(L, 22);

    head_insert(L, 25);
/*
    tail_insert(L, 21);

    head_insert(L, 20);

    tail_insert(L, 22);

    head_insert(L, 25);

    tail_insert(L, 21);
*/
    output(L);

    remove_duplicates(L);

    output(L);

    inset_by_index(L,3,10000);

    output(L);

    del_by_index(L,3);

    output(L);

    printf("22的下标为%d\n", find_by_value(L, 22));

    printf("下标为1对应的值为%d\n", find_by_index(L, 1));

    if (is_empty(L))
    {
        printf("是空表\n");
    }
    else
    {
        printf("不是空表\n");
    }

    if (is_full(L))
    {
        printf("是满表\n");
    }
    else
    {
        printf("不是满表\n");
    }

    change_by_value(L, 22, 2222);

    output(L);

    free_list(&L);

/*
    printf("头删\n");
    head_del(L);

    output(L);

    printf("尾删\n");
    tail_del(L);
    output(L);

    printf("尾删\n");
    tail_del(L);
    output(L);

    printf("尾删\n");
    tail_del(L);
    output(L);
    
    printf("尾删\n");
    tail_del(L);
    output(L);
    
    printf("尾删\n");
    tail_del(L);
    output(L);
    
    printf("尾删\n");
    tail_del(L);
    output(L);
    
    printf("尾删\n");
    tail_del(L);
    output(L);
    
    printf("尾删\n");
    tail_del(L);
    output(L);
    
    printf("尾删\n");
    tail_del(L);
    output(L);
    
    printf("尾删\n");
    tail_del(L);
    output(L);
    
    printf("尾删\n");
    tail_del(L);
    output(L);
*/
    return 0;
}

工程管理文件 : makefile

EXE=fun
CC=gcc
CFLAGs=-c
OBJs+=main.o 
OBJs+=list.o 


all:$(EXE)
$(EXE):$(OBJs)
	$(CC) $^ -o $@

%.o:%.c
	$(CC) $(CFLAGs) $^ -o $@

clean:
	rm *.o fun

思维导图

zhk___
关注
专栏目录
顺序表操作用c语言实现,顺序表的基本操作及C语言实现（详解版）
weixin_39762001的博客
05-16 733
我们学习了顺序表插入元素向已有顺序表中插入数据元素，根据插入位置的不同，可分为以下 3 种情况：插入到顺序表的表头；在表的中间位置插入元素；尾随顺序表中已有元素，作为顺序表中的最后一个元素；虽然数据元素插入顺序表中的位置有所不同，但是都使用的是同一种方式去解决，即：通过遍历，找到数据元素要插入的位置，然后做如下两步工作：将要插入位置元素以及后续的元素整体向后移动一个位置；将元素放到腾出来的位置上；...
顺序表练习
saveotaku的博客
02-04 63
请实现购物车系统,把商品[商品名称,商品属性、价格,个数]信息存储到顺序表中在堆区申请空间实现顺序表数据元素在表尾录入实现顺序表输出实现顺序表按下标插入商品信息.实现顺序表按下标删除商品信息查找商品名称key是否在购物车信息中出现修改商品名称key的购买数量， 修改为n删除最贵的商品信息对商品总价实现升序排序如果有两个商品名称相同的商品信息，则去重释放堆区空间。
5/17 C语言实现顺序表增删改查等操作
weixin_47976606的博客
05-17 101
创建头节点 1:头节点，0：普通节点。C语言实现顺序表增删改查等操作。//8.根据下标修改元素。//9.根据下标查找元素。//12.单链表按值插入。//13.单链表按值删除。//15.单链表按值查找。//10.单向链表排序。//11.单项链表逆置。//14.单链表按值修改。//6.根据下标插入。//7.根据下表删除。
第三周项目4 顺序表应用（1）
scmpart的博客
10-05 331
问题与代码 /* *Copyright (c) 2015,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称:head.h,main.cpp,zdy.cpp,delete.cpp *作者:陈梦萍 *完成日期:2015年10月5日 *版本号:v1.0 * *问题描述: 定义一个采用顺序结构存储的线性表,删除
嵌入式养成计划-21-数据结构之顺序栈，链栈，顺序循环队列，链式队列
This code no bug！
08-30 94
5。
嵌入式养成计划-20-数据结构之双向链表
This code no bug！
08-29 93
【代码】嵌入式养成计划-20-数据结构之双向链表。
嵌入式养成计划-18-数据结构之单链表
This code no bug！
08-28 72
【代码】嵌入式养成计划-18-数据结构之单链表。
嵌入式全栈开发学习笔记---数据结构（顺序表）
xiaobaivera的博客
08-04 1093
顺序表应该支持以下操作： 初始化操作，建立一个空的顺序表 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); 获
嵌入式养成计划-33--数据库-sqlite3
This code no bug！
10-07 303
七十一、 数据库 71.1 数据库基本概念 71.2 sqlite3命令语句 71.3 sql语句 71.4 sqlite3 API
嵌入式全栈开发学习笔记---项目1：停车管理系统
xiaobaivera的博客
08-12 1102
目前为止我们已经学习了linux系统的终端上的一些操作命令、vim编辑器上的一些操作命令、C语言和数据结构，接下来我们就用我们学过的这些知识做一个“停车管理系统”的项目。开发环境：基于VMware Workstation虚拟机上的Linux系统的终端上的vim编辑器。涉及重要知识点：C语言（二维数组）；数据结构（链表、队列、广度优先算法（BFS））；
严蔚敏数据结构c语言版本可运行源码、完全c语言代码实现.zip
06-14
1. **线性表**：包括顺序表和链表的实现，如动态数组、单链表、双向链表等。学习者可以通过这些源码理解数据的增删改查操作。 2. **栈和队列**：这些是两种重要的抽象数据类型，用于实现“后进先出”（LIFO）和...
嵌入式单片机中链表操作与实现详解
嵌入式技术开发
06-08 579
包含单链表，双链表，循环单链表，实际应用中的功能不同，但实现方式都差不多。单链表就像是美国男篮，一代一代往下传；双链表像是中国男足，你传球给我，我传球给你，最终传给了守门员；循环链表就像是中国男篮，火炬从姚明传给王治郅，王治郅传给易建联，现在易建联伤了，又传给了姚明单链表是指结点中只有一个指向其后继的指针，具有单向性，但是有时需要搜索大量数据的时候，就需要多次进行从头开始的遍历，这样的搜索就不是很高效了。
华清远见嵌入式培训_第五周回顾与反思
Anccccc的博客
09-25 646
这是在华清学习的第五个周末，这一周主要学习的是数据结构。老师说数据结构是一门非常庞大的学科，单单是数据结构里的一个小分支，单拎出来一周都未必可以学透，因此这周的数据结构课程里更多的是思维方向的学习，学习数据结构的思维方式和算法、拓宽思路，大方向上，利用好的数据结构和算法，来提升程序的执行效率，合理的使用内存资源；现阶段上，学习数据结构可以提高代码的质量，提升代码量，强化对C语言知识的理解和认识，养成编程思维、逻辑思维。 这一周里主要的学习内容有：顺序表、链表、栈、队列、数和哈希数组，每一部
【数据结构与算法】-空间复杂度
前鼻音的博客
11-07 959
空间复杂度是衡量算法在运行过程中临时占用存储空间大小的一个重要指标。它描述了算法所需的额外存储空间与输入数据规模之间的关系。空间复杂度通常也用大O表示法（Big O notation）来表示。递归调用栈：考虑递归调用栈的深度。动态规划：考虑中间结果的存储空间。多维数组：考虑多维数组的大小。缓存和哈希表：考虑缓存和哈希表的大小。图的遍历：考虑访问状态记录和递归调用栈的大小。
【数据结构和算法】-时间复杂度
前鼻音的博客
11-07 888
时间复杂度是衡量算法执行效率的一个重要指标，它描述了算法运行时间与输入数据规模之间的关系。时间复杂度通常用大O表示法（Big O notation）来表示。选择合适的算法：根据实际需求和数据规模选择合适的时间复杂度，以优化程序性能。分析和优化：在编写算法时，应尽量避免高时间复杂度的操作，特别是在处理大规模数据时。理解时间复杂度有助于评估和优化算法的性能，从而提高程序的效率。
数据结构---排序（下）
深夜敲代码
11-07 452
一.快速排序补充一.快速排序补充快速排序的分治部分还有其他方法，如挖坑法，快慢指针法。1.挖坑法（重要）思路：先将基准位置元素用tmp保存，假定基准位置没有值（有个坑），然后分别从前后向中间遍历，右边大于基准就减减，遇到小于基准的就放到基准值位置的坑中，左边亦然，遍历整个数组后，将基准值填入最后一个左边遍历值。细节注意：填坑不是互换。
数据结构-串
m0_63056769的博客
11-09 795
拷贝构造函数拷贝构造函数的目的是在新对象初始化时，创建一个现有对象的副本。这是 C++ 的一种机制，用于在创建新对象时复制另一个对象的内容，确保新对象获得与原对象一样的内容和状态，但存储在独立的内存中。copy() 函数copy()函数是一个普通成员函数，用于显式复制当前对象并返回一个副本。它提供了一个方法，可以在任何时候手动调用来获取当前对象的副本，而不仅限于对象初始化阶段。特性拷贝构造函数copy() 函数调用方式自动调用（创建新对象并用现有对象初始化时）手动调用主要用途。
单链表的实现(数据结构)
OKkankan的博客
11-05 2089
我们在上一篇中简单的认识了链表的组成和结构，并打印出链表，那么今天就来具体实现一下单链表对于数据增加、删减、插入等。在实现让任何代码之前，我们都因该将思路理清楚，尾插该注意什么，怎么去是实现?首先一定是要找到最后一个结点，pphead是我们的头结点，我们一贯会将pphead赋给一个新的指针pcur，使用while循环找到最后一个结点，但是如果while里面是pcur的那我们不就直接跳出循环，那我们还怎么找最后一个结点呢？
python中常见的8种数据结构之一数组的应用
最新发布
2301_81121233的博客
11-10 287
可能的类型码包括`b`（有符号整数）、`B`（无符号整数）、`u`（Unicode字符）、`h`（有符号短整数）、`H`（无符号短整数）、`i`（有符号整数）、`I`（无符号整数）、`l`（有符号长整数）、`L`（无符号长整数）、`f`（浮点数）、`d`（双精度浮点数）等。数组和列表的主要区别在于数组中的元素必须是同一种类型，而列表中的元素可以是任何类型。可以通过索引访问数组中的元素，也可以使用切片操作来获取数组的子集。3.音频处理：音频数据通常也以数组的形式存储，数组可以用来处理音频的采样值。
嵌入式工程师必备：数据结构与算法详解
- 数据结构定义了计算机内部数据的组织方式，包括线性结构（如顺序表、链表、栈和队列）、树结构（如博弈树、决策树和哈夫曼树）以及图结构（如神经网络和贝叶斯网络），这些结构反映了数据间的内在关系。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhk___

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值