Redis source Learning (25), double end Link List Learning, adlist. H

Sens sans trace 2022-05-14 10:52:35 阅读数:278

redissourcelearningdoubleend

Préface

Terminé.SDSAprès,On a compris.RedisStructure de données sous - jacente de la chaîne,C'est exact.RedisIl y a une compréhension simple de certains traitements pour améliorer les performances,C'est un très bon début,Mais c'est encore la pointe de l'iceberg,Nous avons encore beaucoup à apprendre.

Je crois que j'ai fini.SDSAprès,Tout le monde, comme moi, devrait avoir beaucoup de confiance,La structure des données n'est pas si difficile non plus, n'est - ce pas,La prochaine chose que nous allons apprendre est la liste à double extrémité,C'est l'une des structures de données sous - jacentes qui implémente la liste,Il suffit de trouver une liste à deux extrémités et de revenir en arrière pour examiner certaines des façons dont nous avons appris la liste avant,Ça devrait être plus clair.

RedisLe Code de la liste à double extrémité est placé dansadlist.hEtadlist.cDans les deux fichiers,Voici une petite question pourquoi le nom du fichier estadlistEt alors??En fait, la réponse se trouve au début des deux sources.

 adlist.h - A generic doubly linked list implementation

Ce que ça veut dire.,Une mise en œuvre universelle de la liste de liens bidirectionnels

1 Liste à double extrémité

Les petits partenaires qui ont appris la structure des données devraient savoir ce qu'est une liste à double extrémité,Voici un bref aperçu de la liste à deux extrémités,Il est plus facile d'avoir un concept simple avant de regarder le Code.

Tout d'abord, la liste ressemble à la chaîne que nous voyons habituellement,C'est quelque chose qui est connecté par un noeud après l'autre.

Après avoir compris ce qu'est la liste,Encore une fois, il est facile de comprendre la liste à double extrémité, Une liste à double extrémité signifie que chaque noeud a un pointeur vers le noeud précédent et le noeud suivant , De cette façon, la liste peut être parcourue dans les deux directions , La liste à chaîne unique est un pointeur vers le noeud suivant, qui ne peut être traversé qu'en arrière .

2 Définition de la structure

Autant en parler que de passer au Code. ,Voyons voir.Redis Comment est - ce possible? .

/* Node, List, and Iterator are the only data structures used currently. */
// Définition de la structure du noeud de liste à deux extrémités 
typedef struct listNode {

struct listNode *prev;// Pointeur vers le noeud précédent 
struct listNode *next;//Pointeur vers le noeud suivant
void *value;//Pointeur vers la valeur
} listNode;
typedef struct list {

listNode *head; //Pointeur vers le noeud de tête
listNode *tail; //Pointeur vers le noeud de queue
void *(*dup)(void *ptr); // Pointeur vers une fonction de copie 
void (*free)(void *ptr);// Pointeur vers une fonction de libération 
int (*match)(void *ptr, void *key);// Pointeur vers une fonction correspondante 
unsigned long len;//Nombre de noeuds
} list;

Voici deux structures ,Respectivement.listNode Et list , L'un est le noeud de liaison ,L'un est une liste de liens.

Total des noeuds de liste liés 3Propriétés, Un pointeur vers le noeud précédent , Un pointeur vers le noeud suivant , Enfin, il y a un pointeur vers la valeur , Avec ces trois attributs, vous pouvez organiser un simple noeud de liste liée , Il est également possible de concaténer d'autres noeuds .

Il y a au total 6Propriétés, Les deux premiers sont bien compris. , Un pointeur vers le noeud de tête , Un pointeur vers le noeud de queue ,Derrière3 C'est un peu difficile à comprendre. , Pour l'instant, il suffit de savoir ce qui se passe. 3 Une fonction suffit. , Copie, respectivement 、Release、Fonction de correspondance. Enfin, il y a un attribut pour le nombre de noeuds , Apparemment, cet attribut vous permet d'obtenir rapidement le nombre de noeuds de liste liés .

3 adlist.h Apprendre

3.1 adlist.h Code source

#ifndef __ADLIST_H__
#define __ADLIST_H__
/* Node, List, and Iterator are the only data structures used currently. */
typedef struct listNode {

struct listNode *prev;
struct listNode *next;
void *value;
} listNode;
typedef struct listIter {

listNode *next;
int direction;
} listIter;
typedef struct list {

listNode *head;
listNode *tail;
void *(*dup)(void *ptr);
void (*free)(void *ptr);
int (*match)(void *ptr, void *key);
unsigned long len;
} list;
/* Functions implemented as macros */
#define listLength(l) ((l)->len)
#define listFirst(l) ((l)->head)
#define listLast(l) ((l)->tail)
#define listPrevNode(n) ((n)->prev)
#define listNextNode(n) ((n)->next)
#define listNodeValue(n) ((n)->value)
#define listSetDupMethod(l,m) ((l)->dup = (m))
#define listSetFreeMethod(l,m) ((l)->free = (m))
#define listSetMatchMethod(l,m) ((l)->match = (m))
#define listGetDupMethod(l) ((l)->dup)
#define listGetFree(l) ((l)->free)
#define listGetMatchMethod(l) ((l)->match)
/* Prototypes */
list *listCreate(void);
void listRelease(list *list);
list *listAddNodeHead(list *list, void *value);
list *listAddNodeTail(list *list, void *value);
list *listInsertNode(list *list, listNode *old_node, void *value, int after);
void listDelNode(list *list, listNode *node);
listIter *listGetIterator(list *list, int direction);
listNode *listNext(listIter *iter);
void listReleaseIterator(listIter *iter);
list *listDup(list *orig);
listNode *listSearchKey(list *list, void *key);
listNode *listIndex(list *list, long index);
void listRewind(list *list, listIter *li);
void listRewindTail(list *list, listIter *li);
void listRotate(list *list);
/* Directions for iterators */
#define AL_START_HEAD 0
#define AL_START_TAIL 1
#endif /* __ADLIST_H__ */

3.2 listIter

Dans le code source, sauf que vous pouvez voir listNodeEtlist On a aussi trouvé une structure ,listIter C'est la définition de la structure d'un Itérateur de liste lié , Utilisé lors de la traversée d'une liste liée .

typedef struct listIter {

listNode *next;
int direction;
} listIter;
/* Directions for iterators */
#define AL_START_HEAD 0
#define AL_START_TAIL 1

listIterIl n'y a que deux attributs dans, Un pointeur vers le noeud suivant , L'un est la valeur de la direction , Les directions sont définies comme suit: AL_START_HEAD Et AL_START_TAIL , Ça commence à la tête ou à la queue .

3.2 Méthode macro

Certaines méthodes sont définies directement dans le code source à l'aide de macros , Voyons ce que ces méthodes peuvent faire .

#define listLength(l) ((l)->len)
#define listFirst(l) ((l)->head)
#define listLast(l) ((l)->tail)
#define listPrevNode(n) ((n)->prev)
#define listNextNode(n) ((n)->next)
#define listNodeValue(n) ((n)->value)
#define listSetDupMethod(l,m) ((l)->dup = (m))
#define listSetFreeMethod(l,m) ((l)->free = (m))
#define listSetMatchMethod(l,m) ((l)->match = (m))
#define listGetDupMethod(l) ((l)->dup)
#define listGetFree(l) ((l)->free)
#define listGetMatchMethod(l) ((l)->match)
  • listLength: Obtenir le nombre de noeuds de liste ,Retour à la ListelenPropriétés.
  • listFirst: Obtient un pointeur vers un noeud d'en - tête de liste ,Retour à la ListeheadPropriétés.
  • listLast: Obtient un pointeur vers le noeud de queue de la Liste ,Retour à la ListetailPropriétés.
  • listPrevNode: Obtient le pointeur du noeud précédent ,Retour à la ListeprevPropriétés.
  • listNextNode: Obtient le pointeur du noeud suivant ,Retour à la ListenextPropriétés.
  • listNodeValue: Pointeur pour obtenir la valeur du noeud ,Retour à la ListevaluePropriétés.
  • listSetDupMethod: Définir la fonction de copie .
  • listSetFreeMethod: Définir la fonction de libération .
  • listSetMatchMethod: Définir la fonction de correspondance .
  • listGetDupMethod: Obtenir la fonction de copie .
  • listGetFree: Obtenir la fonction de libération .
  • listGetMatchMethod: Obtenir la fonction correspondante .

3.3 Signature de la méthode

list *listCreate(void);
void listRelease(list *list);
list *listAddNodeHead(list *list, void *value);
list *listAddNodeTail(list *list, void *value);
list *listInsertNode(list *list, listNode *old_node, void *value, int after);
void listDelNode(list *list, listNode *node);
listIter *listGetIterator(list *list, int direction);
listNode *listNext(listIter *iter);
void listReleaseIterator(listIter *iter);
list *listDup(list *orig);
listNode *listSearchKey(list *list, void *key);
listNode *listIndex(list *list, long index);
void listRewind(list *list, listIter *li);
void listRewindTail(list *list, listIter *li);
void listRotate(list *list);
  • listCreate:Créer une liste de liens.
  • listRelease: Libérez une liste de liens .
  • listAddNodeHead: Ajouter un noeud à l'en - tête de la liste .
  • listAddNodeTail: Ajouter un noeud à la fin de la liste .
  • listInsertNode: Ajouter un noeud avant et après un noeud dans la liste .
  • listDelNode:Supprimer un noeud.
  • listGetIterator:Obtenir l'Itérateur de liste.
  • listNext: Obtenir la liste suivante .
  • listReleaseIterator: Libérez l'Itérateur de liste .
  • listDup:Copier une liste.
  • listSearchKey: Rechercher un noeud .
  • listIndex: Renvoie un noeud par index .
  • listRewind: Réinitialiser l'Itérateur à l'en - tête .
  • listRewindTail: Réinitialiser l'Itérateur à la queue .
  • listRotate:Rotation de la Liste .

4 Résumé de l'étude

  1. listNode Est la définition de la structure d'un noeud de liste lié ,Il a trois propriétés, Les pointeurs du noeud précédent 、Pointeur vers le noeud suivant、Pointeur de valeur.
  2. list Est la définition de la structure de la liste liée , Il a six familiarités , Pointeur pour chaque noeud de tête et de queue , Et un pointeur vers trois fonctions , Enfin, le nombre de noeuds de liste .
  3. listIter Est la définition de la structure de l'Itérateur de liste liée , Il a deux familiarités , Un pointeur vers le noeud suivant , L'autre est la direction de traversée .
  4. sds.h Il y a quelques méthodes macroscopiques ,Par exemplelistLength、listFirst、listLast、listPrevNode、listNextNode、listNodeValue.
Copyright:Cet article est[Sens sans trace]Établi,Veuillez apporter le lien original pour réimprimer,remercier。 https://fra.fheadline.com/2022/134/202205141050489885.html