1. Liste à un seul lien: stockage en chaîne d'une liste linéaire.
1) Caractéristiques: utilisez un ensemble d'unités de stockage arbitraires pour stocker les éléments de données (les unités de stockage peuvent être continues ou discontinues), et les emplacements de stockage des éléments logiquement adjacents ne sont pas nécessairement adjacents.
2) Le nœud comprend deux champs: un champ de données (stockage des informations sur les éléments de données) et un champ de pointeur (stockage de l'emplacement de stockage direct successeur)
3) Pointeur ou chaîne: les informations stockées dans le champ du pointeur.
2. Pointeur de tête: emplacement de stockage du premier nœud de la liste liée. L'accès à la liste complète de liens doit commencer à partir du pointeur de tête.
3. Noeud principal: un noeud est attaché avant le premier noeud de la liste liée individuellement, et son champ de données peut ne pas stocker d'informations, mais peut stocker des informations supplémentaires. Si le champ du pointeur est vide, la table linéaire est une table vide.
Les avantages de l'introduction d'un nœud principal:
1) Rendre l'opération à la première position de la liste chaînée cohérente avec l'opération à d'autres positions de la liste.
2) Le traitement des tables vides et des tables non vides est cohérent.
4. Types de nœuds dans des listes liées individuellement
typedef struct LNode {
int data;
struct LNode * next;
} LNode, * Linklist;
5. Liste de
liaison unique LNode * s, * p, * q;
Linklist L;
int i, temp;
1) Insérez le fragment de code du nœud, la complexité temporelle est O (n).
p = GetElem (L, i-1);
s-> next = p-> next;
p-> next = s;
2) Insérez le noeud * s dans le fragment de code avant * p, la complexité temporelle est O ( 1).
s-> suivant = p-> suivant;
p-> suivant = s;
temp = p-> données;
p-> données = s-> données;
s-> données = temp;
3) Supprimer le fragment de code du nœud, , La complexité temporelle est O (n).
p = GetElem (L, i-1);
q = p-> suivant;
p-> suivant = q-> suivant;
libre (q);
4) Supprimer le nœud * p, la complexité temporelle est O (1).
q = p-> suivant;
p-> données = p-> suivant-> données;
p-> suivant = q-> suivant;
libre (q);
6. Utilisez la méthode d'insertion d'en-tête pour établir une liste à liaison unique et inversement établissez une liste à liaison unique L de la fin de la table à la tête de la table, en insérant des éléments après le nœud principal à chaque fois, la complexité temporelle est O (n).
Linklist list_headinsert (Linklist & L)
{
LNode * s;
int x;
L = (Linklist) malloc (sizeof (LNode));
L-> data = NULL;
scanf ("% d", & x);
while (x! = 9999 )
{
s = (LNode *) malloc (sizeof (LNode));
s-> data = x;
s-> next = L-> next;
L-> next = s;
scanf ("% d", & x);
}
return L;
}
7. Utilisez l'interpolation de queue pour créer une liste à liaison unique. De la fin de la table à la tête de la table, une liste à liaison unique est établie dans le sens direct. Chaque fois, un élément est inséré à la fin de la table et la complexité temporelle est O (n).
Linklist List_tailinsert (Linklist & L)
{
int x;
L = (Linklist) malloc (sizeof (LNode));
LNode * s, * r = L; // r est le pointeur de fin de table.
scanf ("% d", & x);
s = (LNode *) malloc (sizeof (LNode));
s-> data = x;
r-> next = s;
r = s;
scanf ("% d", & x);
}
r-> next = NULL;
return L;
}
8. Recherchez la valeur du nœud en fonction du numéro de série et retirez le pointeur du nœud à la i-ème position dans la liste à liaison unique L. La complexité temporelle est O (n).
LNode * GetElem (Linklist L, int i)
{
int j = 1;
LNode * p = L-> suivant;
if (i == 0)
{
return L;
}
if (i <1)
{
return NULL;
}
while ( P && J <I)
{
P = p> Ensuite,
J ++;
}
retour P;
}
. 9, le nœud de table de recherche par la valeur, trouver la liste chaînée unique l de la valeur du champ de données est égal au pointeur de nœud e, la complexité est en O (n ).
LNode * LocateElem (Linklist L, int e)
{
LNode * p = L-> suivant;
while (p! = NULL && p-> data! = e)
{
p = p-> next;
}
return p;
}
10. Trouvez la longueur de la table et la complexité temporelle est O (n).
int listlength (LNode * p)
{
int len = 0;
while (p-> next! = NULL)
{
len ++;
p = p-> next;
}
return len;
}
11. Liste circulaire à liens simples: le pointeur du dernier nœud du tableau pointe vers le nœud principal.
1) Jugement des conditions vides: le pointeur du nœud principal pointe vers le pointeur principal.
2) Réglez le pointeur de tête pour qu'il opère à la fin du tableau, la complexité temporelle est O (n).
3) Réglez le pointeur de queue pour qu'il opère sur la queue et la tête de la table, et la complexité temporelle est O (1).
12. Le nœud de liste à double liaison contient deux champs de pointeur, l'un pointant vers le nœud précurseur et l'autre pointant vers le nœud suivant.
13. Type de nœud de liste à double liaison
typedef struct DNode {
int data;
struct DNode * avant, * suivant;
} DNode, * DLinklist;
14. Double liste chaînée
DNode * m, * k;
1) Insérez un segment d'opération avec une complexité temporelle de O (1).
m-> suivant = k-> suivant;
k-> suivant-> précédent = m;
m-> précédent = k;
k-> suivant = m;
2) Supprimer le segment d'opération, la complexité temporelle est O (1).
m-> suivant = k-> suivant;
k-> suivant-> précédent = m;
libre (k);
15. Liste liée statique: utilisez le tableau pour décrire la structure de stockage chaînée de la table linéaire. Le pointeur est l'adresse relative du nœud (indice de tableau), également appelé curseur.
16. Type de structure de la liste chaînée statique
#define maxsize 50
typedef struct {
int data;
int next;
} slinklist [maxsize];