总结3

最新推荐文章于 2022-12-21 17:59:46 发布
最新推荐文章于 2022-12-21 17:59:46 发布
阅读量117 收藏
点赞数
分类专栏： 总结
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40924666/article/details/103102700
版权

总结3


数据结构
从结构上看：
  1、数组：内存连续
  2、链表：内存不连续
从功能上看：
  1、线性：插入数据的顺序，与位置直接相关：vector list queue stack
  2、关联：插入数据的值，与位置直接相关：map hashmap

增删改查排
线性优优劣劣
关联劣劣优优

实现升序动态数组：增删查询

实现升序动态数组的关键是realloc和memmove和memcpy

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

typedef struct Array{
    void* data;//数组内存
    int size;//单元大小
    int idx;//当前插入的数据个数
    int capa;//当前分配的长度
}array_t;

array_t* arrayInit(int size);//初始化数组是什么数据类型
void arrayFree(array_t* array);//释放一个数据
void* arrayInsert(array_t* array, const void* data, int (*compare)(const void*,
            const void*));//插入一个数据，数据保持升序
void arrayRemove(array_t* array, const void* data, int(*compare)(const void*,
            const void*));
const void* arraySelect(array_t* array, const void* data, int(*compare)(const
            void*, const void*));

int compareInt(const void* d1, const void* d2)
{
    return *(const int*)d1 - *(const int*)d2;
}

int main()
{
    srand(time(0));//随机种子
    array_t* array = arrayInit(sizeof(int));

    int i = 0, data = 0;
    for(i = 0; i < 10; i++){
        arrayInsert(array, &i, compareInt);
    }

    data = 5;
    arrayRemove(array, &data, compareInt);
    data = 6;
    const int* p = (const int*)arraySelect(array, &data, compareInt);
    printf("::%d\n", data);
    for(i = 0; i < array->idx; i++){
        printf("%d\n", *(int*)(array->data + i * array->size));
    }

    arrayFree(array);
    array = NULL;

    return 0;
}

const void* arraySelect(array_t* array, const void* data, int(*compare)(const
            void*, const void*))
{
    if(array == NULL || data == NULL || compare == NULL) return NULL;

    int l = 0, r = array->idx - 1;
    while(l <= r){
        int m = (l + r) / 2;
        if(compare(data, array->data + m * array->size) == 0){
            //返回即可
            return array->data + m * array->size;
        }else if(compare(data, array->data + m * array->size) > 0)
        {
            l = m + 1;
        }else{
            r = m -1;
        }
    }

    return NULL;
}
void arrayRemove(array_t* array, const void* data, int(*compare)(const void*,
            const void*))
{
    if(array == NULL || data == NULL || compare == NULL) return;

    int l = 0, r = array->idx - 1;
    while(l <= r){
        int m = (l + r) / 2;
        if(compare(data, array->data + m * array->size) == 0){
            //删除即可
            int len = array->idx - m - 1;
            if(len > 0) memmove(array->data + m * array->size, array->data + (m
                        + 1) * array->size, len * array->size);
            array->idx--;
            memset(array->data + array->idx * array->size, 0, array->size);
            return;
        }else if(compare(data, array->data + m * array->size) > 0){
            l = m + 1;
        }else{
            r = m - 1;
        }
    }

    return;
}

void* arrayInsert(array_t* array, const void* data, int (*compare)(const void*,
            const void*))
{
    /*健壮性检查*/
    if(array == NULL || data == NULL || compare == NULL) return NULL;
    
    /*扩容*/
    if(array->idx == array->capa){
        array->capa *= 2;
        array->data = realloc(array->data, array->capa * array->size);
        memset(array->data + array->idx * array->size, 0, array->idx *
                array->size);
    }

    int i = 0;
    while(i < array->idx && compare(data, array->data + i * array->size) > 0){
        ++i;
    }

    int len = array->idx - i;
    if(len > 0) memmove(array->data + (i + 1) * array->size, array->data + i *
            array->size, len * array->size);
    memcpy(array->data + i * array->size, data, array->size);
    array->idx++;
}

void arrayFree(array_t* array)
{
    /*健壮性检查*/
    if(array == NULL) return;

    free(array->data);//先释放数据域
    free(array);//再释放节点域
}

array_t* arrayInit(int size)
{
    /*健壮性检查*/
    if(size < 0) return NULL;
    array_t* array = (array_t*)malloc(sizeof(array_t));//节点域
    memset(array, 0, sizeof(array_t));//初始化节点域

    array->size = size;//单元大小
    array->idx = 0;//当前插入的数据有0个
    array->capa = 1;//当前分配的长度为1
    array->data = malloc(array->capa * size);//数据域

    return array;
}

在这里插入图片描述

链表拆分和归并

#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//1、链表拆分，链表一分为二，快慢指针
//2、链表归并，假设两个链表已知升序，合并两张链表后保持升序

typedef struct Node{
    int data;
    struct Node* next;
}node_t;

node_t* listPushBack(node_t* head, int data);
node_t* listPopBack(node_t* head);
void listFree(node_t* head);
node_t* listSeperate(node_t* head);
node_t* listMerge(node_t* head1, node_t* head2);
node_t* listMergeSort(node_t* head);

int main(void)
{
    srand(time(0));
    node_t* head = NULL;
    int i = 0;
    for(i = 0; i < 10; i++){
        head = listPushBack(head, rand() % 1000);
    }

    //排序
    head = listMergeSort(head);

    node_t* p = head;
    while(p){
        printf("%d\n", p->data);
        p = p->next;
    }

    listFree(head);

    return 0;
}
node_t* listMergeSort(node_t* head)
{
    if(head == NULL || head->next == NULL) return head;

    node_t* h = listSeperate(head);

    head = listMergeSort(head);
    h = listMergeSort(h);

    return listMerge(head, h);
}

node_t* listMerge(node_t* head1, node_t* head2)
{
    node_t* p1 = head1, *p2 = head2;
    node_t node;
    node.next = NULL;
    node_t* p = &node;//p表示指向node中最后一个

    while(p1 != NULL && p2 != NULL){
        if(p1->data < p2->data){
            p->next = p1;
            p1 = p1->next;
        }else{
            p->next = p2;
            p2 = p2->next;
        }
        p = p->next;
    }

    if(p1 != NULL){
        p->next = p1;
    }else if(p2 != NULL){
        p->next = p2;
    }

    return node.next;
}

node_t* listSeperate(node_t* head)
{
    node_t node;
    node.next = head;

    node_t* p1 = &node, *p2 = &node;
    while(p1 != NULL){
        p1 = p1->next;
        if(p1 == NULL) break;
        p1 = p1->next;
        p2 = p2->next;
    }

    node_t* ret = p2->next;
    p2->next = NULL;

    return ret;
}
void listFree(node_t* head)
{
    node_t* p = head;
    while(p != NULL){
        node_t* tmp = p;
        p = p->next;
        free(tmp);
    }
}
node_t* listPopBack(node_t* head)
{
    if(head == NULL) return NULL;

    node_t node;
    node.next = head;

    node_t* pre = &node, *p = head;
    while(p->next != NULL){
        p = p->next;
        pre = pre->next;
    }

    pre->next = NULL;
    free(p);

    return node.next;
}
//返回头结点
node_t* listPushBack(node_t* head, int data)
{
    node_t* newNode = (node_t*)malloc(sizeof(node_t));
    memset(newNode, 0, sizeof(node_t));

    newNode->data = data;

    //尾插
    node_t node;
    node.next = head;//节点指向空

    node_t* p = &node;
    while(p->next != NULL){
        p = p->next;
    }

    p->next = newNode;
    newNode->next = NULL;

    return node.next;
}

在这里插入图片描述

带头结点的双向链表

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

typedef struct Node{
	struct Node* next;
	struct Node* prev;
	char data[0];
}node_t;

typedef struct List{
	node_t head;
	int size;
}list_t;

list_t*	listInit(int size);
void	listFree(list_t* list);
void*	listPushBack(list_t* list, const void* data);

int main(void)
{
	list_t* list = listInit(sizeof(int));

	int i = 0;
	for(i = 0; i < 10; i++){
		listPushBack(list, &i);
	}

	node_t* p = list->head.next;
	while(p != &(list->head)){
		printf("%d\n", *(int*)p->data);
		p = p->next;
	}

	listFree(list);

	return 0;
}

list_t*	listInit(int size)
{
	if(size < 0) return NULL;
	list_t* list = (list_t*)malloc(sizeof(list_t));
	memset(list, 0, sizeof(list_t));

	list->size = size;
	list->head.next = &(list->head);
	list->head.prev = &(list->head);

	return list;
}

void	listFree(list_t* list)
{
	if(list == NULL) return;

	node_t* p = list->head.next;
	while(p != &(list->head)){
		node_t* tmp = p;
		p = p->next;
		free(tmp);
	}
	free(list);
}

void*	listPushBack(list_t* list, const void* data)
{
	if(list == NULL || data == NULL) return NULL;

	//1. 创建新节点
	node_t* newNode = (node_t*)malloc(sizeof(node_t) + list->size);
	memcpy(newNode->data, data, list->size);

	newNode->prev = list->head.prev;
	list->head.prev->next = newNode;
	list->head.prev = newNode;
	newNode->next = &list->head;
}

在这里插入图片描述

Ares悟道
关注
专栏目录
Hadoop总结
FYHLH的博客
04-28 3389
Hadoop的核心组件有HDFS、MapReduce和Yarn，以及其他常用组件如：HBase、Hive、Hadoop Streaming、Zookeeper等。具体如下图： HDFS：分布式海量数据存储功能 Yarn：提供资源调度与任务管理功能 资源调度：根据申请的计算任务，合理分配集群中的计算节点(计算机)。 任务管理：任务在执行过程中，负责过程监控、状态反馈、任务再调度等工作。 MapReduce：分布式并行编程模型和计算框架。解决分布式编程门槛高的问题，基于其框架对分布式计算的抽象m.
android studio项目总结,Android Studio 使用总结
weixin_42498006的博客
05-27 1552
一、安装完成并重启后：需要检查一下JDK和SDK：上图中，选择“Project Structure”，弹出如下界面：(确认JDK和Android SDK的路径)二、Android Studio的简单设置：1、主题修改：选择菜单栏“File--settings--apperance--theme”，主题选择Darcula：2、导入第三方主题：下载下来之后，回到Android Studio，选择菜单栏...
Python面向对象总结3
北山啦的博客
02-23 3973
Python面向对象总结3-其他 目标 面向对象三大特性 类属性和实例属性 类方法和静态方法 一. 面向对象三大特性 封装 将属性和方法书写到类的里面的操作即为封装 封装可以为属性和方法添加私有权限 继承 子类默认继承父类的所有属性和方法 子类可以重写父类属性和方法 多态 传入不同的对象，产生不同的结果 二. 多态 2.1 了解多态 多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。 定义：多态是一种使用对象的方式，子类重写父类方法，调用不同子类
vuex store使用总结 3 (模块化的使用 )
唐僧的专栏
05-22 4863
vuex store使用总结 3 (模块化的使用 ) vuex store使用总结 1 ( 简单使用 ) vuex store使用总结 2 ( 功能化的使用 ) 请先翻看前 两节 再看这里的内容 https://vuex.vuejs.org/zh/guide/modules.html 由于使用单一状态树，应用的所...
2019年度技术总结
X北辰北的博客
01-21 4016
2019年相对于2018年来说呢有点不一样，它比2018年多了一年。 这一年是我进入公司的第二个年头，从一名实习生到正式员工，从一名开发菜鸟晋级为一名拥有两年开发经验的菜鸟，中途在技术上遇到了很多坑，也绕过了很多坑，同时也掉进了很多坑，回过头来回忆这一年的时间，心头贸然生出两个字——辛酸与收获！啊哈，是五个字~ 其实从大学到参加工作，一直有记笔记和写博客的习惯，每一年除了给公司交差的...
测试工作经验总结3：简短的总结？
Henryztong的博客
01-12 3218
写了这么多，都不知道写的啥！！！！！！！太乱了！
数理方程突击复习_3、分离变量法_数理方程总复习总结3
weixin_43419816的博客
06-03 4070
1.基础概念 继续总结——数理方程第二章之分离变量法 1.1 三类典型方程 弦振动方程 热传导方程 拉普拉斯方程 1.2 基本概念 线性偏微分方程： 方程关于未知数及其各阶偏导数均是一次的。 古典解： 具有偏微分方程中各阶连续偏导数，且代入方程后能使方程成为恒等式的函数。 定解问题：泛定方程和定解条件 初值/柯西问题：泛定方程和初始条件 边值问题：泛定方程和边界条件 混合问题：泛定方程和初始条件、边界条件 两类边值问题 第一类边值问题/狄利克雷问题/狄氏问题：函数本身在边界上满足某条件。 第一类边
2021 年终总结
烤鸭的世界我们不懂的博客
12-27 1928
2021 年终总结
2015年年终总结
LZUGIS
01-25 2862
2015年总结——关键字：改变、学习&进步、阅读、健身
vue3+ts项目 笔记总结
lemon今天学习了吗？的博客
12-21 3799
1.在终端新建项目输入：vue create vue3-ts 2.接下来的每一步如图所示：注意要通过空格选中TypeScript
大学生学雷锋3月工作总结3篇.docx
02-11
大学生学雷锋3月工作总结3篇.docx
精品工作总结模板范文-导游工作总结3.doc
04-29
精品工作总结模板范文-导游工作总结3.doc
乡村幼儿园个人工作总结3篇.docx
11-23
乡村幼儿园个人工作总结3篇.docx
精品工作总结模板范文-业务员半年总结3.doc
04-29
精品工作总结模板范文-业务员半年总结3.doc
二年级少先队工作总结3篇.docx
02-14
二年级少先队工作总结3篇.docx
为Matlab 用户提供丰富功能的工具集
11-03
Matlab 用户提供丰富功能的工具集。 从优点来看，其涵盖了诸多实用的功能模块。例如在计算机视觉和图像处理领域，可能包含了图像特征提取、目标检测、图像分割等常用算法的实现，这为相关领域的研究人员和开发者节省了大量的时间和精力，无需从头编写复杂的算法代码，提高了开发效率。工具包的文档相对较为详细，能够帮助用户快速上手并理解各个函数和工具的使用方法，降低了使用门槛。同时，它可能具有较好的兼容性，能够与 Matlab 的原生功能和其他常用工具箱协同工作，方便用户整合到自己的项目中。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
技术资料分享KXTE9-2050 Specifications Rev 3非常好的技术资料.zip
11-03
技术资料分享KXTE9-2050 Specifications Rev 3非常好的技术资料.zip
yolo算法-废物数据集-1000张图像带标签-金属废料-杯子-垃圾桶-废物-纸张-塑料-瓶-有机废物.zip
11-03
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，包含数据集配置文件data.yaml，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
VB程序实例-使用Stream读写存储的图像.zip
最新发布
11-03
VB程序实例-使用Stream读写存储的图像.zip
Renesas RCAR H3嵌入式驱动开发总结
例如，对于SPINOR/HyperFLASH启动，可以通过meta-rcar-gen3框架下的相关recipe进行编译，然后使用特定工具将S-record格式的image烧写到NOR或Hyper-FLASH。而对于EMMC启动，需要修改编译选项并执行特定的bitbake命令...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值