Crear una lista única y el funcionamiento básico del lenguaje C

Crear una lista única, en primer lugar crear una estructura, de la siguiente manera:

#include <stdio.h> 
#include <stdlib.h> 
typedef int ElemType; 
typedef struct Lnode { 
    datos ElemType; 
    struct Lnode * siguiente; 
Lnode}, * LinkList;

Crear listas, que se utiliza aquí es el establecimiento de la lista de cola de interpolación, es sobre todo agregando constantemente nuevos elementos en el extremo de la mesa, hasta que la entrada -1, entonces la salida.

LinkList CreatList () // 创建列表
{ 
    ElemType X; 
    Cabeza LinkList, p, cola; 
    cabeza = (LinkList) malloc ( sizeof (Lnode)); 
    cabeza -> siguiente = NULL; 
    cola = cabeza; 
    scanf ( " % d " , y x);
    mientras que (x = - 1 ) { 
        p = (LinkList) malloc ( sizeof (Lnode)); 
        p -> data = x; 
        p -> siguiente = NULL; 
        cola -> siguiente = p;
        cola = p; 
        scanf ( " % d " , y x); 
    } 
    Volver la cabeza; 
}

Cálculo longitud de la tabla, el uso de recorrido, la longitud de la lista mediante una variable se almacena, y un puntero de almacenamiento allí.

int longlist (cabeza LinkList, int * longitud) // Cálculo de una larga lista de la segunda del elemento de tabla de la longitud de almacenamiento de tabla 
{ 
    LinkList P; 
    P = (LinkList) la malloc ( el sizeof (LNode)); 
    P = cabeza-> Siguiente;
     IF (P == NULL) {
         retorno  0 ; 
    } 
    int I = 1. ;
     el tiempo (P) { 
        P = p-> Siguiente; 
        I ++ ; 
    }
     * longitud = I- . 1 ; // porque cada uno consultas posteriores a elementos, por lo que también el último NULL he añadido en él, por lo que para reducir un 
    retorno 1 ; 
}

Insertar elemento, insertar elementos de lista única, la lista necesita saber la posición del elemento, y luego insertar la cola primer elemento está conectado a la cadena, entonces el nodo de acceso cabeza.

int INSERT (cabeza LinkList, int I, elemType X) // Insertar una lista de elementos 3 se inserta en la posición de inserción 2 
{ 
    LinkList P, S; 
    P = (LinkList) la malloc ( el sizeof (LNode)); 
    P = cabeza-> Siguiente;
     int = J 1. ;
     el tiempo (P = I- J &&! 1. ) { 
        P = p-> Siguiente; 
        J ++ ; 
    } 
    IF (P == NULL || J = I-! 1. {)
         volver  0 ; 
    } 
    S = (LinkList ) malloc (sizeof (Lnode)); 
    s -> data = x; 
    s -> siguiente = p-> siguiente; 
    p -> siguiente = s;
    volver  1 ; 
}

elementos de eliminar, las necesidades de la lista de nodos para conocer la ubicación del elemento frontal, a continuación, eliminar, borrar y volver a los elementos, sino también a la memoria del nodo se libera.

int DelList (cabeza LinkList, int I, n-elemType *) // eliminar la lista de elementos 1 2 3 registro de ubicación de borrado suprimido elementos 
{ 
    LinkList P, S; 
    P = (LinkList) la malloc ( el sizeof (LNode)); 
    P = cabeza-> Siguiente; 
    S = (LinkList) la malloc ( el sizeof (LNode));
     int J = 1. ;
     el tiempo (! I- J = . 1 && P) { 
        P = p-> Siguiente; 
        J ++ ; 
    } 
    SI (J = I! - . 1 || p> A continuación ==NULL) {
         volver  0 ; 
    } 
    S = p-> siguiente; 
    p -> siguiente = s-> siguiente;
    * n = s-> datos;
    libre (s);
    volver  1 ; 
}

Consulta de los elementos, el uso por la lista para encontrar el elemento que desea encontrar la ubicación y vuelve.

int Búsqueda (cabeza LinkList, int I, n-elemType *) // encontró lo que elementos de posición 2 encontrar una lista de elementos de la posición del elemento 3 es 
{ 
    LinkList P; 
    P = (LinkList) malloc ( sizeof (LNode)); 
    P cabeza- => Siguiente;
     int J = 1. ;
     el tiempo (J = I &&! P) { 
        P = p-> Siguiente; 
        J ++ ; 
    } 
    IF (P == NULL || J =! I) {
         retorno  0 ; 
    }
     = p-n - *> datos;
     retorno  1. ; 
}

La salida de una lista única de todos los elementos.

vacío de impresión (cabezal LinkList) // 输出
{ 
    LinkList p; 
    p = cabeza-> siguiente;
    mientras que (p) { 
        printf ( " % d " , p-> datos); 
        p = p-> siguiente; 
    } 
}

En la creación y el funcionamiento de la lista básica, he vuelto a 0 ó 1, y su función es poner a prueba si una sola lista de operaciones se ajustan a las normas, la operación tiene éxito, devuelve 1, el fracaso, devuelve 0.