数据结构——顺序表、链表

目录

前言

一，数据结构

1，什么是数据结构？

2，有什么类型？

二，顺序表

1，线性表

2，顺序表基本结构

3，动态顺序表的功能实现

三，链表 

1，链表的分类

2，（单向）链表

3，双向链表

前言

当我们将要对大量相同类型的数据进行存储与操作时，使用通常的定义变量方式会太过机械重复，数据使用起来又太过耗时，此时用上数据结构就会更加便捷。

一，数据结构

1，什么是数据结构？

       数据结构的定义可以从“数据”和“结构”两部分来解释，数据指的是常见的数字、形形色色的信息等等。结构则是对数据的组织方式，数据结构将大量数据有规律的存储起来便于下次的数据操作（继续存储或使用等等）。

总结：数据结构是计算机对数据进行存储与组织的一种方式。

2，有什么类型？

数据结构具有许多类型，常见如下： 

  1. 数组（Array）（又可称为顺序表）：一种基础的数据结构，可以在内存中连续存储多个元素，这些元素通常是相同类型的数据。数组的特点是可以通过索引快速访问元素，但大小固定，扩展性差。

  2. 链表（Linked List）：由一系列节点组成，每个节点包含数据部分和指向下一个节点的指针。链表的优点在于可以动态地分配内存，易于插入和删除操作。

  3. 栈（Stack）：遵循后进先出（LIFO）原则的数据结构。栈的操作主要是压栈（push）和出栈（pop）。

  4. 队列（Queue）：遵循先进先出（FIFO）原则的数据结构。队列的操作主要是入队（enqueue）和出队（dequeue）。

  5. 树（Tree）：一种分层数据结构，由节点组成，每个节点包含数据元素和若干指向其子节点的指针。特殊的树结构包括二叉树、平衡树（如AVL树）、二叉查找树等。

  6. 图（Graph）：由顶点（节点）集合和边集合组成，边可以是有向的也可以是无向的。图用于表示物件之间多对多的关系。

  7. 哈希表（Hash Table）：通过哈希函数将键映射到表中一个位置来访问记录，这种数据结构可以提供快速的插入和查找操作。

  8. 堆（Heap）：一种特殊的完全二叉树，常用于实现优先队列，分为最大堆和最小堆。

 以上即为常用的数据结构，在使用时，要区别不同的使用场景，以便更好地提升程序的效率与性能。

以下我们主讲顺序表与链表：

二，顺序表

声明：在中文的计算机科学教材和文献中，“顺序表”是一个常用的术语，而在英文中，它通常被称为“Array”或者“Linear Array”。因此，当提到数组时，实际上就是在讨论顺序表。

1，线性表

       实际上，顺序表属于线性表的一种，线性表定义是：n个具有相同特性的数据元素的有限序列；线性表还包括链表、栈、队列、字符串等等，从上述举例我们可以得出线性表的一些特性：

  1. 对于数据的获得可以依照某些顺序依次获得。
  2. 对于数据的存放却不一定有规律

总结：线性表在逻辑上是线性结果（因为数据可以依次操作，像一条连续的线）；在物理结构上却不一定连续（实际上不是所有数据都连续存放），在物理上存储时，通常以数组（物理上连续）和链式结构（物理上不连续）的形式存储。

2，顺序表基本结构

       我们知道，顺序表的英文是 “Sequential List”。在计算机科学中，它通常指的是一种线性数据结构，其中元素按照一定的顺序排列，可以通过索引直接访问。在某些情况下，也被称为 “Array” 或 “ArrayList”。顺序表与数组英文一致，为什么如此呢？

实际上，顺序表的底层结构就是数组，即对数组进行封装，实现了增删查改的功能接口。

那么，顺序表是怎样的呢？

 顺序表依据其存储空间是否可以变化可以分为：静态顺序表和动态顺序表两种。

静态顺序表：

静态顺序表的缺点：数据可存储的空间在程序开始时就固定了，空间设置太小不够用，太大又会造成浪费。

 

动态顺序表：

注意：

       1，可能有人有疑问，上图中的 a 仅是一个指针，与数组无关，并且没有创建数组，但这里因为数组的指针的加减是一样的，就把指针当成数组来操作。

        2，尤其要了解的是，因为是数组操作，数组内的数据是连续存放的（顺序存放），依次进行数据的增删查改时尤其要注意位置的改变。

3，动态顺序表的功能实现

    扩容：凭借有效数据个数与容量做对比来考虑是否扩容，扩容一般扩容2/3倍（由数学推理而来）扩容后数据要重新移动到新数组里。；

    插入数据：一般是顺序插入（在尾部插入），要头插时，则需要移动全部数据位置，量大时，十分费时费力（一般考虑链表）；

    删除数据：分为两类，对于尾部的数据可以直接 size - 1（因为对数据查询是依靠size来寻找的），在除尾部之外的地方删除则要将其后的数据向前移一位。

代码如下：（有几个要点，扩容时要检验是否成功，扩容后要释放原有内存，删除时要检验是否有数据，）

头文件

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int SLDatatype;
typedef struct Seqlist//̬˳
{SLDatatype* arr;int size;int capacity;
}SL;void SLInit(SL *ps);
void SLDestory(SL* ps);
//void memorycheck(ps);
void SLPushBack(SL* ps, SLDatatype x);
void SLPushFront(SL* ps, SLDatatype x);
void popback(SL* ps);
void popfront(SL* ps);
void SLTnsert(SL* ps, int pos, SLDatatype x);
void SLErase(SL* ps, int pos);
int find(SL* ps, int pos);
void SLPrint(SL s);

 功能实现文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"
//初始化实现
void SLInit(SL* ps)
{ps->arr = NULL;ps->size = 0;ps->capacity = 0;
}
//销毁实现
void SLDestory(SL* ps)
{if (ps->arr){free(ps->arr);}ps->arr = NULL;ps->size = ps->capacity = 0;
}
//尾插实现
void SLPushBack(SL* ps, SLDatatype x)
{//插入数据之前先看空间够不够assert(ps);if (ps->capacity == ps->size){//申请空间int Newcapacity=ps->capacity == 0 ? 4 : 2 * ps->capacity;SLDatatype* pf= realloc(ps->arr, ps->capacity * sizeof(SLDatatype));//多大空间呢？if (pf == NULL){perror("realloc");exit(1);}ps->arr = pf;ps->capacity = Newcapacity;}//插入ps->arr[ps->size] = x;ps->size++;
}
//头插
void SLPushFront(SL* ps, SLDatatype x)
{//插入数据之前先看空间够不够assert(ps);if (ps->capacity == ps->size){//申请空间int Newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;SLDatatype* pf = realloc(ps->arr, ps->capacity * 2 * sizeof(SLDatatype));//多大空间呢？if (pf == NULL){perror("realloc");exit(1);}ps->arr = pf;ps->capacity = Newcapacity;}//插入//整体移动x位for (int i = ps->size; i>=1; i--){ps->arr[1] = ps->arr[i - 1];}ps->arr[0] = x;ps->size++;}
//尾删
void popback(SL*ps)
{assert(ps);assert(ps->size);--ps->size;
}
//头删
void popfront(SL* ps)
{assert(ps);assert(ps->size);for (int i = 0; i<ps->size; i++){ps->arr[i] = ps->arr[i + 1];}ps->size--;
}
//在指定位置之前插入
void SLTnsert(SL* ps, int pos, SLDatatype x)
{assert(ps);assert(pos >= 0&&pos<=ps->size);if (ps->capacity == ps->size){//申请空间int Newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;SLDatatype* pf = realloc(ps->arr, ps->capacity * 2 * sizeof(SLDatatype));//多大空间呢？if (pf == NULL){perror("realloc");exit(1);}ps->arr = pf;ps->capacity = Newcapacity;}//插入for (int i = ps->size; i > pos; i--){ps->arr[i] = ps->arr[i - 1];}ps->arr[pos] = x;ps->size++;}
//删除指定位置的数
void SLErase(SL* ps, int pos)
{/*判断相关数据*/{assert(ps);assert(pos >= 0 && pos < ps->size);if (ps->capacity == ps->size){//申请空间int Newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;SLDatatype* pf = realloc(ps->arr, ps->capacity * 2 * sizeof(SLDatatype));//多大空间呢？if (pf == NULL){perror("realloc");exit(1);}ps->arr = pf;ps->capacity = Newcapacity;}}for (int i = pos; i < ps->size-1; i++){ps->arr[i] = ps->arr[i + 1];ps->size--;}
}
//查找数据
int find(SL* ps, int pos)
{for (int i = 0; i < ps->size; i++){if (ps->arr[i] = pos){return i;}}return -1;
}
//测试
void SLPrint(SL s)
{for (int i = 0; i < s.size; i++){printf("%d ", s.arr[i]);}printf("\n");
}

 功能运行文件

#define _CRT_SECURE_NO_WARNINGS 1
#include"Seqlist.h"
void SLTest01()
{SL sl;//sl˳SLInit(&sl);//ʼSLPushBack(&sl, 1);SLPushBack(&sl, 2);SLPushBack(&sl, 3);SLPushBack(&sl, 4);SLPushBack(&sl, 5);//SLPushBack(&sl, 6);//SLPushBack(&sl, 7);SLPrint(sl);//SLErase(&sl, 0);}
int main()
{SLTest01();return 0;
}

三，链表 

 通过顺序表的学习我们可以发现顺序表有许多缺点：

  • 在顺序表中插入与删除数据要移动大量数据（数据量大时），复杂度为O(n)；
  • 增容需要申请新空间，拷贝数据，释放旧空间会有不小的消耗。
  • 增容⼀般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到 200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。

此时便要使用链表来避免这些问题。 

1，链表的分类

链表的结构非常多样，以下情况组合起来就有8种（2x2x2）链表结构：

单向与双向、带不带头结点、是否循环。

虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表

  1. 无头单向非循环链表：结构简单，⼀般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。另外这种结构在笔试面试中出现很多。
  2. 带头双向循环链表：结构最复杂，⼀般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。

下面我们介绍带头单向不循环链表（称为链表）和带头双向循环链表 。

2，（单向）链表

 链表属于线性表的一种，在逻辑上是连续的但物理结构上不一定连续。

基本结构：

示意图：

 

 基本原理是，设置一个头结点 （plist），它是一个指针指向下一个节点，而下一个节点有存储着一个数据和一个指针，该指针又指向下一个节点，依次往复，直到最后一个节点，它的指针没有指向的对象，便指向空指针（NULL），使用指针访问其中的数据（值得注意的是它是单向的）。

 注意：

  1. 节点（与结点一种意思），节点包括要保存的数据和下一节点的地址（指针）
  2. 节点⼀般是从堆上申请的，而从堆上申请来的空间，是按照一定策略分配出来的，每次申请的空间可能连续，可能不连续。因此链表的物理结构不一定连续。

实现链表：

增删查改的要点，对于函数的使用要注意分辨要不要用上二级指针；使用完之后要销毁链表。

简要说明链表销毁的原因：

  1. 避免内存泄漏：动态分配的内存如果不手动释放，可能导致内存浪费。
  2. 防止野指针：已释放的内存如果不更新指针，可能导致程序访问非法内存。
  3. 提高内存利用率：及时释放内存可以让操作系统重新分配给其他需要的地方。

删除，分为头删，尾删，中间删，获得其前节点改变其指针指向下一节点或空指针（不要忘记释放相应空间）。

插入，分为头插，尾插，中间插，只需要创建一个新节点，再修改其前后结点指针的指向即可。

查找与修改，一般是利用循环和 if 函数与查找对象比较，然后进行相关操作。 

代码如下： 

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>typedef struct Node {int data;struct Node* next;
} Node;// 创建新节点
Node* createNode(int data) {Node* newNode = (Node*)malloc(sizeof(Node));if (newNode == NULL) {printf("内存分配失败\n");exit(1);}newNode->data = data;newNode->next = NULL;return newNode;
}// 在链表头部插入节点
void insertAtHead(Node** head, int data) {Node* newNode = createNode(data);newNode->next = *head;*head = newNode;
}// 在链表尾部插入节点
void insertAtTail(Node** head, int data) {Node* newNode = createNode(data);if (*head == NULL) {*head = newNode;return;}Node* current = *head;while (current->next != NULL) {current = current->next;}current->next = newNode;
}// 在链表中间插入节点（在值为prevData的节点之后插入）
void insertInMiddle(Node** head, int prevData, int data) {Node* current = *head;while (current != NULL && current->data != prevData) {current = current->next;}if (current == NULL) {printf("找不到值为 %d 的节点\n", prevData);return;}Node* newNode = createNode(data);newNode->next = current->next;current->next = newNode;
}// 删除链表头节点
void deleteAtHead(Node** head) {if (*head == NULL) {printf("链表为空，无法删除头节点\n");return;}Node* temp = *head;*head = (*head)->next;free(temp);
}// 删除链表尾节点
void deleteAtTail(Node** head) {if (*head == NULL) {printf("链表为空，无法删除尾节点\n");return;}Node* current = *head;Node* prev = NULL;while (current->next != NULL) {prev = current;current = current->next;}if (prev != NULL) {prev->next = NULL;}else {*head = NULL;}free(current);
}// 删除链表中间的节点（删除值为data的节点）
void deleteInMiddle(Node** head, int data) {if (*head == NULL) {printf("链表为空，无法删除节点\n");return;}Node* current = *head;Node* prev = NULL;while (current != NULL && current->data != data) {prev = current;current = current->next;}if (current == NULL) {printf("找不到值为 %d 的节点\n", data);return;}if (prev != NULL) {prev->next = current->next;}else {*head = current->next;}free(current);
}// 打印链表
void printList(Node* head) {Node* current = head;while (current != NULL) {printf("%d -> ", current->data);current = current->next;}printf("NULL\n");
}// 释放链表内存
void freeList(Node** head) {Node* current = *head;Node* next;while (current != NULL) {next = current->next;free(current);current = next;}*head = NULL;
}// 主函数
int main() 
{Node* head = NULL;// 插入节点insertAtHead(&head, 30);insertAtTail(&head, 40);insertInMiddle(&head, 30, 35);printList(head); // 应该打印 30 -> 35 -> 40 -> NULL// 删除节点deleteAtHead(&head);printList(head); // 应该打印 35 -> 40 -> NULLdeleteAtTail(&head);printList(head); // 应该打印 35 -> NULLinsertAtTail(&head, 40);insertAtTail(&head, 50);printList(head); // 应该打印 35 -> 40 -> 50 -> NULLdeleteInMiddle(&head, 40);return 0;
}

3，双向链表 

typedef struct DoublyLinkedListNode {int data;                         //存储的数据struct DoublyLinkedListNode* prev;//前一节点地址struct DoublyLinkedListNode* next;//后一节点地址
} Node;

 head 即头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨的”

“哨兵位”存在的意义： 遍历循环链表避免死循环。

优点：避免遍历链表

实现代码如下：

#include <stdio.h>
#include <stdlib.h>// 定义双向链表的节点结构体
typedef struct DoublyLinkedListNode {int data;struct DoublyLinkedListNode* prev;struct DoublyLinkedListNode* next;
} Node;// 创建一个新的节点
Node* createNode(int data) {Node* newNode = (Node*)malloc(sizeof(Node));if (!newNode) {return NULL;}newNode->data = data;newNode->prev = NULL;newNode->next = NULL;return newNode;
}// 在链表尾部添加节点
void appendNode(Node** head, int data) {Node* newNode = createNode(data);if (*head == NULL) {*head = newNode;return;}Node* temp = *head;while (temp->next != NULL) {temp = temp->next;}temp->next = newNode;newNode->prev = temp;
}// 在链表头部添加节点
void prependNode(Node** head, int data) {Node* newNode = createNode(data);if (*head == NULL) {*head = newNode;return;}newNode->next = *head;(*head)->prev = newNode;*head = newNode;
}// 删除节点
void deleteNode(Node** head, Node* delNode) {if (*head == NULL || delNode == NULL) {return;}if (*head == delNode) {*head = delNode->next;}if (delNode->next != NULL) {delNode->next->prev = delNode->prev;}if (delNode->prev != NULL) {delNode->prev->next = delNode->next;}free(delNode);
}// 打印链表
void printList(Node* node) {while (node != NULL) {printf("%d ", node->data);node = node->next;}printf("\n");
}// 释放链表内存
void freeList(Node* head) {Node* temp;while (head != NULL) {temp = head;head = head->next;free(temp);}
}// 主函数
int main() {Node* head = NULL;appendNode(&head, 10);appendNode(&head, 20);appendNode(&head, 30);prependNode(&head, 5);printList(head); // 应该打印 5 10 20 30// 删除节点Node* delNode = head->next; // 删除第二个节点deleteNode(&head, delNode);printList(head); // 应该打印 5 20 30// 释放链表内存freeList(head);return 0;
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.xdnf.cn/news/149216.html

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

乌克兰因安全风险首次禁用Telegram

乌克兰因安全风险首次禁用Telegram

据BleepingComputer消息&#xff0c;乌克兰国家网络安全协调中心 &#xff08;NCCC&#xff09; 以国家安全为由&#xff0c;已下令限制在政府机构、军事单位和关键基础设施内使用 Telegram 消息应用程序。 这一消息通过NCCC的官方 Facebook 账号对外发布&#xff0c;在公告中乌…
阅读更多...
2024icpc(Ⅱ)网络赛补题 L

2024icpc(Ⅱ)网络赛补题 L

L、502 Bad Gateway 题意&#xff1a; 给定一个 T T T&#xff0c;每一步可以做以下两个操作&#xff1a; 1、减1 2、随机重置为 [ 1 , T ] [1,T] [1,T]中的某个整数 求在最优策略下&#xff0c;得到 0 0 0的期望步数 思路&#xff1a; 最优策略为选择一个阈值 S S S&…
阅读更多...
01.系统IO

01.系统IO

文章的函数说明只是简单的说明&#xff0c;具体还得查看man手册 Linux文件说明 linux下一切皆是文件。 Linux 下的文件类型&#xff1a; 1&#xff0c;普通文件&#xff08;regular&#xff09;&#xff1a;存在于外部存储器中&#xff0c;用于存储普通数据。 2&#xff0…
阅读更多...
深入理解音视频pts，dts，time_base以及时间数学公式

深入理解音视频pts，dts，time_base以及时间数学公式

引入 首先介绍一下基础名词 DTS&#xff08;Decoding Time Stamp&#xff09;&#xff1a;即解码时间戳&#xff0c;这个时间戳的意义在于告诉播放器该在什么时候解码这一帧的数据。当数据没b帧时&#xff0c;dts pts&#xff0c;有兴趣可参阅我前面视频知识类文章。 PTS&a…
阅读更多...
统信服务器操作系统【开机自启动】配置方法

统信服务器操作系统【开机自启动】配置方法

开机自启动的四种配置方法，包括systemctl命令、rc.local文件、crontab任务，通过desktop配置开机自动，前三种方法适合后台程序或者脚本启动，最后一种方法适合图形化程序启动。 文章目录 准备环境配置方法一、通过编写service的方法，使用systemctl配置开机自启二、通过rc.lo…
阅读更多...
展锐平台的手机camera 系统isptool 架构

展锐平台的手机camera 系统isptool 架构

展锐平台的isptool 主要用于支持展锐各代芯片isp的各效果模块快速tuning和参数生成打包。 具体需要&#xff1a; 一、工具段能在线实时预览到调试sensor经过isp 处理后的图像&#xff0c;也就是各模块的参数在当下实时生效&#xff0c;通过工具能在PC 上在线观看到修改的效果。…
阅读更多...
【企业微信】群机器人自动消息配置

【企业微信】群机器人自动消息配置

0、群聊机器人 内部企微群聊可以添加一个机器人&#xff0c;这个机器人其实是个消息接口&#xff0c;可以外部脚本来自动定时发送消息到群里&#xff0c;打工人最有用的提醒就是每周提醒发周报了。 1、创建机器人 一般公司都没有人使用&#xff0c;我们可以手动创建一个。 …
阅读更多...
小程序开发设计-小程序的宿主环境：宿主环境简介⑥

小程序开发设计-小程序的宿主环境：宿主环境简介⑥

上一篇文章导航&#xff1a; 小程序开发设计-小程序代码的构成&#xff1a;小程序页面的组成部分详解⑤-CSDN博客https://blog.csdn.net/qq_60872637/article/details/142306902?spm1001.2014.3001.5501 注&#xff1a;不同版本选项有所不同&#xff0c;并无大碍。 目录 上…
阅读更多...
OpenHarmony（鸿蒙南向开发）——小型系统内核（LiteOS-A）【用户态内存调测】

OpenHarmony（鸿蒙南向开发）——小型系统内核（LiteOS-A）【用户态内存调测】

往期知识点记录&#xff1a; 鸿蒙&#xff08;HarmonyOS&#xff09;应用层开发&#xff08;北向&#xff09;知识点汇总 鸿蒙&#xff08;OpenHarmony&#xff09;南向开发保姆级知识点汇总~ 持续更新中…… 基本概念 Debug版本的musl-libc库为用户提供内存泄漏检测、堆内存…
阅读更多...
2024在线翻译工具横评：准确率、速度与易用性大比拼

2024在线翻译工具横评：准确率、速度与易用性大比拼

在日常的学习与生活中&#xff0c;翻译工具无疑成为了我们迅速获取国际新闻与知识的得力助手。起初&#xff0c;我倾向于依赖有道在线翻译这一平台来解决我的语言障碍问题。然而&#xff0c;随着对翻译质量要求的提升和多元化比较的需求增加&#xff0c;我进一步探索并发现了数…
阅读更多...
从入门到精通：计算机视觉学习路线与实战项目推荐

从入门到精通：计算机视觉学习路线与实战项目推荐

全面解析计算机视觉的学习路径&#xff0c;深入探讨关键技术与实战项目&#xff0c;助您快速掌握核心技能 引言 随着人工智能的飞速发展&#xff0c;计算机视觉已成为AI领域中最具潜力和应用价值的分支之一。从自动驾驶到医疗影像分析&#xff0c;计算机视觉技术正在改变我们的…
阅读更多...
vue/配置axios（前后端数据连通/api接口的调用）

vue/配置axios（前后端数据连通/api接口的调用）

1.创建apis文件 2.写入调用的api地址且暴露出去。 import httpInstance from /utils/http;export function getHomeNav() {return httpInstance({url: http://10.0.11.91:91/dailyreport/getdailyreportall,}) }3.创建文件编写拦截器 代码部分 //axios基础封装 import axio…
阅读更多...
OpenCV 3

OpenCV 3

模板匹配方法 尽量采用归一化的方法&#xff0c;因为它更加精细。 匹配效果展示 匹配单一图像 这是一段Python代码&#xff0c;主要使用了OpenCV库进行图像处理。这段代码的主要功能是通过模板匹配方法在一张大图中找到一个小图的位置。 具体来说&#xff1a; - 第一行的for…
阅读更多...
Docker：解决开发运维问题的开源容器化平台

Docker：解决开发运维问题的开源容器化平台

云计算de小白 Docker是一个开源的容器化平台&#xff0c;可以将应用程序及其依赖的环境打包成轻量级、可移植的容器。 Docker为什么这么受欢迎呢?原因很简单&#xff1a;Docker可以解决不同环境一致运行的问题&#xff0c;而且占用资源少&#xff0c;速度快。 所以好的东西…
阅读更多...
Leetcode—329. 矩阵中的最长递增路径【困难】

Leetcode—329. 矩阵中的最长递增路径【困难】

2024每日刷题&#xff08;165&#xff09; Leetcode—329. 矩阵中的最长递增路径 dfs dp实现代码 class Solution { public:int longestIncreasingPath(vector<vector<int>>& matrix) {// 9 9 4// 6 6 8// 2 1 1// 1 1 2// 2 2 1// 3 4 2int m …
阅读更多...
Three.js 3D人物漫游项目（下）

Three.js 3D人物漫游项目（下）

本文目录 前言最终效果1、效果回顾2、编写人物模型动画执行类并调用2.1 代码2.2 代码解读2.3 实例化动画类并调用2.4 效果2.4.1 休息动画2.4.2 跑步动画2.4.3 走路动画2.4.4 舞蹈1动画2.4.5 舞蹈2动画3、键盘控制动画3.1 站立休息、走、跑、舞蹈1、舞蹈2代码3.1.1 效果3.2 跳跃…
阅读更多...
Matlab|基于遗传模拟退火算法的风电功率聚类分析

Matlab|基于遗传模拟退火算法的风电功率聚类分析

目录 主要内容 部分代码 结果一览 下载链接 主要内容 模糊C-均值聚类&#xff0c;也称FCM&#xff0c;是比较常用的一种聚类算法&#xff0c;该算法利用几何贴进度的概念将不同数据分配到不同聚类群中&#xff0c;但是作为局部搜索优化算法&#xff0c;初值选择不…
阅读更多...
趣味运动会随机分组指南

趣味运动会随机分组指南

如何实现男女比例平均分组&#xff1f; 组织趣味运动会时&#xff0c;如何确保男女比例平均且分组公平是一个关键问题。利用云分组小程序&#xff0c;我们可以轻松实现这一目标&#xff0c;让活动更加有趣和公平。 以下是详细的操作步骤&#xff1a;步骤一&#xff1a;创建分组…
阅读更多...
生信技能59 - 基于GATK CallingSNP变异检测及注释流程

生信技能59 - 基于GATK CallingSNP变异检测及注释流程

1. 流程说明 使用BWA MEM比对，如果文件较大，可使用bwa-mem2进行比对，速度会有很大提升；使用GATK对BAM进行排序和标记重复，再使用GATK HaplotypeCaller + GATK GenotypeGVCFs进行变异检测，生产.g.vcf文件，提取SNP并使用annovar进行位点注释。 使用bwa-mem2进行比对，获…
阅读更多...
畅阅读微信小程序

畅阅读微信小程序

畅阅读微信小程序 weixin051畅阅读微信小程序ssm 摘 要 随着社会的发展&#xff0c;社会的方方面面都在利用信息化时代的优势。互联网的优势和普及使得各种系统的开发成为必需。 本文以实际运用为开发背景&#xff0c;运用软件工程原理和开发方法&#xff0c;它主要是采用j…
阅读更多...
最新文章

Copyright @ 2022~2023