CURSO DE ALGORITMOS Y PROGRAMACIÓN A FONDO 2ED

CURSO DE ALGORITMOS Y PROGRAMACIÓN A FONDO 2ED

IMPLEMENTACIONES EN C++

SZNAJDLEDER, PABLO AUGUSTO

28,30 €
IVA incluido
Sin stock. Disponible en 24/48h
Editorial:
MARCOMBO
Año de edición:
2023
Ubicación
A1-3106
ISBN:
978-84-267-3633-8
Páginas:
324
Encuadernación:
Rústica
28,30 €
IVA incluido
Sin stock. Disponible en 24/48h
Añadir a favoritos

Prólogo ......................................................... XV
Agradecimientos ......................................... XVII
CAPÍTULO 1
Introducción al diseño de algoritmos y
programación .............................................. 1
1.1. Lección 1 ............................................... 1
1.1.1. ¿Qué es un algoritmo? .................... 1
1.1.2. Lenguaje algorítmico ....................... 4
1.1.3. Recursos de programación ............. 4
1.1.3.1. El ordenador .................................. 4
1.1.3.2. Operaciones aritméticas
y expresiones lógicas .................................. 4
1.1.3.3. Lenguaje de programación .......... 5
1.1.3.4. Programa ....................................... 5
1.1.3.5. Variables y tipos de dato .............. 6
1.1.3.6. Convención de nombres
de variables .................................................... 7
1.1.3.7. Consola .......................................... 8
1.1.3.8. Compilador .................................... 8
1.1.3.9. Entorno Integrado de
desarrollo ..................................................... 9
1.1.4. Teorema de la programación
estructurada ................................................ 9
1.1.4.1. Acción simple ................................ 10
1.1.4.2. Acción condicional ........................ 11
1.1.4.3. Acción iterativa ............................. 15
1.1.4.4. Acciones de única entrada
y única salida ............................................... 19
1.1.5. Más recursos de programación ...... 20
1.1.5.1. Contadores y acumuladores ........ 20
1.1.5.2. Prueba de escritorio ..................... 20
1.1.5.3. Operadores aritméticos ................ 21
1.1.5.4. Otras operaciones matemáticas .. 23
1.1.5.5. Operadores y expresiones
lógicas ........................................................... 24
1.1.5.6. Operadores relacionales ............... 25
1.1.5.7. Operadores relacionales
y cadenas de caracteres ............................. 26
1.1.6. Análisis de ejercicios y problemas ... 27
1.1.6.1. Datos de entrada, de contexto
y de salida ..................................................... 27
1.1.6.2. Procesos para transformar
la entrada en salida ..................................... 28
1.1.7. Tipos de problema ............................ 28
1.1.7.1. Problemas de registro simple y
problemas de múltiples registros ............... 29
1.1.7.2. Multiplicidad ................................... 30
1.1.7.3. Registros y tablas .......................... 30
1.1.7.4. Problemas de procesamiento
horizontal y procesamiento vertical ............ 32
1.1.7.5. Problemas de corte de control ..... 33
1.1.8. Autoevaluación y ejercicios .............. 35
1.2. Lección 2 ............................................... 35
1.2.1. Tipo de dato ....................................... 36
1.2.1.1. Tipos enteros ................................. 37
1.2.1.2. Tipos flotantes ............................... 38
1.2.1.3. Tipos alfanuméricos ...................... 39
1.2.1.4. Tipos lógicos ................................... 40
1.2.1.5. Tipo de dato nulo ........................... 40
1.2.1.6. Tipos de dato primitivos y tipos
definidos por el programador ...................... 40
1.2.2. Alcance de una variable ................... 41
1.2.3. Metodología Top-Down ..................... 43
1.2.3.1. Funciones ....................................... 43
1.2.3.2. Prototipo de una función .............. 46
1.2.3.3. Compilar un programa que
invoca funciones .......................................... 47
1.2.3.4. Reusabilidad del código ................ 48
1.2.3.5. Legibilidad del código fuente ........ 51
1.2.3.6. Bibliotecas de funciones ............... 51
1.2.3.7. Convención de nombres de
funciones ......................................................... 51
1.2.3.8. Parámetros y argumentos ............ 52
1.2.3.9. Parámetros por valor y
referencia ...................................................... 52
1.2.3.10. Variables locales ......................... 54
1.2.4. Autoevaluación y ejercicios .............. 54
1.3. Lección 3 ............................................... 55
1.3.1. Estructuras ........................................ 55
1.3.1.1. Inicialización de una estructura ... 56
1.3.1.2. Convención de nombres de
estructuras ................................................... 57
1.3.1.3. Función de inicialización
de una estructura......................................... 57
1.3.1.4. Estructuras anidadas .................... 58
1.3.2. Tipo Abstracto de Dato (TAD) .......... 59
1.3.2.1. Usuario del TAD ............................ 62
1.3.2.2. Inicialización de un TAD ............... 62
1.3.2.3. Sobrecarga de funciones ............. 62
1.3.3. Autoevaluación y ejercicios .............. 63
1.4. ¿Qué sigue? .......................................... 63
CAPÍTULO 2
Cadenas de caracteres y estructura
de datos ....................................................... 65
2.1. Lección 4 ............................................... 65
2.1.1. Carácter ............................................. 65
2.1.2. Cadena de caracteres ...................... 67
2.1.2.1. Caracteres especiales y
carácter de escape ...................................... 67
2.1.2.2. Carácter nulo que indica
el final de una cadena ................................. 68
2.1.2.3. Acceso directo a los caracteres
de una cadena ............................................. 68
2.1.2.4. Longitud de una cadena ............... 69
2.1.2.5. Operadores aritméticos unarios ... 69
2.1.2.6. Ciclo iterativo for ............................ 70
2.1.2.7. Concatenar cadenas de
caracteres .................................................... 71
2.1.2.8. Operadores relacionales
aplicados a cadenas .................................... 71
2.1.2.9. Función de comparación .............. 72
2.1.2.10. If-inline ......................................... 74
2.1.3. Biblioteca de funciones y API ........... 76
2.1.3.1. Tratamiento de cadenas
de caracteres ................................................ 77
2.1.3.2. Actividad práctica: API de
tratamiento de cadenas de caracteres ...... 77
2.1.4. Argumentos en línea de
comandos ..................................................... 79
2.1.5. Autoevaluación y ejercicios .............. 80
2.2. Lección 5 ............................................... 81
2.2.1. Tratamiento de tokens ..................... 81
2.2.2. Actividad práctica: API de
tratamiento de tokens ................................. 81
2.2.3 Autoevaluación y ejercicios ............... 84
2.3. Lección 6 ............................................... 84
2.3.1. Funciones como argumentos
de otras funciones ....................................... 85
2.3.2. Tipo de dato genérico (template) .... 87
2.3.3. Autoevaluación y ejercicios .............. 93
2.4. Lección 7 ............................................... 93
2.4.1. Colecciones ....................................... 94
2.4.2. TAD Coll .............................................. 95
2.4.2.1. Ejemplo de uso .............................. 96
2.4.2.2. Estructura del TAD Coll ................. 98
2.4.2.3. Actividad práctica: API del
TAD Coll ........................................................ 98
2.4.3. Autoevaluación y ejercicios .............. 101
2.5. Lección 8 ............................................... 101
2.5.1. Ordenamiento ................................... 101
2.5.1.1. Ordenamiento por inserción
simple ............................................................ 101
2.5.1.2. Ordenamiento por burbujeo ......... 102
2.5.1.3. Ordenamiento por burbujeo
mejorado ....................................................... 103
2.5.1.4. Ordenamiento por inserción
avanzado ....................................................... 104
2.5.2. Búsqueda........................................... 105
2.5.2.1. Búsqueda lineal ............................ 105
2.5.2.2. Búsqueda binaria ......................... 106
2.5.3. Autoevaluación y ejercicios ............. 108
2.6. Lección 9 ............................................... 108
2.6.1. Estructura de datos (parte 1) ........... 109
2.6.1.1. Estructuras estáticas y
dinámicas ..................................................... 109
2.6.1.2. Estructura de datos como
cimiento del algoritmo ................................. 110
2.6.1.3. Colección de estructuras .............. 110
2.6.1.4. Colección de colecciones .............. 116
2.6.1.5. Colecciones de estructuras
que tienen colecciones ................................ 119
2.6.2. Autoevaluación y ejercicios .............. 122
2.7. ¿Qué sigue? .......................................... 122
CAPÍTULO 3
Archivos ......................................................... 123
3.1. Lección 10 ............................................ 123
3.1.1. Introducción ....................................... 123
3.1.1.1. Archivo ............................................ 123
3.1.1.2. Tipos de archivo ............................. 124
3.1.1.3. Archivos binarios ........................... 124
3.1.1.4. Archivos de texto ........................... 124
3.1.2. Gestión de archivos .......................... 125
3.1.2.1. Funciones de biblioteca ................ 125
3.1.2.2. Grabar y leer datos ........................ 125
3.1.2.3. Archivo secuencial ......................... 127
3.1.2.4. Archivos de registros de
longitud fija ................................................... 127
3.1.2.5. Big-endian y Little-endian ............. 128
3.1.2.6. Archivos de registros de
longitud variable ........................................... 129
3.1.2.7. Archivos de estructuras ................ 129
3.1.2.8. Posicionamiento directo ............... 132
3.1.2.9. Posicionamiento directo
en registros ................................................... 133
3.1.2.10. Eliminar registros físicamente ... 134
3.1.2.11. Eliminar registros lógicamente .. 134
3.1.2.12. Modificar registros ...................... 136
3.1.2.13. Longitud de un archivo ............... 137
3.1.2.14. Cantidad de registros .................. 137
3.1.2.15. Restricciones ............................... 137
3.1.3. Actividad práctica: API para el
tratamiento de archivos de registros ......... 138
3.1.4. Ejemplos de uso de las funciones
de la API ........................................................ 139
3.1.4.1. Escribir y leer caracteres .............. 139
3.1.4.2. Escribir y grabar números
enteros (short) .............................................. 139
3.1.4.3. Escribir y leer estructuras
(Persona) ...................................................... 139
3.1.4.4. Baja lógica ...................................... 140
3.1.5. Autoevaluación y ejercicios .............. 141
3.2. Lección 11 ............................................ 141
3.2.1. Operadores de bit ............................. 141
3.2.1.1. Operadores de desplazamiento ... 141
3.2.1.2. Bases numéricas 8 (octal)
y 16 (hexadecimal) ...................................... 142
3.2.1.3. Operadores lógicos ........................ 143
3.2.1.4. Máscara de bit ............................... 144
3.2.2. Actividad práctica: TAD BitWriter y
BitReader ...................................................... 145
3.2.3. Autoevaluación y ejercicios .............. 146
3.3. ¿Qué sigue? .......................................... 146
CAPÍTULO 4
Resolución de problemas ........................... 147
4.1. Cómo analizar un problema ................ 148
4.1.1. Contexto, relevamiento y
enunciado del problema.............................. 148
4.1.2. Datos persistentes ............................ 149
4.1.2.1. Archivos de consulta ..................... 149
4.1.2.2. Archivos de novedades ................. 149
4.1.3. Estrategia ........................................... 150
4.2. Tipos de problema ................................ 150
4.2.1. Problemas de corte de control ......... 150
4.2.2. Problemas de apareo de archivos ... 151
4.2.3. Problemas de procesamiento
directo ........................................................... 153
4.3. Gestión de archivos y persistencia
de datos ........................................................ 154
4.3.1. Restricciones ..................................... 154
4.3.2. Búsqueda sobre archivos ................. 154
4.3.2.1. Subir el archivo a la memoria,
en una colección de objetos ....................... 155
4.3.2.2. Búsqueda binaria sobre
un archivo ..................................................... 157
4.3.2.3. Indexar un archivo ......................... 159
4.3.3. Ordenar archivos ............................... 162
4.3.3.1. Ordenamiento en la memoria....... 162
4.3.3.2. Ordenamiento por indexación ...... 163
4.4. Algoritmos Tools ................................... 164
4.5. Caso de prueba .................................... 165
4.5.1. Corte de control (versión 1) ............. 165
4.5.2. Corte de control, con salida
bufferizada (versión 2) ................................. 168
4.5.3. Descubrimiento (versión 3) .............. 170
4.5.4. Archivos de consultas en la
memoria (versión 4) ..................................... 175
4.5.5. Descubrimiento, otro caso
(versión 5) ..................................................... 181
4.5.6. Actualizar registros (versión 6) ........ 183
4.5.7. Colección de colecciones
(versión 7) ..................................................... 188
4.5.8. Colección de colecciones, con
descubrimiento (versión 8) ......................... 192
4.5.9. Apareo de archivos (versión 9) ........ 197
4.5.10. Apareo de archivos, con corte
de control (versión 10) ................................ 202
4.5.11. Búsqueda binaria sobre el
archivo de consulta (versión 11) ................ 208
4.5.12. Indexación directa (versión 12) ..... 213
4.5.13. Indexación indirecta, con corte
de control (versión 13) ................................ 216
4.5.14. Indexación indirecta múltiple
(versión 14) .................................................. 220
4.5.15. Ordenar y depurar un archivo
(versión 15) .................................................. 225
4.6. Autoevaluación y ejercicios ................. 230
4.7 ¿Qué sigue? ........................................... 231
Estructuras indexadas, lineales y
gestión de memoria .................................... 233
5.1. Lección 12 ............................................ 233
5.1.1. Array ................................................... 233
5.1.1.1. Capacidad del array ...................... 234
5.1.1.2. Inicializar un array a partir de
un conjunto de valores ................................ 235
5.1.1.3. Inicialización programática ........... 235
5.1.1.4. Longitud del array.......................... 236
5.1.1.5. Arrays de estructuras .................... 236
5.1.1.6. Arrays multidimensionales ........... 238
5.1.2. Operaciones sobre arrays ................ 239
5.1.2.1. Agregar un elemento al final
de un array ................................................... 239
5.1.2.2. Determinar si el array contiene
un elemento especificado ........................... 240
5.1.2.3. Insertar un elemento en una
determinada posición .................................. 241
5.1.2.4. Eliminar el elemento ubicado
en una determinada posición ..................... 242
5.1.3. Actividad práctica: API de
operaciones sobre arrays ............................ 244
5.1.4. Autoevaluación y ejercicios .............. 245
5.2. Lección 13 ............................................ 245
5.2.1. Gestión de memoria ......................... 245
5.2.1.1. Punteros ......................................... 246
5.2.1.2. Operador de dirección (&) ............. 247
5.2.1.3. Operador de dirección
o contenido (*) ............................................. 247
5.2.1.4. Funciones que reciben punteros
como parámetros ......................................... 248
5.2.1.5. Punteros a punteros ...................... 249
5.2.1.6. Punteros a estructuras y
operador -> (flecha) ..................................... 249
5.2.1.7. Punteros y arrays ........................... 250
5.2.1.8. Aritmética de direcciones ............. 251
5.2.1.9. Memoria estática ........................... 252
5.2.1.10. Memoria dinámica ...................... 252
5.2.1.11. Crear arrays dinámicamente ..... 255
5.2.1.12. Redimensionar un array ............. 256
5.2.1.13. Crear matrices
dinámicamente ............................................ 257
5.2.2. Actividad práctica: TAD Array ........... 258
5.2.3. Actividad práctica: TAD Map ............ 259
5.2.4. Autoevaluación y ejercicios .............. 260
5.3. Lección 14 ............................................ 261
5.3.1. Nodo ................................................... 261
5.3.2. Lista enlazada (linked list) ............... 262
5.3.2.1. Recorrer una lista enlazada .......... 262
5.3.2.2. Agregar un valor al final de
una lista enlazada ........................................ 264
5.3.2.3. Liberar la memoria que ocupa
la lista ............................................................ 266
5.3.2.4. Determinar si la lista contiene
un valor especificado ................................... 267
5.3.2.5. Insertar un valor en una lista
ordenada ....................................................... 267
5.3.2.6. Eliminar un elemento de la lista... 270
5.3.3. Actividad práctica: API de
operaciones sobre listas enlazadas ........... 271
5.3.4. Pila (stack) ......................................... 273
5.3.4.1. Apilar un elemento (push)............. 273
5.3.4.2. Desapilar un elemento (pop) ........ 274
5.3.4.3. Determinar si la pila tiene
elementos ..................................................... 275
5.3.4.4. Ejemplo de uso .............................. 275
5.3.5. Actividad práctica: API de
operaciones sobre pilas (extensión) ........... 275
5.3.6. Cola (queue) ...................................... 275
5.3.6.1. Encolar un elemento (enqueue) ... 276
5.3.6.2. Desencolar un elemento
(dequeue) ...................................................... 277
5.3.6.3. Determinar si la cola tiene
elementos ..................................................... 278
5.3.6.4. Implementación sobre una
lista circular .................................................. 279
5.3.7. Actividad práctica: API de
operaciones sobre colas (extensión) .......... 281
5.3.8. Actividad práctica: TAD List,
Stack y Queue............................................... 282
5.3.9. Autoevaluación y ejercicios .............. 283
5.4. Lección 15 ............................................ 283
5.4.1. Estructura de datos (parte 2) ........... 284
5.4.1.1. Colección de estructuras .............. 284
5.4.1.2. Colección de colecciones .............. 285
5.4.1.3. Colección de estructuras que
tienen colecciones ....................................... 286
5.4.2. Autoevaluación y ejercicios .............. 288
5.5. ¿Qué sigue? .......................................... 288
CAPÍTULO 6
Algoritmo de Huffman. Ejercicio
integrador .................................................... 289
6.1. Lección 16 ............................................ 289
6.1.1. Introducción ....................................... 289
6.1.2. Alcance del ejercicio ......................... 291
6.1.3. Algoritmo de Huffman....................... 291
6.1.3.1. Paso 1 ? Contar cuántas veces
aparece cada byte ....................................... 293
6.1.3.2. Paso 2 ? Crear una lista
enlazada ....................................................... 294
6.1.3.3. Paso 3 ? Convertir la lista en
un árbol binario (Árbol Huffman) ................ 294
6.1.4. Árbol Huffman ................................... 297
6.1.4.1. Características ............................... 297
6.1.4.2. Códigos Huffman ........................... 297
6.1.4.3. Longitud máxima de un código
Huffman ........................................................ 298
6.1.5. Implementación del ejercicio ........... 298
6.1.5.1. Setup .............................................. 299
6.1.5.2. TAD HuffmanTree .......................... 299
6.1.5.3. Estructura HuffmanTreeInfo ......... 300
6.1.5.4. Recopilación de los códigos
Huffman ........................................................ 300
6.1.5.5. Compresión .................................... 301
6.1.5.6. Estructura del archivo
comprimido (.huf) ......................................... 302
6.1.5.7. Descompresión .............................. 302
6.1.6. Ejemplo .............................................. 303
6.2. ¿Qué sigue? .......................................... 304

Si desea adentrarse en el mundo de la programación desde cero y avanzar progresivamente hasta cubrir los aspectos más complejos de la programación en C++, mediante el análisis y desarrollo de gran cantidad de problemas algorítmicos de todos los niveles, este libro será su gran aliado. Curso de algoritmos y programación a fondo presenta 16 lecciones, distribuidas en 6 capítulos, para estudiar los recursos y las técnicas de programación que le llevarán a tratar cuestiones avanzadas, como el desarrollo de un programa compresor/descompresor de archivos basado en el algoritmo de Huffman. Además, este libro desarrolla funciones y tipos abstractos de datos (TAD) para conformar una biblioteca (API) que podrá utilizar en la resolución de una gran cantidad de ejercicios y problemas. Asimismo, gracias a esta lectura: ' Aprenderá a programar ágilmente con los vídeos explicativos del autor que acompañan cada lección. ' Podrá validar los conocimientos adquiridos con las autoevaluaciones que se proponen y recibirá el feedback con el que determinará si debe releer la lección o parte de esta, antes de pasar a la siguiente. En esta nueva edición se profundiza especialmente en el análisis y la resolución de problemas. Se propone un caso testigo y diversas variantes de este, que le permitirán identificar distintos tipos de problemas que estudiar y discutir estrategias de solución. Sin duda, esta es una obra imprescindible si desea ser un futuro programador o busca afianzar y profundizar sus conocimientos en la materia.

Artículos relacionados

  • DISEÑO DE INTERFACES PARA LA WEB ACTUAL
    GOMEZ DELGADO, JAVIER
    1. **Diseño de interfaces web modernas** Descubre las últimas tendencias y técnicas para diseñar interfaces web modernas y atractivas, desde la jerarquía visual hasta el prototipado avanzado.2. **Optimización de la experiencia de usuario en sitios web** Mejora la usabilidad y accesibilidad de tus sitios web a través de estrategias efectivas de diseño centrado en el usua...
    En stock

    24,00 €

  • 10
    LOPEZ, ELIEZER
    El lenguaje de programación Rust ha ganado popularidad en los últimos años debido a su enfoque en la seguridad y el rendimiento, y se ha convertido en una excelente opción para el desarrollo de aplicaciones críticas y sistemas de alto rendimiento. Con una comunidad en constante crecimiento y el respaldo de importantes empresas, Rust constituye una herramienta poderosa para desa...
    En stock

    29,95 €

  • PYTHON DESDE EL LABORATORIO. ESTRUCTURAS DE CONTROL
    CORDOVA / ARANA / ARANA TORRES, SARA / CÓRDOVA NERI, TEODORO
    Iníciese en el universo de Python y domine las estructuras de control Python es el lenguaje de programación que ha revolucionado el mundo tecnológico. Su simplicidad, gratuidad y versatilidad hacen de él una herramienta imprescindible en el campo de la informática, por lo que es utilizado por las principales compañías globales. Este libro le ofrece la oportunidad de introduci...
    En stock

    23,80 €

  • PYTHON DESDE EL LABORATORIO. APLICACIONES GUI, INTEGRACIÓN CON BASE DE DATOS E I
    CORDOBA / ARANA / ARANA TORRES, SARA / CÓRDOVA NERI, TEODORO
    Descubra las ventajas de integrar Python con las aplicaciones GUI, las bases de datos y la inteligencia artificial En la era digital actual, las interfaces gráficas de usuario (GUI) y la inteligencia artificial (IA) juegan un papel crucial en la informática, facilitando la interacción del usuario y optimizando procesos. Si quiere dominar estos conceptos, ha llegado al libro in...
    En stock

    26,50 €

  • PYTHON DESDE EL LABORATORIO. ESTRUCTURAS DE DATOS
    CORDOBA / ARANA / ARANA TORRES, SARA / CÓRDOVA NERI, TEODORO
    Dé un paso más allá en Python y domine las estructuras de datos En el dinámico mundo de la tecnología, las estructuras de datos son el pilar sobre el que las empresas construyen su capacidad para administrar información y forjar estrategias de crecimiento. Este libro le invita a sumergirse en el fascinante mundo de las estructuras de datos más utilizadas, como las listas y a...
    En stock

    26,50 €

  • LOS 150 MEJORES EJEMPLOS DE COPIAR Y PEGAR
    FORTEA NAVARRO,PEDRO
    Adéntrese con éxito en los lenguajes de programación PHP8, JS y HTML5 con 150 ejemplos prácticos Si quiere dar sus primeros pasos o mejorar sus conocimientos en el mundo de PHP8, JS y HTML5, y perfeccionar sus trabajos como desarrollador, este libro será su gran aliado. En él encontrará desde ejemplos de código sencillos, para afianzar los conceptos básicos, hasta una amplia ...
    En stock

    19,40 €

Otros libros del autor

  • EL GRAN LIBRO DE JAVA A FONDO.
    SZNAJDLEDER, PABLO AUGUSTO / 0 (Ilustración)
    Java a fondo, ya en su tercera edicion, es un curso universitario de lenguaje y desarrollo de aplicaciones Java (actualizado a la version 8) basado en un enfoque totalmente practi?]co, sin vueltas ni rodeos. El libro comienza desde un nivel 'cero' y avanza hasta llegar a temas complejos como introspeccion de clases y objetos, acceso a bases de datos (JDBC), multiprogramacion, ...
    Sin stock. Disponible en 2/3 días

    29,80 €