ejercicio lista simple

#include <stdio.h>
#include <stdlib.h>

struct nodo {
 char est;
 int cod;
 struct nodo *sig;
};

main()
{
 int i = 0;
 int num;
 char x;
 struct nodo *p,*q;
 printf ("favor digite nombre del estudiante");
 scanf("%s",&x);
 printf ("favor digite codigo del estudiante");
 scanf("%d",&num);
 p=(struct nodo *) malloc (sizeof (struct nodo));
 p->cod=num;
 p->est=x;
 p->sig=NULL;
 
while (i<2){
 q=(struct nodo *)malloc (sizeof(struct nodo));
 printf ("favor digite nombre del estudiante");
 scanf("%s",&x);
 printf ("favor digite codigo del estudiante");
 scanf("%d",&num);
 q->sig=p;
 p=q;
 i++;
} 
}

Lista simple

#include <stdio.h>
#include <stdlib.h>

struct nodo {
 int inf;
 struct nodo *sig;
};

main()
{
 int i = 0;
 int num;
 struct nodo *p,*q;
 printf ("favor digite numero");
 scanf("%d",& num);
 p=(struct nodo *) malloc (sizeof (struct nodo));
 p->inf=num;
 p->sig=NULL;
 
while (i<5){
 q=(struct nodo *)malloc (sizeof(struct nodo));
 printf("Si est an gentil digite el HP numero :");
 scanf("%d",&num);
 q->sig=p;
 p=q;
 i++;
} 
}

lista simple recorrer

#include <stdio.h>
#include <stdlib.h>

struct nodo {
char le;
struct nodo *sig;
};

void recorrer (struct nodo *p){
struct nodo *q;
q=p;
printf("%c",(p->sig));
getchar();
while(q->sig!=NULL){
printf("%c",(q->le));
q=q->sig;
}
}

main()
{
char caracter;
struct nodo *p,*t;
printf ("favor digite caracter");
scanf("%c",& caracter);
p=(struct nodo *) malloc (sizeof (struct nodo));
p->le=caracter;
p->sig=NULL;
t=p;

while (caracter !='.'){
struct nodo *q;
q=(struct nodo *)malloc (sizeof(struct nodo));
printf("favor digite caracter");
scanf("%c",&caracter);
q->le=caracter;
q->sig=NULL;
t->sig=q;
t=q;
}
recorrer (p);
}

Arreglos y estructuras

struct: esta orden se emplea para agrupar variables de tipos iguales o diferentes en un solo registro, con la misma se pueden crear estructuras anónimas, estructuras con nombre, y un tipo especial de estructura conocida como bit-fields ( banderas o campos de bits ).

Las estructuras son colecciones de variables relacionadas bajo un nombre. Las estructuras pueden contener variables de muchos tipos diferentes de datos - a diferencia de los arreglos que contienen unicamente elementos de un mismo tipo de datos. 

----------------------------------------------------------------------------------

struct fecha 

{ 

int dia; 

int mes;

int anio; 

int dia del anio; 

char nombre mes[9]; 

}; 

_____________________________

struct persona

{ 

char nombre[tamanio nombre]; 

char direccion[tamanio dir];

long codigo postal; 

long seguridad social; 

double salario; 

fecha cumpleanios; 

fecha contrato; 

}; 

-----------------------------------------------------------------------------------

 ¿QUE ES UN APUNTADOR? Una de las cosas más difíciles que encuentran los principiantes en C es entender el concepto de apuntadores. El propósito de este documento es dar una introducción sobre apuntadores y de su uso a estos principiantes. Me he encontrado a menudo que la principal razón por la que los principiantes tienen problemas con los apuntadores es que tienen una muy pobre o mínima concepción de las variables, (del modo en que C hace uso de ellas). Así que comencemos con una discusión sobre las variables de C en general. Una variable en un programa es algo con un nombre, que contiene un valor que puede variar. El modo en que el compilador y el enlazador (linker) manejan esto es que asignan un bloque específico de la memoria dentro de la computadora para guardar el valor de una variable. El tamaño de este bloque depende del rango en que a esta variable le es permitido variar. Por ejemplo, en PC’s de 32 bits, el tamaño de una variable de tipo entero (int) es de 4 bytes, en una máquina antigua de 16 bits los enteros tienen un tamaño de 2 bytes. En C el tamaño de un tipo de variable como una de tipo entero no tiene porqué ser el mismo en todos los tipos de máquinas. Es más en C disponemos de diferentes tipos de variables enteras, están los enteros largos (long int) y los enteros cortos (short int) sobre los que puedes averiguar en cualquier texto básico sobre C. El presente documento asume que se está usando un sistema de 32 bits con enteros de 4 bytes. 

 TIPOS DE APUNTADORES Y ARREGLOS Consideremos el porqué tenemos que identificar el "tipo" de variable a la que apunta un puntero como en: int *ptr; Una de las razones para hacer esto es que una vez que ptr apunta a algo y si escribimos: *ptr = 2; El compilador sabrá cuantos bytes va a copiar en la posición de memoria a la que apunta ptr. Si ptr fuera declarado como un puntero a entero, se copiarían 4 bytes. De modo similar para números de punto flotante (float) y enteros dobles (doubles), se copiaría el número apropiado de bytes. Pero definir el tipo al que el apuntador apunta permite un cierto número de maneras interesantes en que el compilador puede interpretar el código. Por ejemplo, consideremos un bloque de memoria consistente en 10 números enteros en una fila. Eso es 40 bytes de memoria son reservados para colocar 10 enteros. Digamos que ahora apuntamos nuestro apuntador entero ptr al primero de estos números enteros. Es más, supongamos que este primer entero está almacenado en la posición de memoria 100 (decimal). Entonces que pasa cuando escribimos: ptr + 1;

otro puede ser.