proyecto fime

Ejemplos de Listas

/* obtiene el numero de nodos de la lista */
length = g_slist_length (list);

g_print ("\nEscribe el nº de indice donde se insertara el dato (el indice maximo es %d): ", length);
scanf ("%d", &index);

/* inserta el valor en la posicion indicada */

if (index < length) {
list = g_slist_insert (list, GINT_TO_POINTER (value), index);
print_list(list);
}

Parámetro GCompareFunc para insertar en orden creciente.
gint compare_value1 (gconstpointer a, gconstpointer b) {
gint *value1 = (gint *) a;
gint *value2 = (gint *) b;

return value1 > value2;
}
Insertar elementos en orden creciente.
gint values[] = {8, 14, 5, 12, 1, 27, 3, 13};
gint i;
/* insertando valores en orden creciente */
for (i = 0; i < 8; i++) {
list =g_slist_insert_sorted (list, GINT_TO_POINTER (values[i]),
compare_value1);
}
Elimina un elemento de la lista.
if (list2 != NULL) {
g_print ("\nEl dato %d sera eliminado de la lista.\n", list2->data);

/* eliminando un elemento de la lista */
g_slist_remove (list, list2->data);
}


Ejemplo de Colas
Creando una nueva cola.
GQueue* cola;cola = g_queue_new ();


Función que comprueba si una cola está vacía.
gboolean cola_vacia (GQueue* cola) {
return g_queue_is_empty (cola);
}

Función que consulta el frente de la cola.
gpointer consultar_frente (GQueue* cola) {
return g_queue_peek_head (cola);
}
Función que consulta el final de la cola.
gpointer consultar_final (GQueue* cola) {
return g_queue_peek_tail (cola);
}Introducir un nuevo elemento en la cola.
GQueue* meter_cola (GQueue* cola, gpointer dato) {
g_queue_push_tail (cola, dato);

return cola;
}
Saca un elemento de la cola.
gpointer sacar_cola (GQueue* cola) {
gpointer dato;

dato = g_queue_pop_head (cola);

return dato;
}
Vacía la cola.
g_queue_free (cola);
















Ejemplo de pilas

Creando una nueva pila.
GQueue*pila;
pila = g_queue_new ();
Función que comprueba si una pila está vacía.
gboolean pila_vacia (GQueue* pila) {
return g_queue_is_empty (pila);
}
Función que consulta la cima de la pila.
gpointer consultar_pila (GQueue* pila) {
return g_queue_peek_head (pila);
}

Introducir un nuevo elemento en la pila.
GQueue* meter_pila (GQueue* pila, gpointer dato) {
g_queue_push_head (pila, dato);return pila;
}
Saca un elemento de la pila.
gpointer sacar_pila (GQueue* pila) {
gpointer dato;

dato = g_queue_pop_head (pila);

return dato;
}
Vacía la pila
g_queue_free (pila);

Ejemplo de Árboles

Algoritmos básicos con árboles binarios3 . Para la utilización de árboles binarios es necesario definir las clases NodoArbol y Arbol siguiendo la sintaxis siguiente
: public classNodoArbol {
public NodoArbol (int dato) {
clave = dato; iz = null; de = null;
}
public int clave;
public NodoArbol iz, de;
}
public class Arbol {
public NodoArbol raiz; public Arbol () {
raiz = null;
}
}



Ejemplos de Tablas HASH

La creación de la estructura de datos la tabla hash es la siguiente:
#include
#include
#include #include
#include
#include
#include
#include

#define TAMHASH 1572869

typedef struct {
int *datos;
int num_datos;
} datos_t;

typedef struct {
int k[5];
int v;
} hash_datos_t;

typedef struct
{
hash_datos_t *datos;
int num_datos;
int num_max_datos;
} hash_node_t;
La funcion hash es totalmente como nosotros queramos
inline static inthash_key(int x, int y, int z, int v, int w)
{
return (x * y * (z + 1) + v + w) % TAMHASH;
}
Creamos un hash vacio
hash_node_t *hash_create(void)
{
hash_node_t *hash;
int i;

hash = malloc(sizeof(hash_node_t) * TAMHASH);
for(i = 0; i < TAMHASH; i++)
{
hash[i].datos = malloc(sizeof(hash_datos_t) * 2);
hash[i].num_datos = 0;
hash[i].num_max_datos = 2;
}

return...

Leer documento completo

Regístrate para leer el documento completo.