Une chaîne est-elle une liste linéaire avec des objets de données et des opérations spéciales ?

Oui, la chaîne est une structure de liste linéaire avec des objets de données et des opérations spéciales. La chaîne mentionnée dans la structure de données est une chaîne ; les caractères de la chaîne ont une relation logique "un à un", donc à proprement parler, la structure de stockage de chaîne est une structure de stockage linéaire.

L'environnement d'exploitation de ce tutoriel : système Windows 7, ordinateur Dell G3.

La chaîne mentionnée dans la structure de données, c'est-à-dire une chaîne, est un tout composé de n caractères ( n >= 0 ). Ces n caractères peuvent être composés de lettres, de chiffres ou d'autres caractères.

Dans la structure de données, les chaînes doivent être stockées dans une structure de stockage distincte, appelée structure de stockage de chaînes.

À proprement parler, la structure de stockage de chaîne est également une structure de stockage linéaire, car les caractères de la chaîne ont également une relation logique « un à un ». Cependant, contrairement à la structure de stockage linéaire que nous avons apprise précédemment, la structure de chaîne n'est utilisée que pour stocker des données de type caractère.

Chaînes spéciales

• Chaîne vide : une chaîne contenant zéro caractère. Par exemple : S = "" (rien entre guillemets), généralement exprimé directement par Ø.

• Chaîne d'espace : une chaîne contenant uniquement des espaces. Notez qu'elle est différente de la chaîne vide. Il y a du contenu dans la chaîne d'espace, mais elle contient des espaces et la chaîne d'espace peut contenir plusieurs espaces. Par exemple, a = " " (contient 3 espaces).

• Sous-chaîne et chaîne principale : une chaîne composée de tous les caractères consécutifs de la chaîne est appelée une sous-chaîne de la chaîne, et la chaîne contenant la sous-chaîne est appelée la chaîne principale.

Par exemple : a = "BEI", b = "BEIJING", c = "BJINGEI". Pour les chaînes a et b, puisque b contient la chaîne continue a,

, on peut dire que a est une sous-chaîne de b, et b est la chaîne principale de a et pour c et a, bien que c ; contient également tous les caractères de a, mais pas les "BEI" consécutifs, donc la chaîne c n'a aucune relation avec a.

La position de la sous-chaîne dans la chaîne principale : pour la chaîne a = "BEI", le premier caractère 'B' est à la position 1 dans la chaîne b, donc la sous-chaîne a est dans la chaîne principale b = La position dans "BEIJING" est 1.

La position de la sous-chaîne dans la chaîne principale est différente de la position de stockage des caractères dans le tableau. La position de la sous-chaîne dans la chaîne principale commence à 1.

Critères d'égalité de deux chaînes : Si les valeurs de chaîne de deux chaînes sont exactement les mêmes, alors les deux chaînes sont égales.

Il existe trois structures de stockage pour les chaînes :

Il existe trois structures pour stocker les chaînes :

1 stockage séquentiel de longueur fixe ;

2 stockage d'allocation de tas

3 stockage en chaîne de blocs.

Stockage séquentiel de longueur fixe

Utilisez un tableau de longueur fixe (c'est-à-dire un tableau statique) pour stocker des chaînes.

Par exemple : char a[7] = "abcdfg";

Lorsque vous stockez des chaînes de cette manière, vous devez estimer la longueur de la chaîne et demander suffisamment d'espace de stockage à l'avance. Si la chaîne cible dépasse la longueur demandée par le tableau, la partie excédentaire sera automatiquement supprimée (appelée « troncature »).

Par exemple : char a[3] = "abcdfg";//En fait, seul "abc" est stocké dans le tableau, et les suivants sont tronqués. Stockage alloué au tas

utilise un tableau dynamique pour stocker les chaînes

En langage C, il existe une zone de stockage libre appelée "heap", utilisant la fonction malloc et la gestion des fonctions gratuites , la fonction malloc est responsable de la demande d'espace et la fonction free est responsable de la libération de l'espace.

Par exemple :

char * a = (char*)malloc(5*sizeof(char));//创建 a 数组，动态申请5个 char 类型数据的存储空间

L'avantage d'utiliser le stockage par allocation de tas est que lorsque vous constatez que l'espace appliqué n'est pas suffisant, vous pouvez demander à nouveau un espace de stockage plus grand via la fonction realloc() fonction.

例如：a = (char*)realloc(a, 10*sizeof(char));//前一个参数指申请空间的对象；第二个参数，重新申请空间的大小

L'espace de stockage demandé pour l'utilisation de la fonction malloc ne sera pas libéré automatiquement et le programmeur doit appeler la fonction free() pour le libérer manuellement. S'il n'est pas libéré manuellement, il sera recyclé par le système d'exploitation une fois l'exécution du programme complètement terminée.

例如：free(a);//释放动态数组a申请的空间

Pour donner un exemple complet, les chaînes de connexion "abc" et "defg" deviennent "abcdefg"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main()
{
    char * a1=NULL;
    char * a2=NULL;
    
    a1=(char*)malloc(3*sizeof(char));
    strcpy(a1, "abc");//将字符串“abc”复制给a1
    
    a2=(char*)malloc(3*sizeof(char));
    strcpy(a2, "defg");
    
    int lengthA1=strlen(a1);
    int lengthA2=strlen(a2);
    if (lengthA1<lengthA1+lengthA2) {
        a1=(char*)realloc(a1, (lengthA1+lengthA2)*sizeof(char));
    }
    int i;
    for (i=lengthA1; i<lengthA1+lengthA2; i++) {
        a1[i]=a2[i-lengthA1];
    }
    printf("%s",a1);
    
    free(a1);
    free(a2);
    return 0;
}

Remarque : Dans le programme, Lorsque nous avons attribué des valeurs à a1 et a2, nous avons utilisé la fonction strcpy copy. Il ne peut pas être utilisé directement ici : a1 = "abc".

Si vous faites cela, le programme compilera avec une erreur, vous indiquant que l'espace sans malloc ne peut pas être libéré.

La raison est la suivante : La fonction strcpy copie la chaîne dans l'espace de stockage demandé, tandis que l'affectation directe signifie que la chaîne est stockée dans un autre espace mémoire (lui-même une constante, placée dans la zone constante),

Le pointage des pointeurs a1 et a2 a été modifié. En d'autres termes, bien que l'espace de stockage demandé dynamiquement auparavant ait été demandé, il a été perdu avant d'être utilisé.

Stockage Blockchain

Le stockage Blockchain emprunte en fait la structure de stockage d'une liste chaînée pour stocker des chaînes. Dans des circonstances normales, il suffit d'utiliser une seule liste chaînée et il n'est pas nécessaire d'ajouter un nœud principal.

Lors de la création d'une liste chaînée, chaque nœud peut stocker un ou plusieurs caractères.

链表中最后一个结点的数据域不一定全被串值占满，通常会补上 “#” 或者其他特殊的字符和字符串中的字符区分开。

每个结点设置字符数量的多少和存储的串的长度、可以占用的存储空间以及程序实现的功能相关。

如果串包含数据量很大，但是可用的存储空间有限，那么就需要提高空间利用率，相应地减少结点数量（因为多一个节点，就多申请一个指针域的空间）。

而如果程序中需要大量地插入或者删除数据，如果每个节点包含的字符过多，操作字符就会变得很麻烦，为实现功能增加了障碍。

总结

在平时编写程序，经常会用到例如：char *a = ”abcd”;这种方式表示字符串，和上面三种存储方式最主要的区别是：这种方式用于表示常量字符串，只能使用，不能对字符串内容做修改（否则程序运行出错）；而以上三种方式都可以对字符串进行删改的操作。

例如：

#include <stdio.h>
int main() {
    char* a="abcd";
    a[1]=&#39;b&#39;;
    return 0;
}

程序编译可以通过，运行失败，改成下面堆分配存储的方式就对了：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main() {
    char * a=(char*)malloc(4*sizeof(char));
    strcpy(a, "abcd");
    a[1]=&#39;e&#39;;
    printf("%s",a);
    return 0;
}

三种存储表示方式中，最常用的是堆分配存储，因为它在定长存储的基础上通过使用动态数组，避免了在操作串时可能因为申请存储空间的不足而丢失字符数据；和块链存储方式相比，结构相对简单，更容易操作。

更多计算机编程相关知识，请访问：编程视频！！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!