Documentación

Índice

• getCountStructs
• disableCT
• iterator
• foreach
• newLinkedList
• newSortedList
• newArrayList
• newLinkedStack
• newLinkedQueue
• newArrayStack
• newArrayQueue
• isRange
• add
• addSorted
• findSorted
• add_i
• get
• set
• kremove
• removeAll
• iremove
• rremove
• clear
• find
• size
• isEmpty
• bsort
• sort
• reverse
• min
• max
• delete
• freeAll
• bSearch
• bSearch_i
• setCapacity
• push
• pop
• getTop
• enqueue
• dequeue
• getFront
• isFull

getCountStructs

• Descripción: Retorna la cantidad de estructuras que estén en memoria.
• Parámetros: (expr)
  • expr: Recibe únicamente las siguientes constantes:
    • LINKEDLIST.
    • ARRAYLIST.
    • ARRAYQUEUE.
    • ARRAYSTACK.
    • LINKEDQUEUE.
    • LINKEDSTACK.
• Valor de retorno: Retorna la cantidad de estructuras que estén en memoria.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	for(int i = 0; i != 10; ++i)
	{
		newLinkedList();
		newArrayList();
	}
        //En pantalla debería de imprimir 10
	printf("LinkedList: %d\n", getCountStructs(LINKEDLIST));
	printf("ArrayList: %d\n", getCountStructs(ARRAYLIST));
        return 0;
}

• Volver al índice

disableCT

• Descripción: Inhabilita el contenedor que usa la biblioteca de forma interna. Cada vez que se crea una estructura (como por ejemplo un ArrayList) en memoria, se copia la dirección de dicho objeto en un contenedor y esto sirve para poder tener las referencias de todas las listas que han sido creadas en la RAM.
• Parámetros: Vació.
• Valor de retorno: Vacío.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	disableCT();
	
	for(int i = 0; i != 10; ++i)
	{
		/* 
			Estos objetos no se guardarán en el contenedor
			porque se invocó antes la función disableCT.
		*/
		newLinkedList();
		newArrayList();
	}
	
	/*
		Como se inhabilitó el contenedor, el resultado en pantalla será 0.
	*/
	printf("LinkedList: %d\n", getCountStructs(LINKEDLIST));
	printf("ArrayList: %d\n", getCountStructs(ARRAYLIST));
	
	/* La función freeAll no liberará nada porque el contenedor fue inhabilitado. */
	freeAll(LINKEDLIST);
	freeAll(ARRAYLIST);
        return 0;
}

• Volver al índice

iterator

• Descripción: Permite recorrer una colección de objetos sin la necesidad de conocer los detalles de implementación (estos detalles nos indican como realmente se accede a los datos de la colección).

• Funciones:

  • setDefault: Inicializa y asigna un valor por defecto a la variable (aquí es donde se guarda la posición actual del elemento) que usa el iterador.
  • hasNext: Retorna 1 si hay más elementos que recorrer, de lo contrario, devuelve 0.
  • getNext: Retorna el siguiente elemento de la lista.
  • remv: Elimina un elemento mientras recorres la lista. Esta función solo puede recibir un puntero que sea de tipo ArrayList o LinkedList.

• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	int nums[] = {2, 4, 2, 2, 5, 6, 2, 2, 7, 2};
	ArrayList* al = newArrayList();
	for(int i = 0; i != 10; ++i)
		add(al, nums[i]);
	/* Esto asigna el valor por defecto a la variable que use el iterador. */
	setDefault(al);
	/* Verificamos si hay elementos en la lista. */
	while(hasNext(al))
	{
             /* Le asignamos a "v" el siguiente elemento. */
             int* v = getNext(al);
             if(*v == 2)
	     {
		 /* Imprimimos el elemento. */
		 printf("El numero %d pronto sera eliminado\n", *v);
                 /* Eliminamos el elemento. */
                 remv(al);
                 /* 
                    Ten en cuenta que no se pueda usar más el puntero "v" después de ejecutar la función "remv".
                    Por lo tanto, si tratas de desreferenciar el puntero "v", probablemente ocurra un comportamiento extraño en tiempo de ejecución.
                 */
             }
	}
	printf("Lista actualizada:\n");
	foreach(int, num, al)
		printf("%d\n", *num);
	delete(al);
	return 0;
}

• Volver al índice

foreach

• Descripción: Permite recorrer una colección de objetos sin la necesidad de usar el iterador de forma explícita.
• Sintaxis: foreach(typeData, name, nameList)
  • Parámetros:
    • typeData: Tipo de dato de la variable.
    • name: Nombre de la variable (la macro foreach la declara como un puntero).
    • nameList: El nombre de la lista donde están los elementos.
• Ejemplo:

#include <stdio.h>
#include <stdlib.h> /* malloc */
#include <lst/List.h>

typedef struct 
{
	int edad;
	const char* nombre;
}Persona;

Persona* crearPersona(int edad, const char* nombre)
{
	Persona* per = malloc(sizeof(Persona));
	if(per != NULL)
	{
		per->edad = edad;
		per->nombre = nombre;
	}
	return per;
}

int main(void)
{
     ArrayList* listPersonas = newArrayList();
     add(listPersonas, crearPersona(20, "Roberto Placencio"));
     add(listPersonas, crearPersona(20, "David Roman"));
     add(listPersonas, crearPersona(18, "Johan Sanchez"));
	
     /* 
        - Persona: Es el tipo de dato.
	- per: Es el nombre del puntero de tipo Persona.
	- listPersonas: Nombre de la lista donde está la información de cada persona.
     */
     foreach(Persona, per, listPersonas)
     {
	 printf("Nombre: %s\n", per->name);
	 printf("Edad: %d\n\n", per->edad);
     }
	
     delete(listPersonas);
     return 0;
}

A partir de la versión 3.9 de LibraryList, se puede eliminar un elemento mientras recorres la lista.

Ejemplo:

#include <stdio.h>
#include <string.h> /* strcmp */
#include <lst/List.h>

int main(void)
{
	char* nombres[] = {"Dario","Josue","Lorenzo","Dario","Dario","Danny","Pepe","Dario"};
	char nombre[24];
	LinkedList* listaNombres = newLinkedList();
	for(int i = 0; i != 8; ++i)
		add(listaNombres, nombres[i]);
	printf("Ingrese un nombre que quieras buscar: ");
	scanf("%24s", nombre);
	
	foreach(char, nom, listaNombres)
	{
		if(strcmp(nom, nombre) == 0)
		{
			printf("El nombre %s fue eliminado.\n", nom);
                        /* Esta función eliminará el elemento de la lista. */
			remv(listaNombres);
                        /* Es totalmente ilegal usar el puntero "nom" después de "remv". */
		}
	}
	printf("Lista actualizada:\n");
	foreach(char, nom, listaNombres)
		printf("%s\n", nom);
		
	delete(listaNombres);
	return 0;
}

• Volver al índice

newLinkedList

• Descripción: Crea una lista doblemente enlazada con 0 elementos.
• Parámetros: Vacío.
• Valor de retorno: Devuelve NULL si la función no pudo asignar memoria, de lo contrario, retorna la dirección base de un objeto de tipo LinkedList.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	LinkedList* lk = newLinkedList();
        int nums[] = {1, 2, 3, 4};
        for(int i = 0; i != 4; ++i)
           add(lk, nums[i]);
        printf("Cantidad de elementos: %d\n", size(lk));
        delete(lk);
	return 0;
}

• Volver al índice

newSortedList

• Descripción: Crea una lista ordenada con 0 elementos.
• Parámetros: (compare)

  • compare: Indica la manera como se va a ordenar los elementos. Por ejemplo, en orden ascendente o descendente.

    El prototipo de esta función debe ser: int compare(const void* p1, const void* p2);

    • Valor de retorno:
      • Si la función retorna un valor menor a 0, es porque el elemento que apunta p1 es menor al elemento que apunte p2.
      • Si la función retorna un 0, es porque el elemento que apunta p1 es igual al elemento que apunte p2.
      • Si la función retorna un valor mayor a 0, es porque el elemento que apunta p1 es mayor al elemento que apunte p2.
• Valor de retorno: Devuelve NULL si la función no pudo asignar memoria, de lo contrario, retorna la dirección base de un objeto de tipo LinkedList.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

typedef struct 
{
	int edad;
	char nombre[24];
}Persona;

/* Esta función define la forma como se ordenará la lista enlazada. */
int OrdenarPorEdad(const void* p1, const void* p2)
{
	return ((Persona*)p1)->edad - ((Persona*)p2)->edad;
}

int main(void)
{
    LinkedList* lk = newSortedList(OrdenarPorEdad);
    int nums[] = {5, 2, -1, 20};
    for(int i = 0; i != 4; ++i)
        addSorted(lk, nums[i]);
    printf("Elementos: %d\n", size(count));
    delete(lk);
    return 0;
}

• Volver al índice

newArrayList

• Descripción: Crea un arreglo dinámico vacío.
• Parámetros: Vacío.
• Valor de retorno: Devuelve NULL si la función no pudo asignar memoria, de lo contrario, retorna la dirección base de un objeto de tipo ArrayList.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayList* al = newArrayList();
        int nums[] = {1, 2, 3, 4};
        for(int i = 0; i != 4; ++i)
           add(al, nums[i]);
        printf("Elementos: %d\n", size(al));
        printf("Capacidad: %d\n", al->capacity);
        delete(al);
	return 0;
}

• Volver al índice

newLinkedStack

• Descripción: Crea una pila vacía. La forma como se implementa esta pila es usando una lista enlazada simple.
• Parámetros: Vacío.
• Valor de retorno: Devuelve NULL si la función no pudo asignar memoria, de lo contrario, retorna la dirección base de un objeto de tipo LinkedStack.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	LinkedStack* st = newLinkedStack();
        int nums[] = {10, 22, 34, 45};
        for(int i = 0; i != 4; ++i)
           push(st, nums[i]);
        free(pop(st));
        printf("Elementos: %d\n", size(count));
        delete(st);
	return 0;
}

• Volver al índice

newLinkedQueue

• Descripción: Crea una cola vacía. La forma como se implementa esta cola es a través de una lista enlazada simple.
• Parámetros: Vacío.
• Valor de retorno: Devuelve NULL si la función no pudo asignar memoria, de lo contrario, retorna la dirección base de un objeto de tipo LinkedQueue.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	LinkedQueue* qe = newLinkedQueue();
        int nums[] = {12, 2, 333, 44};
        for(int i = 0; i != 4; ++i)
           enqueue(qe, nums[i]);
        free(dequeue(qe));
        printf("Elementos: %d\n", size(count));
        delete(qe);
	return 0;
}

• Volver al índice

newArrayStack

• Descripción: Crea una pila vacía. La forma como se implementa esta pila es a través de un array.
• Parámetros: (max)
  • max: Recibe el tamaño del array. Básicamente este tamaño representa la cantidad máxima de elementos que puede tener el array. El tamaño debe ser mayor 0.
• Valor de retorno: Devuelve NULL si la función no pudo asignar memoria, de lo contrario, retorna la dirección base de un objeto de tipo ArrayStack.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
        /* Crea un pila vacía y solo aceptará hasta 8 elementos. */
	ArrayStack* as = newArrayStack(8);
        int nums[] = {2, 2, 3, 4};
        for(int i = 0; i != 4; ++i)
           push(as, nums[i]);
        printf("Elementos: %d, Capacidad: %d\n", as->count, as->max);
        delete(as);
	return 0;
}

• Volver al índice

newArrayQueue

• Descripción: Crea una cola vacía. La forma como se implementa esta cola es a través de un array circular.
• Parámetros: (max)
  • max: Recibe el tamaño del array circular. Básicamente este tamaño representa la cantidad máxima de elementos que puede tener el array. El tamaño debe ser mayor 0.
• Valor de retorno: Devuelve NULL si la función no pudo asignar memoria, de lo contrario, retorna la dirección base de un objeto de tipo ArrayQueue.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
        /* Crea un cola vacía y solo aceptará hasta 10 elementos. */
	ArrayQueue* qe = newArrayQueue(10);
        int nums[] = {1, 766, 34, 445};
        for(int i = 0; i != 4; ++i)
           enqueue(qe, nums[i]);
        printf("Elementos: %d, Capacidad: %d\n", qe->count, qe->max);
        delete(qe);
	return 0;
}

• Volver al índice

isRange

• Descripción: Verifica si la posición de un elemento cumple con esta condición: (index < 0 || index >= size)
• Parámetros: (expr, index)
  • expr: Recibe un puntero de tipo ArrayList, LinkedList, LinkedQueue, LinkedStack, ArrayQueue o ArrayStack.
  • index: Recibe una posición de cualquier elemento.
• Valor de retorno: Retorna 1 si la posición no está en el rango establecido, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	int pos;
	LinkedList* ptr_lk = newLinkedList();
	add(ptr_lk, 10);
	add(ptr_lk, 12);
	add(ptr_lk, -11);
	
	printf("Ingrese una posicion que este en el rango de 0 a %d:\n", size(ptr_lk)-1);
	scanf("%d", &pos);
	
	if(isRange(ptr_lk, pos))
	        printf("Posicion fuera de rango\n");
	else
		printf("Posicion valida!\n");
	
	delete(ptr_lk);
	return 0;
}

• Volver al índice

add

• Descripción: Añade al final de la lista un elemento.
• Parámetros: (expr, obj)
  • expr: Recibe un puntero de tipo ArrayList o LinkedList.
  • obj: Recibe un argumento de cualquier tipo, ya sea una variable de tipo int, float, etc.
• Valor de retorno: Retorna 1 si hubo una falla en la asignación de memoria, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, 23);
        add(ptr_al, 25);
        
        foreach(int, num_int, ptr_al)
          printf("%d\n", *num_int);

        LinkedList* ptr_lk = newLinkedList();
        add(ptr_lk, 100.23);
        add(ptr_lk, 123.21);
  
        foreach(double, num_d, ptr_lk)
          printf("%f\n", *num_d);

	delete(ptr_al);
        delete(ptr_lk);
	return 0;
}

• Volver al índice

addSorted

• Descripción: Añade un elemento de forma ordenada en la lista.
• Parámetros: (expr, obj)
  • expr: Recibe un puntero de tipo LinkedList.
  • obj: Recibe un argumento de cualquier tipo, ya sea una variable de tipo int, float, etc.
• Valor de retorno: Retorna 1 si hubo una falla en la asignación de memoria, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

/* Esta función indica que la lista se ordenará de forma ascendente. */
int ordenarAsc(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

int main(void)
{
	LinkedList* listNums = newSortedList(ordenarAsc);
	/* La función addSorted invoca internamente la función ordenarAsc. */
	addSorted(listNums, 10);
	addSorted(listNums, 5);
	addSorted(listNums, 8);
	addSorted(listNums, 1);
	addSorted(listNums, -1);

	/* Imprimir la lista ordenada. */
        foreach(int, num, listNums)
           printf("%d\n", *num);

	delete(listNums);
	return 0;
}

• Volver al índice

findSorted

• Descripción: Busca un elemento en la lista ordenada para poder modificar el elemento. Esta función se encarga que la lista siempre quede ordenada.

• Parámetros: (expr, key, newElement, equals)

  • expr: Recibe un puntero de tipo LinkedList.
  • key: Recibe el elemento que se quiere buscar para poderlo modificar.
  • newElement: Recibe el nuevo elemento que posiblemente hará que la lista quede desordenada.

  Tanto el parámetro key como newElement deben recibir la dirección de memoria de una variable, no puede ser un literal (a excepción de una cadena literal).

  Ejemplo del error: findSorted(lk, 23, 100, equals); //Error: 23 y 100 es un literal.

  • equals: Recibe la dirección de una función en la cual servirá para buscar el elemento que se quiera modificar.

    El prototipo de esta función debe ser: boolean equals(const void* p1, const void* pKey);

    • Valor de retorno:
      • Si la función retorna true, es porque el elemento que apunta p1 es igual al elemento que apunte pKey.
      • Si la función retorna false, es porque el elemento que apunta p1 no es igual al elemento que apunte pKey.

• Valor de retorno: Retorna NULL si no pudo encontrar el elemento, de lo contrario, devuelve la dirección base del objeto hallado.

• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

/* Esta función indica que la lista se ordenará de forma ascendente. */
int ordenarAsc(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

/* Esta función servirá para encontrar el elemento que queramos modificar. */
boolean encontrarNumero(const void* p1, const void* key)
{
	return *(int*)p1 == *(int*)key;
}

int main(void)
{
	int numero;
	int nuevoNumero;
	int* numeroEncontrado;
	LinkedList* listNums = newSortedList(ordenarAsc);
	/* La función addSorted invoca internamente la función ordenarAsc. */
	addSorted(listNums, 10);
	addSorted(listNums, 5);
	addSorted(listNums, 8);
	addSorted(listNums, 1);
	addSorted(listNums, -1);
	
	/*
		La función anterior debe ordenar los elementos de esta forma:
		-1, 1, 5, 8, 10
	*/
	/* La variable "numero" es el "key". */
	printf("Ingrese el numero que quieras modificar:");
	scanf("%d", &numero);
	/* La variable "nuevoNumero" es el "newElement". */
	printf("\nIngrese el nuevo numero: ");
	scanf("%d", &nuevoNumero);
	/* 
		La función findSorted invocará a las funciones: 
		-> encontrarNumero.
		-> ordenarAsc.
	*/
	numeroEncontrado = findSorted(listNums, &numero, &nuevoNumero, encontrarNumero);
	if(numeroEncontrado == NULL)
	{
		printf("El numero %d no se encuentran en la lista\n", numero);
                delete(listNums);
		return 1;
	}
	/* Actualizamos el elemento encontrado. */
	*numeroEncontrado = nuevoNumero;
	
	foreach(int, num, listNums)
		printf("%d\n", *num);
	
	/*
		Si "key" = 5 y "newElement" = 20
		La salida en pantalla debería ser:
		-1, 1, 8, 10, 20
	*/
	delete(listNums);
	return 0;
}

• Volver al índice

add_i

• Descripción: Añade un nuevo elemento en una determinada posición de la lista. Esta función no verifica si la posición no está en el rango establecido (de 0 a N-1), por lo tanto, se recomienda hacer una comprobación antes de invocar esta función, de lo contrario, hay la posibilidad que la rutina ocasione una falla de segmentación (acceder a memoria que no le pertenece al programa).
• Parámetros: (expr, index, obj)
  • expr: Recibe un puntero de tipo ArrayList o LinkedList.
  • index: Recibe la posición donde se quiere añadir el nuevo elemento.
  • obj: Recibe un argumento de cualquier tipo, ya sea una variable de tipo int, float, etc.
• Valor de retorno: Retorna 1 si hubo una falla en la asignación de memoria, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	int pos, numb;
	/* Crea la lista vacía */
	ArrayList* ptr_al = newArrayList();
	/* Añade los elementos */
        add(ptr_al, 1);
        add(ptr_al, 2);
        add(ptr_al, 3);
	
	/* Añadimos nuevos elementos en X posiciones */
	add_i(ptr_al, 0, -1);
	add_i(ptr_al, 1, -2);
	
	/* Imprimimos los elementos actualizados */
	foreach(int, num, ptr_al)
		printf("%d\n", *num);
	
	/* Pedir al usuario una posicion */
	printf("Ingrese una posicion:\n");
	scanf("%d", &pos);
	
	/* 
		Verificamos que la posición cumpla con esta condición:
		pos < 0 || pos >= ptr_al->count
	*/
	if(isRange(ptr_al, pos))
	{
		printf("La posicion debe estar en el rango de 0 a %d\n", size(ptr_al)-1);
                delete(ptr_al);
		return 1;
	}
	/* Pedir al usuario un nuevo elemento */
	printf("Ingrese un numero:\n");
	scanf("%d", &numb);
	/* Añadimos ese elemento en la posición que quiera el usuario */
	if(add_i(ptr_al, pos, numb))
	{
		printf("Error: No se pudo añadir el nuevo elemento!");
                delete(ptr_al);
		return 1;
	}
	/* Imprimimos la lista*/
	foreach(int, num, ptr_al)
		printf("%d\n", *num);
	
	/* Liberamos memoria */
	delete(ptr_al);
	return 0;
}

• Volver al índice

get

• Descripción: Obtiene un elemento de la lista.
• Parámetros: (expr, index)
  • expr: Recibe un puntero de tipo ArrayList o LinkedList.
  • index: Recibe la posición del elemento.
• Valor de retorno: Retorna NULL si el índice que se pasó no está en el rango de 0 a N-1 (donde N es la cantidad actual de elementos de la lista), de lo contrario, retorna la dirección base del objeto.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, 23);
        add(ptr_al, 25);
        printf("Elemento 2: %d\n", *(int*)get(ptr_al, 1));

        LinkedList* ptr_lk = newLinkedList();
        add(ptr_lk, 100.23);
        add(ptr_lk, 123.21);
        
        double* value = get(ptr_lk, -12);
        if(value == NULL)
          printf("Indice invalido!\n");
	
        delete(ptr_al);
        delete(ptr_lk);
	return 0;
}

• Volver al índice

set

• Descripción: Reemplaza el elemento de una determinada posición con el elemento especificado. Se debe tomar en cuenta que está función no verifica si la posición está en el rango establecido (de 0 a N-1), por lo tanto, se recomienda hacer una comprobación antes de invocar esta función, de lo contrario, la rutina puede ocasionar una falla de segmentación (acceder a memoria que no le pertenece al programa).
• Parámetros: (expr, index, newObject)
  • expr: Recibe un puntero de tipo ArrayList o LinkedList.
  • index: Recibe la posición del elemento.
  • newObject: Recibe un nuevo objeto en la cual será el reemplazo del anterior.
• Valor de retorno: Retorna NULL si no se pudo reservar memoria para el nuevo objeto, de lo contrario, devuelve la dirección base del objeto que estaba antes en la lista.
• Ejemplo de uso:

#include <stdio.h>
#include <stdlib.h> /* free */
#include <lst/List.h>

int main(void)
{
      int pos;
      int* elementPrev;
      /* Creamos la lista vacía */
      ArrayList* ptr_al = newArrayList();
      /* Añadimos elementos */
      add(ptr_al, 23);
      add(ptr_al, 25);
      /* Pedimos la posición donde está el elemento */
      printf("Ingrese una posicion [0-%d]:\n", size(ptr_al) - 1);
      scanf("%d", &pos);
	
      /* Validamos si la posición está fuera de rango */
      if(isRange(ptr_al, pos))
      {
           printf("Error: La posicion debe estar en el rango de 0 a %d\n", size(ptr_al) - 1);
           delete(ptr_al);
           return 1;
      }
      /* Recuperamos el elemento anterior */
      elementPrev = set(ptr_al, pos, 30);
      /* Si hubo una falla en asignar el nuevo objeto (es decir, el número 30) */
      if(elementPrev == NULL)
      {
           printf("Error: Hubo una falla al momento de asignar el nuevo elemento");
           delete(ptr_al);
           return 1;
      }
      printf("Elemento Anterior: %d\n", *elementPrev);
      /* Liberamos el objeto, de lo contrario, habrá fuga de memoria */
      free(elementPrev);
      printf("Nuevo elemento: %d\n, *(int*)get(ptr_al, pos));  
      delete(ptr_al);
      return 0;
}

• Volver al índice

kremove

• Descripción: Elimina un elemento de la lista según su clave.
• Parámetros: (expr, key, equals)

  • expr: Recibe un puntero de tipo ArrayList o LinkedList.

  • key: Recibe el elemento que se quiere eliminar. Debe recibir la dirección de memoria de una variable, no puede ser un literal (a excepción de una cadena literal). Ejemplo del error: oremove(al, 23, equals); //Error: 23 es un literal.

  • equals: Recibe la dirección de una función que compara dos elementos.

    El prototipo de esta función debe ser: boolean equals(const void* p1, const void* pKey);

    • Valor de retorno:
      • Si la función retorna true, es porque el elemento que apunta p1 es igual al elemento que apunte pKey.
      • Si la función retorna false, es porque el elemento que apunta p1 no es igual al elemento que apunte pKey.
• Valor de retorno: Retorna 1 si no pudo eliminar el elemento, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

boolean intEquals(const void* p1, const void* pKey)
{
    return *(int*)p1 == *(int*)pKey;
}

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        int key;
        add(ptr_al, 23);
        add(ptr_al, 25);
        add(ptr_al, 232);
        key = 232;
        printf("Delete: %d\n", kremove(ptr_al, &key, intEquals));
        key = -121;
        printf("Delete: %d\n", kremove(ptr_al, &key, intEquals));
	delete(ptr_al);
	return 0;
}

• Volver al índice

removeAll

• Descripción: Elimina el elemento con más aparición en la lista.
• Parámetros: (expr, key, equals)

  • expr: Recibe un puntero de tipo ArrayList o LinkedList.

  • key: Recibe el elemento que se quiere eliminar. Debe recibir la dirección de memoria de una variable, no puede ser un literal (a excepción de una cadena literal). Ejemplo del error: removeAll(al, 23, equals); //Error: 23 es un literal.

  • equals: Recibe la dirección de una función que compara dos elementos.

    El prototipo de esta función debe ser: boolean equals(const void* p1, const void* pKey);

    • Valor de retorno:
      • Si la función retorna true, es porque el elemento que apunta p1 es igual al elemento que apunte pKey.
      • Si la función retorna false, es porque el elemento que apunta p1 no es igual al elemento que apunte pKey.
• Valor de retorno: Retorna 1 si no pudo eliminar el elemento, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

boolean intEquals(const void* p1, const void* pKey)
{
    return *(int*)p1 == *(int*)pKey;
}

boolean intEquals_2(const void* p1, const void* pKey)
{
    return *(int*)p1 < *(int*)pKey;
}

int main(void)
{
        int key;
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, 23);
        add(ptr_al, 23);
        add(ptr_al, 12);
        add(ptr_al, 23);
        add(ptr_al, 232);
        key = 23;
        /* Cada vez que aparezca el número 23 en la lista, será eliminado */
        printf("Delete: %d\n", removeAll(ptr_al, &key, intEquals));

        LinkedList* ptr_lk = newLinkedList();
        add(ptr_lk , 2);
        add(ptr_lk , 2);
        add(ptr_lk , 2322);
        add(ptr_lk , 223);
        add(ptr_lk , 12);
        /* Todos los elementos que sean menores que 23 serán eliminados */
        printf("Delete: %d\n", removeAll(ptr_lk , &key, intEquals_2));

	delete(ptr_al);
        delete(ptr_lk);
	return 0;
}

• Volver al índice

iremove

• Descripción: Elimina un elemento de la lista según su índice.
• Parámetros: (expr, index)
  • expr: Recibe un puntero de tipo ArrayList o LinkedList.
  • index: Recibe el índice del elemento que se quiere eliminar y empieza de 0 a N-1.
• Valor de retorno: Retorna 1 si el índice esta fuera de rango, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, 23);
        add(ptr_al, 25);
        add(ptr_al, 232);

        printf("Delete: %d\n", iremove(ptr_al, 1));
        printf("Delete: %d\n", iremove(ptr_al, 3));
	delete(ptr_al);
	return 0;
}

• Volver al índice

rremove

• Descripción: Elimina uno o más elementos de la lista según su rango de índices.
• Parámetros: (expr, indexFirst, indexEnd)
  • expr: Recibe un puntero de tipo ArrayList o LinkedList.
  • indexFirst: Recibe el índice inferior.
  • indexEnd: Recibe el índice superior.
• Valor de retorno: Retorna 1 si los índices están fuera de rango o si el índice inferior llega a ser mayor que el índice superior, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayList* al = newArrayList();
	
	add(al, 10);
	add(al, 11);
	add(al, 5);
	add(al, 15);
	add(al, 1);
	add(al, 0);
	
	/*
		Esta función elimina los elementos que estén 
		en la posición (o índice) del 1 al 4.
	*/
	rremove(al, 1, 4);
	
	/*
		Imprime los elementos:
		10 y 0.
	*/
	foreach(int, num, al)
		printf("%d\n", *num);
		
	delete(al);
        return 0;
}

• Volver al índice

clear

• Descripción: Elimina todos los elementos de una lista.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo ArrayList, LinkedList, LinkedQueue, LinkedStack, ArrayQueue o ArrayStack.
• Valor de retorno: Vacío.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, 23);
        add(ptr_al, 25);
        add(ptr_al, 232);
        /* Todos los elementos serán eliminados, por lo tanto, la lista queda vacía*/
        clear(ptr_al);
        printf("Size: %d\n", size(ptr_al));
	delete(ptr_al);
	return 0;
}

• Volver al índice

find

• Descripción: Busca un elemento de la lista según su clave.
• Parámetros: (expr, key, equals)

  • expr: Recibe un puntero de tipo ArrayList, LinkedList, LinkedQueue, LinkedStack, ArrayQueue o ArrayStack.

  • key: Recibe el elemento que se quiere buscar. Debe recibir la dirección de memoria de una variable, no puede ser un literal (a excepción de una cadena literal). Ejemplo del error: find(al, 23, equals); //Error: 23 es un literal.

  • equals: Recibe la dirección de una función que compara dos elementos.

    El prototipo de esta función debe ser: boolean equals(const void* p1, const void* pKey);

    • Valor de retorno:
      • Si la función retorna true, es porque el elemento que apunta p1 es igual al elemento que apunte pKey.
      • Si la función retorna false, es porque el elemento que apunta p1 no es igual al elemento que apunte pKey.
• Valor de retorno: Retorna NULL si no pudo encontrar el elemento, de lo contrario, devuelve la dirección base del objeto hallado.
• Ejemplo de uso:

#include <stdio.h>
#include <string.h> /* strcmp */
#include <lst/List.h>

boolean nameEquals(const void* p1, const void* pKey)
{
    return strcmp(p1, pKey) == 0;
}

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, "David");
        add(ptr_al, "Jose");
        add(ptr_al, "Roberto");
     
        printf("Elemento buscado: %s\n", (char*)find(ptr_al, "Jose", nameEquals));
        if(find(ptr_al, "Johan Sanchez", nameEquals) == NULL)
           printf("Johan Sanchez no se encuentra en la lista!\n");
	delete(ptr_al);
	return 0;
}

• Volver al índice

size

• Descripción: Obtiene la cantidad de elementos de una lista.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo ArrayList, LinkedList, LinkedQueue, LinkedStack, ArrayQueue o ArrayStack.
• Valor de retorno: Retorna el tamaño actual de la lista.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, "Pepito");
        add(ptr_al, "Jose");
        printf("Size: %d\n", size(ptr_al));
	delete(ptr_al);
	return 0;
}

• Volver al índice

isEmpty

• Descripción: Verifica si la lista está vacía.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo ArrayList, LinkedList, LinkedQueue, LinkedStack, ArrayQueue o ArrayStack.
• Valor de retorno: Retorna 1 si la lista está vacía, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        printf("isEmpty: %d\n", isEmpty(ptr_al));
        add(ptr_al, 23);
        printf("isEmpty: %d\n", isEmpty(ptr_al));
	delete(ptr_al);
	return 0;
}

• Volver al índice

bsort

• Descripción: Ordena los elementos de una lista con el algoritmo de burbuja.
• Parámetros: (expr, compare)

  • expr: Recibe un puntero de tipo ArrayList o LinkedList.

  • compare: Recibe la dirección de una función que compara dos elementos.

    El prototipo de esta función debe ser: int compare(const void* p1, const void* p2);

    • Valor de retorno:
      • Si la función retorna un valor menor a 0, es porque el elemento que apunta p1 es menor al elemento que apunte p2.
      • Si la función retorna un 0, es porque el elemento que apunta p1 es igual al elemento que apunte p2.
      • Si la función retorna un valor mayor a 0, es porque el elemento que apunta p1 es mayor al elemento que apunte p2.
• Valor de retorno: Retorna 1 si la lista está vacía, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int intCompare_asc(const void* p1, const void* p2)
{ /* Hace que la función bsort ordene de forma ascendente */
    return *(int*)p1 - *(int*)p2;
}

int intCompare_desc(const void* p1, const void* p2)
{ /* Hace que la función bsort ordene de forma descendente */
    return *(int*)p2 - *(int*)p1;
}

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, 233);
        add(ptr_al, 25);
        add(ptr_al, 111);
        add(ptr_al, -23);
        bsort(ptr_al, intCompare_asc);
        /* Imprimir lista de forma ascendente */
        foreach(int, num, ptr_al)
          printf("%d\n", *num);

        bsort(ptr_al, intCompare_desc);
        /* Imprimir lista de forma descendente */
        foreach(int, num, ptr_al)
          printf("%d\n", *num);
	delete(ptr_al);
	return 0;
}

• Volver al índice

sort

• Descripción: Selecciona el algoritmo de ordenamiento dependiendo si es un ArrayList o LinkedList.
• Parámetros: (expr, compare)

  • expr: Recibe un puntero de tipo:

    • ArrayList: Esto hace que la macro sort use el algoritmo quicksort.
    • LinkedList: Esto hace que la macro sort use el algoritmo mergesort.

  • compare: Recibe la dirección de una función que compara dos elementos.

    El prototipo de esta función debe ser: int compare(const void* p1, const void* p2);

    • Valor de retorno:
      • Si la función retorna un valor menor a 0, es porque el elemento que apunta p1 es menor al elemento que apunte p2.
      • Si la función retorna un 0, es porque el elemento que apunta p1 es igual al elemento que apunte p2.
      • Si la función retorna un valor mayor a 0, es porque el elemento que apunta p1 es mayor al elemento que apunte p2.
• Valor de retorno: Retorna 1 si la lista está vacía, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <lst/List.h>
#define N 100

int intCompare(const void* p1, const void* p2)
{
	return *(int*)p1 - *(int*)p2;
}

int main(void)
{
	srand(time(0));
	ArrayList* list1 = newArrayList();
	LinkedList* list2 = newLinkedList();
	for(int i = 0; i != N; ++i)
	{
		add(list1, rand() % 1000);
		add(list2, rand() % 1000);
	}
	
	/* Ordena el ArrayList con el algoritmo quicksort. */
	sort(list1, intCompare);
	/* Imprimimos el ArrayList ordenado. */
	foreach(int, num, list1)
		printf("%d\n", *num);
	
	/* Ordena el LinkedList con el algoritmo mergesort. */
	sort(list2, intCompare);
	/* Imprimimos el LinkedList ordenado. */
	foreach(int, num, list2)
		printf("%d\n", *num);
	
	delete(list1);
	delete(list2);
	return 0;
}

• Volver al índice

reverse

• Descripción: Invierte los elementos de una lista.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo ArrayList o LinkedList.
• Valor de retorno: Retorna 1 si la lista está vacía, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	int nums[] = {1, 10, 5, 11, 5};
	int size = sizeof nums / sizeof(int);
	ArrayList* list = newArrayList();
	for(int i = 0; i != size; ++i)
		add(list, nums[i]);
	
	/* Invierte los elementos de la lista. */
	reverse(list);
	
	/* Imprime los elementos al revés: 5, 11, 5, 10, 1 */
	foreach(int, n, list)
		printf("%d\n", *n);
	
	delete(list1);
	return 0;
}

• Volver al índice

min

• Descripción: Obtiene el elemento menor de la lista.
• Parámetros: (expr, compare)

  • expr: Recibe un puntero de tipo ArrayList o LinkedList.

  • compare: Recibe la dirección de una función que compara dos elementos.

    El prototipo de esta función debe ser: int compare(const void* p1, const void* p2);

    • Valor de retorno:
      • Si la función retorna un valor menor a 0, es porque el elemento que apunta p1 es menor al elemento que apunte p2.
      • Si la función retorna un 0, es porque el elemento que apunta p1 es igual al elemento que apunte p2.
      • Si la función retorna un valor mayor a 0, es porque el elemento que apunta p1 es mayor al elemento que apunte p2.
• Valor de retorno: Retorna NULL si la lista está vacía, de lo contrario, retorna el elemento menor.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int intCompare(const void* p1, const void* p2)
{ 
    return *(int*)p1 - *(int*)p2;
}

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, 233);
        add(ptr_al, 25);
        add(ptr_al, 111);
        add(ptr_al, -23);
        printf("Elemento menor: %d\n", *(int*)min(ptr_al, intCompare));
	delete(ptr_al);
	return 0;
}

• Volver al índice

max

• Descripción: Obtiene el elemento mayor de la lista.
• Parámetros: (expr, compare)

  • expr: Recibe un puntero de tipo ArrayList o LinkedList.

  • compare: Recibe la dirección de una función que compara dos elementos.

    El prototipo de esta función debe ser: int compare(const void* p1, const void* p2);

    • Valor de retorno:
      • Si la función retorna un valor menor a 0, es porque el elemento que apunta p1 es menor al elemento que apunte p2.
      • Si la función retorna un 0, es porque el elemento que apunta p1 es igual al elemento que apunte p2.
      • Si la función retorna un valor mayor a 0, es porque el elemento que apunta p1 es mayor al elemento que apunte p2.
• Valor de retorno: Retorna NULL si la lista está vacía, de lo contrario, retorna el elemento mayor.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int intCompare(const void* p1, const void* p2)
{ 
    return *(int*)p1 - *(int*)p2;
}

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, 233);
        add(ptr_al, 25);
        add(ptr_al, 111);
        add(ptr_al, -23);
        printf("Elemento mayor: %d\n", *(int*)max(ptr_al, intCompare));
	delete(ptr_al);
	return 0;
}

• Volver al índice

delete

• Descripción: Libera de memoria la estructura con sus respectivos elementos.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo ArrayList, LinkedList, LinkedQueue, LinkedStack, ArrayQueue o ArrayStack.
• Valor de retorno: Vacío.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, 23);
        /* Libera el objeto al que apuntaba "ptr_al" y también los elementos de la lista */
	delete(ptr_al);
	return 0;
}

• Volver al índice

freeAll

• Descripción: Libera todas las estructuras que estén en memoria.
• Parámetros: (expr)
  • expr: Recibe únicamente las siguientes constantes:
    • LINKEDLIST.
    • ARRAYLIST.
    • ARRAYQUEUE.
    • ARRAYSTACK.
    • LINKEDQUEUE.
    • LINKEDSTACK.
• Valor de retorno: Vacío.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	for(int i = 0; i != 10; ++i)
		newArrayList();
	
	for(int i = 0; i != 5; ++i)
	{
		newLinkedQueue();
		newLinkedStack();
	}
		
	for(int i = 0; i != 4; ++i)
	{
		newArrayQueue(10);
		newArrayStack(11);
	}
	
	for(int i = 0; i != 6; ++i)
		newLinkedList();
	
	for(int i = 0; i != 3; ++i)
		newSortedList(NULL);
	
	printf("ArrayList: %d\n", getCountStructs(ARRAYLIST));
	printf("LinkedList: %d\n", getCountStructs(LINKEDLIST));
	printf("ArrayStack: %d\n", getCountStructs(ARRAYSTACK));
	printf("ArrayQueue: %d\n", getCountStructs(ARRAYQUEUE));
	printf("LinkedStack: %d\n", getCountStructs(LINKEDSTACK));
	printf("LinkedQueue: %d\n", getCountStructs(LINKEDQUEUE));	
	
	freeAll(ARRAYLIST);
	freeAll(LINKEDLIST);
	freeAll(ARRAYSTACK);
	freeAll(ARRAYQUEUE);
	freeAll(LINKEDSTACK);
	freeAll(LINKEDQUEUE);

	return 0;
}

• Volver al índice

bSearch

• Descripción: Busca un determinado elemento usando el algoritmo de la búsqueda binaria. Se requiere que la lista esté ordenada, de lo contrario, no funcionará.
• Parámetros: (expr, key, compare)

  • expr: Recibe un puntero de tipo ArrayList.

  • key: Recibe el elemento que se quiere buscar. Debe recibir la dirección de memoria de una variable, no puede ser un literal (a excepción de una cadena literal). Ejemplo del error: bSearch(al, 23, compare); //Error: 23 es un literal.

  • compare: Recibe la dirección de una función que compara dos elementos.

    El prototipo de esta función debe ser: int compare(const void* p1, const void* p2);

    • Valor de retorno:
      • Si la función retorna un valor menor a 0, es porque el elemento que apunta p1 es menor al elemento que apunte p2.
      • Si la función retorna un 0, es porque el elemento que apunta p1 es igual al elemento que apunte p2.
      • Si la función retorna un valor mayor a 0, es porque el elemento que apunta p1 es mayor al elemento que apunte p2.
• Valor de retorno: Retorna NULL si el elemento no se encuentra en la lista, de lo contrario, retorna el elemento hallado.
• Ejemplo de uso:

#include <stdio.h>
#include <string.h> /* strcmp */
#include <lst/List.h>

int nameCompare_asc(const void* p1, const void* p2)
{ 
    return strcmp(p1, p2);
}

int nameCompare_desc(const void* p1, const void* p2)
{ 
    return strcmp(p2, p1);
}

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, "David");
        add(ptr_al, "Jose");
        add(ptr_al, "Pepito");
        add(ptr_al, "Johan");

        /* Ordenamos la lista de forma ascendente */
        bsort(ptr_al, nameCompare_asc);
        /*Imprimimos la lista ordenada */
        foreach(char, name, ptr_al)
          printf("%s\n", name);
        /* Como la lista fue ordenada de forma ascendente, hay que pasar la función nameCompare_asc */
        printf("Elemento buscado: %s\n", (char*)bSearch(ptr_al, "Jose", nameCompare_asc));

        /* Ordenamos la lista de forma descendente */
        bsort(ptr_al, nameCompare_desc);
        /*Imprimimos la lista ordenada */
        foreach(char, name, ptr_al)
          printf("%s\n", name);
        /* Como la lista fue ordenada de forma descendente, hay que pasar la función nameCompare_desc */
        printf("Elemento buscado: %s\n", (char*)bSearch(ptr_al, "Jose", nameCompare_desc));

	delete(ptr_al);
	return 0;
}

• Volver al índice

bSearch_i

• Descripción: Busca un determinado elemento usando el algoritmo de la búsqueda binaria. Se requiere que la lista esté ordenada, de lo contrario, no funcionará.
• Parámetros: (expr, key, compare)

  • expr: Recibe un puntero de tipo ArrayList.

  • key: Recibe el elemento que se quiere buscar. Debe recibir la dirección de memoria de una variable, no puede ser un literal (a excepción de una cadena literal). Ejemplo del error: bSearch_i(al, 23, compare); //Error: 23 es un literal.

  • compare: Recibe la dirección de una función que compara dos elementos.

    El prototipo de esta función debe ser: int compare(const void* p1, const void* p2);

    • Valor de retorno:
      • Si la función retorna un valor menor a 0, es porque el elemento que apunta p1 es menor al elemento que apunte p2.
      • Si la función retorna un 0, es porque el elemento que apunta p1 es igual al elemento que apunte p2.
      • Si la función retorna un valor mayor a 0, es porque el elemento que apunta p1 es mayor al elemento que apunte p2.
• Valor de retorno: Retorna -1 si el elemento no se encuentra en la lista, de lo contrario, retorna la posición del elemento.
• Ejemplo de uso:

#include <stdio.h>
#include <string.h> /* strcmp */
#include <lst/List.h>

int nameCompare_asc(const void* p1, const void* p2)
{ 
    return strcmp(p1, p2);
}

int nameCompare_desc(const void* p1, const void* p2)
{ 
    return strcmp(p2, p1);
}

int main(void)
{
	ArrayList* ptr_al = newArrayList();
        add(ptr_al, "David");
        add(ptr_al, "Jose");
        add(ptr_al, "Pepito");
        add(ptr_al, "Johan");

        /* Ordenamos la lista de forma ascendente */
        bsort(ptr_al, nameCompare_asc);
        /*Imprimimos la lista ordenada */
        foreach(char, name, ptr_al)
          printf("%s\n", name);
        /* Como la lista fue ordenada de forma ascendente, hay que pasar la función nameCompare_asc */
        printf("La posicion donde se encuentra el elemento: %d\n", bSearch_i(ptr_al, "Jose", nameCompare_asc));

        /* Ordenamos la lista de forma descendente */
        bsort(ptr_al, nameCompare_desc);
        /*Imprimimos la lista ordenada */
        foreach(char, name, ptr_al)
          printf("%s\n", name);
        /* Como la lista fue ordenada de forma descendente, hay que pasar la función nameCompare_desc */
        printf("La posicion donde se encuentra el elemento: %d\n", bSearch_i(ptr_al, "Jose", nameCompare_desc));

	delete(ptr_al);
	return 0;
}

• Volver al índice

setCapacity

• Descripción: Establece una nueva capacidad máxima de almacenamiento para un ArrayList.
• Parámetros: (expr, newCapacity)
  • expr: Recibe un puntero de tipo ArrayList.
  • newCapacity: Recibe la cantidad máxima de elementos que puede almacenar el array.
• Valor de retorno: Retorna 1 si hubo una falla al momento de asignar memoria dinámica, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	/* Creamos la lista vacía */
	ArrayList* ptr_al = newArrayList();
        /* La capacidad inicial ahora es de 5 */
        setCapacity(ptr_al, 5);
	/* Añadimos los elementos */
        add(ptr_al, 23.2f);
	add(ptr_al, 23.8f);
	add(ptr_al, 255.3f);
	add(ptr_al, 2322.3f);
	add(ptr_al, 23343.3f);
	/* Imprimimos la lista */
	foreach(float, n, ptr_al)
		printf("%f\n", *n);
	/* Imprimimos la capacidad actual */
	printf("\n-> Capacidad actual: %d\n", ptr_al->capacity);
	/* Aumentamos la capacidad de 5 a 10 */
	setCapacity(ptr_al, 10);
	/* Añadimos dos elementos mas */
	add(ptr_al, 232.2f);
	add(ptr_al, 232.22f);
	/* Imprimimos la nueva capacidad */
	printf("\n-> Nueva capacidad: %d\n", ptr_al->capacity);
	/* Liberamos la memoria */
	delete(ptr_al);
	return 0;
}

• Volver al índice

push

• Descripción: Añade al principio de la lista un elemento.
• Parámetros: (expr, obj)
  • expr: Recibe un puntero de tipo LinkedStack, LinkedList o ArrayStack.
  • obj: Recibe un argumento de cualquier tipo, ya sea una variable de tipo int, float, etc.
• Valor de retorno: Retorna 1 si hubo una falla en la asignación de memoria, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	LinkedStack* elements = newLinkedStack();
        push(elements, 23);
        push(elements, 25);
        push(elements, 23);
        push(elements, 12);
        push(elements, 444);
        push(elements, 215);
        /* Imprimir elementos de la lista */ 
        foreach(int, element, elements)
          printf("%d\n", *element);
	delete(elements);
	return 0;
}

• Volver al índice

pop

• Descripción: Elimina el último elemento que entró en la lista.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo LinkedStack, LinkedList o ArrayStack.
• Valor de retorno: Retorna NULL si la lista está vacía, de lo contrario, devuelve el objeto eliminado (se requiere que sea liberado con la función free).
• Ejemplo de uso:

#include <stdio.h>
#include <stdlib.h> /* free */
#include <lst/List.h>

int main(void)
{
	LinkedStack* elements = newLinkedStack();
        push(elements, 23);
        push(elements, 25);
        push(elements, 23);
        push(elements, 12);
        push(elements, 444);
        push(elements, 215);
        int* element = pop(elements);
        printf("Element deleted: %d\n", *element);
        free(element);
        element = pop(elements);
        printf("Element deleted: %d\n", *element);
        free(element);
	delete(elements);
	return 0;
}

• Volver al índice

getTop

• Descripción: Obtiene el último elemento que entró en la lista.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo LinkedStack, LinkedList o ArrayStack.
• Valor de retorno: Retorna el último elemento que entró en la lista.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	LinkedStack* elements = newLinkedStack();
        push(elements, 23);
        push(elements, 25);
        push(elements, 23);
        printf("Top element: %d\n", *(int*)getTop(elements));
	delete(elements);
	return 0;
}

• Volver al índice

enqueue

• Descripción: Añade al final de la lista un elemento.
• Parámetros: (expr, obj)
  • expr: Recibe un puntero de tipo LinkedQueue, ArrayQueue o LinkedList.
  • obj: Recibe un argumento de cualquier tipo, ya sea una variable de tipo int, float, etc.
• Valor de retorno: Retorna 1 si hubo una falla en la asignación de memoria, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	LinkedQueue* elements = newLinkedQueue();
        enqueue(elements, 23);
        enqueue(elements, 25);
        enqueue(elements, 23);
        enqueue(elements, 12);
        enqueue(elements, 444);
        enqueue(elements, 215);
        /* Imprimir elementos de la lista */ 
        foreach(int, element, elements)
          printf("%d\n", *element);
	delete(elements);
	return 0;
}

• Volver al índice

dequeue

• Descripción: Elimina el primer elemento que entró en la lista.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo LinkedQueue, ArrayQueue o LinkedList.
• Valor de retorno: Retorna NULL si la lista está vacía, de lo contrario, devuelve el objeto eliminado (se requiere que sea liberado con la función free).
• Ejemplo de uso:

#include <stdio.h>
#include <stdlib.h> /* free */
#include <lst/List.h>

int main(void)
{
	LinkedQueue* elements = newLinkedQueue();
        int* element;
        enqueue(elements, 23);
        enqueue(elements, 25);
        enqueue(elements, 23);
        enqueue(elements, 12);
        enqueue(elements, 444);
        enqueue(elements, 215);
        for(int i = 0; i != 4; ++i)
        {
             element = dequeue(elements);
             printf("Elemento eliminado: %d\n", *element);
             free(element);
        }
	delete(elements);
	return 0;
}

• Volver al índice

getFront

• Descripción: Obtiene el primer elemento de la lista.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo LinkedQueue, ArrayQueue o LinkedList.
• Valor de retorno: Retorna el primer elemento de la lista.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	LinkedQueue* elements = newLinkedQueue();
        enqueue(elements, 23);
        enqueue(elements, 25);
        enqueue(elements, 23);
        printf("Front element: %d\n", *(int*)getFront(elements));
	delete(elements);
	return 0;
}

• Volver al índice

isFull

• Descripción: Verifica si la pila o cola están llenas.
• Parámetros: (expr)
  • expr: Recibe un puntero de tipo ArrayQueue o ArrayStack.
• Valor de retorno: Retorna 1 si la pila o cola está llena, de lo contrario, devuelve 0.
• Ejemplo de uso:

#include <stdio.h>
#include <lst/List.h>

int main(void)
{
	ArrayQueue* aq = newArrayQueue(5);
	enqueue(aq, 2);
	enqueue(aq, 3);
	enqueue(aq, 5);
	enqueue(aq, 1);
	enqueue(aq, 87);
	
	/* Verifica si la cola llegó a su límite, en este caso solo acepta hasta 5 elementos. */
	if(isFull(aq))
	{
		printf("La cola esta llena!\n");
                delete(aq);
		return 1;
	}
        enqueue(aq, 1000);
	return 0;
}

• Volver al índice