探索数据结构：顺序串与链式串的深入理解

✨✨ 欢迎大家来到贝蒂大讲堂✨✨

🎈🎈养成好习惯，先赞后看哦~🎈🎈

所属专栏：数据结构与算法
贝蒂的主页：Betty’s blog

1. 串的定义

串是一种特殊的顺序表，即每一个元素都是单独一个字符。在C语言中我们学习的字符串便是串的一种，它在我们的数据搜索与文本编译中起着不可或缺的作用。

img

特别注意：空格也是一个字符！！

下面是与串相关概念：

  • 串的长度：指串中有效元素的个数(不包括字符\0)。
  • 空串：不含任何元素的串，即长度为0。
  • 子序列：抽取串的一些字符，按照原字符串的顺序进行放置的新串。
  • 子串：串中任意连续字符组成的子序列称为该串的子串，其中空串是任意串的子串。
  • 主串：包含子串的串称为该子串的主串。

2. 串的实现方式

串是一种特殊的顺序表，所以实现方式也与顺序表类似，分别以顺序表和链表来实现。

  1. 顺序实现

img

  1. 链式实现

img

3. 串的功能

  1. 串的初始化
  2. 串的生成。
  3. 串的复制。
  4. 判断两个串是否相等。
  5. 返回串的长度。
  6. 链接两个串。
  7. 取子串。
  8. 在串1的指定位置插入串2。
  9. 删除指定位置长度为n的某个子串。

4. 串的声明

4.1. 顺序串

顺序串的存储自然是以顺序表的形式，但是在定义其长度有三种实现方式，如下：

  1. 初始化一个头结点作为长度的存储。

img

但是这种存储有一个明显的缺点就是char类型的最大表示范围为255，所以这种方式并不可取。

  1. 以字符\0作为结束标志。

img

C/C++中的字符串就是以这种实现方式，但是这种实现方式每次求长度都需要遍历整个顺序表。所以在这里也不是特别好。

  1. 添加为结构体成员。

img

这种实现方式相较于前两种更加合理，后续我们也将以这种方式实现。

同时为了方便扩容，我们可以再增加一个结构体成员capacity。

#define MAXSIZE 50
typedef struct string
{char *data;int length;int capacity;
}Sstring;

4.2. 链式串

链式串我们使用单链表来实现，为了方便操作我们可以添加一个头节点。

typedef struct snode 
{char data;struct snode* next;
}LinkStrNode;

5. 串的初始化

5.1. 顺序串

void StrInit(Sstring* s)//初始化串
{char *arr = (char*)malloc(sizeof(char) * MAXSIZE);if (arr == NULL){perror("malloc fail");return;}s->data = arr;s->length = 0;s->capacity = MAXSIZE;
}

5.2. 链式串

链式串并不需要单独初始化，可以在具体的实现中初始化。

5.3. 复杂度分析

  • 时间复杂度：顺序串花费时间是一个常数，所以时间复杂度为O(1)。
  • 空间复杂度：初始化开辟了MAXSIZE的空间。可以视为O(N)的复杂度。

6. 串的生成

6.1. 顺序串

在对串进行拷贝时，要检查是否需要扩容，放置越界。

void CheckCapacity(Sstring* s, int len)
{if (s->length + len > s->capacity){char* tmp = (char*)realloc(s->data, sizeof(char) * (s->length + len));if (tmp == NULL){perror("realloc fail");return;}s->data = tmp;s->capacity = MAXSIZE + len;}
}
void StrAssign(Sstring* s, char*str)//生成串
{assert(s && str);int i = 0;int len = strlen(str);CheckCapacity(s, len);for (i = 0; str[i] != '\0'; i++){s->data[i] = str[i];}s->length = len;
}

6.2. 链式串

链式串每次插入都要生成一个节点，所以我们可以单独封装成一个函数。

LinkStrNode* BuyListNode()
{LinkStrNode*tmp= (LinkStrNode*)malloc(sizeof(LinkStrNode));if (tmp == NULL){perror("malloc fail");}return tmp;
}
void StrAssign(LinkStrNode** s, char*str)
{assert(str);LinkStrNode* r, * p;*s = BuyListNode();r = *s;for (int i = 0; str[i] != '\0'; ++i){p = BuyListNode();p->data = str[i];r->next = p;	r = p;}r->next = NULL;
}

6.3. 复杂度分析

  • 时间复杂度：无论是顺序串还是链式串都需要遍历一遍目标串，间复杂度可以视为O(N))。
  • 空间复杂度：顺序串可能会扩容，链式串需要开辟等量节点，所以空间复杂度可以视为O(N)。

7. 串的复制

7.1. 顺序串

串的复制也需要检查是否需要扩容，然后再依次拷贝。

void StrCopy(Sstring* s, Sstring* t)//复制串
{assert(s && t);if (s->capacity < t->capacity){char* tmp = (char*)realloc(s->data, sizeof(char) * t->capacity);if (tmp == NULL){perror("realloc fail");return;}s->data = tmp;s->capacity = t->capacity;}for (int i = 0; i < t->length; i++){s->data[i] = t->data[i];}s->length = t->length;
}

7.2. 链式串

链式串的拷贝我们采用一种方法：即先将原串销毁，然后再拷贝。

void StrCopy(LinkStrNode** s, LinkStrNode* t)//复杂
{assert(t);DestroyStr(*s);//销毁LinkStrNode* r, * q;LinkStrNode* p = t->next;*s = BuyListNode();r = *s;while (p != NULL){q = BuyListNode();q->data = p->data;		r->next = q;r = q;			p = p->next;}r->next = NULL;
}

7.3. 复杂度分析

  • 时间复杂度：需要遍历一遍被复制串，所以时间复杂度可以视为O(N)。
  • 空间复杂度：顺序串可能扩容，链式串需要复制等量节点，所以空间复杂度可以视为O(N)。

8. 串的比较

串的比较与C语言中strcmp函数功能类似，都是依次比较串中的字符，直至结束或者出现不同的字符为至。

若大于则返回>0，等于返回0，小于则返回<0。

列如：

  • 当串长度不同时：“aabc”>“abbca”，“aaa”<“aaab”。
  • 当串长度相同时：“acbc”>“bcbc”，“acac”=“acac”。

8.1. 顺序串

int StrCmp(Sstring* s, Sstring* t)//比较两个串
{assert(s && t);char* p1 = s->data;char* p2 = t->data;int i = 0;while (i < s->length && i < t->length && p1[i] == p2[i]){i++;}if (i == s->length&&i==t->length){return 0;}if (i == s->length && i != t->length){return -1;}if (i != s->length && i == t->length){return 1;}return p1[i] - p2[i];
}

8.2. 链式串

int StrCmp(LinkStrNode* s, LinkStrNode* t)//比较两个串
{assert(s&&t);LinkStrNode* p = s->next, * q = t->next;while (p != NULL && q != NULL && p->data == q->data){p = p->next;q = q->next;}if (p == NULL&&q == NULL)		return 0;if (p == NULL && q != NULL){return -1;}if (p != NULL && q == NULL){return 1;}return p->data - q->data;
}

8.3. 复杂度分析

  • 时间复杂度：无论是链式串还是顺序串都可能遍历整个串，所以时间复杂度可以视为O(N)
  • 空间复杂度：无论是顺序串还是链式串花费空间是一个常数，所以空间复杂度为O(1)。

9. 返回串的长度

9.1. 顺序串

int StrLength(Sstring* s)//返回串的长度
{assert(s);return s->length;
}

9.2. 链式串

int StrLength(LinkStrNode* s)//返回串的长度
{assert(s);int count = 0;LinkStrNode* p = s->next;while (p != NULL){count++;p = p->next;}return count;
}

9.3. 复杂度分析

  • 时间复杂度：顺序串是一个常数，所以时间复杂度为O(1)。但是链式串需要遍历整个串，所以为O(N)。
  • 空间复杂度：无论是顺序串还是链式串花费空间是一个常数，所以空间复杂度为O(1)。

10. 链接两个串

链接两个串十分简单，首先找个一个串的末尾，然后再链接即可。

10.1. 顺序串

链接两个串也需要判断该串是否需要扩容。

Sstring Strcat(Sstring* s, Sstring* t)//链接两个串
{assert(s && t);int len = t->length;CheckCapacity(s, len);for (int i = s->length; i < s->length + t->length; i++){s->data[i] = t->data[i - s->length];}s->length = s->length + t->length;return *s;
}

10.2. 链式串

LinkStrNode*Strcat(LinkStrNode* s, LinkStrNode* t)//链接两个串
{assert(s && t);LinkStrNode* p = s->next, * q = t->next;while (p->next != NULL){p = p->next;}LinkStrNode* str1 = p,*str2;while (q != NULL){str2 = BuyListNode();str2->data =q->data;str1->next = str2;str1 = str2;q = q->next;}str1->next = NULL;return s;
}

10.3. 复杂度分析

  • 时间复杂度：无论是顺序串还是链式串都需要遍历两个串，所以时间复杂度为O(N)。
  • 空间复杂度：顺序串可能会扩容，链式串需要开辟等量节点，所以空间复杂度为O(N)

11. 取子串

我们通过传入的目标位置与长度来截取一段子串返回，如果长度过大则截取后续所有字符。

11.1. 顺序串

Sstring SubStr(Sstring* s, int i, int len)//取子串
{assert(i < s->length);assert(s);Sstring str;str.data = (char*)malloc(sizeof(char) * s->capacity);if (str.data == NULL){perror("malloc fail");return *s;}str.capacity = s->capacity;if (i + len >= s->length){for (int pos = i; pos < s->length; pos++){str.data[pos-i] = s->data[pos];}str.length = s->length - i;}else{for (int pos = i; pos < i+len; pos++){str.data[pos - i] = s->data[pos];}str.length = len;}return str;
}

11.2. 链式串

LinkStrNode*SubStr(LinkStrNode* s, int i, int len)//取子串
{assert(s);assert(i <= StrLength(s));int count = 0;LinkStrNode* r, * p;p = s->next;//跳过头节点r = BuyListNode();while (p != NULL)//找到第i个位置{count++;if (count == i){break;}p = p->next;}LinkStrNode* str1=r,*str2;while (len--&&p!=NULL){str2 = BuyListNode();str2->data = p->data;str1->next = str2;str1 = str2;p = p->next;}str1->next = NULL;//末尾置空return r;
}

11.3. 复杂度分析

  • 时间复杂度：都可能遍历整个串，所以时间复杂度为O(N)。
  • 空间复杂度：都需要开辟len个大小的空间，所以空间复杂度可以视为O(N)。

12. 指定位置插入

12.1. 顺序串

指定位置插入也许检查是否扩容，然后指定位置后续字符移动len个单位。

img

img

Sstring InsStr(Sstring* s1, int i, Sstring* s2)//指定位置插入
{assert(s1 && s2);assert(i < s1->length);int len = s2->length;CheckCapacity(s1, len);for (int pos = s1->length - 1; pos >= i; pos--){s1->data[pos + len] = s1->data[pos];}for (int pos = i; pos < i + len; pos++){s1->data[pos] = s2->data[pos - i];}s1->length += len;return *s1;
}

12.2. 链式串

LinkStrNode*InsStr(LinkStrNode* s1, int i, LinkStrNode* s2)//指定位置插入
{assert(s1&&s2);assert(i <= StrLength(s1));int count = 0;LinkStrNode* r, * p,*q;q=p = s1->next;//q为i之前的位置while (p != NULL)//找到第i个位置{count++;if (count == i){break;}q = p;//记录前一个位置p = p->next;}r = q;LinkStrNode* str;LinkStrNode* ptr=s2->next;//跳过头节点while (ptr != NULL){str = BuyListNode();str->data = ptr->data;r->next = str;r = str;ptr = ptr->next;}r->next= p;//链接return s1;
}

12.3. 复杂度分析

  • 时间复杂度：顺序串需要移动覆盖，链式串需要寻找目标位置，时间复杂度都可以视为O(N)。
  • 空间复杂度：顺序串可能扩容，链式串需要开辟等量空间，空间复杂度都可以视为O(N)。

13. 指定删除子串

13.1. 顺序串

如果删除的长度过长，只需要修改串的length。否则需要从前往后覆盖。

Sstring DelStr(Sstring* s, int i, int len)//指定删除子串
{assert(i < s->length);assert(s);if (i + len >=s->length){s->length = i ;}else{for (int pos = i+len; pos <s->length; pos++){s->data[pos-len] = s->data[pos];}s->length -= len;}return *s;
}

13.2. 链式串

LinkStrNode* DelStr(LinkStrNode* s, int i, int len)//指定删除子串
{assert(s);assert(i < StrLength(s));int count = 0;LinkStrNode* r, * p;p = s->next;r = p;//r为前一个节点while (p != NULL){count++;if (count == i){break;}r = p;p = p->next;}while (len-- && p != NULL){LinkStrNode* str = p->next;free(p);p = str;}r->next = p;return s;
}

13.3. 复杂度分析

  • 时间复杂度：顺序串可能需要移动覆盖，链式串需要寻找目标位置，时间复杂度都可以视为O(N)。
  • 空间复杂度：顺序串与链式串都不需要开辟格外空间，空间复杂度都可以视为O(1)。

14. 串的打印

14.1. 顺序串

void PrintStr(Sstring* s)
{assert(s);char* p = s->data;for (int i = 0; i < s->length; i++){printf("%c", p[i]);}printf("\n");
}

14.2. 链式串

void PrintStr(LinkStrNode* s)//打印
{assert(s);LinkStrNode* p = s->next;while (p != NULL){printf("%c", p->data);p = p->next;}printf("\n");
}

14.3. 复杂度分析

  • 时间复杂度：无论是顺序串还是链式串都需要遍历整个串，所以时间复杂度为O(N)。
  • 空间复杂度：顺序串与链式串都不需要开辟格外空间，空间复杂度都可以视为O(1)。

15. 串的销毁

15.1. 顺序串

void StrDestroy(Sstring* s)//销毁串
{free(s->data);s->data = NULL;s->length = s->capacity = 0;
}

15.2. 链式串

void DestroyStr(LinkStrNode* s)//销毁
{LinkStrNode* pre = s, * p = s->next;while (p != NULL){free(pre);pre = p;p = p->next;}free(pre);
}

15.3. 复杂度分析

  • 时间复杂度：顺序串消耗时间固定，时间复杂度为O(1)。链式串需要遍历这个串，时间复杂度为O(N)
  • 空间复杂度：顺序串与链式串都不需要开辟格外空间，空间复杂度都可以视为O(1)。

16. 对比与应用

16.1. 对比

因为串也是一种顺序表，所以无论是顺序表还是链式串的优劣都与顺序表与链表差不多。这里就不在赘述。

16.2. 应用

串在计算机领域有着广泛的应用：

  1. **文本处理：**文本编辑器或处理器中，文本被表示为一个字符串，可以进行查找、替换、插入、删除等操作
  2. 加密和安全：加密算法中经常使用字符串表示数据，例如对称加密和非对称加密中的密钥和明文。

17. 完整代码

17.1. 顺序串

17.1.1. Sstring.h
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#include<string.h>
#define MAXSIZE 50
typedef struct string
{char *data;int length;int capacity;
}Sstring;
void StrInit(Sstring* s);//初始化串
void StrAssign(Sstring* s, char str[]);//生成串
void StrCopy(Sstring* s, Sstring*t);//复制串
int StrCmp(Sstring*s, Sstring*t);//比较两个串
int StrLength(Sstring*s);//返回串的长度
Sstring Strcat(Sstring*s, Sstring*t);//链接两个串
Sstring SubStr(Sstring* s, int i, int len);//取子串
Sstring InsStr(Sstring* s1, int i, Sstring* s2);//指定位置插入
Sstring DelStr(Sstring* s, int i, int len);//指定删除子串
void PrintStr(Sstring* s);//打印
void StrDestroy(Sstring* s);//销毁串
17.1.2. Sstring.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"Sstring.h"
void CheckCapacity(Sstring* s, int len)
{if (s->length + len > s->capacity){char* tmp = (char*)realloc(s->data, sizeof(char) * (s->length + len));if (tmp == NULL){perror("realloc fail");return;}s->data = tmp;s->capacity = MAXSIZE + len;}
}
void StrInit(Sstring* s)//初始化串
{char *arr = (char*)malloc(sizeof(char) * MAXSIZE);if (arr == NULL){perror("malloc fail");return;}s->data = arr;s->length = 0;s->capacity = MAXSIZE;
}
void StrAssign(Sstring* s, char*str)//生成串
{assert(s && str);int i = 0;int len = strlen(str);CheckCapacity(s, len);for (i = 0; str[i] != '\0'; i++){s->data[i] = str[i];}s->length = len;
}
void StrCopy(Sstring* s, Sstring* t)//复制串
{assert(s && t);if (s->capacity < t->capacity){char* tmp = (char*)realloc(s->data, sizeof(char) * t->capacity);if (tmp == NULL){perror("realloc fail");return;}s->data = tmp;s->capacity = t->capacity;}for (int i = 0; i < t->length; i++){s->data[i] = t->data[i];}s->length = s->length > t->length ? s->length : t->length;
}
int StrCmp(Sstring* s, Sstring* t)//比较两个串
{assert(s && t);char* p1 = s->data;char* p2 = t->data;int i = 0;while (i < s->length && i < t->length && p1[i] == p2[i]){i++;}if (i == s->length&&i==t->length){return 0;}if (i == s->length && i != t->length){return -1;}if (i != s->length && i == t->length){return 1;}return p1[i] - p2[i];
}
int StrLength(Sstring* s)//返回串的长度
{assert(s);return s->length;
}
Sstring Strcat(Sstring* s, Sstring* t)//链接两个串
{assert(s && t);int len = t->length;CheckCapacity(s, len);for (int i = s->length; i < s->length + t->length; i++){s->data[i] = t->data[i - s->length];}s->length = s->length + t->length;return *s;
}
Sstring SubStr(Sstring* s, int i, int len)//取子串
{assert(i < s->length);assert(s);Sstring str;str.data = (char*)malloc(sizeof(char) * s->capacity);if (str.data == NULL){perror("malloc fail");return *s;}str.capacity = s->capacity;if (i + len >= s->length){for (int pos = i; pos < s->length; pos++){str.data[pos-i] = s->data[pos];}str.length = s->length - i;}else{for (int pos = i; pos < i+len; pos++){str.data[pos - i] = s->data[pos];}str.length = len;}return str;
}
Sstring InsStr(Sstring* s1, int i, Sstring* s2)//指定位置插入
{assert(s1 && s2);assert(i < s1->length);int len = s2->length;CheckCapacity(s1, len);for (int pos = s1->length - 1; pos >= i; pos--){s1->data[pos + len] = s1->data[pos];}for (int pos = i; pos < i + len; pos++){s1->data[pos] = s2->data[pos - i];}s1->length += len;return *s1;
}
Sstring DelStr(Sstring* s, int i, int len)//指定删除子串
{assert(i < s->length);assert(s);if (i + len >=s->length){s->length = i ;}else{for (int pos = i+len; pos <s->length; pos++){s->data[pos-len] = s->data[pos];}s->length -= len;}return *s;
}
void PrintStr(Sstring* s)
{assert(s);char* p = s->data;for (int i = 0; i < s->length; i++){printf("%c", p[i]);}printf("\n");
}
void StrDestroy(Sstring* s)//销毁串
{free(s->data);s->data = NULL;s->length = s->capacity = 0;
}

17.2. 链式串

17.2.1. Sstring.h
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#include<string.h>
typedef struct snode 
{char data;struct snode* next;
}LinkStrNode;
void StrInit(LinkStrNode* s);//初始化串
void StrAssign(LinkStrNode**s, char str[]);//生成串
void StrCopy(LinkStrNode**s, LinkStrNode*t);//复制串
int StrCmp(LinkStrNode*s, LinkStrNode*t);//比较两个串
int StrLength(LinkStrNode*s);//返回串的长度
LinkStrNode*Strcat(LinkStrNode*s, LinkStrNode*t);//链接两个串
LinkStrNode*SubStr(LinkStrNode* s, int i, int len);//取子串
LinkStrNode*InsStr(LinkStrNode* s1, int i, LinkStrNode* s2);//指定位置插入
LinkStrNode*DelStr(LinkStrNode* s, int i, int len);//指定删除子串
void PrintStr(LinkStrNode* s);//打印
void DestroyStr(LinkStrNode* s);//销毁串
17.2.2. Sstring.c
#include"Sstring.h"
LinkStrNode* BuyListNode()
{LinkStrNode*tmp= (LinkStrNode*)malloc(sizeof(LinkStrNode));if (tmp == NULL){perror("malloc fail");}return tmp;
}
void StrAssign(LinkStrNode** s, char*str)
{assert(str);LinkStrNode* r, * p;*s = BuyListNode();r = *s;for (int i = 0; str[i] != '\0'; ++i){p = BuyListNode();p->data = str[i];r->next = p;	r = p;}r->next = NULL;
}void StrCopy(LinkStrNode** s, LinkStrNode* t)
{assert(t);DestroyStr(*s);LinkStrNode* r, * q;LinkStrNode* p = t->next;*s = BuyListNode();r = *s;while (p != NULL){q = BuyListNode();q->data = p->data;		r->next = q;r = q;			p = p->next;}r->next = NULL;
}int StrCmp(LinkStrNode* s, LinkStrNode* t)//比较两个串
{assert(s&&t);LinkStrNode* p = s->next, * q = t->next;while (p != NULL && q != NULL && p->data == q->data){p = p->next;q = q->next;}if (p == NULL&&q == NULL)		return 0;if (p == NULL && q != NULL){return -1;}if (p != NULL && q == NULL){return 1;}return p->data - q->data;
}
int StrLength(LinkStrNode* s)//返回串的长度
{assert(s);int count = 0;LinkStrNode* p = s->next;while (p != NULL){count++;p = p->next;}return count;
}
LinkStrNode*Strcat(LinkStrNode* s, LinkStrNode* t)//链接两个串
{assert(s && t);LinkStrNode* p = s->next, * q = t->next;while (p->next != NULL){p = p->next;}LinkStrNode* str1 = p,*str2;while (q != NULL){str2 = BuyListNode();str2->data =q->data;str1->next = str2;str1 = str2;q = q->next;}str1->next = NULL;return s;
}
LinkStrNode*SubStr(LinkStrNode* s, int i, int len)//取子串
{assert(s);assert(i <= StrLength(s));int count = 0;LinkStrNode* r, * p;p = s->next;//跳过头节点r = BuyListNode();while (p != NULL)//找到第i个位置{count++;if (count == i){break;}p = p->next;}LinkStrNode* str1=r,*str2;while (len--&&p!=NULL){str2 = BuyListNode();str2->data = p->data;str1->next = str2;str1 = str2;p = p->next;}str1->next = NULL;//末尾置空return r;
}
LinkStrNode*InsStr(LinkStrNode* s1, int i, LinkStrNode* s2)//指定位置插入
{assert(s1&&s2);assert(i <= StrLength(s1));int count = 0;LinkStrNode* r, * p,*q;q=p = s1->next;//q为i之前的位置while (p != NULL)//找到第i个位置{count++;if (count == i){break;}q = p;//记录前一个位置p = p->next;}r = q;LinkStrNode* str;LinkStrNode* ptr=s2->next;//跳过头节点while (ptr != NULL){str = BuyListNode();str->data = ptr->data;r->next = str;r = str;ptr = ptr->next;}r->next= p;//链接return s1;
}
LinkStrNode* DelStr(LinkStrNode* s, int i, int len)//指定删除子串
{assert(s);assert(i < StrLength(s));int count = 0;LinkStrNode* r, * p;p = s->next;r = p;//r为前一个节点while (p != NULL){count++;if (count == i){break;}r = p;p = p->next;}while (len-- && p != NULL){LinkStrNode* str = p->next;free(p);p = str;}r->next = p;return s;
}
void PrintStr(LinkStrNode* s)//打印
{assert(s);LinkStrNode* p = s->next;while (p != NULL){printf("%c", p->data);p = p->next;}printf("\n");
}
void DestroyStr(LinkStrNode* s)//销毁
{LinkStrNode* pre = s, * p = s->next;while (p != NULL){free(pre);pre = p;p = p->next;}free(pre);
}

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

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

相关文章

STL--list双向链表

STL--list双向链表

功能 将数据进行链式存储 链表&#xff08;list&#xff09;是一种物理存储单元上非连续的存储结构&#xff0c;数据元素的逻辑顺序是通过链表中的指针链接实现的 链表的组成&#xff1a;链表由一系列结点组成 结点的组成&#xff1a;一个是存储数据元素的数据域&#xff0…
阅读更多...
Finetuning vs. Prompting：大语言模型两种使用方式

Finetuning vs. Prompting：大语言模型两种使用方式

目录 前言1. 对于大型语言模型的两种不同期待2. Finetune(专才)3. Prompt(通才)3.1 In-context Learning3.2 Instruction-tuning3.3 Chain of Thought(COT) Prompting3.4 用机器来找Prompt 总结参考 前言 这里和大家分享下关于大语言模型的两种使用方式&#xff0c;一种是 Fine…
阅读更多...
4.Godot图片素材的获取和编辑

4.Godot图片素材的获取和编辑

游戏开发中经常遇到图片素材的需求 1. 图片素材的准备 术语&#xff1a;Sprite 精灵&#xff0c;游戏开发中指一张图片来源不明的图片&#xff0c;切勿在商业用途使用&#xff0c;以免引起版权风险。 1. 在学习阶段&#xff0c;可以百度或者从一些资源网站获取&#xff0c;这…
阅读更多...
黑马苍穹外卖--再来一单(stream流转换、赋值与收集映射)

黑马苍穹外卖--再来一单(stream流转换、赋值与收集映射)

1.首先明确一下业务规则: 业务规则&#xff1a; 再来一单就是将原订单中的商品重新加入到购物车中 2.产品页面原型和开发接口文档 3.业务层逻辑代码开发 3.1 查询方向 我们要明确的是: 再来一单就是将原订单中的商品重新加入到购物车中------直接把商品加入到购物车&#…
阅读更多...
关于机器学习/深度学习的一些事-答知乎问（二）

关于机器学习/深度学习的一些事-答知乎问（二）

进化算法与深度强化学习算法结合如何进行改进&#xff1f; &#xff08;1&#xff09;进化算法普遍存在着样本效率低下的问题&#xff0c;虽然其探索度较高&#xff0c;但其本质为全局随机性搜索&#xff0c;需要在整个回合结束后才能更新其种群&#xff0c;而深度强化学习在每…
阅读更多...
云笔记小程序的实现

云笔记小程序的实现

1.前言 云笔记, 是基于HotApp小程序统计云后台提供的api接口开发的一个微信小程序。 2.功能 离线保存笔记 云端数据同步, 更换了设备也可以找到以前的笔记 接入了好推二维码提供的数据统计工具, 可以到平台上查看用户分析、留存分析、事件分析。 3.界面效果 ***HotApp云笔…
阅读更多...
一个基于单片机内存管理-开源模块

一个基于单片机内存管理-开源模块

概述 此模块是一位大佬写的应用于单片机内存管理模块mem_malloc，这个mem_malloc的使用不会产生内存碎片，可以高效利用单片机ram空间。 源码仓库：GitHub - chenqy2018/mem_malloc mem_malloc介绍 一般单片机的内存都比较小，而且没有MMU，malloc 与free的使用容易造成内存碎…
阅读更多...
【opencv】示例-stereo_match.cpp 立体匹配：通过对左右视图图像进行处理来生成视差图和点云数据...

【opencv】示例-stereo_match.cpp 立体匹配：通过对左右视图图像进行处理来生成视差图和点云数据...

/** stereo_match.cpp* calibration** 创建者 Victor Eruhimov&#xff0c;日期为 2010年1月18日。* 版权所有 2010 Argus Corp.**/#include "opencv2/calib3d/calib3d.hpp" // 导入OpenCV相机标定和三维重建相关的头文件 #include "opencv2/imgproc.hpp&qu…
阅读更多...
您与此网站之间建立的连接不安全

您与此网站之间建立的连接不安全

正如标题一样&#xff0c;打开的网站地址栏显示&#xff1a;如果你使用浏览器提示您与此网站之间建立的连接不安全、与此站点的连接不安全、网站非安全连接等类似提示。 是因为网站采取的是http地址协议&#xff0c;这种协议有一种缺点&#xff0c;当您常使用的网站出现上述提示…
阅读更多...
ASP.NET基于BS的图书销售管理系统的设计与实现

ASP.NET基于BS的图书销售管理系统的设计与实现

随着Internet的兴起&#xff0c;网络已经成为现代人生活中的一部分&#xff0c;越来越多的人喜欢在网上交易。本系统就是一个基于B/S模式的网络化的图书销售管理系统,采用的是ASP.NET技术&#xff0c;实现了用户注册信息管理、用户信息管理、图书销售点管理、图书信息管理、客户…
阅读更多...
8. Spring Boot 配置文件

8. Spring Boot 配置文件

源码地址&#xff1a;SpringBoot_demo 本篇文章内容源码位于上述地址的com/chenshu/springboot_demo/config包下 1. 配置文件是什么 上节说到&#xff0c;Spring Boot的项目分为三个部分&#xff1a;源代码目录、资源目录、单元测试目录。 而配置文件的位置就位于资源目录res…
阅读更多...
科技助力输电线安全隐患预警，基于YOLOv8全系列【n/s/m/l/x】参数模型开发构建电力设备场景下输电线安全隐患目标检测预警系统

科技助力输电线安全隐患预警，基于YOLOv8全系列【n/s/m/l/x】参数模型开发构建电力设备场景下输电线安全隐患目标检测预警系统

电力的普及让我们的生活变得更加便利&#xff0c;四通八达的电网连接着生活的方方面面&#xff0c;电力能源主要是依托于庞大复杂的电网电力设备进行传输的&#xff0c;有效地保障电网场景下输电线的安全对于保障我们日常生活所需要的电力有着重要的意义&#xff0c;但是电力设…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023