C语言备忘-一些数据结构和相关的算法

最新推荐文章于 2024-09-05 10:13:13 发布
最新推荐文章于 2024-09-05 10:13:13 发布
阅读量286 收藏 1
点赞数 1
分类专栏： C语言 基础数据结构和算法 文章标签： 数据结构 算法 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/animefans/article/details/127825413
版权

自己写的一些基础的C函数，如发现问题请不吝赐教。

一、循环队列。

注意对队列的任何操作都应该在list_lock_begin和list_lock_end之间。

1.1 循环队列结构体定义。

index - 下一个数据append时的索引；shift - 队列填满并开始“旋转”之后最旧的那个数据的索引。

typedef int32_t y_t;
typedef uint64_t x_t;

typedef struct {
    x_t x;
    y_t y;
} XYDATA;

typedef struct {
    XYDATA *buf;
    volatile uint8_t changed;
    volatile uint8_t locked;
    volatile uint8_t cleared;
    uint32_t cnt; //data count now
    uint32_t index; //index now
    uint32_t shift; //shift count now
    uint32_t TOTAL; //total data count of this list can hold
} DataListTypeDef;

1.2 初始化。为循环队列的buffer申请空间，并初始化结构体其他元素。

输入 ：dl - 要初始化的循环队列指针；total - 循环队列元素总个数；

输出：无；

void list_init(DataListTypeDef *dl, uint32_t total) {
    if (dl->buf == NULL) {
        dl->buf = (XYDATA*)malloc((total) * sizeof(XYDATA)); 
    }
    else {
        if (dl->TOTAL != total) {
            dl->buf = (XYDATA*)realloc(dl->buf, dl->TOTAL * sizeof(XYDATA));
        }
    }
    dl->locked = 0;
    dl->TOTAL = total;
    list_clear(dl);
    dl->changed = 0;
    dl->cleared = 0;
}

1.3 删除队列。释放buffer内存，并复位其他元素为默认值。

输入：dl - 队列指针；

输出：无；

void list_deinit(DataListTypeDef *dl) {
    if (dl->buf != NULL) {
        free(dl->buf);
        dl->buf = NULL;
    }
    dl->TOTAL = 0;
    dl->changed = 0;
}

1.4 队列追加一个新元素。

输入：dl - 队列指针；element - 新元素地址；

输出：无；

void list_append(DataListTypeDef *dl, XYDATA *element) {
    memcpy(&(dl->buf[dl->index]), element, sizeof(XYDATA));
    if (dl->cnt < dl->TOTAL) {
        dl->cnt++; //modify count
        dl->index++;
        if (dl->index == dl->TOTAL) { //it is full just now
            dl->index = 0;
        }
    } else { //it is full
        if (dl->index < dl->TOTAL - 1) {
            dl->index++;
        } else {
            dl->index = 0;
        }
        if (dl->shift < dl->TOTAL - 1) {
            dl->shift++;
        } else {
            dl->shift = 0;
        }
    }
    dl->changed = 1;
}

1.5 向队列追加一个子队列，同时子队列被清空。

输入：dl - 源队列指针；dl_extra - 子队列地址；

void list_append_list(DataListTypeDef *dl, DataListTypeDef *dl_extra) {
    XYDATA *xy_pop;
    while (!list_is_empty(dl_extra)) {
        xy_pop = list_shift(dl_extra);
        memcpy(&(dl->buf[dl->index]), xy_pop, sizeof(XYDATA));
        if (dl->cnt < dl->TOTAL) {
            dl->cnt++; //modify count
            dl->index++;
            if (dl->index == dl->TOTAL) { //it is full just now
                dl->index = 0;
                dl->shift = 1;
            }
        } else { //it is full
            if (dl->index < dl->TOTAL - 1) {
                dl->index++;
            } else {
                dl->index = 0;
            }
            if (dl->shift < dl->TOTAL - 1) {
                dl->shift++;
            } else {
                dl->shift = 0;
            }
        }
    }
    dl->changed = 1;
}

1.6 获取指定索引的元素。

输入：dl - 队列指针；

输出：获取的元素的指针；

XYDATA* list_at(const DataListTypeDef *dl, uint32_t _index) {
    if (_index + dl->shift < dl->TOTAL) {
        return &(dl->buf[_index + dl->shift]);
    } else {
        return &(dl->buf[_index + dl->shift - dl->TOTAL]);
    }
}

1.7 获取队列中最后一个元素。

输入：dl - 队列指针；

输出：获取的元素的指针；

XYDATA* list_last(const DataListTypeDef *dl) {
    if (dl->index > 0) {
        return &(dl->buf[dl->index - 1]);
    } else {
        return &(dl->buf[dl->TOTAL - 1]);
    }
}

1.8 删除队列中的第一个元素并返回该元素的指针。

输入：dl - 队列指针；

输出：获取的元素的指针；

XYDATA *list_shift(DataListTypeDef *dl) {
    if (dl->cnt == 0) {
        return NULL;
    }

    XYDATA *xy_data = &(dl->buf[dl->shift]);
    dl->shift++;
    if (dl->shift == dl->TOTAL) {
        dl->shift = 0;
    }
    dl->cnt--;
    dl->changed = 1;

    return xy_data;
}

1.9 清除队列。实际上不清除数据buffer，只是修改结构体变量。

void list_clear(DataListTypeDef *dl) {
    dl->cnt = 0;
    dl->index = 0;
    dl->shift = 0;
    dl->changed = 1;
    dl->cleared = 1;
}

 1.10 队列上锁。这里使用sleep_ms(1)函数避免可能造成的CPU占用过高，可以根据具体场合进行修改。

void list_lock_begin(DataListTypeDef *dl) {
    while (dl->locked) {
        sleep_ms(1);
    }
    dl->locked = 1;
}

1.11 队列解锁。

void list_lock_end(DataListTypeDef *dl) {
    dl->locked = 0;
}

1.12 判断队列是否为空。

uint8_t list_is_empty(const DataListTypeDef *dl) {
    return dl->cnt == 0;
}

1.13 判断队列是否已满。

uint8_t list_is_full(const DataListTypeDef *dl) {
    return dl->cnt == dl->TOTAL;
}

1.14 获取队列当前元素数量。

uint32_t list_count(const DataListTypeDef *dl) {
    return dl->cnt;
}

1.15 清除脏标志。

void list_clear_change_flag(DataListTypeDef *dl) {
    dl->changed = 0;
}

1.16 获取脏标志。

uint8_t list_get_change_flag(const DataListTypeDef *dl) {
    return dl->changed;
}

二、FIFO。

FIFO结构体定义。注意buf这里用了char*而没有用void*，是为了计算索引位置时方便。

ipp - 数据push索引；opp - 数据pop索引；

typedef struct {
    char *buf;
    uint16_t locked;
    uint16_t ele_size;
    uint32_t ipp;
    uint32_t opp;
    uint32_t depth;
} FifoListTypeDef;

2.1 初始化。

输入：stu - FIFO指针；ele_size - buf中一个数据所占用的字节数；realloc_cnt - buf可存储的最大数据个数；

输出：无；

void fifo_init(FifoListTypeDef *stu, int ele_size, uint32_t realloc_cnt) {
    stu->ele_size = ele_size;
    stu->ipp = 0;
    stu->opp = 0;
    stu->locked = 0;
    stu->depth = realloc_cnt;
    stu->buf = (char*)malloc(stu->depth * stu->ele_size);
}

2.2 删除FIFO。释放buf空间，并初始化结构体中的其他变量。

fifo_deinit(FifoListTypeDef *stu) {
    if (stu->buf != NULL) {
        free(stu->buf);
        stu->buf = NULL;
    }
    stu->ipp = 0;
    stu->opp = 0;
}

2.3 批量添加新数据。这里使用sleep_ms(1)函数避免可能造成的CPU占用过高，可以根据具体场合进行修改。

输入：stu - fifo指针；ele_arr - 数据数组指针；cnt - 要push的数据个数；

输出：无。

void fifo_in(FifoListTypeDef *stu, void* ele_arr, uint32_t cnt) {
    while (stu->locked == 2) { //fifo clearing
        sleep_ms(1);
    }
    stu->locked = 1;
    if (stu->ipp < stu->opp) {
        if (stu->ipp + cnt >= stu->opp) { //no enough memory
            stu->locked = 0;
            return;
        }
    }
    else if (cnt >= stu->depth - stu->ipp + stu->opp) { //no enough memory
        stu->locked = 0;
        return;
    }

    if (stu->ele_size == 1) {
        if (stu->ipp + cnt <= stu->depth) { //one part
            memcpy(stu->buf + stu->ipp, ele_arr, cnt);
        } else { //two parts
            uint32_t cnt_part1 = stu->depth - stu->ipp;
            memcpy(stu->buf + stu->ipp, ele_arr, cnt_part1);
            memcpy(stu->buf, (char*)ele_arr + cnt_part1, cnt - cnt_part1);
        }
    } else {
        if (stu->ipp + cnt <= stu->depth) { //one part
            memcpy(stu->buf + stu->ele_size * stu->ipp, ele_arr, stu->ele_size * cnt);
        } else { //two parts
            uint32_t cnt_part1 = stu->depth - stu->ipp;
            memcpy(stu->buf + stu->ele_size * stu->ipp, ele_arr, stu->ele_size * cnt_part1);
            memcpy(stu->buf, (char*)ele_arr + stu->ele_size * cnt_part1, stu->ele_size * (cnt - cnt_part1));
        }
    }
    stu->ipp = (stu->ipp + cnt)%stu->depth;
    stu->locked = 0;
}

2.4 取出FIFO中的第一个数据。sleep_ms(1)说明同上。

void* fifo_out(FifoListTypeDef *stu) {
    while (stu->locked == 2) { //fifo clearing
        sleep_ms(1);
    }
    stu->locked = 1;
    char* tmp;
    if (stu->opp == stu->ipp) { //empty
        stu->locked = 0;
        return NULL;
    }
    tmp = stu->buf + stu->ele_size * stu->opp;
    stu->opp = (stu->opp + 1)%stu->depth;
    stu->locked = 0;
    return tmp;
}

2.5 取出FIFO中前4个字节数据（double word）。sleep_ms(1)说明同上。

输入：stu - fifo指针；p_data - 要存储的4字节buffer地址；

输出：无。

int fifo_out_dw(FifoListTypeDef *stu, char *p_data) {
    while (stu->locked == 2) { //fifo clearing
        sleep_ms(1);
    }
    stu->locked = 1;
    int cnt = stu->ipp - stu->opp;
    if (cnt < 0) {
        cnt += stu->depth;
    }
    if (cnt > 3) {
        *(int*)p_data = *(int*)(stu->buf + stu->opp);
        stu->opp = (stu->opp + 4)%stu->depth;
        stu->locked = 0;
        return 4;
    }
    stu->locked = 0;
    return 0;
}

2.6 清除fifo。实际上不清除数据buffer，只是修改结构体变量。

void fifo_clear(FifoListTypeDef *stu) {
    while (stu->locked) {
        sleep_ms(1);
    }
    stu->locked = 2;
    stu->ipp = 0;
    stu->opp = 0;
    stu->locked = 0;
}

三、双向链表。

该双向链表结构如下图。其中head->prev指向tail，这样可以通过head快速找到tail，方便进行尾插节点。

 节点数据结构定义如下。

typedef struct _linklist {
    void *buf;
    struct _linklist *prev;
    struct _linklist *next;
} LinkListTypeDef;

3.1 链表初始化。

输入：pp_head - 指向链表头指针的指针。注意要修改的主体是指针本身，因此要传入二级指针。

输出：无。

void linklist_init(LinkListTypeDef **pp_head) {
    *pp_head = NULL;
}

3.2 删除链表。释放所有节点空间。

void linklist_deinit(LinkListTypeDef **pp_head) {
    LinkListTypeDef *p = (*pp_head);
    LinkListTypeDef *p_next;
    while (p != NULL) {
        p_next = p->next;
        free(p);
        p = p_next;
    }
    *pp_head = NULL;
}

3.3 添加节点（尾插法）。注意：1）ele不是节点指针而只是节点的数据指针，也就是节点的buf，下同；2）malloc的节点数据指针只是指向ele指向的内存区域，而没有进行深拷贝，如果需要进行深拷贝请将buf也malloc一份（但要知道malloc空间大小）然后memcpy。

输入：pp_head - 指向头指针的指针；ele - 要添加的节点数据

void linklist_append(LinkListTypeDef **pp_head, void* ele) {
    if (*pp_head == NULL) {
        *pp_head = (LinkListTypeDef *)malloc(sizeof(LinkListTypeDef));
        (*pp_head)->buf = ele;
        (*pp_head)->prev = *pp_head; //NOTE: *pp_head->prev pointer to linklist tail
        (*pp_head)->next=NULL;
        return;
    }

    LinkListTypeDef *p_tail = (*pp_head)->prev; //it is linklist tail
    p_tail->next = (LinkListTypeDef *)malloc(sizeof(LinkListTypeDef));
    p_tail->next->buf = ele;
    p_tail->next->prev = p_tail;
    p_tail->next->next = NULL;
    (*pp_head)->prev = p_tail->next; //NOTE
}

3.4 添加节点（任意位置）。

输入：pp_head - 指向头指针的指针；ele - 要添加的节点数据指针；ele_after - 要插入的位置处的节点数据指针（ele添加到ele_after原来的位置，ele_after后移成为ele->next）；

输出：无。

void linklist_insert(LinkListTypeDef **pp_head, void* ele, void* ele_after) {
    if (ele_after == NULL) {
        linklist_append(pp_head, ele);
        return;
    }

    LinkListTypeDef *p = (*pp_head);
    while (p != NULL && p->buf != ele_after) {
        p = p->next;
    }
    if (p == NULL) { //not find ele_after, so append ele to linklist end
        linklist_append(pp_head, ele);
        return;
    }

    LinkListTypeDef *p_prev = p->prev;
    LinkListTypeDef *p_insert = (LinkListTypeDef *)malloc(sizeof(LinkListTypeDef));
    p_insert->buf = ele;
    p_insert->prev = p_prev;
    p_insert->next = p;
    p->prev = p_insert;
    if (p != (*pp_head)) {
        p_prev->next = p_insert;
    }
}

3.5 删除数据ele对应的节点。

void linklist_remove(LinkListTypeDef **pp_head, void* ele) {
    LinkListTypeDef *p = (*pp_head);
    while (p != NULL && p->buf != ele) {
        p = p->next;
    }
    if (p != NULL) { //find ele in linklist
        LinkListTypeDef *p_prev = p->prev;
        if (p != (*pp_head)) {
            p_prev->next = p->next;
            if (p->next != NULL) {
                p->next->prev = p_prev;
            } else { //linklist tail
                (*pp_head)->prev = p->prev; //NOTE
            }
        } else { //p_head is just the element to delete
            if (p->next != NULL) { //list count more than 1
                p->next->prev = p_prev;
            }
            *pp_head = p->next;
        }
        free(p);
    }
}

animefans
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Java数据结构与算法-基本概念和认识
qq_41649001的博客
07-12 482
前言 文章内容是本人之前学习数据结构时所做的零散笔记的汇总及补充，整理过程难免有瑕疵，如果小伙伴发现错误请及时不吝指出，在此谢过！ 绪论 1 数据结构的起源 早期人们都把计算机理解为数值计算工具,就是感觉计算机当然是用来计算的,所以计算机解决问题,应该是先从具体问题中抽象出一个适当的数据模型,设计出一个解此数据模型的算法,然后在编写程序,得到一个实际的软件. 现实中,我们更多的不是解决数值计算的问题,而是需要一些更科学有效的手段(比如表,树和图等数据结构)的帮助,才能更好的处理问题,所以数据结构是一门
计算树的深度算法c语言,C语言实现计算树的深度的方法
weixin_32653933的博客
05-23 1161
C语言实现计算树的深度的方法本文实例讲述了C语言实现计算树的深度的方法。是算法设计中常用的技巧。分享给大家供大家参考。具体方法如下：/** Copyright (c) 2011 alexingcool. All Rights Reserved.*/#include using namespace std;struct Node {Node(int i = 0, Node *l = NULL, No...
C语言排序算法备忘 顺序存储
rexsam111的博客
04-11 1124
//排序 #include<stdlib.h> #include<stdio.h> #include<string.h> #define MAXSIZE 99 typedef struct{ int data[MAXSIZE+1];//0位哨兵位从1开始排序 int length; }*SqList,sqlist; //插入排序 void ChaRuPaiXv(SqList L){ for(int i=2;i<=L->length;i++){ .
c语言备忘录算法矩阵链乘,算法题系列：矩阵链乘问题
weixin_34900026的博客
05-23 752
矩阵链乘问题是最典型的动态规划问题，要理解下面的内容请先阅读这篇动态规划的总结。1.问题描述矩阵链乘问题的描述如下，就是说要确定一个完全加括号的形式使得矩阵链乘需要进行的标量计算数目最少，矩阵Ai的维数为pi−1×pi，如果穷举所有可能形式的话，时间复杂度是指数级的！因为该问题满足最优子结构，并且子问题存在重叠，所以我们可以借助动态规划来求解。 2.问题分析我们需要确定一个递归式来将我们要求解的问...
两数相加 -力扣（Leetcode） C语言算法图文代码详解
weixin_45706632的博客
03-19 1747
题目描述 给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照逆序 的方式存储的，并且每个节点只能存储一位数字。 请你将两个数相加，并以相同形式返回一个表示和的链表。 你可以假设除了数字 0 之外，这两个数都不会以 0 开头。 题目链接：https://leetcode-cn.com/problems/add-two-numbers 示例1 输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[7,0,8] 解释：342 + 465 = 807. 示例2 输入：l1 = [
数据结构与算法--pta复习
m0_54453375的博客
06-24 1577
拓扑序一定是唯一的 F如果从有向图 G 的每一点均能通过深度优先搜索遍历到所有其它顶点，那么该图一定不存在拓扑序列 TAOE图的权值最大的边（活动）一定是关键活动 F在关键路径上的活动都是关键活动，而关键活动也必在关键路径上。T关键路径是AOE网中从源点到汇点的最短路径 F最长路径在AOE网络中，从源点到汇点具有最大长度的路径称为关键路径。完成AOE所表示的整个工程所需要的时间取决于关键路径的路径长度 TA.ABCDFEGB.ADFCEBGC.ACDFBEGB.3C.4D.5。
C语言 算法 数据结构 练习题
07-16
### C语言、算法与数据结构综合训练知识点概览 #### C语言基础编程 1. **字符串处理** - 题目示例：求解连续重复最长的子串。 - **知识点**：掌握字符串遍历、比较及子串提取技巧，理解字符串的存储结构。 2. *...
C语言备忘录程序代码
07-01
`MemoInfo`结构体是该备忘录程序的核心数据结构，包含了备忘录的所有必要信息： - `charevent[200]`：用于存储事件的描述，最多可容纳200个字符。 - 时间字段：包括`remindtime_year`、`remindtime_month`、`...
数据结构算法练习试卷
07-11
数据结构算法练习试卷 本试卷涵盖了数据结构中学习的各种算法，包括选择题、填空题、求解题和算法设计题。选择题部分考查了算法的基本概念、算法设计步骤、算法的复杂性、动态规划和备忘录方法、图论等知识点。填空...
树、二叉树
2301_79909332的博客
08-30 768
1、满二叉树：满二叉树是一种特殊的二叉树，其中每个层级的节点数都是最大值，即每个层级都是完全填充的。深度： 从根节点出发到达节点的分支节点个数称为该节点的深度。高度：从叶子节点出发到该节点最大的节点个数称为该节点的高度。树的高度：整个树形结构中高度最高的节点的高度称为树的高度。树的深度：整个树形结构中深度最深的节点的深度称为树的深度。3、二叉树特点：叶子节点、只有左孩子、只有右孩子、左右孩子都有。树的层数 == 树的高度 == 树的深度。3.叶子节点：没有后继的节点。节点的度： 叶子节点度数为0。
9/2 pandas数据结构介绍
m0_58285219的博客
09-02 1063
1.对于Series ：当对象相加时，如果存在不同的索引对，则结果的索引是所有索引的并集，对于不重叠的标签，会导致缺失值 obj1 + obj2。注：在重构时，标签只含新的指定序列中的标签，新的和原来的匹配则保留，不匹配则删除原来的，添加新的。2.对于DataFrame：会将行和列的索引同时进行匹配，得到的行列索引是所有索引的并集，不重叠的标签，会导致缺失值。data.drop(["a”，“b"]，axis="index或columns"）担当索引不为整数索引时，可用data[-1]来提取最后一个数据。
C++笔记16•数据结构:关联式容器map和set•
qq_64446190的博客
09-02 877
数据结构:关联式容器map和set
经典数据结构-栈计算逆波兰表达式
最新发布
一个好学的低级程序猿
09-05 187
栈计算逆波兰表达式
桶排序【算法 14】
delepaste的博客
08-31 812
桶排序是一种适用于特定数据分布的高效排序算法，特别适合均匀分布的数据集合。在大多数情况下，它可以达到线性时间复杂度，因此在处理某些数值排序问题时非常实用。然而，桶排序对输入数据的分布有较高要求，因此在使用时需考虑数据特性。
插入排序的动画展示与实现
weixin_73483158的博客
08-30 365
回忆下自己玩扑克牌的时候是怎么把手上的牌理顺的吧！其实那就是插入排序，从左边往右边，把一张张抽出来在左边插入到它适合的位置。插入排序的特点是：完成插入动作的牌之间的是有序的，如下面动图中，开始插入7时，它前面插入过的3，5，9是有序的；开始插入2时，它前面插入过的3，5，9，7之间是有序的。
滑动窗口系列(不定长滑动窗口长度) 9/2
2301_78191305的博客
09-02 1154
移动right的时候，需要更新costK，costK=(nums[right]-nums[right-1])*(right-left);逆向思维就是：题目中是否存在一段子串满足字符出现最多的次数为:count[0]-k,count[1]-k,count[2]-k。每次遍历到一个字符，就将出现的次数-1(还可以出现多少次)，如果出现<0的情况，左边界就要改变了。每次操作的时候，移除左边和右边的元素，使得移除元素之和=x。给定一个数组nums,求子数组中删除k个元素后，所有元素都相等，返回相同元素的最大个数。
数据结构---循环队列---树的基本概念
m0_65301172的博客
08-30 772
循环队列的循环思想很重要，也要知道为啥要使用循环队列，循环队列是如何实现循环的，如何判断队空，对满；树呢，二叉树是用的最多的，其中要分清满二叉树和完全二叉树；还有就是满二叉树中的节点个数的计算。
数据结构的三要素以及数据类型和抽象数据类型
ADCvbV的博客
08-30 478
顺序存储链式存储索引存储散列存储注：顺序存储数据之间必须相邻。链式存储，索引存储和散列存储的数据之间是不相邻的，即离散，也叫非顺序存储或离散存储。如连续的数据可用顺序存储，找不到连续的数据可用非顺序存储如上述例子中在b和d之间插入c，对于顺序存储插入c的话要把大量元素进行移动空出位置后才能插入c，而非顺序存储只需要在b和d之间找一个空的地方插入c再修改指针指向的地址即可，效率比顺序存储高。
数据结构C语言版-严蔚敏算法分析
"《算法分析应用举例-数据结构c语言版严蔚敏PPT》是关于数据结构和算法分析的学习资料，重点讲述了算法的时间复杂度和数据结构的重要性。" 在计算机科学中，算法分析是评估算法性能的关键工具，特别是在处理大规模...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值