【线性表】顺序存储和链式存储的实现

文章目录

  • 顺序存储
  • 链式存储
    • 单向链表
    • 循环链表

线性表的定义 

(1)概念定义：用数据元素的有限序列表示叫做线性表；线性表中数据元素的类型可以为简单类型，也可以为复杂类型。许多实际应用问题所涉的基本操作有很大相似性，不应为每个具体应用单独编写一个程序。从具体应用中抽象出共性的逻辑结构和基本操作（抽象数据类型），然后实现其存储结构和基本操作。(2)类型定义：首先抽象出ADT List表的结构，在C/C++中一般都是采用struct来实现的。基本操作有如下：InitList(&L)：创建一个新表；DestroyList(&L)：销毁一个线性表；ClearList(&L)：清空表；ListEmpty(L)：判断表是否为空；ListLength(L)：求表的长度；GetElem(L,i,&e)：读取表的元素；LocateElem(L,e)：查找表的元素； PriorElem(L,cur_ e,&pre _e)：求表的前驱；NextElem(L,cur_ e,&next_e) ：求表的后继；ListInsert(&L,i,e) ：前插表；ListDelete(&L,i,&e)：删除表；TraverseList (L)：遍历表；

顺序存储

 顺序存储结构将线性表中的元素存储在连续的内存空间中。每个元素占据固定大小的存储空间，其物理位置和索引号相对应。顺序存储结构的优点是访问元素的速度快，缺点是插入和删除操作复杂，需要移动后续元素。
 顺序存储的底层实现就是使用数组来实现，主要就是对数组进行操作。当内存不足时重新分配一块新的内存（这块内存为原来内存的2倍），并将原来内存的值复制到新的内存里。
DynamicArray.h

#pragma once
#ifndef DYNAMIC_ARRAY_H
#define DYNAMIC_ARRAY_H#include<stdio.h>
#include<stdlib.h>
#include<string.h>//动态增长内存，策略将存放数据的内存放到那？堆上
//动态数组 如果5个元素 申请内存 拷贝数据 释放内存 6插入第七个？
//容量capacity表示我的这块内存空间一共可以存放多少元素
// size概念记录当前数组中具体的元素个数了typedef struct DYNAMICARRAY {int* pAddr;	//存放数据的地址int size;	//当前有多少个元素int capacity;  // 容量，我容器当前最大能容纳多少元素
}Dynamic_Array;//写一系列的相关对DYNAMICARRAY结构体操作的函数
//初始化
Dynamic_Array* Init_Array();
//插入
void Push_Back_Array(Dynamic_Array* arr, int value);
//根据位置删除
void RemoveByPos_Array(Dynamic_Array* arr, int pos);
//根据值删除
void RemoveByValue_Array(Dynamic_Array* arr, int value);
//查找
int Find_Array(Dynamic_Array* arr, int value);
//打印
void Print_Array(Dynamic_Array* arr);
//释放动态数组的内存
void FreeSpace_Array(Dynamic_Array* arr);
// 清空数组
void Clear_Array(Dynamic_Array* arr);
//获得动态数组容量
int Capacity_Array(Dynamic_Array* arr);
//获得动态数据当前元素个数
int Size_Array(Dynamic_Array* arr);
// 根据位置获得某个位置元素
int At_Array(Dynamic_Array* arr, int pos);#endif

DynamicArray.c

#include "DynamicArray.h"//初始化
Dynamic_Array* Init_Array()
{Dynamic_Array* myarray = (Dynamic_Array*)malloc(sizeof(Dynamic_Array));//初始化myarray->capacity = 20;myarray->size = 0;myarray->pAddr = (int*)malloc(sizeof(int) * myarray->capacity);return myarray;
}//插入
void Push_Back_Array(Dynamic_Array* arr, int value)
{if (!arr){return;}//查看空间是否足够if (arr->size == arr->capacity){//扩大容量为原来的两倍int* newSpace = (int*)malloc(sizeof(int) * arr->capacity * 2);memcpy(newSpace, arr->pAddr, arr->capacity * sizeof(int));//释放旧空间的内存free(arr->pAddr);arr->pAddr = newSpace;arr->capacity *= 2;}//插入新元素 arr->pAddr[arr->size] = value;arr->size++;
}
//根据位置删除
void RemoveByPos_Array(Dynamic_Array* arr, int pos)
{if (!arr){return;}for (int i = pos; i < arr->size - 1; i++){arr->pAddr[i] = arr->pAddr[i + 1];}arr->size--;}
//根据值删除
void RemoveByValue_Array(Dynamic_Array* arr, int value)
{//找到值的位置int pos = Find_Array(arr, value);//根据位置删除RemoveByPos_Array(arr, pos);
}//查找
int Find_Array(Dynamic_Array* arr, int value)
{if (!arr){return -1;}int pos = -1;for (int i = 0; i < arr->size; i++){if (arr->pAddr[i] == value){pos = i;break;}}return pos;
}//打印
void Print_Array(Dynamic_Array* arr)
{if (!arr){return;}for (int i = 0; i < arr->size; i++){printf("%d ", arr->pAddr[i]);}printf("\n");
}//释放动态数组的内存
void FreeSpace_Array(Dynamic_Array* arr)
{if (!arr){return;}if (arr->pAddr != NULL){free(arr->pAddr);}free(arr);
}// 清空数组
void Clear_Array(Dynamic_Array* arr)
{if (!arr){return;}arr->size = 0;
}//获得动态数组容量
int Capacity_Array(Dynamic_Array* arr)
{if (!arr){return -1;}return arr->capacity;
}
//获得动态数据当前元素个数
int Size_Array(Dynamic_Array* arr)
{if (!arr){return -1;}return arr->size;
}// 根据位置获得某个位置元素
int At_Array(Dynamic_Array* arr, int pos)
{return arr->pAddr[pos];
}

main.c

#include "DynamicArray.h"void test01() 
{//初始化动态数组Dynamic_Array* myArray = Init_Array();//打印容量printf("数组容量：%d\n", Capacity_Array(myArray));printf("数组大小：%d\n", Size_Array(myArray));//插入元素for (int i = 0; i < 30; i++) {Push_Back_Array(myArray, i);}printf("数组容量：%d\n", Capacity_Array(myArray));printf("数组大小：%d\n", Size_Array(myArray));//打印Print_Array(myArray);//删除RemoveByPos_Array(myArray, 0);RemoveByValue_Array(myArray, 27);//打印Print_Array(myArray);//查找5个位置int pos = Find_Array(myArray, 5);printf("查找第5处位置的下标(pos值):%d，值: %d\n", pos, At_Array(myArray, pos));//销毁FreeSpace_Array(myArray);
}int main()
{test01();return 0;
}

在这里插入图片描述

链式存储

 链式存储结构将线性表中的元素存储在分散的内存空间中。每个元素由一个节点组成，包含数据和指向下一个节点的指针。链式存储结构的优点是插入和删除操作简单，无需移动其他元素。缺点是访问元素的速度较慢，需要遍历链表。

单向链表

在这里插入图片描述

 主要就是定义了一个数据结构里面包含了一个数据域和一个指针域，每一个节点的指针域指向下一个节点的地址，通过这种方式使用一个头节点就可以遍历整个链表。
LinkList.h

#pragma once
#ifndef LINKLIST_H
#define LINKLIST_H#include<stdio.h>
#include<stdlib.h>//链表节点
typedef struct LINKNODE {void* data;		//指向任何类型的数据struct LINKNODE* next;
}LinkNode;//链表结构体
typedef struct LINKLIST {LinkNode* head;int size;}LinkList;//打印函数指针,自定义类型写法
typedef void(*PRINTLINKNODE)(void*);//比较函数指针
//typedef int(*COMPARENODE)(LinkNode*, LinkNode*);//初始化链表
LinkList* Init_LinkList();
//指定位置插入
void Insert_LinkList(LinkList* list, int pos, void* data);
//删除指定位置的值
void RemoveByPos_LinkList(LinkList* list, int pos);
//获得链表的长度
int Size_LinkList(LinkList* list);
//查找
//int Find_LinkList(LinkList* list, void* data, COMPARENODE compare);
int Find_LinkList(LinkList* list, void* data);
//返回第一个结点
void* Front_LinkList(LinkList* list);
//打印链表结点
void Print_LinkList(LinkList* list, PRINTLINKNODE print);
//释放链表内存
void FreeSpace_LinkList(LinkList* list);#endif // !LINKLIST_H

LinkList.c

#include "LinkList.h"//初始化链表
LinkList* Init_LinkList()
{LinkList* myList = (LinkList*)malloc(sizeof(LinkList));myList->size = 0;//头结点不保存数据myList->head = (LinkNode*)malloc(sizeof(LinkNode));myList->head->data = NULL;myList->head->next = NULL;return myList;
}//指定位置插入
void Insert_LinkList(LinkList* list, int pos, void* data)
{if (!list){return;}if (pos < 0 || pos > list->size){pos = list->size;}//创建新节点LinkNode* newNode = (LinkNode*)malloc(sizeof(LinkNode));newNode->next = NULL;newNode->data = data;//找到辅助指针变量LinkNode* pCurrent = list->head;for (int i = 0; i < pos; i++){pCurrent = pCurrent->next;}//新节点联入表newNode->next = pCurrent->next;pCurrent->next = newNode;list->size++;
}//删除指定位置的值
void RemoveByPos_LinkList(LinkList* list, int pos)
{if (!list){return;}if (pos < 0 || pos >= list->size){return;}LinkNode* pCurrent = list->head;for (int i = 0; i < pos; i++) {pCurrent = pCurrent->next;}LinkNode* pDel = pCurrent->next;pCurrent->next = pDel->next;free(pDel);list->size--;
}//获得链表的长度
int Size_LinkList(LinkList* list)
{return list->size;
}
//查找
int Find_LinkList(LinkList* list, void* data)
{if (!list || !data){return -1;}LinkNode* pCurrent = list->head->next;int index = 0;int flag = -1;while (pCurrent){if (pCurrent->data == data){flag = index;break;}index++;pCurrent = pCurrent->next;}return flag;
}
//返回第一个结点
void* Front_LinkList(LinkList* list)
{return list->head->next->data;
}
//打印链表结点
void Print_LinkList(LinkList* list, PRINTLINKNODE print)
{if (!list){return;}LinkNode* pCurrent = list->head->next;while (pCurrent){print(pCurrent->data);pCurrent = pCurrent->next;}
}//释放链表内存
void FreeSpace_LinkList(LinkList* list)
{if (!list){return;}LinkNode* pCurrent = list->head->next;while (pCurrent){LinkNode* pNode = pCurrent->next;free(pCurrent);pCurrent = pNode;}list->size = 0;free(list);
}

main.c

#include "LinkList.h"//自定义数据类型
typedef struct PERSON {char name[64];int age;int score;
}Person;void MyPrint(void* data)
{Person* person = (Person*)data;printf("结点数据：Name:%s, Age:%d, Score:%d\n", person->name, person->age, person->score);
}int main()
{//创建一个链表LinkList* list = Init_LinkList();//创建数据Person p1 = { "青铜", 18, 80 };Person p2 = { "白银", 19, 85 };Person p3 = { "黄金", 20, 90 };Person p4 = { "钻石", 21, 95 };Person p5 = { "星耀", 22, 100 };//数据插入链表Insert_LinkList(list, 0, &p1);Insert_LinkList(list, 0, &p2);Insert_LinkList(list, 0, &p3);Insert_LinkList(list, 0, &p4);Insert_LinkList(list, 0, &p5);//打印Print_LinkList(list, MyPrint);//删除3RemoveByPos_LinkList(list, 3);//打印printf("--------------------\n");Print_LinkList(list, MyPrint);//返回第一个结点printf("--------------------\n");Person* ret = (Person*)Front_LinkList(list);printf("首结点数据：Name:%s, Age:%d, Score:%d\n", ret->name, ret->age, ret->score);/*//查找(比较的是已有指针类型的data),返回其索引值Person f1 = { "青铜2", 18, 80 };Person f2 = { "青铜", 18, 80 };int index = Find_LinkList(list, &f1, MyCompare);printf("查到的索引值：%d", index);*///销毁链表FreeSpace_LinkList(list);return 0;
}

在这里插入图片描述

循环链表

在这里插入图片描述
 循环链表和单链表的主要区别就是循环链表的尾节点的指针域会指向头结点的节点。
CircleLinkList.h

#pragma once
#ifndef CIRCLELINKLIST_H
#define CIRCLELINKLIST_H#include <stdlib.h>
#include <stdio.h>//链表的小节点
typedef struct CIRCLELINKNODE {struct CIRCLELINKNODE* next;
}CircleLinkNode;//链表结构体
typedef struct CIRCLELINKLIST {CircleLinkNode head;int size;
}CircleLinkList;//编写针对链表结构体操作的API函数#define CIRCLELINKLIST_TRUE 1
#define CIRCLELINKLIST_FALSE 0//比较回调
typedef int(*COMPARENODE)(CircleLinkNode*, CircleLinkNode*);//打印回调
typedef void(*PRINTNODE)(CircleLinkNode*);//初始化函数
CircleLinkList* Init_CircleLinkList();
//插入函数
void Insert_CircleLinkList(CircleLinkList* clist, int pos, CircleLinkNode* data);
// 获得第一个元素
CircleLinkNode* Front_CircleLinkList(CircleLinkList* clist);
//根据位置删除
void RemoveByPos_CircleLinkList(CircleLinkList* clist, int pos);
//根据值去删除
void RemoveByValue_CircleLinkList(CircleLinkList* clist, CircleLinkNode* data, COMPARENODE compare);
//获得链表的长度
int Size_CircleLinkList(CircleLinkList* clist);
//判断是否为空
int IsEmpty_CircleLinkList(CircleLinkList* clist);
//查找
int Find_CircleLinkList(CircleLinkList* clist, CircleLinkNode* data, COMPARENODE compare);
//打印节点
void Print_CircleLinkList(CircleLinkList* clist, PRINTNODE print);
//释放内存
void FreeSpace_CircleLinkList(CircleLinkList* clist);#endif // !CIRCLELINKLIST_H

CircleLinkList.c

#include "CircleLinkList.h"//初始化函数
CircleLinkList* Init_CircleLinkList()
{CircleLinkList* list = (CircleLinkList*)malloc(sizeof(CircleLinkList));list->head.next = &(list->head);list->size = 0;return list;
}
//插入函数
void Insert_CircleLinkList(CircleLinkList* clist, int pos, CircleLinkNode* data)
{if (!clist){return;}if (pos<0 || pos>clist->size){pos = clist->size;}CircleLinkNode* pCurrent = &(clist->head);for (int i = 0; i < pos; i++){pCurrent = pCurrent->next;}data->next = pCurrent->next;pCurrent->next = data;clist->size++;
}
// 获得第一个元素
CircleLinkNode* Front_CircleLinkList(CircleLinkList* clist)
{return clist->head.next;
}//根据位置删除
void RemoveByPos_CircleLinkList(CircleLinkList* clist, int pos)
{if (!clist){return;}if (pos < 0 || pos >= clist->size){return;}CircleLinkNode* pCurrent = &(clist->head);for (int i = 0; i < pos; i++){pCurrent = pCurrent->next;}pCurrent->next = pCurrent->next->next;clist->size--;
}//根据值去删除
void RemoveByValue_CircleLinkList(CircleLinkList* clist, CircleLinkNode* data, COMPARENODE compare)
{if (!clist || !data){return;}CircleLinkNode* pPrev = &(clist->head);CircleLinkNode* pCurrent = pPrev->next;for (int i = 0; i < clist->size; i++){if (compare(pCurrent, data) == CIRCLELINKLIST_TRUE){pPrev->next = pCurrent->next;clist->size--;break;}pPrev = pCurrent;pCurrent = pCurrent->next;}
}//获得链表的长度
int Size_CircleLinkList(CircleLinkList* clist)
{return clist->size;
}//判断是否为空
int IsEmpty_CircleLinkList(CircleLinkList* clist)
{if (clist->size == 0) {return CIRCLELINKLIST_TRUE;}return CIRCLELINKLIST_FALSE;
}//查找
int Find_CircleLinkList(CircleLinkList* clist, CircleLinkNode* data, COMPARENODE compare)
{if (!clist || !data){return -1;}int index = 0;int flag = -1;CircleLinkNode* pCurrent = clist->head.next;for (int i = 0; i < clist->size; i++){if (compare(pCurrent, data) == CIRCLELINKLIST_TRUE){flag = index;break;}pCurrent = pCurrent->next;index++;}return index;
}//打印节点
void Print_CircleLinkList(CircleLinkList* clist, PRINTNODE print)
{if (!clist){return;}CircleLinkNode* pCurrent = clist->head.next;for (int i = 0; i < clist->size * 2; i++){if (pCurrent == &(clist->head)){pCurrent = pCurrent->next;printf("-----------------------\n");}print(pCurrent);pCurrent = pCurrent->next;}
}//释放内存
void FreeSpace_CircleLinkList(CircleLinkList* clist)
{if (!clist){return;}free(clist);
}

main.c

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "CircleLinkList.h"typedef struct PERSON {CircleLinkNode node;char name[64];int age;int score;
} Person;void MyPrint(CircleLinkNode* data) {Person* p = (Person*)data;printf("Name:%s, Age:%d, Score:%d\n", p->name, p->age, p->score);
}int MyCompare(CircleLinkNode* data1, CircleLinkNode* data2) {Person* p1 = (Person*)data1;Person* p2 = (Person*)data2;if (strcmp(p1->name, p2->name) == 0 && p1->age == p2->age && p1->score == p2->score) {return CIRCLELINKLIST_TRUE;}return CIRCLELINKLIST_FALSE;
}
int main(void) {//创建循环链表CircleLinkList* clist = Init_CircleLinkList();//创建数据Person p1, p2, p3, p4, p5;strcpy(p1.name, "aaa");strcpy(p2.name, "bbb");strcpy(p3.name, "ccc");strcpy(p4.name, "ddd");strcpy(p5.name, "eee");p1.age = 10;p2.age = 20;p3.age = 30;p4.age = 40;p5.age = 50;p1.score = 50;p2.score = 60;p3.score = 70;p4.score = 80;p5.score = 90;//数据入链表Insert_CircleLinkList(clist, 100, (CircleLinkNode*)&p1);Insert_CircleLinkList(clist, 100, (CircleLinkNode*)&p2);Insert_CircleLinkList(clist, 100, (CircleLinkNode*)&p3);Insert_CircleLinkList(clist, 100, (CircleLinkNode*)&p4);Insert_CircleLinkList(clist, 100, (CircleLinkNode*)&p5);//打印Print_CircleLinkList(clist, MyPrint);Person pDel;strcpy(pDel.name, "ccc");pDel.age = 30;pDel.score = 70;//根据值删除RemoveByValue_CircleLinkList(clist, (CircleLinkNode*)&pDel, MyCompare);//打印printf("------------\n");Print_CircleLinkList(clist, MyPrint);//释放内存FreeSpace_CircleLinkList(clist);system("pause");return 0;
}

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

建模杂谈系列244 TimeTraveller

建模杂谈系列244 TimeTraveller

说明 所有的基于时间处理和运行的程序将以同样的节奏同步和执行 TT(TimeTraveller)是一个新的设计&#xff0c;它最初会服务与量化过程的大量任务管理&#xff1a;分散开发、协同运行。但是很显然&#xff0c;TT的功能将远不止于此&#xff0c;它将服务大量的&#xff0c;基于时…
阅读更多...
【spring】第二篇 bean实例化

【spring】第二篇 bean实例化

对象已经能交给Spring的IOC容器来创建了&#xff0c;但是容器是如何来创建对象的呢? 就需要研究下bean的实例化过程&#xff0c;在这块内容中主要解决两部分内容&#xff0c;分别是 bean是如何创建的 实例化bean的三种方式&#xff0c;构造方法,静态工厂和实例工厂 在讲解这…
阅读更多...
WPF -＞ MVVM

WPF -＞ MVVM

1.1安装MVV MLight 打开 Visual Studio 2022。 在顶部菜单栏中选择“工具” -> “NuGet 包管理器” -> “程序包管理器控制台”。 在控制台中输入以下命令&#xff0c;并按回车键运行&#xff1a; Install-Package MvvmLightLibsStd104.等待安装完成后&#xff0c;你就…
阅读更多...
十_信号13 - abort()

十_信号13 - abort()

abort() 1 首先进程不能忽略 SIGABRT信号 2 要么在 SIGABRT信号的处理函数中 清理缓冲区并自己退出进程。如果信号处理函数中没有执行退出进程操作&#xff0c;返回到 abort()函数中&#xff0c;要求在 abort()函数中结束进程&#xff0c;不能返回到其调用者
阅读更多...
数据库(17)——DCL数据控制语言

数据库(17)——DCL数据控制语言

DCL DCL是Data Control Language数据控制语言&#xff0c;用来管理数据库用户、控制数据库的访问权限。 DCL-管理用户 语法 1.查询用户 USE mysql; SELECT * FROM user; 也可以直接在datagrip找到user表 我们要操作用户要通过User和Host同时定位。Host表示当前用户只能在哪个…
阅读更多...
音视频开发9 FFmpeg 解复用相关整体说明，重要API说明

音视频开发9 FFmpeg 解复用相关整体说明，重要API说明

一&#xff0c;播放器框架 二 常用音视频术语 容器&#xff0f;文件&#xff08;Conainer/File&#xff09;&#xff1a; 即特定格式的多媒体文件&#xff0c; 比如mp4、flv、mkv等。 媒体流&#xff08;Stream&#xff09;&#xff1a; 表示时间轴上的一段连续数据&#xff0…
阅读更多...
SIMBA：单细胞嵌入与特征

SIMBA：单细胞嵌入与特征

目前大多数单细胞分析管道仅限于细胞嵌入&#xff0c;并且严重依赖于聚类&#xff0c;而缺乏显式建模不同特征类型之间相互作用的能力。此外&#xff0c;这些方法适合于特定的任务&#xff0c;因为不同的单细胞问题的表述方式不同。为了解决这些缺点&#xff0c;SIMBA作为一种图…
阅读更多...
【Python网络爬虫】详解python爬虫中URL资源抓取

【Python网络爬虫】详解python爬虫中URL资源抓取

&#x1f517; 运行环境&#xff1a;PYTHON &#x1f6a9; 撰写作者&#xff1a;左手の明天 &#x1f947; 精选专栏&#xff1a;《python》 &#x1f525; 推荐专栏&#xff1a;《算法研究》 #### 防伪水印——左手の明天 #### &#x1f497; 大家好&#x1f917;&#x1f91…
阅读更多...
bootstrap5-学习笔记2-模态框+弹窗+tooltip+popover+信息提示框

bootstrap5-学习笔记2-模态框+弹窗+tooltip+popover+信息提示框

参考&#xff1a; Bootstrap5 教程 | 菜鸟教程 https://www.runoob.com/bootstrap5/bootstrap5-tutorial.html Bootstrap 入门 Bootstrap v5 中文文档 v5.3 | Bootstrap 中文网 https://v5.bootcss.com/docs/getting-started/introduction/ 之前用bootstrap2和3比较多&#x…
阅读更多...
上位机图像处理和嵌入式模块部署（f407 mcu中的单独烧录方法）

上位机图像处理和嵌入式模块部署（f407 mcu中的单独烧录方法）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 前面我们说过&#xff0c;stm32有三种烧录方法&#xff0c;一种是st-link v2&#xff0c;一种是dap&#xff0c;一种是j-link。不过我们在实际操作…
阅读更多...
架构设计之可部署和可管理属性深度剖析：从理论到实践的完美融合

架构设计之可部署和可管理属性深度剖析：从理论到实践的完美融合

文章目录 引言一、可部署属性的深度剖析1.1 理论基础1.2 实践应用1.3 关键要素1.4 评估方法 二、可管理属性的深度剖析2.1 理论基础2.2 实践应用2.3 关键要素2.4 评估方法 三、从理论到实践的完美融合3.1. 架构设计阶段的融合3.2. 开发过程中的融合3.3. 部署和管理的融合3.4. 监…
阅读更多...
54. 螺旋矩阵【rust题解】

54. 螺旋矩阵【rust题解】

题目 给你一个 m 行 n 列的矩阵 matrix &#xff0c;请按照 顺时针螺旋顺序 &#xff0c;返回矩阵中的所有元素。 示例 示例 1 输入&#xff1a;matrix [[1,2,3],[4,5,6],[7,8,9]] 输出&#xff1a;[1,2,3,6,9,8,7,4,5] 示例 2 输入&#xff1a;matrix [[1,2,3,4],[5,6,…
阅读更多...
Leecode---栈---每日温度 / 最小栈及栈和队列的相互实现

Leecode---栈---每日温度 / 最小栈及栈和队列的相互实现

栈&#xff1a;先入后出&#xff1b;队列&#xff1a;先入先出 一、每日温度 Leecode—739题目&#xff1a; 给定一个整数数组 temperatures &#xff0c;表示每天的温度&#xff0c;返回一个数组 answer &#xff0c;其中 answer[i] 是指对于第 i 天&#xff0c;下一个更高温…
阅读更多...
day20

day20

第一题 23. 合并 K 个升序链表 本题是已经知道有多个链表&#xff0c;需要我们将这些链表按照升序排列的规则组合到一起&#xff0c;同时这些链表都是升序排列的&#xff1b; 解法一&#xff1a; 利用优先级队列 步骤一&#xff1a;利用优先级队列床架一个小根堆&#xff1b; …
阅读更多...
【OpenHarmony】TypeScript 语法 ④ ( 函数 | TypeScript 具名函数和匿名函数 | 可选参数 | 剩余参数 | 箭头参数 )

【OpenHarmony】TypeScript 语法 ④ ( 函数 | TypeScript 具名函数和匿名函数 | 可选参数 | 剩余参数 | 箭头参数 )

文章目录 一、TypeScript 函数1、TypeScript 具名函数和匿名函数2、TypeScript 函数 与 JavaScript 函数对比3、TypeScript 函数 可选参数4、TypeScript 函数 剩余参数5、TypeScript 箭头函数 参考文档 : <HarmonyOS第一课>ArkTS开发语言介绍 一、TypeScript 函数 1、Typ…
阅读更多...
Llama（二）：Open WebUI作为前端界面，使用本机的llama3

Llama（二）：Open WebUI作为前端界面，使用本机的llama3

目录 背景 Open WebUI是什么 工程能力特性 产品功能特性 用户体验特性 Open WebUI安装并使用 背景 Mac M1芯片&#xff0c;16G 内存 llama3 8B的部署参考Llama&#xff08;一&#xff09;&#xff1a;Mac M1芯片运行Llama3-CSDN博客在Mac M1 16G内存环境中&#xff0c;…
阅读更多...
牛客热题：缺失的第一个正整数

牛客热题：缺失的第一个正整数

牛客热题&#xff1a;数组中出现一次的两个数字> &#x1f4df;作者主页&#xff1a;慢热的陕西人 &#x1f334;专栏链接&#xff1a;力扣刷题日记 &#x1f4e3;欢迎各位大佬&#x1f44d;点赞&#x1f525;关注&#x1f693;收藏&#xff0c;&#x1f349;留言 文章目录 …
阅读更多...
6月2号总结

6月2号总结

刷题记录Codeforces Round 925 &#xff08;A,B,C&#xff09; 1.A. Recovering a Small String 问题 - A - Codeforces 输入&#xff1a; 5 24 70 3 55 48 输出&#xff1a; aav rzz aaa czz auz 给定一个3~78的整数&#xff0c;将这个整数分成a,b,c&#xff0c;其中1表示…
阅读更多...
数据结构之二叉搜索树（TreeSetTreeMap）

数据结构之二叉搜索树（TreeSetTreeMap）

目录 一.搜索树 1.1概念 1.2适用场景 2.二叉搜索树的基本操作 2.1二叉搜索树的定义 2.2查找 2.1.1基本思路 2.3插入 2.3.1基本思路 2.4删除 2.4.1基本思路 2.5遍历 2.6性能分析 二.TreeSet Map和Set 1.概念 2.模型 1.定义 2.基本操作 三.TreeMap 1.定义 2.基…
阅读更多...
LLM大语言模型学习资料网站（git、gitee、等）

LLM大语言模型学习资料网站（git、gitee、等）

先上几个关于大模型方面比较好的开源地址吧&#xff1a; 1.清华智普ChatGLM&#xff1a; GitHub - THUDM/ChatGLM3: ChatGLM3 series: Open Bilingual Chat LLMs | 开源双语对话语言模型 ChatGLM3 series: Open Bilingual Chat LLMs | 开源双语对话语言模型&#xff0c;详细…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023