Buscar este blog

16 de enero de 2010

#include 
#include //malloc, free
#include 
//#include  //kbhit, clrscr (No es ANSIC)
#include 

enum boolean {FALSE, TRUE};

typedef struct _primos{  //Así lo puedo referenciar aquí dentro
  unsigned long int num;
  struct _primos *siguiente; //Aún no está definido el tipo
  } primos;  //Nombre del nuevo tipo

primos *primero, *ultimo; //Estas son las variables globales

void imprimir_primos ();
void liberar();
boolean esprimo (unsigned long int i);
boolean insertar_primo (unsigned long int x);
void leer_fichero_txt ();
void guardar_fichero_txt();
void menu();
void contar();


void main()
{
unsigned long int i=3, max;
char opcion;
boolean salir = FALSE;
clock_t start, end;
start = clock();


//1 primo//
primero = (primos *) malloc (sizeof (primos));
primero -> siguiente = NULL;
primero -> num = 1;
ultimo = primero;
/////
insertar_primo (2); /*caso raro, para tener referencia*/


do{
//   clrscr(); //No es ANSCI C
   menu();
   fflush (stdin);
   opcion = getc(stdin);

   switch (opcion)
      { 
//Esta función la he comentado por no ser ANSIC por el kbhit()//
/*      case '1':   puts ("CALCULANDO..."); 
        start = clock(); 

        for (; !kbhit(); i+=2 ) 
           { 
         if (esprimo(i)) 
            { 
            if (!insertar_primo (i)) break;; 
            } 
           } 
        end = clock(); 
 printf ("\aFINALIZADO\n\nÚltimo nº comprobado: 
 %li\nTiempo empleado: %f\nPresiona una tecla para continuar"
 , i, (end-start)/ CLK_TCK);
 fflush(stdin);
 getc(stdin);
      // break; */

      case '2':   printf ("\n Hasta qué nº quieres buscar?  ");
 scanf ("%li", &max);
 puts ("CALCULANDO...");
 start = clock();
 for (; i < max; i=i+2 )
    {
  if (esprimo(i))
     {
     if (!insertar_primo (i)) break;
     }
    }
       end = clock ();
       printf ("\aFINALIZADO\n\nÚltimo nº comprobado:
 %li\nTiempo empleado:
     %f\nPresiona una tecla para continuar", i, (end-star
t) / CLK_TCK);
       fflush(stdin);
       getc(stdin);
       break;
      case '3': leer_fichero_txt (); break;
      case '4': guardar_fichero_txt (); break;
      case '5': imprimir_primos (); break;
      case '6': salir = TRUE; break;
      case '7': contar(); break;
      default : puts ("OPCION INCORRECTA");
      }
  } while (!salir);
liberar();
}


boolean esprimo (unsigned long int i)
{
unsigned long int max;
primos *aux;
max = (long int) (sqrt (i)); 
//Probamos los menores o igual a la raíz

aux = primero->siguiente; /*apunto al 2*/

while (aux -> num <= max)
//aux no puede ser NULL pq nunca será el último elemento
  {
  if (i % aux -> num == 0) return FALSE;
  aux = aux -> siguiente;
  }
  return TRUE;
}


void imprimir_primos ()
{
primos *aux;
aux = primero;

while (aux -> siguiente != NULL)
  {
  printf ("%5li ",aux->num);
  aux = aux -> siguiente;
  }

getc(stdin);
}


boolean insertar_primo (unsigned long int x)
{
primos *aux;

if ((aux = (primos *) malloc (sizeof (primos)))!=NULL)
//reservo memoria para siguiente primo
   {
   ultimo -> siguiente = aux;      //último apunta al siguiente
   ultimo = aux;                   //último primo es el nuevo
   ultimo -> num = x;              //inserto el número en último
   ultimo -> siguiente = NULL;     //último apunta a NULL
   return TRUE;
   }
else
   {
   printf ("\n\nOUT OF MEMORY\n");
   return (FALSE);
   }
}


void liberar()
{
primos *aux, *ant;
ant = primero;
for (aux = primero->siguiente; aux != NULL; aux = aux->siguiente)
   {
   free (ant);
   ant = aux;
   }
}

void menu()
{
puts ("\nMenu");
puts ("====\n");
//puts ("1-Calcular números primos hasta que presionemos una tecla");
//La opción1 utiliza kbhit que no es ANSIC
puts ("2-Calcular hasta un nº primo");
puts ("3-Cargar fichero de números primos");
puts ("4-Guardar primos en fichero");
puts ("5-Imprimir números primos calculados hasta el momento");
puts ("6-Salir");
puts ("7-Contar memoria");
}


void leer_fichero_txt ()
{
unsigned long i;
FILE *f;

if ((f = fopen ("primos.txt", "rt")) != NULL)
   {
   fscanf (f, "%li ", &i);
   fscanf (f, "%li ", &i); //as¡ ya he leido hasta el 2
   printf ("\n\nLeyendo fichero primos.txt");
   while (!feof(f))
      {
      fscanf (f, "%li ", &i);
      insertar_primo(i);
      }
   printf ("\nFichero leido\nPresiona cualquier tecla 
para continuar");
   fclose(f);

   }
else printf ("\n\nERROR AL ABRIR EL FICHERO");
getc(stdin);
}


void guardar_fichero_txt ()
{
primos *aux;
FILE *f;

if ((f = fopen ("primos.txt", "wt")) != NULL)
   {
   printf ("\n\nGuardando primos.txt");
   for (aux = primero; aux != NULL; aux = aux -> siguiente)
      {
      fprintf (f, "%li ", aux -> num);
      }
   printf ("\nFichero guardado\nPresiona cualquier
   tecla para continuar");
   fclose(f);
   }
else (printf ("\n\nERROR AL GUARDAR EL FICHERO"));
getc(stdin);
}



void contar ()
{

primos *aux;
unsigned long i = 0;

for (aux = primero; aux != NULL; aux = aux -> siguiente)
   {
   i++;
   }

printf ("\n\nHay un total de %li nums primos\n
Ocupan %li * %i bytes = %li bytes", i, i, sizeof(primos),
 i*sizeof(primos));
getc(stdin);
}
Publicado por en No hay comentarios:
Etiquetas: 
#include 
#include 
#include  //exit()
#include 

typedef struct _agenda {
  char nombre[20];
  char telefono[12];
  _agenda *siguiente;
  };

void mostrar_menu();
void anadir_elemento();
void mostrar_lista();


_agenda *primero, *ultimo;
/*De momento lo haremos con variables globales,
más adelante veremos como pasar punteros a funciones*/

void main() {
char opcion;

primero = (_agenda *) NULL;
ultimo = (_agenda *) NULL;
do {
   mostrar_menu();
   opcion = getch();
   switch ( opcion ) {
      case '1': anadir_elemento();
      break;
      case '2':  printf("Ir pensando como hacer esto :D\n");
      break;
      case '3': mostrar_lista();
      break;
      case '4': exit( 1 );
      default: printf( "Opción no válida\n" );
      break;
      }
   } while (opcion!='4');
}


void mostrar_menu() {
printf("\n\nMenú:\n=====\n\n");
printf("1.- Añadir elementos\n");
printf("2.- Borrar elementos\n");
printf("3.- Mostrar lista\n");
printf("4.- Salir\n\n");
printf("Escoge una opción: ");fflush(stdin);
}

/* Con esta función añadimos un elemento al final de la lista */
void anadir_elemento() {
_agenda *nuevo;
/* reservamos memoria para el nuevo elemento */
nuevo = (_agenda *) malloc (sizeof(_agenda));
if (nuevo==NULL) printf( "No hay memoria disponible!\n");
else {
   printf("\nNuevo elemento:\n");
   printf("Nombre: "); fflush(stdin);
   gets(nuevo->nombre);
   printf("Teléfono: "); fflush(stdin);
   gets(nuevo->telefono);
/* el campo siguiente va a ser NULL por ser el último elemento
 la lista */
   nuevo->siguiente = NULL;
/* ahora metemos el nuevo elemento en la lista. lo situamos
al final de la lista */
/* comprobamos si l0a lista está vacía. si primero==NULL es que no
hay ningún elemento en la lista. también vale ultimo==NULL */
   if (primero==NULL) {
      printf( "Primer elemento\n");
      primero = nuevo;
      ultimo = nuevo;
      }
   else {
      /* el que hasta ahora era el último tiene que 
apuntar al nuevo */
      ultimo->siguiente = nuevo;
      /* hacemos que el nuevo sea ahora el último */
      ultimo = nuevo;
      }
   }
}

void mostrar_lista() {
_agenda *auxiliar; /* lo usamos para recorrer la lista */
int i;
i=0;
auxiliar = primero;
printf("\nMostrando la lista completa:\n");
while (auxiliar!=NULL) {
   printf( "Nombre: %s, Teléfono: %s\n", 
   auxiliar->nombre,auxiliar->telefono);
   auxiliar = auxiliar->siguiente;
   i++;
   }
if (i==0) printf( "\nLa lista está vacía!!\n" );
}
Publicado por en No hay comentarios:
Etiquetas:
#include
#include
#include

struct nodo {
int val;
struct nodo *siquiente;
};

struct nodo *primero, *ultimo;

void anadir_elemento() {
struct nodo *nuevo;
nuevo = (struct nodo *) malloc (sizeof(struct nodo));
if (nuevo == NULL)
printf("No hay memoria Disponible!\n");

printf("\n Nuevo elemento \n");
printf("Ingrese un valor: ");
scanf("%d", nuevo->val);
nuevo->siquiente = NULL;

if(primero == NULL){
printf("Primer elemento\n");
primero = nuevo;
ultimo = nuevo;
}
else {
ultimo->siquiente = nuevo;
ultimo = nuevo;
}
}

void mostrar_lista() {
struct nodo *auxiliar; /* lo usamos para recorrer la lista */
int i;

i=0;
auxiliar = primero;
printf("\nMostrando la lista completa:\n");
while (auxiliar!=NULL) {
printf("%d ", auxiliar->val);
auxiliar = auxiliar->siquiente;
i++;
}
if (i==0) printf( "\nLa lista está vacía!!\n" );
}


void mostrar_menu() {
printf("\n\nMenú:\n=====\n\n");
printf("1.- Añadir elementos\n");
printf("2.- Mostrar la lista\n");
printf("3.- Salir\n\n");
printf("Escoge una opción: ");
fflush(stdout);
}


int main() {
char opcion;

primero = (struct nodo *) NULL;
ultimo = (struct nodo *) NULL;
do {
mostrar_menu();
opcion = getch();
switch ( opcion ) {
case '1': anadir_elemento();
break;
case '2': mostrar_lista();
break;
case '3': printf("Salida del programa principal\n");
default: printf( "Opción no válida\n" );
break;
}
} while (opcion!='3');
}
Publicado por en No hay comentarios:
Etiquetas:

#include
#include
#include

void InicializarABB(pArbol &A)
{
A=NULL;
}

//MOVIMIENTO EN ABB
void MostrarDato(int Dato)
{
printf("
%d",Dato);
}

void InOrden(pArbol &A)
{
if(A!=NULL)
{
InOrden(A->izq);
MostrarDato(A->Dato);
InOrden(A->der);
}
}

void PreOrden(pArbol &A)
{
if(A!=NULL)
{
MostrarDato(A->Dato);
PreOrden(A->izq);
PreOrden(A->der);
}
}

void PosOrden(pArbol &A)
{
if(A!=NULL)
{
PosOrden(A->izq);
PosOrden(A->der);
MostrarDato(A->Dato);
}
}

//INFORMACION DE ABB
int ArbolVacio(pArbol &A)
{
if(A==NULL)
return 1;
else
return 0;
}

int EsHoja(pArbol &A)
{
if((A->der==NULL)&&(A->izq==NULL))
return 1;
else
return 0;
}

void NumerosDeNodos(pArbol &A, int &x)
{
if(A!=NULL)
{
x++;
NumerosDeNodos(A->izq,x);
NumerosDeNodos(A->der,x);
}
}

int CantidadDeNodos(pArbol &A)
{
int Cantidad=0;
if(A!=NULL)
NumerosDeNodos(A,Cantidad);
return Cantidad;
}

int AlturaDeUnNodo(pArbol &A, int x)
{
int Altura=0;
Nodo Aux=A;
while(Aux!=NULL)
{
if(x==Aux->Dato)
return Altura;
else
{
Altura++;
if(x>Aux->Dato)
Aux=Aux->der;
else
Aux=Aux->izq;
}
}
if(Altura==0)
return 1;
return Altura;
}

void VaciarABB(pArbol &A)
{
if(A!=NULL)
{
VaciarABB(A->izq);
VaciarABB(A->der);
delete(A);
}
A=NULL;
}

int AlturaArbol(pArbol &A)
{
int AltDer=0,AltIzq=0;
if(A==NULL)
return -1;
else
{
AltIzq=AlturaArbol(A->izq);
AltDer=AlturaArbol(A->der);
if(AltIzq>AltDer)
AltIzq=AltIzq+1;
else
AltIzq=AltDer+1;

}
return AltIzq;
}

//OPRECIONES EN ABB
int BuscarMenorEnABB(pArbol &A)
{
Nodo Aux=A;
if(Aux!=NULL)
{
while(Aux->izq!=NULL)
Aux=Aux->izq;
}
return (Aux->Dato);
}

int BuscarMayorEnABB(pArbol &A)
{
Nodo Aux=A;
if(Aux!=NULL)
{
while(Aux->der!=NULL)
Aux=Aux->der;
}
return (Aux->Dato);
}

int BuscarElementoEnABB(pArbol &A, int x) // 1: Encontado, 0: No Existe
{
Nodo Aux=A;
if(Aux!=NULL)
{
if(Aux->Dato==x)
return 1;
else
{
if(Aux->Dato>x)
BuscarElementoEnABB(Aux->izq,x);
if(Aux->Dato
BuscarElementoEnABB(Aux->der,x);
}
}
return 0;
}

int InsertarNodoEnArbol(pArbol &A, int x)
{
int bandera=0;
pArbol Aux,Padre;
Aux=A;
Padre=NULL;
while((Aux!=NULL)&&(Aux->Dato!=x))
{
Padre=Aux;
if(Aux->Dato>x)
Aux=Aux->izq;
else
if(Aux->Dato
Aux=Aux->der;
}
if(Aux==NULL)
{
Aux=new Arbol;
Aux->Dato=x;
Aux->der=NULL;
Aux->izq=NULL;
if(Padre!=NULL)
{
if(Padre->Dato>x)
Padre->izq=Aux;
else
Padre->der=Aux;
bandera=1;
}
else
{
A=Aux;
bandera=1;
}
}
return bandera;
}

int EliminarNodoEnABB(pArbol &A, int x)
{
pArbol Aux;
if(A!=NULL)
{
Aux=A;
if(Aux->Dato==x)
{
if(EsHoja(Aux))//Es hoja
{
delete(Aux);
A=NULL;
return(1);
}
else
{
if(A->izq!=NULL)
{
Aux=Aux->izq;
while(Aux->der!=NULL)
Aux=Aux->der;
A->Dato=Aux->Dato;
Aux->Dato=x;
EliminarNodoEnABB(A->izq,x);
}
else
{
Aux=Aux->der;
while(Aux->izq!=NULL)
Aux=Aux->izq;
A->Dato=Aux->Dato;
Aux->Dato=x;
EliminarNodoEnABB(A->der,x);

}
}
}
else
if(A->Dato>x)
EliminarNodoEnABB(A->izq,x);
else
EliminarNodoEnABB(A->der,x);
}
else
return 0;
}

int PodaABB(pArbol &A, int x)
{
pArbol Aux;
int Bandera;
if(A!=NULL)
{
Aux=A;
if(Aux->Dato==x)
{
Aux->der=NULL;
Aux->izq=NULL;
Bandera=1;
}
else
{
if(Aux->Dato>x)
PodaABB(Aux->izq,x);

else
{
if(Aux->Dato<=x)
PodaABB(Aux->der,x);

}
}

}
else
Bandera=0;
return Bandera;
}
Publicado por en No hay comentarios:
Etiquetas:

Códigos de listas enlazadas
#include
#include
#include
int Recorrido(int Info[8],int Indice[8],int Inicio,int Disp)
int InsPr(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento)
{
clrscr();
int Info[8]={12,10,0,9,5,3,0,20};
int Indice[8]={5,7,6,1,-999,3,-999,4};
int Inicio=0,Disp=2,Elemento,Res;
cout<<"Lista Original\n";
Recorrido(Info,Indice,Inicio,Disp);
cout<<"Que Numero deseas Insertar?";
cin>>Elemento;
InsPr(Info,Indice,Inicio,Disp,Elemento);
getch();
}
void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp)
{
int Apuntador=Inicio;
while(Apuntador!=-999)
{
cout<<
Apuntador=Indice[Apuntador];
}
}
void InsPr(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento)
{
if(Disp!=-999)
{
int Apuntador=Disp;
Disp=Indice[Disp];
Info[Apuntador]=Elemento;
Indice[Apuntador]=Inicio;
Inicio=Apuntador;
Recorrido(Info,Indice,Inicio,Disp);
}
else
cout<<"Overflow...";
}

{
void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp);
void EliBusq(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento);

{
clrscr();
int Info[8]={12,10,0,9,5,3,0,20};
int Indice[8]={5,7,6,1,-999,3,-999,4};
int Inicio=0,Disp=2,Elemento,Res;
cout<<"Lista Original\n";
Recorrido(Info,Indice,Inicio,Disp);
cout<<"Que Numero deseas Eliminar?";
cin>>Elemento;
EliBusq(Info,Indice,Inicio,Disp,Elemento);
getch();
}
void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp)
{
int Apuntador=Inicio;
while(Apuntador!=-999)
{
cout<<
Apuntador=Indice[Apuntador];
}
}
void EliBusq(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento)
{
int Temp=Inicio,Temp2;
if(Temp==-999)
{
cout<<"Lista Vacia... Imposible Eliminar";
return;
}
while(Temp!=-999)
{
if(Elemento==Info[Temp])
{
if(Temp==Inicio)
{
Inicio=Indice[Inicio];
else
Indice[Temp2]=Indice[Temp];
Indice[Temp]=Disp;
Disp=Temp;
Recorrido(Info,Indice,Inicio,Disp);
return;
}
else
{
Temp2=Temp;
Temp=Indice[Temp];
}
}
cout<<"Dato no encontrado... Imposible Eliminar";
return;
}

{
int Busqueda(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento);

{
clrscr();
int Info[8]={12,10,0,9,5,3,0,20};
int Indice[8]={5,7,6,1,-999,3,-999,4};
int Inicio=0,Disp=2,Elemento,Res;
cout<<"Que Numero deseas buscar?";
cin>>Elemento;
Res=Busqueda(Info,Indice,Inicio,Disp,Elemento);
if(Res==-999)
cout<<"Dato No Encontrado...";
getch();
}
int Busqueda(int Info[8],int Indice[8],int Inicio,int Disp,int Elemento)
{
int Apuntador=Inicio;
while(Apuntador!=-999)
{
if(Elemento==Info[Apuntador])
{
cout<<"Numero "<<<" encontrado...";
return Apuntador;
}
Apuntador=Indice[Apuntador];
}
return Apuntador;
}

{
int InsOrd(int Info[8],int Indice[8],int Inicio,int Elemento);
void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp);
void InsNd(int Info[8],int Indice[8],int Inicio,int Disp, int Elemento, int Npos);

{
clrscr();
int Info[8]={12,10,0,9,5,3,0,20};
int Indice[8]={5,7,6,1,-999,3,-999,4};
int Inicio=0,Disp=2,Elemento,Res;
cout<<"Lista Original\n";
Recorrido(Info,Indice,Inicio,Disp);
cout<<"Que Numero deseas Insertar?";
cin>>Elemento;
Res=InsOrd(Info,Indice,Inicio,Elemento);
InsNd(Info,Indice,Inicio,Disp,Elemento,Res);
getch();
}
void Recorrido(int Info[8],int Indice[8],int Inicio,int Disp)
{
int Apuntador=Inicio;
while(Apuntador!=-999)
{
cout<<
Apuntador=Indice[Apuntador];
}
}
void InsNd(int Info[8],int Indice[8],int Inicio,int Disp, int Elemento, int Npos)
{
if(Disp!=-999)
{
int Apuntador=Disp;
Disp=Indice[Disp];
Info[Apuntador]=Elemento;
if(Npos==-999)
{
Indice[Apuntador]=Inicio;
Inicio=Apuntador;
}
else
{
Indice[Apuntador]=Indice[Npos];
Indice[Npos]=Apuntador;
}
Recorrido(Info,Indice,Inicio,Disp);
}
else
cout<<"Overflow...";
}
int InsOrd(int Info[8],int Indice[8],int Inicio,int Elemento)
{
int Temp=-999,Temp2;
if(Inicio==Temp||Elemento
return Temp;
Temp=Inicio;
Temp2=Indice[Inicio];
while(Temp2!=-999)
{
if(Elemento
return Temp;
Temp=Temp2;
Temp2=Indice[Temp2];
}
return Temp;
}
{
void Recorrido(char Info[8][2],int Indice[8],int Inicio,int Disp);

{
clrscr();
char Info[8][2]={{"G"},{"I"},{" "},{"T"},{"O"},{"A"},
{" "},{"T"}};
int Indice[8]={5,7,6,1,-999,3,-999,4};
int Inicio=0,Disp=2;
cout<<"El Recorrido es:\n";
Recorrido(Info,Indice,Inicio,Disp);
getch();
}
void Recorrido(char Info[8][2],int Indice[8],int Inicio,int Disp)
{
int Apuntador=Inicio;
while(Apuntador!=-999)
{
cout<
Apuntador=Indice[Apuntador];
getch ();
return 0;
}
main()
{
int OP;
do{
clrscr ();
float s,r,m,d;
cout<<"MENU PRINCIPAL"<
cout<
cout<<"1.- INSERTAR NODO"<
cout<<"2.- ELIMINAR NODO"<
cout<<"3.- BUSCAR NODO"<
cout<<"4.- RECORRIDO NODO"<
cout<<"5.- VISUALIZAR"<
cout<<"6.- SALIR"<
cout<
cout<<"elige una opcion"<
cin>>OP;
switch (OP){
case 1:insertar();break;
case 2:eliminar();break;
case 3:busqueda();break;
case 4:recorrido();break;
case 5:visualizar();break;
}
}while(OP!=6);
getch();
return 0;
}
CÓDIGOS DE LISTA
#include
#include
#include
void funcion2(int **,int ,int ,int );
void funcion1(int **,int ,int ,int );
int origen;
void funcion1(int **M,int n,int or,int dest)
{
int cont=0;
for(int i=0;i
{
if(M[or][i] == 1)
{
cout << i;

for (int j=0;j
if (M[i][j] == 1)
cont++;
if (cont == 1)
M[or][i] = 0;
if (i!=dest)
funcion2(M,n,i,dest);
else
{
cout << "\n" << origen-1;
funcion1(M,n,origen-1,dest);
}
}
}
}

void funcion2(int **M,int n,int or,int dest)
{
int cont=0;
for(int i=0;i
{
if(M[or][i] == 1)
{
cout << i;

for (int j=0;j
if (M[i][j] == 1)
cont++;
if (cont == 1)
M[or][i] = 0;
if (i!=dest)
funcion1(M,n,i,dest);
else
{
cout << "\n" << origen-1;
funcion2(M,n,origen-1,dest);
}
}
}
}
void main()
{
int **M, n, or, dest, con, aux;
clrscr();
cout << "Ingrese cantidad de nodos : ";
cin >> n;

M = new int*[n];
for (int i=0;i
M[i] = new int [n];
for (i=0;i
for (int j=0;j
{
if (i==j)
{
printf(" NO EXISTE conexion entre (%d,%d)\n",i+1,j+1);
M[i][j] = 0;
}
else
{
printf(" Hay conexion (%d,%d) 1/si 0/no = ",i+1,j+1);
cin >> con;
M[i][j] = con;
}
}

for (i=0;i
{
for (j=0;j
cout << " " << M[i][j];
cout << "\n";
}

printf("Ingrese nodo origen (del 1 al %d) : ",n);
cin >> origen;
printf("Ingrese nodo destino (del 1 al %d) : ",n);
cin >> dest;

or = origen-1;
dest = dest-1;


// en caso que el origen sea distinto a la primera posision en la matriz
// de adyacencia, reordena la matriz para que as¡ sea...
if (or != 0)
{
for (i=0;i
{
aux = M[0][i];
M[0][i] = M[or][i];
M[or][i] = aux;
}

cout << "\n";
for (i=0;i
{
for (j=0;j
cout << " " << M[i][j];
cout << "\n";
}
getche();

for (i=0;i
{
aux = M[i][0];
M[i][0] = M[i][or];
M[i][or] = aux;
}
cout << "\n";
for (i=0;i
{
for (j=0;j
cout << " " << M[i][j];
cout << "\n";
}
getche();
}
// en caso que el destino sea distinto a la ultima posision en la matriz
// de adyacencia, reordena la matriz para que as¡ sea...
if (dest != (n-1))
{
for (i=0;i
{
aux = M[0][i];
M[0][i] = M[dest][i];
M[dest][i] = aux;
}
cout << "\n";
for (i=0;i
{
for (j=0;j
cout << " " << M[i][j];
cout << "\n";
}
getche();
for (i=0;i
{
aux = M[i][0];
M[i][dest] = M[i][dest];
M[i][dest] = aux;
}
cout << "\n";
for (i=0;i
{
for (j=0;j
cout << " " << M[i][j];
cout << "\n";
}
getche();
}
for (i=0;i
{
for (j=0;j
cout << " " << M[i][j];
cout << "\n";
}
getche();

//restringe la busqueda para que no entre en loop
for (i=0;i<=n;i++)
M[i][or] = 0;

for (j=0;j<=n;j++)
M[dest][j] = 0;

cout << "\n";
for (i=0;i<=n;i++)
{
for (j=0;j<=n;j++)
cout << " " << M[i][j];
cout << "\n";
}

getche();
cout << or;
funcion1(M,n,or,dest);
getche();
}
 
CÓDIGO DE LISTAS
#include
#include
       struct nodoLista{
char dato;
struct nodoLista *ptrsig; /*apuntador al siguiente nodo*
typedef struct nodoLista NodoLista;
typedef NodoLista *ptrNodoLista;
void insertar(ptrNodoLista *ptrS,char valor);
main(){
char eliminar (ptrNodoLista *ptrS,char valor);
void imprime(ptrNodoLista ptrActual);
int vacia(ptrNodoLista ptrS);
//void ptrNodoLista ptrInicial=NULL;/*No existen nodos*/
int opc;
char elemento;
do{
printf("---Menu---\n");
printf("1..Insertar\n");
printf("2..Eliminar\n");
printf("3..Salir\n");
printf("opc:");scanf("%d",&opc);
switch(opc){
case 1:
system("cls");
printf("Introduzca Caracter:");scanf("\n%c",&elemento);
insertar(&ptrInicial,elemento);
imprime(ptrInicial);
system("cls");
break;
case 2:
system("cls");
if(!vacia(ptrInicial)){
printf("Introduzca elemento a Eliminar:");scanf("\n%c",&elemento);
/*si encuentra el carater lo remueve*/
if(eliminar(&ptrInicial,elemento)){
printf("Caracter eliminado\n");
imprime(ptrInicial);
}else printf("No se encuentra el caracter %c\n",elemento);
}/*fin del if*/
else printf("La lista esta vacia\n");
system("cls");
break;
case 3:exit(0);
break;
default rintf("Opcion Invalidad\n");
}
}while(opc!=3);
getch();
return 0;
}
void insertar(ptrNodoLista *ptrS,char valor){
ptrNodoLista ptrNuevo; /*apuntador nuevo nodo*/
ptrNodoLista ptrAnterior;/*apuntador a un nodo anterior*/
ptrNodoLista ptrActual;/*apuntador al nodo actual*/
ptrNuevo=(struct nodoLista*)malloc(sizeof(NodoLista));/*crea un nodo*/
if(ptrNuevo!=NULL){
ptrNuevo->dato=valor;
ptrNuevo->ptrsig=NULL;
ptrAnterior=NULL;
ptrActual=*ptrS;
/*localiza la ubicacion correcta de la lista*/
while(ptrActual!=NULL && valor> ptrActual->dato){
ptrAnterior=ptrActual;
ptrActual=ptrActual->ptrsig;/*siguiente nodo*/

/*insertar un nuevo nodo al principio de la lista*/
if(ptrAnterior==NULL){
ptrNuevo->ptrsig = *ptrS;
*ptrS=ptrNuevo;
}else{
ptrAnterior->ptrsig=ptrNuevo;
ptrNuevo->ptrsig=ptrActual;
}
}
/*fin de if*/
else printf("No se inserto dato no hay espacio disponible en memoria");
}/*fin de la funcion insertar*/
char eliminar (ptrNodoLista *ptrS,char valor){
ptrNodoLista ptrAnterior;
ptrNodoLista ptrActual;
ptrNodoLista ptrTemp;/*apuntador a un nodo temporal*/
/*eliminar primer nodo*/
if(valor==(*ptrS)->dato){
ptrTemp=*ptrS;/*almacena el nodo a eliminar*/
*ptrS=(*ptrS)->ptrsig;/*desata el nodo*/
free(ptrTemp);/*libera memoria del nodo desatado*/
return valor;
}/*fin del if*/
else {
ptrAnterior=*ptrS;
ptrActual=(*ptrS)->ptrsig;
while(ptrActual!=NULL && ptrActual->dato !=valor){
ptrAnterior=ptrActual;
ptrActual=ptrActual->ptrsig;
}
/*elimina nodo actual*/
if(ptrActual!=NULL){
ptrTemp=ptrActual;
ptrAnterior->ptrsig=ptrActual->ptrsig;
free(ptrTemp);
return valor;
}
}/*fin else*/
getch();
}/*fin dela funcion eliminar*/
void imprime(ptrNodoLista ptrActual){
if(ptrActual==NULL)printf("La lista esta vacia\n");
else{
/*mientras no sea el final de la lista*/
while(ptrActual!=NULL){
printf("%c->",ptrActual->dato);
ptrActual=ptrActual->ptrsig;
}
printf("NULL\n");
}/*fin del else*/
getch();
}
}/*fin de la funcion imprimir*/
int vacia(ptrNodoLista ptrS){
return ptrS==NULL;
}/*fin dela funcion vacia*/

Publicado por en No hay comentarios:
Etiquetas:
Suscribirse a: Entradas (Atom)