Créer une liste unique et le fonctionnement de base de la langue C

Créer une liste unique, tout d'abord créer une structure, comme suit:

#include <stdio.h> 
#include <stdlib.h> 
typedef int ElemType; 
typedef struct inode { 
    données ElemType; 
    struct inode * suivant; 
} Inode, * LinkList;

Créer des listes, utilisé ici est la mise en place de la liste d'interpolation de la queue, il est principalement ajoute constamment de nouveaux éléments à la fin de la table, jusqu'à ce que l'entrée -1, puis la sortie.

LinkList CreatList () // 创建列表
{ 
    ElemType x; 
    Tête LinkList, p, queue; 
    tête = (LinkList) malloc ( sizeof (noeud limite)); 
    tête -> suivant = NULL; 
    queue = tête; 
    scanf ( " % d " , et x);
    tandis que (x = - 1 ) { 
        p = (LinkList) malloc ( sizeof (inode)); 
        p -> data = x; 
        p -> suivant = NULL; 
        tail -> next = p;
        queue = p; 
        scanf ( " % d " , et x); 
    } 
    Retourner la tête; 
}

longueur de la table de calcul, l'utilisation de la traversée, la longueur de la liste à l'aide d'une variable est stockée, et un stockage de pointeur là.

int longlist (tête de LinkList, int * longueur) // calcul d'une longue liste du deuxième élément de table de la longueur de mémorisation de table 
{ 
    LinkList P; 
    P = (LinkList) le malloc ( le sizeof (noeud limite)); 
    P = BANDEAUX> Suivant;
     IF (P == NULL) {
         retour  0 ; 
    } 
    int I = 1. ,
     le tout en (P) { 
        P = p> Ensuite, 
        je ++ ; 
    }
     * = longueur I . 1 ; // parce que chaque requêtes ultérieures éléments, donc aussi la dernière NULL i ajouté dans, pour ainsi réduire un 
    retour 1 ; 
}

Insert élément insert liste unique des éléments, la liste doit connaître la position de l'élément, puis insérer la queue premier élément est relié à la chaîne, puis l'accès au noeud de tête.

int INSERT (tête de LinkList, int I, elemType X) // Insérer un élément liste 3 est insérée dans la position d'insertion 2 
{ 
    LinkList P, S; 
    P = (LinkList) le malloc ( le sizeof (noeud limite)); 
    P = BANDEAUX> Suivant;
     int = J 1. ;
     pendant ce temps (P = I J &&! 1. ) { 
        P = p> Ensuite, 
        J ++ ; 
    } 
    IF (P == NULL || J = I! 1. {)
         retour  0 ; 
    } 
    S = (LinkList ) malloc (sizeof (noeud limite)); 
    s -> data = x; 
    s -> suivant = P-> suivant; 
    p -> next = s;
    retourner  1 ; 
}

éléments Supprimer, les besoins de nœud de liste pour connaître l'emplacement de l'élément avant, puis supprimer, supprimer et revenir aux éléments, mais aussi à la mémoire de nœud est libéré.

int DelList (tête de LinkList, int I, n-elemType *) // supprimer la liste des éléments 1 2 3 enregistrement d'emplacements de suppression supprimé éléments 
{ 
    LinkList P, S; 
    P = (LinkList) le malloc ( le sizeof (noeud limite)); 
    P = BANDEAUX> Ensuite, 
    S = (LinkList) malloc ( le sizeof (inode));
     int J = 1. ;
     le tout (! I J = . 1 && P) { 
        P = p> Ensuite, 
        J ++ ; 
    } 
    IF (J = I! - . 1 || P-> Suivant ==NULL) {
         retour  0 ; 
    } 
    S = P-> suivant; 
    p -> next = s-> suivante;
    * n = s-> données;
    libre (s);
    retourner  1 ; 
}

Requête éléments, utilisez la liste pour trouver l'élément que vous voulez trouver l'emplacement et les retours.

int Recherche (tête de LinkList, int I, n-elemType *) // Trouver Quels sont les éléments de position 2 trouver une liste d'éléments sur la position de l'élément 3 est 
{ 
    LinkList P; 
    P = (LinkList) malloc ( le sizeof (inode)); 
    P BANDEAUX => suivant;
     int J = 1. ;
     le tout (J = I &&! P) { 
        P = p> Ensuite, 
        J ++ ; 
    } 
    IF (P == NULL || J =! I) {
         retour  0 ; 
    }
     = p-n - *> données;
     rendement  1. ; 
}

La sortie d'une liste unique de tous les éléments.

vide impression (tête de LinkList) // 输出
{ 
    LinkList p; 
    p = BANDEAUX> suivante;
    tandis que (p) { 
        printf ( " % d " , p-> données); 
        p = p-> suivante; 
    } 
}

Dans la création et le fonctionnement de la liste de base, je suis revenu à 0 ou 1, et son rôle est de vérifier si une liste unique des opérations sont conformes aux règles, l'opération est réussie, retourne 1, échec, retourne 0.