Lista única de operaciones relacionadas

  . 1 #include <stdio.h>
   2 #include <stdlib.h>
   3. Typedef int elemType;
   . 4 typedef struct LNode {
   . 5      elemType de datos;
   . 6      struct LNode * Siguiente;
   . 7 } LNode, * LinkList;
   . 8  // nueva interpolación cabeza lista 
  . 9 LinkList CreatList1 (LinkList y L)
 10  {
 11.      LNode S *; int X;
 12 es      // lista de nodos de plomo 
13 es      L = (LinkList) la malloc ( el sizeof (LNode));
14      L-> siguiente = NULL;
15      scanf ( " % d " , y x);
16      , mientras que (x =! 9999 ) {
 17          s = (LNode *) malloc ( sizeof (LNode));
18          s-> data = x;
19          s-> siguiente = L-> siguiente;
20          L-> siguiente = s;
21          scanf ( " % d " , y x);
22      }
 23      de retorno L;
24  }
 25  //Tail interpolación nueva lista 
26 es LinkList CreatList2 (LinkList y L)
 27  {
 28      int X;
 29      L = (LinkList) la malloc ( el sizeof (LNode)); // lista el nodo de plomo 
30      LNode S *, R & lt * = L;
 31 es      scanf ( " % D " , y X);
 32      al mismo tiempo que (X =! 9999 ) {
 33 es          S = (LNode *) el malloc ( el sizeof (LNode));
 34 es          S-> Data = X;
 35          R-> Siguiente = S ;
 36         S = R & lt; // R & lt punto a la nueva cola nodo de 
37 [          Scanf ( " % D " , y X);
 38 es      }
 39      R-> Siguiente = NULL;
 40      de retorno L;
 41 es  }
 42 es  // Encuentra el número de nodo por el valor 
43 es LNode getElem * (L LinkList, int I)
 44 es  {
 45      int J = 1. ;
 46 es      LNode * = L-P> Siguiente;
 47      IF (I == 0 ) de retorno L;
 48      IF (I < . 1)     Volver NULL;
49      , mientras que (p && j < i) {
 50          p = p-> siguiente;
51          j ++ ;
52      }
 53      de retorno p;
54  }
 55  // 按值查找
56 LNode * LocateElem (LinkList L, ElemType e)
 57  {
 58      LNode * p = L-> siguiente;
59      , mientras que (! P = NULL && p> Los datos = e) {
 60          p = p-> siguiente;
61      }
 62      de retorno p;
63  }
64  // nuevo nodo se inserta en la i-ésima posición 
65  BOOL ListFrontInsert (LinkList L, int i, elemType E)
 66  {
 67      LinkList getElem P = (L, I- 1. );
 68      IF (P == NULL) de retorno  en false ;
 69      // recién insertado espacio de aplicación del nodo 
70      LinkList S = (LNode *) malloc ( sizeof (LNode));
 71 es      S-> datos = ; E
 72      Siguiente = p-S - >> Siguiente;
 73 es      p-> = Siguiente S;
 74      de retorno  a la verdadera ;
 75  }
76  // eliminar el i-ésimo nodo 
77  BOOL ListDelete (LinkList L, int i)
 78  {
 79      LinkList getElem P = (L, I- 1. );
 80      IF (P == NULL) de retorno  en false ;
 81      LinkList Q;
 82      = p-Q> Siguiente;
 83      p-> = Q Siguiente> Siguiente;
 84      libre (Q);
 85      de retorno  a la verdadera ;
 86  }
 87  // imprimir el valor de cada nodo de lista enlazada 
88  vacío imprimeLista (LinkList L)
 89  {
90      L = L-> Siguiente;
 91 es      el tiempo (L =! NULL) {
 92          printf ( " % 3D " , L-> Datos);
 93          L = L-> Siguiente;
 94      }
 95      printf ( " \ n " );
 96  }
 97  int main ()
 98  {
 99      LinkList L;
 100      LinkList búsqueda;
 101      // nuevo método de interpolación lista cabeza, los datos de entrada puede ser 9999. 7. 6. 5. 4. 3
 102      // CreatList1 (L);
 103      //El nuevo extremo de la interpolación lista, los datos de entrada puede ser 3. 4. 5. 6. 7 9.999. 
104      CreatList2 (L);
 105      printList (L);
 106      Buscar = getElem (L, 2 );
 107      IF (! Buscar = NULL) {
 108          el printf ( " Buscar el éxito número \ n " );
 109          printf ( " % 3D \ n ' , Buscar-> datos);
 110      }
 111      Buscar LocateElem = (L, 6. );
 112      SI ! (search = NULL) {
 113          printf ( " por valor de encontrar el éxito \ n- el " );
 114         la printf ( " % 3D \ n- " , Buscar-> Data);
 115      }
 1 16      ListFrontInsert (L, 2 , 99 );
 117      printList (L);
 1 18      ListDelete (L, 4. );
 119      la printf ( " cuarta unión Delete punto exitosa \ n- " );
 120      printList (L);
 121      del sistema ( " PAUSA " );
 122 }