El documento describe las tablas hash y diferentes representaciones para implementarlas. Las tablas hash mapean claves a valores usando una función hash que distribuye las claves uniformemente entre las cubetas de la tabla. Se describen tablas abiertas que almacenan listas en cada cubeta para manejar colisiones, tablas cerradas que reasignan elementos a cubetas alternativas, y representaciones basadas en listas, diccionarios y vectores.
El documento describe un programa en C que implementa una lista enlazada simple para almacenar y manipular datos de contactos. Incluye funciones para agregar nuevos nodos a la lista, imprimir los datos almacenados, y eliminar nodos según un número de correlativo. El programa presenta un menú principal para interactuar con estas funciones de la lista enlazada.
Los documentos presentan varios ejemplos de código Java que incluyen clases, métodos main, variables, operadores, condicionales if-else, ciclos for y while, arrays unidimensionales y bidimensionales, y manejo de excepciones e ingreso de datos por medio de JOptionPane. Los ejemplos cubren temas básicos de programación como entrada y salida de datos, procesamiento de cadenas y números, y estructuras de control de flujo.
Este documento describe diferentes funciones para modificar arrays en PHP, incluyendo funciones para crear arrays, intercambiar elementos aleatoriamente, agregar y eliminar elementos, extraer subconjuntos de elementos, y revertir el orden de los elementos. Se proporcionan ejemplos de código para ilustrar el uso de cada función.
1. El documento explica cómo usar diccionarios en Python, incluyendo cómo definirlos, agregar elementos, acceder a valores mediante claves y recorrerlos. 2. Los diccionarios almacenan datos no ordenados mediante claves únicas asociadas a valores. 3. Se pueden usar diccionarios para crear bases de datos simples donde la clave identifica un elemento y el valor contiene sus datos.
El documento presenta un programa para inscribir estudiantes en un curso. El programa solicita al usuario que ingrese los números de lista de los estudiantes inscritos y los agrega a una lista. Cuando el usuario termina de ingresar listados, el programa muestra la lista final de estudiantes inscritos.
El resumen resume brevemente los pasos para usar punteros en C++ y las listas enlazadas: 1) Se define el tipo de puntero, 2) se declaran las variables puntero y se les asigna memoria, 3) se accede y modifica la memoria apuntada por los punteros, 4) cuando ya no se necesitan, se libera la memoria asignada a los punteros. Para listas enlazadas, se definen los nodos con punteros al siguiente nodo, se crea la lista enlazada insertando y borrando nodos.
Este documento describe un algoritmo de búsqueda en anchura (BFS) para determinar si un grafo puede colorearse con dos colores. Implementa BFS almacenando nodos en una cola y marcando sus colores y padres. Revisa conflictos de color entre nodos adyacentes. Devuelve si el grafo es 2-coloreable o no y muestra su coloración. También lee un grafo de un archivo, almacena sus aristas en una matriz y permite especificar un nodo de inicio para BFS.
El algoritmo toma una lista enlazada L como entrada. Crea una nueva lista vacía L1. Recorre L insertando los elementos en L1 en orden inverso usando InsertarInicio. Finalmente recorre L1 escribiendo los elementos. Esto tiene el efecto de invertir el orden de los elementos en la lista.
El documento describe un programa en C que implementa una lista enlazada simple para almacenar y manipular datos de contactos. Incluye funciones para agregar nuevos nodos a la lista, imprimir los datos almacenados, y eliminar nodos según un número de correlativo. El programa presenta un menú principal para interactuar con estas funciones de la lista enlazada.
Los documentos presentan varios ejemplos de código Java que incluyen clases, métodos main, variables, operadores, condicionales if-else, ciclos for y while, arrays unidimensionales y bidimensionales, y manejo de excepciones e ingreso de datos por medio de JOptionPane. Los ejemplos cubren temas básicos de programación como entrada y salida de datos, procesamiento de cadenas y números, y estructuras de control de flujo.
Este documento describe diferentes funciones para modificar arrays en PHP, incluyendo funciones para crear arrays, intercambiar elementos aleatoriamente, agregar y eliminar elementos, extraer subconjuntos de elementos, y revertir el orden de los elementos. Se proporcionan ejemplos de código para ilustrar el uso de cada función.
1. El documento explica cómo usar diccionarios en Python, incluyendo cómo definirlos, agregar elementos, acceder a valores mediante claves y recorrerlos. 2. Los diccionarios almacenan datos no ordenados mediante claves únicas asociadas a valores. 3. Se pueden usar diccionarios para crear bases de datos simples donde la clave identifica un elemento y el valor contiene sus datos.
El documento presenta un programa para inscribir estudiantes en un curso. El programa solicita al usuario que ingrese los números de lista de los estudiantes inscritos y los agrega a una lista. Cuando el usuario termina de ingresar listados, el programa muestra la lista final de estudiantes inscritos.
El resumen resume brevemente los pasos para usar punteros en C++ y las listas enlazadas: 1) Se define el tipo de puntero, 2) se declaran las variables puntero y se les asigna memoria, 3) se accede y modifica la memoria apuntada por los punteros, 4) cuando ya no se necesitan, se libera la memoria asignada a los punteros. Para listas enlazadas, se definen los nodos con punteros al siguiente nodo, se crea la lista enlazada insertando y borrando nodos.
Este documento describe un algoritmo de búsqueda en anchura (BFS) para determinar si un grafo puede colorearse con dos colores. Implementa BFS almacenando nodos en una cola y marcando sus colores y padres. Revisa conflictos de color entre nodos adyacentes. Devuelve si el grafo es 2-coloreable o no y muestra su coloración. También lee un grafo de un archivo, almacena sus aristas en una matriz y permite especificar un nodo de inicio para BFS.
El algoritmo toma una lista enlazada L como entrada. Crea una nueva lista vacía L1. Recorre L insertando los elementos en L1 en orden inverso usando InsertarInicio. Finalmente recorre L1 escribiendo los elementos. Esto tiene el efecto de invertir el orden de los elementos en la lista.
Scala es un lenguaje de programación funcional y orientado a objetos que se ejecuta en la JVM. Aunque comparte similitudes con Java, Scala evita la mutabilidad de datos, asignaciones y bucles imperativos para favorecer la escalabilidad, legibilidad del código y programación paralela. Aprender la programación funcional requiere adaptarse a un nuevo paradigma y siempre tendrá un coste asociado. Scala proporciona características potentes como funciones de alto orden, pattern matching, case classes y colecciones inmutables que reducen
Este documento presenta conceptos sobre tipos de datos compuestos y recursivos en Prolog, incluyendo:
1) Se introducen listas como un tipo de datos recursivo y se proveen ejemplos de su manipulación como agregar y concatenar elementos.
2) Se explica el uso de assert y retract para modificar una base de datos interna en Prolog y operaciones como guardar y consultar bases de datos.
3) Se pide repetir un ejercicio anterior usando un enfoque recursivo y las operaciones de bases de datos como findall.
Charla congreso web introducción programación funcional en JavaScriptRicardo Pallás Román
Este documento presenta una introducción a la programación funcional en JavaScript. Explica conceptos como funciones puras, currying, composición y categorías. También muestra ejemplos de cómo trabajar con arrays sin bucles utilizando funciones como map, filter y reduce. Finalmente, introduce conceptos de teoría de categorías y estructuras de datos como Functor y Maybe.
El documento contiene varios trucos y métodos para realizar tareas comunes en Visual Basic, como hacer que una ventana siempre sea visible, simular clics de ratón, copiar tablas entre bases de datos, reproducir sonido, controlar el volumen y detectar si hay conexión a Internet.
El documento proporciona ejemplos de cómo manipular arrays dinámicos y acceder a archivos de texto en C y C#. En C, se usan funciones como malloc, realloc y free para manejar arrays dinámicos, mientras que en C# se usan clases como ArrayList. Para el acceso a archivos, C usa funciones como fopen y fprintf, mientras que C# usa clases como StreamReader y StreamWriter.
El documento contiene una serie de funciones en Visual Basic para el análisis de cadenas de texto. Incluye funciones para comprobar si una palabra comienza por un prefijo, comparar dos palabras, quitar acentos de un texto, y comprobar si un contenedor contiene un contenido. También incluye ejemplos de macros de Excel para registrar trabajadores en una hoja y realizar consultas filtrando datos según una celda seleccionada.
El documento presenta 4 programas escritos en Java que demuestran el uso de hilos concurrentes y paralelos. El primer programa crea una ventana gráfica simple que muestra la palabra "HOLA". Los programas 2 y 3 imprimen cadenas de texto usando hilos con herencia y la interfaz Runnable. El programa 4 establece prioridades y atributos como "daemon" en hilos creados con herencia e interfaz.
Este documento describe cómo implementar una tabla hash en Java. Explica que los objetos insertados en la tabla deben redefinir el método hashCode() o implementar una interfaz Hashable que devuelva la clave del objeto. También detalla una función de dispersión basada en la regla de Horner que calcula el hash de una cadena de caracteres de manera óptima. Finalmente, muestra un ejemplo de cómo una clase Mercancía podría implementar la interfaz Hashable devolviendo el código como clave.
El documento describe la creación de objetos de la clase W y la ejecución de su constructor. Se crea un objeto n mediante new W(3, 8.1, "a3"), se inicializan sus variables y se muestran mensajes. Luego se crea x e igualmente se inicializan sus variables.
El documento contiene varios ejemplos de código C++ que muestran el uso de diferentes tipos de variables (enteras, booleanas, float, double), operadores (aritméticos, de comparación, lógicos), estructuras de control (if, switch, while, for), funciones, clases y métodos. Los ejemplos van desde "Hola Mundo" hasta cálculos más complejos como el cálculo del sueldo de empleados y operaciones matemáticas con números.
El documento describe la creación de objetos de la clase W y la ejecución de su constructor y método g. Se crean dos objetos W llamados n y x, invocando su constructor y pasando parámetros. Luego se invoca el método g del objeto x, pasando el atributo k del objeto n.
El documento define los arreglos como colecciones ordenadas y homogéneas de elementos. Explica que los arreglos unidimensionales son listas de variables del mismo tipo, mientras que los arreglos bidimensionales representan datos en forma de tabla con filas y columnas. Finalmente, presenta un problema y su codificación en Java para almacenar datos de equipos y partidos de un mundial de fútbol usando arreglos.
Este documento proporciona información sobre arrays (listas y tablas) en C, incluyendo cómo declarar, inicializar y acceder a elementos de arrays unidimensionales y multidimensionales. También cubre temas como el paso de arrays como parámetros, ordenación de listas, búsqueda en listas y ejemplos de código.
Este documento presenta una introducción a las colecciones y generics en Java. Explica los métodos Object clave como toString(), equals() y hashCode(), y cómo deben implementarse correctamente. Luego resume las principales interfaces y clases de colecciones como List, Set, Map y Queue, y describe algunas de sus implementaciones más comunes como ArrayList, LinkedList, HashSet, TreeSet, HashMap y TreeMap. Finalmente, introduce conceptos como ordenado, sorted y los contratos de equals() y hashCode().
El documento describe el código para agregar artículos en un formulario de ventas en Visual Basic. Se conecta a una base de datos Access para obtener datos de artículos y llenar listas desplegables. Al seleccionar un artículo, carga los campos con sus detalles. Actualiza el stock al guardar y pasa los datos al formulario de venta principal.
El documento explica cómo implementar una tabla hash utilizando objetos como elementos. Sugiere crear una interfaz con un método getClave() y hacer que la clase de los elementos implemente esta interfaz para obtener la clave de cada elemento. También describe cómo calcular el índice de la tabla aplicando el método de Horner a la clave para evitar colisiones. Finalmente, muestra un ejemplo de código para implementar la función de dispersión.
Este documento describe varios temas relacionados con matrices y estructuras de datos lineales en Java. Explica los métodos de suma y multiplicación de matrices usando la clase Matrix, y cómo resolver sistemas lineales mediante el método de Gauss. También describe pilas y colas como estructuras de datos FIFO y LIFO usando las clases Stack y Queue, respectivamente.
El documento presenta el pseudocódigo para una clase Tabla Hash que utiliza la aproximación abierta. La clase permite añadir y borrar elementos y calcular el factor de carga. Si el factor de carga supera 1 o es inferior a 0.33, se realiza una redispersion aumentando o disminuyendo el tamaño de la tabla, respectivamente. El pseudocódigo define los métodos constructor, añadir, borrar, buscar, factorDeCarga, funciónHash y los métodos de redispersion.
Este documento discute el uso de objetos en tablas hash. Explica que es posible usar la clase Object directamente como elementos en una tabla hash redefiniendo el método hashCode(). También sugiere usar una clase contenedora que asocie claves de tipo String a objetos para cada elemento. Describe una función de dispersión basada en el método hashCode() de las cadenas que calcula el código hash como una suma ponderada de los códigos ASCII de cada carácter.
El documento describe cómo implementar una tabla hash cerrada con borrado perezoso utilizando una clase contenedor para gestionar las etiquetas de cada celda (borrado, vacío, legítimo). Explica que la función de dispersión transforma la clave en un índice numérico usando la regla de Horner y el módulo para calcular la posición, y provee un ejemplo con claves 'Ana' y 'Juan'.
Las interfaces principales son Collection, List, Set, Queue y Map. Collection permite agregar elementos y recorrerlos, mientras que Map asocia valores a llaves usando métodos como put() y get(). Las colecciones soportan ordenamiento natural y comparadores personalizados. La clase Collections provee algoritmos como ordenamiento y búsqueda, además de métodos para generar colecciones inmutables y sincronizadas.
Una tabla hash es una estructura de datos que permite realizar operaciones de recuperación, eliminación e inserción de elementos de forma rápida mediante el uso de funciones hash que mapean claves a posiciones de una tabla. Las tablas hash son útiles para implementar diccionarios y otras estructuras asociativas, pero pueden sufrir colisiones cuando múltiples claves son mapeadas a la misma posición.
Scala es un lenguaje de programación funcional y orientado a objetos que se ejecuta en la JVM. Aunque comparte similitudes con Java, Scala evita la mutabilidad de datos, asignaciones y bucles imperativos para favorecer la escalabilidad, legibilidad del código y programación paralela. Aprender la programación funcional requiere adaptarse a un nuevo paradigma y siempre tendrá un coste asociado. Scala proporciona características potentes como funciones de alto orden, pattern matching, case classes y colecciones inmutables que reducen
Este documento presenta conceptos sobre tipos de datos compuestos y recursivos en Prolog, incluyendo:
1) Se introducen listas como un tipo de datos recursivo y se proveen ejemplos de su manipulación como agregar y concatenar elementos.
2) Se explica el uso de assert y retract para modificar una base de datos interna en Prolog y operaciones como guardar y consultar bases de datos.
3) Se pide repetir un ejercicio anterior usando un enfoque recursivo y las operaciones de bases de datos como findall.
Charla congreso web introducción programación funcional en JavaScriptRicardo Pallás Román
Este documento presenta una introducción a la programación funcional en JavaScript. Explica conceptos como funciones puras, currying, composición y categorías. También muestra ejemplos de cómo trabajar con arrays sin bucles utilizando funciones como map, filter y reduce. Finalmente, introduce conceptos de teoría de categorías y estructuras de datos como Functor y Maybe.
El documento contiene varios trucos y métodos para realizar tareas comunes en Visual Basic, como hacer que una ventana siempre sea visible, simular clics de ratón, copiar tablas entre bases de datos, reproducir sonido, controlar el volumen y detectar si hay conexión a Internet.
El documento proporciona ejemplos de cómo manipular arrays dinámicos y acceder a archivos de texto en C y C#. En C, se usan funciones como malloc, realloc y free para manejar arrays dinámicos, mientras que en C# se usan clases como ArrayList. Para el acceso a archivos, C usa funciones como fopen y fprintf, mientras que C# usa clases como StreamReader y StreamWriter.
El documento contiene una serie de funciones en Visual Basic para el análisis de cadenas de texto. Incluye funciones para comprobar si una palabra comienza por un prefijo, comparar dos palabras, quitar acentos de un texto, y comprobar si un contenedor contiene un contenido. También incluye ejemplos de macros de Excel para registrar trabajadores en una hoja y realizar consultas filtrando datos según una celda seleccionada.
El documento presenta 4 programas escritos en Java que demuestran el uso de hilos concurrentes y paralelos. El primer programa crea una ventana gráfica simple que muestra la palabra "HOLA". Los programas 2 y 3 imprimen cadenas de texto usando hilos con herencia y la interfaz Runnable. El programa 4 establece prioridades y atributos como "daemon" en hilos creados con herencia e interfaz.
Este documento describe cómo implementar una tabla hash en Java. Explica que los objetos insertados en la tabla deben redefinir el método hashCode() o implementar una interfaz Hashable que devuelva la clave del objeto. También detalla una función de dispersión basada en la regla de Horner que calcula el hash de una cadena de caracteres de manera óptima. Finalmente, muestra un ejemplo de cómo una clase Mercancía podría implementar la interfaz Hashable devolviendo el código como clave.
El documento describe la creación de objetos de la clase W y la ejecución de su constructor. Se crea un objeto n mediante new W(3, 8.1, "a3"), se inicializan sus variables y se muestran mensajes. Luego se crea x e igualmente se inicializan sus variables.
El documento contiene varios ejemplos de código C++ que muestran el uso de diferentes tipos de variables (enteras, booleanas, float, double), operadores (aritméticos, de comparación, lógicos), estructuras de control (if, switch, while, for), funciones, clases y métodos. Los ejemplos van desde "Hola Mundo" hasta cálculos más complejos como el cálculo del sueldo de empleados y operaciones matemáticas con números.
El documento describe la creación de objetos de la clase W y la ejecución de su constructor y método g. Se crean dos objetos W llamados n y x, invocando su constructor y pasando parámetros. Luego se invoca el método g del objeto x, pasando el atributo k del objeto n.
El documento define los arreglos como colecciones ordenadas y homogéneas de elementos. Explica que los arreglos unidimensionales son listas de variables del mismo tipo, mientras que los arreglos bidimensionales representan datos en forma de tabla con filas y columnas. Finalmente, presenta un problema y su codificación en Java para almacenar datos de equipos y partidos de un mundial de fútbol usando arreglos.
Este documento proporciona información sobre arrays (listas y tablas) en C, incluyendo cómo declarar, inicializar y acceder a elementos de arrays unidimensionales y multidimensionales. También cubre temas como el paso de arrays como parámetros, ordenación de listas, búsqueda en listas y ejemplos de código.
Este documento presenta una introducción a las colecciones y generics en Java. Explica los métodos Object clave como toString(), equals() y hashCode(), y cómo deben implementarse correctamente. Luego resume las principales interfaces y clases de colecciones como List, Set, Map y Queue, y describe algunas de sus implementaciones más comunes como ArrayList, LinkedList, HashSet, TreeSet, HashMap y TreeMap. Finalmente, introduce conceptos como ordenado, sorted y los contratos de equals() y hashCode().
El documento describe el código para agregar artículos en un formulario de ventas en Visual Basic. Se conecta a una base de datos Access para obtener datos de artículos y llenar listas desplegables. Al seleccionar un artículo, carga los campos con sus detalles. Actualiza el stock al guardar y pasa los datos al formulario de venta principal.
El documento explica cómo implementar una tabla hash utilizando objetos como elementos. Sugiere crear una interfaz con un método getClave() y hacer que la clase de los elementos implemente esta interfaz para obtener la clave de cada elemento. También describe cómo calcular el índice de la tabla aplicando el método de Horner a la clave para evitar colisiones. Finalmente, muestra un ejemplo de código para implementar la función de dispersión.
Este documento describe varios temas relacionados con matrices y estructuras de datos lineales en Java. Explica los métodos de suma y multiplicación de matrices usando la clase Matrix, y cómo resolver sistemas lineales mediante el método de Gauss. También describe pilas y colas como estructuras de datos FIFO y LIFO usando las clases Stack y Queue, respectivamente.
El documento presenta el pseudocódigo para una clase Tabla Hash que utiliza la aproximación abierta. La clase permite añadir y borrar elementos y calcular el factor de carga. Si el factor de carga supera 1 o es inferior a 0.33, se realiza una redispersion aumentando o disminuyendo el tamaño de la tabla, respectivamente. El pseudocódigo define los métodos constructor, añadir, borrar, buscar, factorDeCarga, funciónHash y los métodos de redispersion.
Este documento discute el uso de objetos en tablas hash. Explica que es posible usar la clase Object directamente como elementos en una tabla hash redefiniendo el método hashCode(). También sugiere usar una clase contenedora que asocie claves de tipo String a objetos para cada elemento. Describe una función de dispersión basada en el método hashCode() de las cadenas que calcula el código hash como una suma ponderada de los códigos ASCII de cada carácter.
El documento describe cómo implementar una tabla hash cerrada con borrado perezoso utilizando una clase contenedor para gestionar las etiquetas de cada celda (borrado, vacío, legítimo). Explica que la función de dispersión transforma la clave en un índice numérico usando la regla de Horner y el módulo para calcular la posición, y provee un ejemplo con claves 'Ana' y 'Juan'.
Las interfaces principales son Collection, List, Set, Queue y Map. Collection permite agregar elementos y recorrerlos, mientras que Map asocia valores a llaves usando métodos como put() y get(). Las colecciones soportan ordenamiento natural y comparadores personalizados. La clase Collections provee algoritmos como ordenamiento y búsqueda, además de métodos para generar colecciones inmutables y sincronizadas.
Una tabla hash es una estructura de datos que permite realizar operaciones de recuperación, eliminación e inserción de elementos de forma rápida mediante el uso de funciones hash que mapean claves a posiciones de una tabla. Las tablas hash son útiles para implementar diccionarios y otras estructuras asociativas, pero pueden sufrir colisiones cuando múltiples claves son mapeadas a la misma posición.
El documento discute si se puede usar la clase Object para los elementos de una tabla hash. Explica que no se puede usar Object porque no tiene un método público que devuelva una cadena clave para cada elemento, aunque tiene el método hashCode que devuelve un número entero. También describe brevemente cómo funciona la función de dispersión matemática para asociar elementos con claves en una tabla hash y reducir colisiones.
Este documento describe los vectores en C++, incluyendo cómo declararlos, insertar y eliminar elementos, acceder a elementos mediante subíndices, cambiar el tamaño, pasar vectores a funciones, y ordenar y buscar en vectores. Los vectores permiten acceso aleatorio eficiente a elementos y administran la memoria automáticamente a medida que cambia de tamaño.
El documento proporciona instrucciones sobre el uso de MySQL para la creación y gestión de bases de datos y tablas, la inserción y modificación de datos, y el manejo de claves primarias y claves foráneas. Se explican sentencias como CREATE DATABASE, CREATE TABLE, INSERT, ALTER TABLE, y se definen conceptos como claves primarias, claves foráneas y actualización en cascada.
El documento habla sobre arrays (listas y tablas) en C. Explica que un array es una secuencia de datos del mismo tipo almacenados de forma contigua en memoria. Cubre temas como declaración, inicialización, acceso e indexación de elementos de arrays unidimensionales y multidimensionales. También describe el paso de arrays como parámetros a funciones y ejemplos de código para sumar y encontrar el máximo de una lista de números.
ejercicios de programacion java orienta a objetosMiguelAmc
El documento describe las interfaces y clases principales para trabajar con colecciones en Java. Define las interfaces Collection, List, Map, y sus métodos. También describe colecciones concretas como HashSet, TreeSet, ArrayList y HashMap. Explica cómo iterar sobre colecciones e implementa ejemplos de código para contar palabras únicas, calcular frecuencias de palabras y ordenar por frecuencia usando diferentes estructuras de datos y comparadores.
La tabla hash almacena elementos en celdas de un array utilizando una función de dispersión que calcula el módulo del código hash de la clave y el tamaño de la tabla. La clase Contenedor guarda la clave, el objeto y el estado de cada elemento para su gestión en la tabla hash.
La tabla hash utiliza el método hashCode() de la clase Object para almacenar objetos. Para implementar la función hash, se convierte la clave en un entero usando el código ASCII de cada carácter y operaciones matemáticas, y luego se toma el módulo de ese número y el tamaño de la tabla para determinar la posición. Para manejar colisiones, se explora secuencialmente las celdas siguientes usando un incremento lineal hasta encontrar una vacía.
Este documento explica cómo crear y utilizar arreglos de objetos en Java. Primero se define una clase Punto que representa un punto en el plano. Luego se define una clase ArregloPunto que almacena arreglos de objetos Punto, incluyendo métodos para agregar, mostrar y obtener la cantidad de puntos. Finalmente, en la clase app se crea un objeto ArregloPunto, se solicitan puntos al usuario y se almacenan y muestran usando los métodos de la clase ArregloPunto.
Este documento explica cómo crear y utilizar arreglos de objetos en Java. Primero se define una clase Punto que representa un punto en el plano. Luego se define una clase ArregloPunto que almacena arreglos de objetos Punto, incluyendo métodos para agregar, mostrar y obtener la cantidad de puntos. Finalmente, en la clase app se crea un objeto ArregloPunto, se solicitan puntos al usuario y se almacenan y muestran usando los métodos de la clase ArregloPunto.
Este documento discute cómo usar objetos en tablas hash y cómo se implementan las funciones de dispersión. Explica que los objetos pueden usarse en tablas hash mediante el método hashCode() de Object o creando una clase o interfaz. También describe que la función hashCode() devuelve un entero que representa la posición en la tabla hash, y que la función de dispersión predeterminada para cadenas usa una fórmula polinómica sobre los caracteres.
Este documento explica cómo conectarse y gestionar bases de datos en Gambas. Primero, se debe activar el componente de bases de datos y crear una conexión especificando parámetros como el tipo, host, nombre de usuario y contraseña. Luego, se puede crear una base de datos si no existe y agregar tablas con campos. Finalmente, se explican funciones para crear, buscar, editar y eliminar registros, usando métodos como Create, Find, Edit y Exec. El documento también resalta la importancia de iniciar transacciones para realizar cambios de
Estudiaremos las instrucciones para la manipulación de datos (DML) en el API WebSQL Database, como son el Insert, Update y Delete, para insertar, modificar y borrar un registro, respectivamente.
Este documento describe las estructuras de datos de lista, pila y cola. Define cada una y propone un TAD (tipo abstracto de datos) para modelarlas con constructores y operaciones básicas como vaciar, insertar, eliminar, etc. También indica objetos del mundo real que pueden modelarse con cada estructura y cómo se implementan pilas y colas a través de listas y vectores en los lenguajes de programación.
ESPERAMOS QUE ESTA INFOGRAFÍA SEA UNA HERRAMIENTA ÚTIL Y EDUCATIVA QUE INSPIRE A MÁS PERSONAS A ADENTRARSE EN EL APASIONANTE CAMPO DE LA INGENIERÍA CIVIŁ. ¡ACOMPAÑANOS EN ESTE VIAJE DE APRENDIZAJE Y DESCUBRIMIENTO
1. TABLAS HASH
INTRODUCCIÓN
- Intuitivamente, una tabla es una colección de elementos, cada uno de los cuales tiene una clave y una información
asociada.
- Esta aproximación consiste en proceder, no por comparaciones entre valores clave, sino encontrando alguna
función h(k), función de dispersión, que nos dé directamente la localización de la clave k en la tabla.
- La función de dispersión se aplica a lo que habitualmente se denomina como la clave del elemento (y que en
ocasiones será él mismo). Se denomina valor de dispersión al valor h(clave_de_x), y cubetas a las clases. Se dice que x
pertenece a la cubta de h(clave_de_x).
- El objetivo será encontrar una función hash que provoque el menor número posible de colisiones (ocurrencias de
sinónimos), aunque esto es solo un aspecto del problema, el otro será el de diseñar métodos de resolución de colisiones
cuando éstas se produzcan.
2. TABLAS DE DISPERSIÓN ABIERTAS
- La manera más simple de resolver una colisión es construir, para cada localización de la tabla, una lista enlazada
de registros cuyas claves caigan en esa dirección. Puede ser LIFO o FIFO.
3. CLASE ABSTRACTA
template <class B, class H, class T>
class hashTable {
friend class hashTableIterator<B, H, T>;
public:
// constructores
4. hashTable (const unsigned int & max,
unsigned int (*f) (const H &));
hashTable (const hashTable<B, H, T> & source);
virtual bool isEmpty () const;
/* Produce: cierto si la tabla receptora está vacía. */
virtual void deleteAllValues ();
/* Modifica: la tabla receptora haciéndola vacía. */
protected:
// área de datos
const unsigned int tablesize;
vector<B *> buckets;
unsigned int (*hashfun) (const H &);
// operaciones internas
unsigned int hash (const H & key) const;
/* Necesita: una clave.
Produce: el valor de dispersión de la clave dada. */
virtual iterator<T> * makeIterator (const unsigned int &) = 0;
/* Necesita: un número de clase o cubeta.
Produce: un iterador para la clase dada. */
};
template <class B, class H, class T>
hashTable<B, H, T>::hashTable (const unsigned int & max,
unsigned int (*f)(const H &))
: tablesize(primo(max)), buckets(primo(max)), hashfun(f)
{
for (unsigned int i = 0; i < tablesize; i++) {
buckets[i] = new B;
assert(buckets[i] != 0);
}
}
5. template <class B, class H, class T>
hashTable<B, H, T>::hashTable
(const hashTable<B, H, T> & source)
: tablesize(source.tablesize), buckets(source.buckets),
hashfun(source.hashfun)
{
for (unsigned int i = 0; i < tablesize; i++) {
buckets[i] = new B(*source.buckest[i]);
assert(buckets[i] != 0);
}
}
template <class B, class H, class T>
bool hashTable<B, H, T>::isEmpty () const
{
for (int i = 0; i < tablesize; i++)
if (!buckets[i]->isEmpty())
return false;
// todas las cubetas están vacías
return true;
}
template <class B, class H, class T>
void hashTable<B, H, T>::deleteAllValues()
{
// borrar todos los elementos en cada cubeta
for (int i = 0; i < tablesize; i++)
6. buckets[i]->deleteAllValues();
}
template <class B, class H, class T>
unsigned int hashTable<B, H, T>::hash (const H & key) const
{
return (*hashfun)(key) % tablesize;
}
template <class B, class H, class T>
class hashTableIterator : public iterator<T> {
public:
// constructor
hashTableIterator(hashTable<B, H, T> & aHashTable);
hashTableIterator(const hashTableIterator<B, H, T> & source);
// protocolo iterador
virtual bool init ();
virtual T operator () ();
virtual bool operator ! ();
virtual bool operator ++ ();
virtual bool operator ++ (int);
virtual T & operator = (const T & value);
protected:
// área de datos
unsigned int currentIndex; // índice de la cubeta actual
iterator<T> * itr; // iterador de la cubeta actual
hashTable<B, H, T> & base;
// operación interna
bool getNextIterator ();
7. /* Efecto: obtiene el iterador sobre la siguiente
cubeta no vacía.
Produce: cierto si encuentra una cubeta no vacía. */
};
template <class B, class H, class T>
hashTableIterator<B, H, T>::hashTableIterator
(hashTable<B, H, T> & aHashTable)
: base(aHashTable), currentIndex(0), itr(0)
{
init();
}
template <class B, class H, class T>
bool hashTableIterator<B, H, T>::init ()
{
// obtener la primera cubeta no vacia
currentIndex = 0;
return getNextIterator();
}
template <class B, class H, class T>
T hashTableIterator<B, H, T>::operator () ()
{
return (*itr)();
}
8. template <class B, class H, class T>
bool hashTableIterator<B, H, T>::operator ! ()
{
return itr != 0;
}
template <class B, class H, class T>
bool hashTableIterator<B, H, T>::operator ++ ()
{
// si se puede, avanzar en el iterador actual
if (itr && (*itr)++)
return true;
// en caso contrario obtener el siguiente iterador
currentIndex++;
return getNextIterator();
}
template <class B, class H, class T>
bool hashTableIterator<B, H, T>::getNextIterator ()
{
if (itr != 0)
delete itr;
// buscar el nuevo cubo en el que iterar
for (; currentIndex < base.tablesize; currentIndex++) {
itr = base.makeIterator(currentIndex);
assert(itr != 0);
if (itr->init()) // si hay elemento actual retornar
return true;
9. delete itr;
}
itr = 0; // no hay más elementos
return false;
}
REPRESENTACIÓN BASADA EN LISTAS
// Clase hashList
// Implementación de la clase hashTable con listas.
// La clave es el valor.
template <class T>
class hashList : public hashTable<setList<T>, T, T> {
public:
// constructores
hashList (const unsigned int & max,
unsigned int (*f) (const T &));
hashList (const hashList<T> & source);
void add (const T & value);
/* Necesita: un valor de tipo T.
Modifica: la tabla receptora añadiendo, si no existe,
el valor dado. */
bool includes (const T & value) const;
/* Necesita: un valor de tipo T.
Produce: cierto si el valor dado se encuentra
en la tabla receptora. */
void remove (const T & value);
/* Necesita: un valor de tipo T.
10. Modifica: la tabla receptora eliminando de la misma,
si existe, el valor dado. */
protected:
// operación interna
virtual iterator<T> * makeIterator (const unsigned int & i );
};
template <class T>
hashList<T>::hashList (const unsigned int & max,
unsigned int (*f) (const T &))
: hashTable<setList<T>, T, T>(max, f)
{}
template <class T>
void hashList<T>::add (const T & value)
{
buckets[hash(value)]->add(value);
}
template <class T>
bool hashList<T>::includes (const T & value) const
{
return buckets[hash(value)]->includes(value);
}
template <class T>
15. }
TABLAS DE DISPERSIÓN CERRADAS
- En una tabla de dispersión cerrada sólo se permite un elemento por clase, ya que los miembros de la colección se
almacenan directamente en la tabla, en vez de usar ésta para almacenar las direcciones de las cubetas.
- Deberá existir una estrategia de redispersión (función de rehashing) para miembros de la colección con el mismo
valor de dispersión.
- Así, si se intenta colocar x en la cubeta h(clave_de_x) y ésta ya tiene un elemento (situación denominada colisión),
la estrategia de redispersión elige una sucesión de cubetas alternativas h1(clave_de_x), h2(clave_de_x), ... hasta encontrar
una libre en la que poder ubicar el elemento.
16. ANÁLISIS DE DISPERSIÓN CERRADA
template <class H, class T>
class hashVector {
friend class hashVectorIterator<H, T>;
public:
// constructores
hashVector (unsigned int max,
Número de
colisiones
17. unsigned int (*hash)(const H &),
unsigned int (*rhash)(const H &, int));
hashVector (unsigned int max,
unsigned int (*hash)(const H &),
unsigned int (*rhash)(const H &, int),
const T & init);
hashVector (const hashVector<H, T> & source);
// destructor
~hashVector ();
// test de vacío
bool isEmpty () const;
// operación de índice (adición, acceso y modificación)
T & operator [] (const H & aKey);
// operación de borrado
void remove (const H & aKey);
// test de pertenencia
bool includes (const H & aKey);
// borrado de todos los elementos
void deleteAllValues ();
protected:
// área de datos
vector<association<H,T> *> data; // tabla de cubetas
vector<bool> erase; // se borró el contenido de una
// cubeta?
unsigned int numberOfSlots; // cubetas nunca ocupadas
unsigned int numberOfElements; // elementos en la tabla
unsigned int tablesize; // dimensión de la tabla
T initial; // valor por defecto
unsigned int (*hashfun) (const H &); // función hash
unsigned int (*rhashfun) (const H &, int); // función
// de rehash
// operaciones internas
unsigned int firstEqualEmpty (const H &) const;
18. /* Necesita: una clave.
Produce: la cubeta que contiene la clave dada, o la
primera cubeta nunca ocupada que se
encuentra en la sucesión de cubetas que se
obtiene al aplicar la función de dispersión y,
si es necesario, las funciones de redispersión
a la clave dada. */
unsigned int firstEqualEraseEmpty (const H &) const;
/* Necesita: una clave.
Produce: la cubeta que contiene la clave dada, o la
primera cubeta nunca ocupada o en la que
se borró el contenido, en la sucesión de cubetas
generada al aplicar la función de dispersión
y, si es necesario, las funciones de redispersión
a la clave dada. */
};
template <class H, class T>
hashVector<H, T>::hashVector
(unsigned int max, unsigned int (*hash)(const H &),
unsigned int (*rhash)(const H &, int))
: data(primo(max), (association<H, T> *) 0),
erase(primo(max), false), hashfun(hash),
rhashfun(rhash), numberOfElements(0)
{
tablesize = data.length();
numberOfSlots = tablesize;
}
template <class H, class T>
19. hashVector<H, T>::hashVector
(const hashVector<H,T> & source)
: data(source.tablesize), erase(source.erase),
hashfun(source.hashfun), rhashfun(source.rhashfun),
numberOfSlots(source.numberOfSlots),
numberOfElements(source.numberOfElements),
tablesize(source.tablesize), initial(source.initial)
{
for (unsigned int i = 0; i < tablesize; i++)
if (source.data[i])
data[i] = new association<H, T>(*source.data[i]);
else
data[i] = 0;
}
template <class H, class T>
hashVector<H, T>::~hashVector ()
{
deleteAllValues();
}
template <class H, class T>
bool hashVector<H, T>::isEmpty () const
{
for (int i = 0; i != data.length() ; i++)
if (data[i])
return false;
return true;
20. }
template <class H, class T>
unsigned int hashVector<H, T>::firstEqualEmpty
(const H & aKey) const
{
int pos = (*hashfun)(aKey) % tablesize;
for (unsigned int i=0; i < tablesize && (data[pos] ||
erase[pos]) && data[pos]->key() != aKey; i++)
pos = (*rhashfun)(aKey, i+1) % tablesize;
return pos;
}
template <class H, class T>
unsigned int hashVector<H, T>::firstEqualEraseEmpty
(const H & aKey) const
{
int pos = (*hashfun)(aKey) % tablesize;
for (unsigned int i=0; i < tablesize && data[pos]
&& data[pos]->key() != aKey; i++)
pos = (*rhashfun)(aKey, i+1) % tablesize;
return pos;
}
template <class H, class T>
bool hashVector<H, T>::includes (const H & aKey)
{
21. int pos = firstEqualEmpty(aKey);
return data[pos] && data[pos]->key() == aKey;
}
template <class H, class T>
T & hashVector<H, T>::operator [] (const H & aKey)
{
int pos = firstEqualEmpty(aKey);
// clave encontrada
if (data[pos] && data[pos]->key() == aKey)
return data[pos]->valueField;
// clave no encontrada
pos = firstEqualEraseEmpty(aKey);
// si es necesario redimensionar la tabla
if (numberOfSlots <= 0.1 * tablesize) {
vector<association<H,T> *> oldData(data);
// inicialmente en la nueva tabla no habra elementos
tablesize = primo(2 * tablesize); // se duplica el
// espacio
data = vector<association<H,T> *> (tablesize,
(association<H,T> *) 0);
erase = vector<bool>(tablesize, false);
numberOfSlots = tablesize;
numberOfElements = 0;
// insertar todos los elementos que ya estaban en
// la tabla
for (unsigned int i = 0; i < oldData.length(); i++)
if (oldData[i] != 0) {
operator [] (oldData[i]->key()) =
oldData[i]->value();
delete oldData[i];
22. }
}
// insertar clave y valor por defecto
data[pos] = new association<H,T>(aKey, initial);
if (erase[pos])
erase[pos] = false;
else
numberOfSlots--;
numberOfElements++;
return data[pos]->valueField;
}
template <class H, class T>
void hashVector<H, T>::remove (const H & aKey)
{
int pos = firstEqualEmpty(aKey);
if (data[pos] && data[pos]->key() == aKey) {
erase[pos] = true;
numberOfElements--;
// recuperar el espacio
delete data[pos];
data[pos] = 0;
}
}
template <class H, class T>
class hashVectorIterator : public iterator<T> {
public:
// constructor
23. hashVectorIterator (hashVector<H, T> & aHashVector);
hashVectorIterator (const hashVectorIterator<H, T> &
source);
// protocolo iterador
virtual bool init ();
virtual bool operator ! ();
virtual bool operator ++ (); // prefijo
virtual bool operator ++ (int); // postfijo
virtual T operator () ();
virtual T & operator = (const T & val);
// método especifico de esta subclase
H key ();
/* Produce: la clave del elemento actual. */
protected:
// área de datos
unsigned int currentKey;
hashVector<H, T> & theHashVector;
// operación interna
bool getNext ();
/* Efecto: obtiene la siguiente cubeta que contiene
un elemento de la tabla.
Produce: cierto si encuentra una cubeta no vacía. */
};
template <class T>
void heapSort (vector<T> & v)
/* Necesita: un vector v.
Modifica: el vector ordenando sus componentes por
el método del montículo (heap). */
{
unsigned int n = v.length();
24. /*
*/
for (int i = n / 2 - 1; i >= 0; --i)
reorganize(v, i, n - 1);
for (unsigned int i = n - 1; i > 0; --i) {
/*
*/
swap(v, 0, i);
/*
*/
reorganize(v, 0, i-1);
}
}
template <class T>
setList<setList<T> *> partes (setList<T> & c)
{
setListIterator<T> itrC(c);
Está mal la
raíz
25. setList<setList<T> *> result;
setList<T> * vacio = new setList<T>();
// adición del conjunto vacío
result.add(vacio);
for (itrC.init(); !itrC; ++itrC) {
setList<setList<T> *> temp(result);
setListIterator<setList<T> *> itrT(temp);
for (itrT.init(); !itrT; ++itrT) {
// añadir el elemento de C a cada elemento de temp
setList<T> * newParte = new setList<T>(*itr());
newParte->add(itrC());
result.add(newParte);
}
}
return result;
}
FUNCIONES HASH
HASHING MULTIPLICATIVO
- Esta técnica trabaja multiplicando la clave k por sí misma o por una constante, usando después alguna porción de
los bits del producto como una localización de la tabla hash.
26. HASHING POR DIVISIÓN
- En este caso la función se calcula simplemente como h(k) = k mod M usando el 0 como el primer índice de la tabla
hash de tamaño M.
BORRADOS Y REHASHING
- Cuando intentamos borrar un valor k de una tabla que ha sido generada por dispersión cerrada, nos encontramos
con un problema. Si k precede a cualquier otro valor k en una secuencia de pruebas, no podemos eliminarlo sin más, ya
que si lo hiciéramos, las pruebas siguientes para k se encontrarían el "agujero" dejado por k por lo que podríamos concluir
que k no está en la tabla, hecho que puede ser falso.
- La solución es que necesitamos mirar cada localización de la tabla hash como inmersa en uno de los tres posibles
estados: vacía, ocupada o borrada, de forma que en lo que concierne a la búsqueda, una celda borrada se trata exactamente
igual que una ocupada. En el caso de las inserciones, podemos usar la primera localización vacía o borrada que se
encuentre en la secuencia de pruebas para realizar la operación.
- Cuando una tabla llega a un desbordamiento o cuando su eficiencia baja demasiado debido a los borrados, el
único recurso es llevarla a otra tabla de un tamaño más apropiado, no necesariamente mayor, puesto que como las
localizaciones borradas no tienen que reasignarse, la nueva tabla podría ser mayor, menor o incluso del mismo tamaño
que la original. Este proceso se suele denominar rehashing y es muy simple de implementar si el arca de la nueva tabla es
distinta al de la primitiva, pero puede complicarse bastante si deseamos hacer un rehashing en la propia tabla.
28. - Imaginemos que queremos introducir en la tabla un nuevo dato cuya clave es 596397. Utilizando una función de
dispersión,
f (k) = k % 1000
obtenemos f (596397) = 397. Por lo tanto, el dato habrá que almacenarlo en la posición 397.
- Dicha posición está ocupada por otro dato con clave distinta (4957397), por lo que el nuevo dato se deberá insertar
en otra posición.
- El método más simple consiste en realizar una búsqueda lineal de la siguiente posición libre en el vector, es decir,
definir
h (k) = (k+1) % 1000
- Hay que exigir a la función h que produzca índices uniformemente distribuidos en el intervalo 0, …, n-1 (siendo n
el número de elementos del vector).
MEDIANTE ENCADENAMIENTO
- Este método consiste en permitir múltiples claves de registros en una misma posición. En este caso existen dos
posibilidades:
29. 1. Que cada dirección calculada contenga espacios para múltiples pares, en vez de un único par. Cada una de estas
posiciones se denomina cubo.
2. Otra solución, es usar la dirección calculada, no como posición real del registro, sino como el índice en un vector
de listas enlazadas. Cada posición del vector accede a una lista de pares que comparten la misma dirección.
30. - Para buscar un registro dado, aplicamos primero la función hash a su clave y luego buscamos la cadena para el
registro en la línea. De este modo, si la lista es muy grande, se pierde la eficiencia del método.