Problemas Resueltos de Punteros
1.- ENCUENTRA LOS ERRORES EN LA SIGUIENTE DECLARACIÓN DE PUNTEROS:
Int x, *p, &y;
Char* b= “cadena larga” ;
Char* c= ‘C’ ;
Float x;
Void* r= &x;
Es incorrecta sintácticamente al declaración int &y. no tiene ningún sentido en C.
Cuando un carácter esta rodeado por comillas simples es considerado como una constante de tipo char no como una cadena, para lo cual debería estar rodeado de dobles comillas.
Char* c= “C”;
No se puede declarar un puntero a tipo void.
2.- DADA LA SIGUENTE DECLARACIÓN ESCRIBIR UNA FUNCIÓN QUE TENGA COMO ARGUMENTO UN PUNTERO AL TIPO DE DATO Y MUESTRE POR PANTALLA LOS CAMPOS.
Struct botón
{
Char * rotulo;
Int código;
};
La función puede ser la siguiente
Void mostrarboton (struct botón *pb)
{
Printf (“rotulo del boton : %s \n” , pb ->rotulo ) ;
Printf (“Codigo asociado al botón : %d\n” , pb->código ) ;
}
3.- EN EL SIGUIENTE CÓDIGO SE ACCEDE A LOS ELEMENTOS DE UNA MATRIZ. ACCEDER A LOS MISMOS ELEMENTOS CON ARITMÉTICA DE PUNTEROS.
#define N 4
#define N 5
Int f . c ;
Double mt [N] [M] ;
For ( f = 0; f<N; f++)
{
For (c = 0 , c < M ; c++)
Pintf (“%l f “. Mt [f] [c] );
Printf (“\n”) ;
}
Análisis del problema
Se define un puntero la primera posición de la matriz y se calcula la posición de memoria donde se van encontrando cada uno de los elementos de la matriz, base de sumar la longitud de las filas desde el comienzo de la matriz y los elementos desde el comienzo de la fila donde está situado el elemento al que desea acceder. Si un elemento está en la fila 5, habrá que saltar 5 filas enteras de elementos del tipo de la matriz, ´para situarse al comienzo de su fila en la memoria. Recordar que en C los arrays siempre se enumeran desde 0. Si el elemento que se busca está en la columna 3, hay que calcular 3 posiciones desde el comienzo de su fila calculado antes. Así se llega a la dirección donde se encuentra el elemento buscado. Para hacer estos cálculos es imprescindible conocer el número de columnas de la matriz que es igual al tamaño de cada fila. Sin este dato sería imposible reconstruir la estructura de la matriz, partiendo solo del espacio que ocupa en la memoria, ya que este es puramente lineal. Una vez que se tiene dicha dirección se accede a su contenido. Esta expresión es la misma que sustituye el compilador de C cuando compila la indireccion que representan los operadores corchetes de los arrays.
Codificación
#define N 4
#define M 5
Int f.c ;
Doublé mt [N] [M] , *pmt=mt ;
For ( f = 0 ; f<N ; f++)
{
For ( c = 0 ; c<M; c++ )
Printf (“\n”) ;
}
Otra opción podría haber sido hacer que el puntero recorra la matriz sabiendo que la matriz esta almacenada en memoria fila a fila de forma lineal.
#define N 4
#define M 5
Int f.c ;
Doublé mt [N] [M] , *pmt=mt ;
For ( f = 0 ; f<N ; f++)
{
For (c = 0 ; c<M ; c++)
Printf (“%l f “ , *pmt++) ;
Printf (“\n”) ;
}
4.- ESCRIBA UNA FUNCIÓN CON UN ARGUMENTO DE TIPO PUNTERO A DOUBLÉ Y OTRO ARGUMENTÓ DE TIPO INT. EL PRIMER ARGUMENTO SE DEBE CORRESPONDER CON UN ARRAY Y EL SEGUNDO CON EL NUMERO DE ELEMENTOS DEL ARRAY. LA FUNCIÓN A DE SER DE TIPO PUNTERO A DOUBLÉ PARA DEVOLVER LA DIRECCIÓN DEL ELEMENTO MENOR.
Análisis del problema.
Al hacer la llamada función se pasa el nombre del array a recorrer o un puntero con la direccione del comienzo del array. De la misma manera el puntero que recibe la función puede ser tratado dentro de su código como si fuera un array, usando el operador corchete, o como un simple puntero que se va a mover por la memoria. En ambos casos el segundo parámetro de la función es imprescindible para no acceder fuera de la región de la memoria donde están los datos validos del array original almacenados.
Codificación
Doublé *menorArray (doublé *v, int n)
{
Int i , min = -1 ;
/ * suponer que los elementos del arrays son positivos */
Doublé *menor ;
For (i=0 ; i<n ; i++)
If (v[i] < min ) menor = &v[ I ] ;
/* o if (*v++ < min ) menor = v – 1 ; */
Return menor ;
}
5.- DADAS LAS SIGUIENTES DECLARACIONES DE ESTRUCTURAS, ESCRIBE COMO ACCEDER AL CAMPO X DE LA VARIABLE ESTRUCTURA T.
Struct fecha
{
Int d, m, a;
Float x;
} ;
Struct dato
{
Char* mes;
Struct fecha* f;
} t;
Análisis del problema
La variable t es una variable de tipo estructura, por lo que se usa el operador punto para acceder al miembro f. desde el dato miembro f es necesario usar el operador flecha para acceder al campo x de la estructura fecha a la que apunta.
t.f -> x ;
que problema habría en la siguiente sentencia
gets (t. mes) ;
El campo mes de la estructura fecha no apunta a ningún sitio , por lo cual dará problemas de asignación de memoria cuando la función gets ( ) intente colocar el resultado en el puntero que se le pasa como argumento. Para evitar esto sería necesario reservar memoria antes de llamar a gets ( ).
Problemas Resueltos de Listas
1.- Escriba una función que devuelva cierto si la lista esta vacía y falso en otros caso, y otra que cree una lista vacía.
Codificación
Si se supone siguiente declaración:
Typedef int Item;
Typedef struct Registro
{
Item el;
Struct Registro* sig;
} Nodo;
La codificacion de la funcion Esvacia sera:
Int Esvacia (Nodo _* Primero)
{
Return (Primero == NULL);
}
La codificacion de la funcion VaciaL sera:
Void VaciaL (Nodo ** Primero)
{
*Primero == NULL;
}
2.- Escriba una función entera que devuelva el numero de nodos de una lista enlazada.
Codificación
Si se supone la declaración de problema anterior se tiene:
Int NumerNodos (Nodo *Primero)
{
Int k = 0;
Nodo *p;
P = Primero;
While (p ¡= NULL)
{
K++;
P = p->sig;
}
Return(k);
}
3.- Escriba una función que elimine el nodo que ocupa la posición i de una lista enlazada ordenada
Análisis del problema
Para resolver el problema se necesita recorrer la lista contando el número de elementos que van pasando, y corte el recorrido, cuando la lista este vacía, o cuando se haya llegado a la posición que se busca. Una vez terminado el primer bucle de búsqueda en el caso de que haya que eliminar el elemento, se borra teniendo en cuenta si es o no el primer elemento de acuerdo con lo indicado en la teoría.
Codificación
Si se supone la declaración realizada en el problema se tiene:
Void EliminaPosicion (Nodo** Primero, Int i)
{
Int k = 0;
Nodo *ptr, *ant;
Ptr = *Primero;
Ant = NULL:
While ( (k < i) && (ptr != NULL))
{
K++;
Ant = ptr;
Ptr = ptr->sig;
}
If(k == i)
{
If( ant == NULL)
*Primero = ptr->sig;
Else
Ant->sig = ptr->sig;
Free(ptr);
}
}
4.- Escriba una función que reciba como parámetro una lista enlazada apuntada por Primero, un dato cualquiera e inserte en la lista enlazada un nuevo nodo con la información almacenada en dato y de tal forma que sea el primer elemento de la lista.
Análisis del problema
Los pasos que se seguirán son: asignar memoria a un nuevo puntero nuevo; situar el nuevo dato en el campo el; mover el campo sig de nuevo puntero nuevo al puntero Primero y hacer que Primero apunte a nuevo. Esta función trabaja correctamente, aun cuando la lista este vacía, siempre que previamente se haya iniciado a NULL
Codificación
Si se supone la siguiente declaración:
Typedef int Item;
Typedef struct Registro
{
Item el;
Struct Registro * sig;
} Nodo;
La codificacion de la function sera:
Void InsertarprimeroLista (Nodo** Primero, Item dato)
{
Nodo *nuevo;
Nuevo = (Nodo*) malloc (sizeof(Nodo));
Nuevo -> el = dato;
Nuevo -> sig = *Primero;
*Primero = nuevo;
}
5.- Escriba una función que reciba como parámetro un puntero ant que apunte a un nodo de una lista enlazada e inserte el valor recibido en el parámetro dato como un nuevo nodo que este inmediatamente después de ant (Inserción en el centro y final de una lista).
Análisis del problema
Se crea un nuevo nodo apuntado por nuevo, donde se almacena el dato, para posteriormente poner como siguiente del nuevo nodo nuevo el siguiente de ant, para por ultimo enlazar el siguiente de ant con nuevo.
Codificación
Si se supone la siguiente declaración:
Typedef int Item;
Typedef struct Registro
{
Item el;
Struct Registro* sig;
} Nodo;
La codificación de la función será:
Void InsertarLista (Nodo* ant, Item dato)
{
Nodo *nuevo;
Nuevo = (Nodo*) malloc (sizeof(Nodo));
Nuevo -> el = dato;
Nuevo -> sig = ant -> sig;
Ant -> sig = nuevo;
}
Problemas Resueltos de Pila
1.- Escriba las primitivas de gestión de una pila implementada con un array.
Análisis del problema
Se define en primer lugar una constante MaxTamaPila de valor 100 valor máximo de los elementos que podrá contener la pila. Se define la pila como una estructura cuyos campos (miembros) serán el puntero cima que apuntara siempre al ultimo elemento añadido a la pila y un array A cuyos índices variaran entre 0 y MaxTamaPila-1. Posteriormente se implementan las primitivas
• VaciaP. Crea la pila vacía poniendo la cima en el valor -1.
• EsvaciaP. Decide si la pila esta vacia. En este caso ocurrira cuando su cima valga -1.
• EstallenaP. Si bien no es una primitiva basica de gestion de una pila; la implementacion se realiza con un array conviene disponer de ella para prevenir posibles errores. En este caso la pila estara llena cuando la cima apunte al valor MazTamaPila-º.
• AnadeP. Añade un elemento a la pila. Para hacerlo comprueba en primer lugar que la pila no este ellena, y en caso afirmativo. Incrementa la cima en unidad, para posteriormente poner en el array A en la posicion cima el elemento.
• PrimeroP. Comprueba que la pila no este vacía, y en caso de que asi sea, dara el elemento del array A almacenado en la posición apuntada por la cima.
• BorrarP. Se encarga de eliminar el último elemento que entro en la pila. En primer lugar comprueba que la pila no este vacia cuyo caso, disminuye la cima en una unidad.
• Pop. Esta operación extrae el primer elemento de la pila y lo borra. Puede ser implementada directamente, o bien llamando a las primitivas PrimeroP y posteriormente a BorrarP.
• Push. Esta primitiva coincide con AnadeP.
Codificación
Typedef int TipoDato;
/* archivo pilaarray.h */
#include <stdio.h>
#include <stdlib.h>
#define MaxTamaPila 100
Typedef struct
{
TipoDato A[MaxTamaPila];
Int cima;
}Pila;
Void VaciaP(Pila* P);
Void AnadeP(Pila* P,TipoDato elemento);
Void BorrarP(Pila* P);
TipoDato Primero(Pila P);
Int EsVaciaP(Pila P);
Int EstallenaP(Pila P);
Void Pop(Pila* P. TipoDato elemento);
TipoDato Push(Pila *P);
Void VaciaP(Pila* P)
{
P -> cima = -1;
}
Void AnadeP(Pila* P,TipoDato elemento)
{
If (EstallenaP(*P))
{
Puts(“Desbordamiento pila”);
Exit (1);
}
P->cima++;
p->A[P->cima] = elemento;
}
Void Pop(Pila* P,TipoDato elemento)
{
AnadeP(P, elemento);
}
TipoDato Push(Pila *P)
{
TipoDato Aux;
If (EsVaciaP(*P))
{
Puts(“Se intenta sacar un elemento en pila vacia”);
Exit (1);
}
Aux = P->A[P->cima];
P->cima-;
Return Aux;
}
TipoDato PrimeroP(Pila P)
{
TipoDato Aux;
If (EsVaciaP(P))
{
Puts(“Se intenta sacar un elemento en pila vacia”);
Exit (1);
}
P->cima --;
}
Int EsVaciaP(Pila P)
{
Return P,cima == -º;
}
Int EstallenaP(Pila P)
{
Return P,cima == MaxTamaPila-1;
}
2.- Escribir un programa que usando las primitivas de gestion de una pila, lea datos de la entrada (-1 fin de datos) los almacene en una pila y posteriormente visualice dicha la pila.
Analisis del problema
Si se supone que el archivo pilaarray.cpp contiene todas las primitivas de gestion de una pila, para resolver el problema bastara declarar TipoDato como un entero incluir el archivo pilaarray.cpp anterior, y mediante un programa principal en un primer bucle while se leen dato y se almacenan en una pila, para posteriormente en otro bucle extraer datos de la pila y presentarlos en pantalla.
Codificación
Typedef char TipoDato
#Include <pilaarray.cpp>
Void main()
{
Pila P;
Int X;
VaciaP(&P);
Do
{
Printf(“dame dato -1=fin \n”);
Scanf(“%d”,&x);
If (x != -1)
AnadeP(&P, x);
While (x != -1);
}
Printf(“escritura de la pila\n”);
While(¡EsVaciaP(P))
{
Printf(“%d \n”,PrimeroP(P));
BorrarP( &P);
}
}
3.- escriba las primitivas de gestión de una pila implementada con una lista simple enlazada.
Análisis del problema
Se define como una lista simplemente enlazada. Posteriormente se implementan las primitivas:
• VaciaP. Crea la pila vacia poniendo la pila P a NULL.
• EsvaciaP. Decide si pila vacia. Esto ocurrira cuando P valga NULL.
• AnadeP. Añade un elemento a la pila. Para hacerlo, lo unico que se debe hacer, es añadir un nuevo nodo que contenga como informacion el elemento que se quiera añadir y ponerlo como primero de la lista enlazada.
• PrimeroP. En primer lugar se comprobara que la pila (lista) no este vacia, y en caso de que asi sea dara el campo el almacenado en el primer nodo de la lista enlazada.
• BorrarP. Se encarga de eliminar el ultimo elemento que entro en la pila. En primer lugar se comprueba que la pila no este vacia en cuyo caso, se borra el primer nodo de la pila (lista enlazada).
• Pop. Esta operación extrae el primer elemento de la pila y lo borra. Puede ser implementada directamente, o bien llamando a las primitivas PrimeroP y posteriormente a BorrarP.
• Push. Esta primitiva coincide con AnadeP.
• NuevoNodo. Es una función auxiliar de la implementación que se encarga de reserva de reservar memeoria para la operación AnadeP.
• EstallenaP. En esta implementación no tiene ningún sentido, ya que se supone que la memoria dinámica es en principio inagotable.
Codificación
#include <stdio.h>
#include <stdlib.h>
Typedef int TipoDato;
Typedef struct unnodo
{
TipoDato el;
Struct unnodo *sig;
}Nodo;
Typedef Nodo Pila;
Nodo* NuevoNovo(TipoDato element);
Void VaciaP(Pila** P);
Void AnadeP(Pila** P,TipoDato element);
Void BorrarP(Pila** P);
TipoDato PrimeroP(Pila *P);
Int EsVaciaP(Pila *P);
Void Pop(Pila** P,TipoDato elemento);
TipoDato Push(Pila **P);
Nodo* NuevoNodo(TipoDato elemento)
{
Nodo *a;
A = (Nodo*)malloc(sizeof(Nodo));
A -> el = elemento;
A -> sig = NULL;
Return a;
}
Void VaciaP(Pila** P)
{
*P = nn;
}
Void AnadeP(Pila** P, TipoDato elemento)
{
Nodo * nn;
Nn = NuevoNodo(elemento);
nn->sig = (*P);
*P = nn;
}
TipoDato Pop(Pila** P, TipoDato elemento)
{
AnadeP(P, elemento);
}
TipoDato Push(Pila **P)
{
TipoDato Aux;
Pila *nn;
If (EsVaciaP(*P));
{
Puts(“Se intenta sacar un elemento en pila vacia”);
Exit (1);
}
Aux = (*P)->el;
Nn = *P;
*P = nn->sig;
Free(nn);
Return Aux;
}
TipoDato PrimeroP(Pila *P)
{
TipoDato Aux;
If (EsVaciaP(P))
{
Puts(“Se intenta sacar un elemento en pila vacia”);
Exit (1);
}
Nn =(*P);
(*P)= nn->sig;
Free(nn);
}
Int EsVaciaP(Pila *P)
{
Return P == NULL;
}
4.- Usando las primitivas de gestión de una pila de enteros escriba las siguientes funciones: EscribePila que recibe como parámetro una pila y la escribe. CopiadPila que coia una pila en otra. DaVueltaPila que da la vuelta a una pila.
Análisis del problema
Usando el archivo pilalista.cpp en el que se tiene ya la implementacion de las primitivas de una pila, lo unico que se debe hacer es implementar las siguientes funciones:
• EscribePila que recibe como parametro por valor una pila y mediante un bucle while, se van extrayendo, borrando y escribiendo los elementos de la pila.
• CopiaPila que recibe como parametro por valor una pila p y devuelve en Pcop una copia exacta de la pila P. Par ello basta con volcar la pila P en una pila Paux auxiliar, para posteriormente volcar la pila Paux en la pila Pcop.
• DaVueltaPila que recibe como parametro por valor la pila P y vuelva su contenido en la pila Pcop.
Codificación
Void CopiaPila (Pila *P, Pila**Pcop)
{
Pila *Paux;
TipoDato e;
VaciaP(&Paux);
While (! EsVaciaP(P))
{
E = PrimeroP(P);
BorrarP(&P);
AnadeP(&Paux,e);
}
VaciaP(Pcop);
While (! EsVaciaP(Paux);
{
E = PrimeroP(Paux))
BorrarP(&Paux);
AnadeP(Pcop,e);
}
}
Void DaVueltaPila (Pila *P, Pila**Pcop)
{
TipoDato e;
VaciaP(Pcop);
While (!EsVaciaP(P))
{
E = PrimeroP(p);
BorrarP(&P);
AnadeP(Pcop,e);
}
}
Void EscribePila(Pila *P)
{
TipoDato e;
While (! EsVaciaP(P))
{
E = PrimeroP(P);
BorrarP(&P);
Printf(“%d\n”, e);
}
}
5.- Escriba las funciones LiberarPila y SonIgualesPilas que respectivamente libera todos los nodos de una pila implementada con lista y decide si dos pilas son iguales.
Análisis del problema
Al igual que en el ejercicio anterior se usa pilalista.cpp en el que se tiene ya la implementacion de las primitivas de una pila, lo unico que resta por hacer es implementar las siguientes funciones:
• LiberarPila que mediante un bucle mientras se encarga de ir extrayendo los elementos de la pila y mediante la funcion BorrarP irlos eliminando.
• SonIgualesPilas. Dos pilas son iguales si tienen el mismo numero de elementos y ademas coinciden en el orden de colocacion. Por lo tanto basta con un bucle mientras, controlado por haber datos en las dos pilas y haber sido todos los elementos extraido anteriormente iguale, extraer un elemento de cada una de las pilas y seguir decidiendo sobre su igualdad. Al final del bucle debe ocurrir que las dos pilas esten vacias y ademas que las variable logica que controla el bucle sea verdadera.
Codificación
Void LiberarPila(Pila**P)
{
While (!EsVaciaP(*P))
BorrarP(P);
}
Int SonIgualesPilas(Pila *P, Pila* P1)
{
Int sw = 1;
TipoDato e,e1;
While (! EsVaciaP(P) && !EsVaciaP(P1) && sw)
{
E = PrimeroP(P);
BorrarP(&P);
El = PrimeroP(P1);
BorrarP(&P1);
Sw = (e == el);
}
Return (sw && EsVaciaP(P)&& EsVaciaP(P1));
}
Problemas Resueltos de Colas
1.- Escriba las declaraciones necesarias y las primitivas de gestión de una cola implementada con listas enlazadas
Análisis del problema
Se declaran en primer lugar todos los tipos de datos necesarios para una lista enlazada. Una cola será una estructura con dos punteros a la lista frente que apuntara al primer elemento de la cola y final que apuntara al último elemento.
• VaciarC. Crea una cola vacia, para lo cual basta con poner en frente y el final a null.
• EsvaciaC. Decide si la cola esta vacía. Es decir si frente y final valen null
• EstallenaC. Esta función no es ahora necesaria ya que teóricamente no hay límite.
• PrimeroC. Extrae el primer elemento de la cola que se encuentra en el nodo frente. Previamente a esta operación ha de comprobarse que la cola no este vacia.
• AñadeC. Añade un elemento a la cola.este elemento se añade en un nuevo nodo que será el siguiente de final en el caso de que la cola no este vacia. Si la cola esta vacia el frente debe apuntar a este nuevo nodo. En todo caso el final siempre debe moverse al nuevo nodo.
• BorrarC. Elimina el primer elemento de la cola. Para hacer esta operación la cola no debe estar vacia. El borrado se realiza avanzando frente al nodo siguiente y liberando la memoria correspondiente .
• EliminarC. Esta primitiva libera toda la memoria que tenga una cola ya creada. Se realiza mediante un bucle controlado por el final de la lista. Liberando la memoria ocupada por cada nodo en cada una de las interacciones del bucle.
Codificación
#include<stdio.h>
#include<stdlib.h>
Typedef int tipodato;
Struct nodo
{
Tipodato el;
Struct nodo* sig;
};
Typedef struct
}
Nodo* frente;
Nodo * final;
}cola;
Void vaciaC(cola* C);
Void añadeC(cola* C. tipodato el);
Void eliminarC(cola*C);
Void borrarC(cola* C);
Tipodato primeroC (cola C);
Int esvaciaC(cola C);
Nodo* crearnodo(tipodato el);
Void vaciarC(cola* C)
{
C->frente = null;
C->final = null;
}
Nodo*crearnodo(tipodato el)
{
Nodo* nn;
Nn = (nodo*) malloc(sizeof(nodo));
nn->el = el;
nn->sig = null;
return nn;}
int esvaciaC(Cola C)
return (C.frente == null);
}
Voyd añadeC(cola* C,tipodato el)
{
Nodo* a;
A = crearnodo(el);
If (esvaciaC(*C))
C->frente = a;
Else
C->final->sig = a;
C->final = a;
}
Void borrarC(cola*C)
{
Nodo *a;
If (esvaciaC(*C))
{
A = C->frente;
C->frente = C->frente->sig;
If(C->frente == null)
C->final ==null;
Free(a);
}
Else
{
Puts(“error eliminacion de una cola vacia”);
Exit(-1);
}
}
Topodato primeroC(cola C)
{
If (esvaciaC(C))
{
Puts(“error: cola vacia”);
Exit(-1);
}
Return (C.frente->el);
}
Void eliminaC(Cola* C)
{
For (;C->frente;)
{
Nodo* n;
N =C->frente;
C->frente = C->frente->sig;
Free(n);
}
}
2.- Escriba una función que tenga como argumento dos colas del mismo tipo. Devuelva cierto si las dos colas son idénticas
Análisis del problema
Se usan para resolver el problema las primitivas de gestión de colas implementando una función son igualescolas que dará el valor verdadero cuando las dos colas tengan igual numero de elementos y además estén colocada en el mismo orden.
Codificación
Int sonigualescolas(cola* C. cola* C1)
{
Int sw=1;
Tipodato e,el;
While(esvaciaC(C)&& esvaciaC(C1)&& sw)
{
E =primeroC(C);
borrarC(&C);
el =primeroC(C1);
borrarP(&C1);
sw =(e ==el);
}
Return (sw && esvaciaC(C)&& esvaciaC(C1));
}
3.- Escriba una función que reciba como parámetro una cola de números enteros y nos devuelva el mayor y el menor de la cola.
Análisis del problema
Se usan las primitivas de gestión de colas implementadas con listas, lo único que hay que hacer es inicializar mayor y menor al primer elemento de la cola, y mediante en bucle voraz controlado por si se vacía la cola, ir actualizando las variables mayor y menor.
Codificación
Void mayormenor(cola*C.tipodato *mayor. Tipodato *menor)
{
Tipodato M.m.e;
M=-32767;
m =32367;
while(esvadciaC(*C))
{
E=primeroC(*C);
borrarC(C);
if(m<e)
m=e;
if(m>e)
M=e;
}
*Mayor=M;
*mrnor=m;
}
4.- Problema de colas
• Estallenac. Decide si la cola esta llena. Es decir, si (final+1)%maxtamc==frente.
• Primeroc. Extrae el primer elemento de la cola que se encuentra en (frente+1) maxtamc. Previamente a esta operación a de comprobarse que la cola no este vacia.
• Añadec. Añade un elemento a la cola. Este elemento se añade a la posición del array (final+1) %maxtamc. Final también debe ponerse en esa posición. Previamente a esta operación a de comprobarse si la cola esta llena.
• Borrarc. Elimina el primer elemento de la cola. Para ello basta con hacer frente=(frente+1) %maxtamc. Previamente a esta operación ha de comprobarse que la cola no este vacia.
Codificación
#include<stdio.h>
#include<stdlib.h>
#definemaxtamc 100
Typedef int tipodato;
Typedef struct
{
Int frente. Final;
Tipodato A [maxtamc];
}cola;
Void vaciaC(cola* C);
Void anade C (cola* C, tipodato E);
Void borrarC(cola* C);
Tipodato primeroC(cola C);
Int esvaciaC(cola C);
Int estallenaC(cola C);
Void vaciaC (cola* C)
{
C->frente= 0;
C->final=0;
}
Void anadeC(cola* C, tipodato E)
{
If (estallenaC( *C))
{
Puts(“desbordamiento cola”);
Exit (1);
}
c->final = (C-> final + 1)% maxtamc;
C->A[C->final] =E;
}
Tipodato primeroC(cola C)
{
If (esvaciaC))
{
Puts(“elemento drente de una cola vacia”);
Exit (1);
Return (C.A[(C.frente+1) % maxtamC]);
}
Int esvaciaC (cola C)
{
Return (C.frente==C. final);
}
Int estallenaC(cola C)
{
Return ( C.frente==(==(C.final+1) % maxtamC);
}
Void borrarC (cola* C)
{
If (esvaciaC(*C))
{
Puts(“eliminacion de una cola vacia”);
Exit (1);
C->frente =(C->frente+1) % maxtamC;
}
Problema resuelto de árbol
1.- se dispone de un árbol binario de elementos de tipo entero. Escriba funciones que calculen:
a) La suma se sus elementos.
b) La suma de sus elementos que son múltiplos de 3
Análisis del problema
Para resolver el problema basta con implementar las dos funciones efectuando al hacer un recorrido del árbol las correspondientes operaciones.
Codificación
Int Suma (Nodo*a)
{
If(a)
Return (a->el + Suma(a->hi) + Suma(a-<>hd));
Else
Return(0);
}
Int SumaMultimpos (Nodo*a)
{
If(a)
If (a->el%3)
Return( a->el + SumaMultimpos(a->hi)+SumaMultimpos(a->hd);
Else
Return( sumaMultimpos(a->hi) + SumaMultimpos(a->hd)
Else
Return(0);
}
