crear un puntero de función con una forma que no pase a crear listas?

1  // Crear puntero de función con una forma que no pase a crear listas? 
2  
3. #Include <stdio.h>
 4. #Include <stdlib.h>
 5.  Struct la Persona
 6.  {
 7.      Int NUM;
 . 8      struct la Persona * Siguiente;
 . 9  };
 10  
. 11  int main ()
 12 es  {
 13 es      struct la Persona * P = NULL ;
 14      int n-, m;
 15      Scanf ( " % D% D " , y n-, y m);
 16      void Crear ( struct la Persona *,int );     // con struct persona * crear (int); Can 
. 17      int Yue ( struct la Persona *, int , int );
 18 se      Crear (P, n-);                         // para p = crear (n); lata 
19      printf ( " % d \ el n- " , Yue (p-, el n-, m));
 20      de retorno  0 ;
 21  }
 22  
23  sin efecto la Crear ( struct la Persona del * p, int la N-)         // pregunta: ¿por qué de esta manera no se puede crear con éxito la nueva lista? 
24  {
 25      structPersona * p1, p2 *;                // 改为: Persona struct * cabeza, * p1, p2 *; 
26      p1 = ( struct persona *) malloc ( sizeof (persona));
27      int i = 0 ;
28      , mientras que (i < n)
 29      {
 30          i ++ ;
31          P1-> num = i;
32          si (i == 1 ) p = p2 = p1;                // 改为: si (i == 1) cabeza = p2 = p1; 
33          más 
34          {
 35              P2-> siguiente = p1;
36             p2 = p1;
37          }
 38          p1 = ( struct persona *) malloc ( sizeof (persona));
39      }
 40      P2-> siguiente = NULL;
41      libre (p1);
42      p1 = NULL;
43                                          // 加一行: la cabeza de retorno; 
44  }
 45  
46  int Yue ( struct persona * p, int n, int m)
 47  {
 48      int i = 0 , j = 1 , k = 0;
49      struct persona q *, * r;
50      q = r = p;
51      , mientras que (k <n- 1 )
 52      {
 53          i ++ ;
54          j ++ ;
55          
56          Si (i =! 1 ) r = r-> siguiente;
57          si (r == NULL) r = p;
58          
59          q = q-> siguiente;
60          si (q == NULL) q = p;
61          
62          si (j == m)
 63          {
 64              j =1 ;
65              k ++ ;
66              si (q == p)
 67              {
 68                  p = p-> siguiente;
69                  q-> siguiente = NULL;
70                  libre (q);
71                  q = p;
72              }
 73              más  si (q-> siguiente == NULL)
 74              {
 75                  r-> siguiente = NULL;
76                  libre (q);
77                  q = p;
78              }
79              más 
80              {
 81                  r-> siguiente = q-> siguiente;
82                  libre (q);
83                  q = r> siguiente;
84              }
 85          }
 86      }
 87      de retorno q-> num;
88 }