Código para Grafo

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct nodo{
            char nombre[2];//nombre del vertice o nodo
            struct nodo *sgte;
            struct arista *ady;//puntero hacia la primera arista del nodo
            };
struct nodo *primero=NULL, *ultimo=NULL;
struct arista{
              struct nodo *destino;//puntero al nodo de llegada
              struct arista *sgte;
              };
void insertar_nodo();
void insertar_arista();
void vaciar_aristas();
void eliminar_nodo();
void eliminar_arista();
void mostrar_grafo();
void mostrar_aristas();
void visualizar();

main  (){
 int opcion;
 do{

  printf("\n\n\n");
  printf("\n****************************************");
  printf("\n*******************GRAFO****************");
  printf("\n\n");
  printf("\n1. Insertar un nodo");
  printf("\n2. Insertar un arista");
  printf("\n3. Eliminar un nodo");
  printf("\n4. Eliminar una arista");
  printf("\n5. Mostrar grafo");
  printf("\n6. Mostrar aristas de un nodo");
  printf("\n7. Salir");
  printf("\n8. visualizar nodo");
  printf("\n****************************************\n");
  printf("Ingresar opcion");
  scanf("%d", &opcion);

 
     switch(opcion){
    case 1: insertar_nodo();
                    break;
            case 2: insertar_arista();
                    break;
            case 3: eliminar_nodo();
                    break;
            case 4: eliminar_arista();
                    break;
            case 5: mostrar_grafo();
                    break;
            case 6: mostrar_aristas();
                    break;
            case 7: printf("Salir");
break;
case 8: visualizar ();
break;
default: system("pause");
break;
 
   }
  }
   while (opcion !=8);
}
void insertar_nodo(){
struct nodo *nuevo;
nuevo=(struct nodo*)malloc(sizeof(struct nodo));
if (nuevo == NULL)
printf("\n Memoria insuficiente");
else{
printf("\nINGRESE NODO: ");
    scanf("%s", nuevo->nombre);
       nuevo->sgte = NULL;
    nuevo->ady=NULL;}
 
    if(primero==NULL)
     {
        printf("PRIMER NODO...!!!");
primero = nuevo;
        ultimo = nuevo;
       
      }
    else
     {
      nuevo->sgte=NULL;
ultimo->sgte=nuevo;
ultimo=nuevo;
           while(ultimo->sgte!=NULL)
         {
            ultimo = ultimo->sgte;
          }
     
        printf("NODO INGRESADO...!!!");
      }

 }

 void visualizar(){

struct nodo *actual;
actual=primero;
if(actual==NULL){
printf("\nGrafo vacio");}
else{

while(actual!=NULL){
printf("%s\n",actual->nombre);
actual=actual->sgte;
}}
printf("\n\n\n");
system("pause");
}


/*INSERTAR ARISTA---------------------------------------------------------------------*/
void insertar_arista()
{   char ini[2], fin[2];
    struct arista *nuevo, *q;
    struct nodo *aux, *aux2;
 nuevo=(struct arista*)malloc(sizeof(struct arista));
    if(primero==NULL)
     {
         printf("GRAFO VACIO...!!!!");
         return;
     }else{

    nuevo->sgte=NULL;
    printf("\nINGRESE NODO DE INICIO:");
    scanf("%s", &ini);
    printf("\nINGRESE NODO FINAL:");
    scanf("%s", &fin);
    aux=primero;
    aux2=primero;
    }
    while(aux2!=NULL){
    if(strcmp(fin, aux2->nombre)==0)
        {
          break;
        }else{
         aux2=aux2->sgte;}
    }
    while(aux!=NULL)
    {
   
        if(strcmp(ini, aux->nombre)==0)
        {
    if(aux->ady==NULL)
    {   aux->ady=nuevo;
        nuevo->destino=aux2;
        printf("PRIMERA ARISTA....!");
}
    else
    {  
q=aux->ady;
  while(q->sgte!=NULL)
            q=q->sgte;
        nuevo->destino=aux2;
        q->sgte=nuevo;
        printf("ARISTA AGREGADA...!!!!");
             
    }
    return;
        }

        aux = aux->sgte;
    }
}
 
void eliminar_nodo(){
char var[2];
    struct nodo *aux,*ant;
    aux=primero;
    printf("ELIMINAR UN NODO\n");
    if(primero==NULL)
     {
         printf("GRAFO VACIO...!!!!");
         return;
     }
    printf("INGRESE NOMBRE DE VARIABLE:");
    scanf("%s",var);

    while(aux!=NULL)
    {
        if(strcmp(var, aux->nombre)==0)
        {
            if(aux->ady!=NULL)
                vaciar_aristas();

            if(aux==primero)
            {

                    primero=primero->sgte;
                    free(aux);
                    printf("NODO ELIMINADO...!!!!");
                    return;
             }
            else
            {
                ant->sgte = aux->sgte;
                free(aux);
                printf("NODO ELIMINADO...!!!!");
                return;
            }
        }
        else
        {
            ant=aux;
            aux=aux->sgte;
         }
    }
}
void eliminar_arista(){
char ini[2], fin[2];
    struct nodo *aux, *aux2;
    struct arista *q,*r;
    printf("\n ELIMINAR ARISTA\n");
    printf("INGRESE NODO DE INICIO:");
    scanf("%s",ini);
    printf("INGRESE NODO FINAL:");
    scanf("%s", fin);
    aux=primero;
    aux2=primero;
    while(aux2!=NULL)
    {
        if(strcmp(fin, aux2->nombre)==0)
        {
            break;
        }
        else
        aux2=aux2->sgte;
    }
     while(aux!=NULL)
    {
        if(strcmp(ini, aux->nombre)==0)
        {
            q=aux->ady;
            while(q!=NULL)
            {
                if(q->destino==aux2)
                {
                    if(q==aux->ady)
                        aux->ady=aux->ady->sgte;
                    else
                        r->sgte=q->sgte;
                    free(q);
                    printf("ARISTA  ", aux->nombre, "----->", aux2->nombre, " ELIMINADA.....!!!!");
                    return;
                }
            }
            r=q;
            q=q->sgte;
        }
        aux = aux->sgte;
    }
}
void mostrar_grafo(){
struct nodo *ap;
    struct arista *ca;
    ap=primero;
    printf("NODO|LISTA DE ADYACENCIA\n");
   while(ap!=NULL){
printf("%s| ", ap->nombre);
if(ap->ady!=NULL)
        {
ca=ap->ady;
while(ca!=NULL)
            {  
printf("%s ",ca->destino->nombre);
                ca=ca->sgte; }        }
        ap=ap->sgte;
        printf("\n");}
}
void mostrar_aristas(){
struct nodo *aux;
    struct arista *ar;
    char var[2];
    printf("MOSTRAR ARISTAS DE NODO\n");
    printf("INGRESE NODO:");
    scanf("%s",var);
  aux=primero;
    while(aux!=NULL)
    {
        if(strcmp(var, aux->nombre)==0)
        {
            if(aux->ady==NULL)
            {   printf("EL NODO NO TIENE ARISTAS...!!!!");
                return;
             }
            else
            {
                printf("NODO|LISTA DE ADYACENCIA\n");
                printf("%s  | ",aux->nombre);
                ar=aux->ady;
                while(ar!=NULL)
                {
                    printf(ar->destino->nombre,"  ");
                    ar=ar->sgte;
                                  }
             
                return;
            }
        }
        else
        aux=aux->sgte;
    }
}
void vaciar_aristas(){
struct arista *q,*r;
struct nodo *aux;
aux=primero;
    q=aux->ady;
    while(q->sgte!=NULL)
    {
        r=q;
        q=q->sgte;
        free(r);
    }

Apuntes Arboles

Realizar un resumen del Capitulo 6 Arboles desde la Pág. 176  hasta la pág. 179

Algoritmo de Floyd

#include<stdio.h>
#include<conio.h>
int min(int,int);
void floyds(int p[10][10],int n)
{
 int i,j,k;
 for(k=1;k<=n;k++)
   for(i=1;i<=n;i++)
   for(j=1;j<=n;j++)
    if(i==j)
     p[i][j]=0;
    else
     p[i][j]=min(p[i][j],p[i][k]+p[k][j]);
}
int min(int a,int b)
{
 if(a<b)
  return(a);
 else
  return(b);
}
main()
{
 int p[10][10],w,n,e,u,v,i,j;;
 //clrscr();
 printf("\n Introduce el numero de vertices:");
 scanf("%d",&n);
 printf("\n Introduce el número de aristas:\n");
 scanf("%d",&e);
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=n;j++)
   p[i][j]=999;
 }
 for(i=1;i<=e;i++)
 {
  printf("\n Introduzca los vértices finales de primera línea %d con suetiqueta de costo \n",i);
  scanf("%d%d%d",&u,&v,&w);
  p[u][v]=w;
 }
 printf("\n Matriz de datos de entrada:\n");
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=n;j++)
   printf("%d \t",p[i][j]);
  printf("\n");
 }
 floyds(p,n);
 printf("\nClausura transitiva:\n");
 for(i=1;i<=n;i++)
 {
  for(j=1;j<=n;j++)
   printf("%d \t",p[i][j]);
  printf("\n");
 }
 printf("\nLas rutas más cortas son:\n");
 for(i=1;i<=n;i++)
  for(j=1;j<=n;j++)
  {
   if(i!=j)
    printf("\n <%d,%d>=%d",i,j,p[i][j]);
  }
 getch();
}

Apunte de libro Estructuras de datos

Pagina 277 Gráficas desde el punto  7.2 Definicion de graficas ,7.3 Conceptos basicos (todos)
y pagina 280 desde la imagen hasta antes de gráficas dirigidas.

Estructuras de Datos

Libro en linea
http://www.colegiodrriodelaloza.edu.mx/informatica/Manejo%20de%20memoria%20en%20la%20estructura%20de%20datos/95950672-Estructura-de-Datos-Tercera-Edicion.pdf

Código para Listas Circulares Doblemente Enlazadas

#include <stdio.h>
#include <stdlib.h>//utilizar symtem cls limpiar pantralla y system pause salir mediante tecla
#include <string.h>//comparar cadenas de caracteres
struct nodo{
char nombre[40];

struct nodo *siguiente;
struct nodo *anterior;
};
struct nodo *primero=NULL, *ultimo=NULL;

int numNodos=0;
int pos;
void insertarUltimo();
void insertarPrimero();
void insertarIntermedio ();
void visualizarInicioFinal ();
void visualizarFinalInicio ();
void visualizarPosicionFinal ();
void visualizarPosicionInicio ();
void visualizarPrimeroUltimo ();
void Buscar ();
void Eliminar ();
main(){
int opcion;
do{
system ("cls");
printf("");
printf("\n  *******LISTA CIRCULAR DOBLEMENTE ENLAZADA********\n");
printf("\n  ****ITIC. ANA FRANCISCA MARTINEZ BETANCOURT*****\n\n");
printf("\n  1. Insertar al Final                  *");
printf("\n  2. Insertar al Inicio               *");
printf("\n  3. Insertar  en X posicion         *");
printf("\n  4. Visualizar  de Inicio - Fin           *");
printf("\n  5. Visualizar de  Fin - Inicio          *");
printf("\n  6. Visualizar Desde X Posicion al Final *");
printf("\n  7. Visualizar desde X Posicion al Inicio*");
printf("\n  8. Visualizar Primero y ultimo        *");
printf("\n  9. Buscar                         *");
printf("\n  10.Eliminar                        *");
printf("\n  11.Salir                                       *");
printf("\n");
printf("\n  ************************************************");
printf("\n\n\n");
printf("\n Elija una opcion    ");
scanf("%d", &opcion);

switch (opcion){

case 1: insertarUltimo ();
break;
case 2: insertarPrimero ();
break;
case 3: insertarIntermedio ();
break;
case 4: visualizarInicioFinal ();
break;
case 5: visualizarFinalInicio ();
break;
case 6: visualizarPosicionFinal ();
break;
case 7: visualizarPosicionInicio ();
break;
case 8: visualizarPrimeroUltimo ();
break;
case 9: Buscar ();
break;
case 10: Eliminar ();
break;
case 11: printf ("Salir");
break;
default: system ("cls");
break;
}
} while (opcion !=11);
}

void insertarUltimo(){
system ("cls");
struct nodo *nuevo;

nuevo=(struct nodo*)malloc(sizeof( struct nodo));
if ((nuevo==NULL))
printf ("\n MEMORIA INSUFICIENTE\n");
else{
printf ("\n Nombre:  ");
fflush (stdin);
gets(nuevo->nombre);
nuevo->siguiente=primero;
if (primero==NULL)
{
primero=nuevo;
ultimo=nuevo;
nuevo->anterior=ultimo;
nuevo->siguiente=primero;

}else{
nuevo->siguiente=primero;
nuevo->anterior=ultimo;
ultimo->siguiente=nuevo;
ultimo=nuevo;
primero->anterior=ultimo;
}
}
numNodos++;
}
void insertarPrimero(){
system ("cls");
struct nodo *nuevo;
nuevo=( struct nodo*)malloc (sizeof( struct nodo));
if (nuevo==NULL)
printf("MEMORIA INSUFICIENTE\n");
else{
printf("\n Nombre:  ");
fflush(stdin);
gets(nuevo->nombre);
ultimo->siguiente=nuevo;
if (ultimo==NULL)
{
primero=nuevo;
ultimo=nuevo;
nuevo->anterior=ultimo;
nuevo->siguiente=primero;

}else{
nuevo->anterior=ultimo;
nuevo->siguiente=primero;
primero->anterior=nuevo;
primero=nuevo;
numNodos++;}

}
}
void insertarIntermedio (){
system ("cls");
struct nodo *actual;
struct nodo *nuevo;
nuevo =( struct nodo*)malloc(sizeof( struct nodo));
if (nuevo==NULL)
printf("\n MEMORIA INSUFUCIENTE\n");
if (numNodos <2)
printf ("\n Número de nodos insuficiente");
else{
int pos_insertar;
printf("\n Nombre:   ");
fflush(stdin);
gets(nuevo->nombre);
printf ("\n Posicion:  ");
scanf ("%d", &pos_insertar);
if((pos_insertar >1) &&(pos_insertar <= numNodos)){
actual=primero;
for (pos = 2; pos <pos_insertar; ++pos)
actual= actual->siguiente;
nuevo->siguiente= actual->siguiente;
nuevo->anterior = actual;
actual->siguiente->anterior = nuevo;
actual->siguiente = nuevo;
numNodos++;
}
}
printf("\n\n\n\n\n\n\n");
system("pause");
}
void visualizarInicioFinal (){
system ("cls");
struct nodo *actual;
pos=1;
actual=primero;
while(pos<=numNodos){

printf("\n\n");
printf(" %d.- ", pos);
printf(" Nombre:  %s", actual->nombre);
printf("\n");
actual= actual->siguiente;
pos++;
}
if(numNodos==0)
printf("\n LISTA VACIA");
printf("\n\n\n\n\n\n\n");
system("pause");
}
void visualizarFinalInicio (){
system("cls");
struct nodo *actual;
actual=ultimo;
pos= numNodos;
printf("\nITIC Ana Francisca Martínez Betancourt");
printf("\n\n");
while (pos >0){
printf(" %d.- ", pos);
printf("Nombre: %s ",actual->nombre);
printf("\n\n");
actual =actual->anterior;
pos--;
}
if(numNodos==0)
printf("\n LISTA VACIA");
printf("\n\n\n\n\n\n\n");
system("pause");
}
void visualizarPrimeroUltimo (){
system("cls");
if(numNodos==0)
printf("\n LISTA VACIA");
else
printf("\n PRIMERO ------->  Nombre: %s ", primero->nombre);
printf("\n");
printf("\n ULTIMO  ------> Nombre: %s ", ultimo->nombre);
printf("\n\n\n\n\n\n\n");
system ("pause");
}
void visualizarPosicionFinal (){
system("cls");
int p=1;
int posicion;
struct nodo *actual;
actual = primero;
printf("\n Indique posicion     ");
scanf("%d", &posicion);
system("cls");
for (pos = 2; pos<=posicion; pos++){
actual = actual->siguiente;
}
while (p <= numNodos){
// printf("%d.-", posicion);
printf(" Nombre: %s\n ", actual->nombre);
actual = actual->siguiente;
p++;
}
printf("\n\n\n\n\n\n\n");
system("pause");
}
void visualizarPosicionInicio (){
system("cls");
    int p=1;
int posicion;
struct nodo *actual;
actual = primero;
printf ("\n Indique posicion   ");
scanf("%d",&posicion);
system ("cls");
for (pos = 2; pos <=posicion; pos++){
actual  = actual->siguiente;
}
//posicion = pos;
while (p <= numNodos){
//printf("%d.-", posicion);
printf(" Nombre: %s\n ", actual->nombre);
actual = actual->anterior;
p++;
}
printf("\n\n\n\n\n\n\n");
system("pause");
}
void Buscar (){
system("cls");
struct nodo *actual;
char aux [40];
int p = 1;
int encontrado =0;
actual = primero;
system("cls");
printf("\n Indique nombre a buscar  ");
fflush(stdin);
gets(aux);
system("cls");
while (p <= numNodos){
if(strcmp(aux, actual->nombre)==0){
printf("\n Contacto  %s EXISTE", aux);
printf("\n *** Datos del contacto ***");
printf("\n Nombre:  %s", actual->nombre);
encontrado =1;
}
p++;
actual = actual->siguiente;
}
if (encontrado==0)
printf("\n %s NO EXISTE", aux);
printf("\n\n\n\n\n\n\n");
system("pause");
}
void Eliminar (){
system("cls");
struct nodo *aux;
struct nodo *actual;
int nodo_eliminar;
int x;
printf("\n Indique la posicion del nombre a eliminar ");
scanf(" %d", &nodo_eliminar);
if (nodo_eliminar > numNodos || nodo_eliminar < 1)
printf("Elemento inexistente");
if (nodo_eliminar == 1){
aux = primero;
primero = primero->siguiente;
if (primero == NULL)
ultimo = NULL;
else
primero ->anterior == NULL;
}
else if (nodo_eliminar == numNodos){
aux = ultimo;
ultimo->anterior->siguiente = NULL;
ultimo = ultimo->anterior;
}else{
actual = primero;
for (x=1; x<nodo_eliminar; ++x)
actual = actual->siguiente;
aux = actual;
actual->anterior->siguiente = actual->siguiente;
actual->siguiente->anterior = actual->anterior;
}
free(aux);
numNodos--;
}