嵌入式学习day15(顺序表)

一、数据结构概念

1.1 数据

数据：能被计算机识别、存储、处理的描述客观事物的符号

【整数、汉字、小数、视频、图片、声音、文件…】

数据元素：由数据项组成、是数据的基本单位

​ (如:下表的一个人的信息)

数据项：是数据的最小单位

​ (如:下表的单元格数据)

数据对象：有相同类型的数据元素组成

​ （如:下表的名字.性别.年龄）

数据> 数据对象>数据元素>数据项

数据对象(同类型)
	姓名	性别	年龄
	张三	男	11(数据项)
数据元素	李四	女	12
	王五	男	13
	…	…	…

1.2 数据结构

数据结构：是由类型相同的数据元素之间一种或多种关系的集合

D_S=(D,R)

1.2.1 逻辑结构

数据元素之间一种或多种关系

种类	概述
集合结构	数据元素之间没有关系 【地铁上的人】
线性结构	数据元素之间一对一【地铁上的座位，数组】,头结点无前驱，尾结点无后继，中间结点有唯一的前驱，唯一的后继
树形结构	数据元素之间一对多【家谱】,头结点无前驱，尾结点无后继，中间结点有唯一的前驱，多个后继
图形结构	数据元素之间多对多【地图】

1.2.2 存储结构

种类	概述
存储结构	是逻辑结构在计算机中的存储形式
顺序结构	使用一段连续的存储空间进行存储的方式【逻辑相邻，物理也相邻】
链式结构	使用任意一块存储空间进行存储的方式【逻辑相邻，物理不一定相邻】
散列结构(哈希结构)	数据元素和存储地址有一定的对应关系【词典中的按首字母查找】
索引结构	使用索引表和数据文件结合的一种查找方式

1.3 时间复杂度

时间复杂度：代码的执行次数

时间复杂度越小，代码的执行速度越快

时间复杂度公式：T(n)=O(f(n))

• T(n):时间复杂度

• n: 问题的规模

• f(n): 问题规模的函数

• O: 渐进符，大O阶

f(n)=2*n^2+3*n+100   ===>2*n^2  ===》n^2  O(n^2)
1>O(1):常数阶   【没有循环】
    int t=a;  执行次数:1
    a=b;      1
    b=t;      1
    f(n)=3=3*n^0=n^0=1    ==>T(n)=O(1)
2>O(n):线性阶   【一个循环】
    for(int i=1;i<=n;i++)  m+1
    {
        printf("你好\n");    n
    }
    f(n)=2*n+1  ==>n  ===>O(n)
3>O(n^2):平方阶  【两层循环】
    for(int i=1;i<=n;i++)  n+1
    {
        for(int j=1;i<=n;j++) n*(n+1)
        {
            printf("你好\n");    n*n    
        }    
    }
    f(n)=2n^2+2n+1 ===>n^2  ===>O(n^2)
    
4> log2n:对数阶 
    int i=1;        1
    while(i<=n)
    {
        i*=3;    1次循环*2  2次循环2
    }
    2^次数=n   ===> log2 n

二、线性表

线性表：由多个类型相同的有限个数的数据元素组成的线性结构【星座、属相】

逻辑结构：数据元素之间存在一对一的关系

存储结构：顺序存储、链式存储

线性表：顺序表、链表、字符串、栈、队列

三、顺序表

1. 顺序表类似一维数组，但是不等价于一维数组

2. 顺序表下标从0开始

3. 顺序表：线性表的顺序存储称为顺序表

4. 逻辑结构：线性结构（一对一）

5. 顺序存储：逻辑相邻，物理也相邻

6. 线性表长度/数组长度：不变 #define MAXSIZE 7

7. 顺序表长度：可变 int len;
   

8. 顺序表满：顺序表长度等于线性表长度 len==MAXSIZE

   #define MAXSIZE 7 // 线性表长度

9. 顺序表长度：可变 int len;

10. 顺序表满：顺序表长度等于线性表长度 len==MAXSIZE

11. 顺序表空： 没有数据元素 len=0

3.2 顺序表操作

3.2.1 顺序表结构体定义

#define MAXSIZE 10 //定义顺序表元素数
typedef int data_type;//用于数据表数据类型定义
typedef struct
{
    data_type data[MAXSIZE];
    int len;
} seqlist;

3.2.2 顺序表在堆区申请空间

seqlist *Create()
{
    seqlist *list = (seqlist *)malloc(sizeof(seqlist));
    if (list == NULL)
        return NULL;
    list->len = 0;
    return list;
}

3.2.3 顺序表在尾部插入

void insert_rear(seqlist *list, data_type e)
{
    // 判满
    if (full_seqlist(list))
    {
        printf("顺序表已满,插入失败\n");
        return;
    }
    // 插入
    list->data[list->len] = e; // 在len当前位置插入数据
    list->len++;
}

3.2.4 顺序表在尾部删除

int deleta_rear(seqlist *list)
{
    if (empty_seqlist(list))
    {
        printf("顺序表为空,删除失败\n");
        return 0;
    }
    list->len--;
    return -1;
}

3.2.5 顺序表按下标插入

int insert_by_sub(seqlist *list, int sub, data_type e)
{
    // 先判满,和插入的下标是否符合
    if (full_seqlist(list) || sub < 0 || sub > list->len)
    {
        printf("插入失败\n");
        return 0;
    }
    // 再逐次往后移动
    for (int i = list->len - 1; i >= sub; i--)
    {
        list->data[i + 1] = list->data[i];
    }
    // 把e值赋给sub下标
    list->data[sub] = e;
    list->len++;
    return -1;
}

3.2.6 顺序表按下标删除

int deleta_by_sub(seqlist *list, int sub)
{
    // 先判空
    if (empty_seqlist(list) || sub < 0 || sub > list->len)
    {
        printf("删除的下标错误,删除失败\n");
        return 0;
    }
    // 再逐次往前移动
    for (int i = sub; i < list->len; i++)
    {
        list->data[i] = list->data[i + 1];
    }
    list->len--;
    return -1;
}

3.2.7 顺序表按下标修改

int Updata_sub(seqlist *list, int sub, data_type e)
{
    if (empty_seqlist(list) || sub > list->len || sub < 0) // 判空 || 下标小于0 || 下标大于最大值
    {
        return 0;
    }

    list->data[sub] = e;
    return -1;
}

3.2.8 顺序表按下标查找

int search(seqlist *list, int sub)
{
    if (empty_seqlist(list) == -1 || list->len < 0 || sub > list->len)
    {
        printf("查询的下标超范围,查询失败\n");
        return 0;
    }
    printf("查询的值为%d\n", list->data[sub]);
    return -1;
}

3.2.9 顺序表按元素删除

3.2.10 顺序表按元素修改

int revamp_by_value(seqlist *list, data_type e, data_type value)
{
    // 判空
    if (empty_seqlist(list))
    {
        printf("修改失败,顺序表为空");
        return 0;
    }
    int flag = 0;
    // 循环寻找,只找第一个
    for (int i = 0; i < list->len; i++)
    {
        if (list->data[i] == e)
        {
            // list->data[i] = value;
            Updata_sub(list, i, value); // 修改数据
            flag = 1;
        }
    }
    if (flag == 0)
    {
        printf("修改失败,未找到元素\n");
        return 0;
    }

    return -1;
}

3.2.11 顺序表按元素查找

3.2.12 顺序表排序

void seqlist_sort(seqlist *list)
{
    for (int i = 0; i < list->len - 1; i++)
    {
        for (int j = 0; j < list->len - i - 1; j++)
        {
            if (list->data[j] > list->data[j + 1])
            {
                data_type t = list->data[j];
                list->data[j] = list->data[j + 1];
                list->data[j + 1] = t;
            }
        }
    }
}

3.2.13顺序表去重

3.2.14 顺序表输出

3.2.15 顺序表有序合并

3.2.16 顺序表空间释放

seqlist *free_fun(seqlist *list)
{
    if (list != NULL)
    {
        free(list);
        list = NULL;
    }
    return list;
}