Proyecto TSO

UNIVERSIDAD NACIONAL DE TRUJILLO
FACULTAD DE CIENCIAS FISICAS Y MATEMATICAS

ESCUELA PROFESIONAL DE INFORMÁTICA
“Diseño de un sistema operativo con características

inteligentes para mejorar la curva de aprendizaje de
programación en niños de la I. E. "RAFAEL NARVÁEZ
CADENILLAS”
Proyecto de Investigación de Tópicos Especiales en

Sistemas Operativos
AUTORES:
-Cabanillas Encarnación, Mac Kevin.
-Velasquez Bolaños,William Santiago.
- Tafur Trujillo, Luis Angel.
- Saavedra Jimenez, Lenin Sleyter
ASESOR:
Ing. Bravo Escalante, Jorge David
Trujillo - Perú
2019
Contenido
1. Realidad Problemática........................................................................................................... 4
2. Formulación del Problema .................................................................................................... 4
3. Antecedentes .......................................................................................................................... 5
3.1. Antecedente 1: .................................................................................................................... 5
3.2. Antecedente 2: .................................................................................................................... 5
3.3. Antecedente 3: .................................................................................................................... 5
3.4. Antecedente 4: .................................................................................................................... 6
3.5. Antecedente 5: .................................................................................................................... 6
4. Justificación ............................................................................................................................. 7
4.1. Justificación Económica .................................................................................................... 7
4.2. Justificación social .............................................................................................................. 7
4.3. Justificación Tecnológica ................................................................................................... 7
4.4. Justificación Académica .................................................................................................... 7
5. Objetivos .................................................................................................................................. 8
5.1. Objetivo general .................................................................................................................. 8
5.2. Objetivos Específico ........................................................................................................... 8
6. Hipótesis y Variables ............................................................................................................. 8
6.1. Hipótesis .............................................................................................................................. 8
6.2. Variables .............................................................................................................................. 8
CAPÍTULO II: ...................................................................................................................................... 9
7. MARCO TEÓRICO ................................................................................................................ 9
7.1. Sistema Operativo: ............................................................................................................. 9
7.2. Software Libre: .................................................................................................................. 10
7.3. Kernel Linux: ..................................................................................................................... 11
7.3.1. Núcleo de sistema operativo ....................................................................................... 12
7.4. Bases de la programación:.............................................................................................. 15
7.5. Estructura de Datos.......................................................................................................... 21
7.6. Metodología Kendall & Kendall ....................................................................................... 44
REFERENCIAS BIBLIOGRÁFICAS .............................................................................................. 53
2
Tabla de Ilustraciones
Ilustración 1: Interacción entre el sistema operativo con el resto de las partes.................................................... 9
Ilustración 2:Logos de diferentes sistemas operativos ....................................................................................... 10
Ilustración 3: Logo de diferentes software libres ............................................................................................... 11
Ilustración 4: Linus Torvalds .............................................................................................................................. 11
Ilustración 5: El núcleo Monolítico de Linux. ...................................................................................................... 12
Ilustración 6: Diagrama del núcleo 2.4.0. .......................................................................................................... 15
Ilustración 7: Interpretación dinámica y cíclica de las etapas planteadas por Polya para resolver problemas .... 15
Ilustración 8: Ciclo Fases de Programación....................................................................................................... 16
Ilustración 9: Elementos de un diagrama de flujo.............................................................................................. 18
Ilustración 10: Pseudocódigo ............................................................................................................................ 19
Ilustración 11: Ejemplo de tabla de hash ........................................................................................................... 21
Ilustración 12: Ejemplo de Pila .......................................................................................................................... 23
Ilustración 13: Diagrama de Flujo de una Pila ................................................................................................... 23
Ilustración 14: Ejemplos de Cola ....................................................................................................................... 27
Ilustración 15: Ejemplo de Listas simples enlazadas .......................................................................................... 32
Ilustración 16: Ejemplo de Lista Doblemente Enlazada...................................................................................... 39
Ilustración 17: Ejemplo de Listas enlazadas circulares ....................................................................................... 39
Ilustración 18: Metodología Kendall & Kendall.................................................................................................. 44
Ilustración 19: Fase 1 - Identificar el problema .................................................................................................. 45
Ilustración 20: Fase 2 - Determinar los requerimientos ..................................................................................... 46
Ilustración 21: Fase 3 - Análisis de necesidades ................................................................................................. 47
Ilustración 22: Fase 4 - Diseño del sistema ........................................................................................................ 48
Ilustración 23: Fase 5 - Desarrollo y Documentación ......................................................................................... 50
Ilustración 24: Fase 6 - Pruebas y mantenimiento ............................................................................................. 51
Ilustración 25: Fase 7 - Implementación y evaluación........................................................................................ 52
Tabla de Algoritmos
Algoritmo 1:Implementación de una Pila en C++ ............................................................................................... 27
Algoritmo 2:Implementación de una Cola en C++.............................................................................................. 31
Algoritmo 3:Implementación de una Lista Enlazada Simple Lineal en C++ ......................................................... 38
Algoritmo 4:Implementación de una Lista Simple Circular en C++ ..................................................................... 43
3
CAPÍTULO I:
1. Realidad Problemática
La I.E. RNC se ubica en Av. America Oeste, Trujillo 13011, en el estudian un
total de 1,240 alumnos en sus niveles de educación inicial, primaria y
secundaria, los mismos que reciben las clases y orientaciones de 98
docentes.
Por ello en el desarrollo del logro de sus objetivos, se han encontrado con la
necesidad actual de tener que hacer usos de las herramientas tecnológicas
para mejorar la enseñanza en programación en los niños del nivel primaria,
pero debido a lo dificultoso que es el manejo de un sistema operativo
convencional para los niños de primaria y con el fin de facilitar el manejo de
un sistema operativo a un niño la solucionar el problema de la I.E
proponemos el “Diseño de un sistema operativo con características
inteligentes para mejorar la curva de aprendizaje de programación en niños
de la Institución Educativa "RAFAEL NARVÁEZ CADENILLAS”.
2. Formulación del Problema

¿Se logrará mejorar la curva de aprendizaje de programación mediante el
diseño de un sistema operativo con características inteligentes en niños de la
I. E. Rafael Narváez Cadenillas?
4
3. Antecedentes
3.1. Antecedente 1:
• Título: Intérprete y entorno de desarrollo aplicados al auto-aprendizaje
de los conceptos de programación orientada a objetos.
• Autor: Mitta Flores, Ever Ricardo
• Lugar:Lima-Perú
• Resumen:Con el surgimiento de los lenguajes de programación y el
gran interés que estos atraen, cada vez hay más personas que
deciden sumergirse a este mundo. Otro punto a tomar en cuenta es
que no solo hay un estilo de programación, sino que la programación
puede estar sujeta a diversos paradigmas, siendo estos el paradigma
estructurado, el paradigma orientado a objetos, el paradigma orientado
a eventos, entre otros.
• Aporte: Nos da un enfoque de aplicación de intérprete e entorno de
desarrollo que se puede aplicar en el auto-aprendizaje de
programación, en este caso: Programación orientada a objetos.
3.2. Antecedente 2:
• Título: Competencias para el uso de la tecnología en alumnos de nivel
técnico superior para los estudiantes del primer ciclo de computación e
informática del Instituto Internacional de Sistemas.
• Autor:Cárdenas Oscco, Layo
• Lugar: Lima Norte-Perú
• Resumen: Se tuvo como objetivo analizar el nivel de competencia en
el uso de la tecnología de los alumnos del Instituto Internacional de
sistemas. El diseño que se empleó fue no experimental de tipo
descriptivo, busca especificar las propiedades, características y los
perfiles de personas, grupos, comunidades, procesos, objetos o
cualquier otro fenómeno que se someta a un análisis. Es decir
pretenden medir o recolectar información de manera independiente o
conjunta sobre los conceptos de las variables a las que se refieren. Se
utilizó una muestra con toda la población de 80 alumnos.
• Aporte: El aporte que brinda a nuestro proyecto, es el de recolectar
información de manera eficaz, utilizando una muestra hacia una
población específica.
3.3. Antecedente 3:
• Título:Métodos operativos y su influencia en el desarrollo de
capacidad del área de matemática en estudiantes del nivel
secundario del distrito de Santa Maria del Valle, Huánuco-2014.
• Autor:Coz Tolentino, Héctor
• Lugar:Huánuco-Perú.
• Resumen: El trabajo de investigación tuvo como objetivo demostrar en
qué medida la aplicación de métodos operativos influye en el
desarrollo de capacidades del área de matemática en estudiantes del
nivel secundario del distrito de Santa María del Valle, Huánuco - 2014.
Con la finalidad de profundizar el análisis e interpretación de los
5
resultados se utilizó el diseño cuasi experimental y mediante el
muestreo no probabilístico se eligió un grupo de trabajo conformado
por 48 estudiantes del segundo año de educación secundaria,
matriculados en el año académico 2014 en el área de Matemática.
• Aporte: Nos sirve para poder diferenciar qué fundamentos, son
necesarias en el aprendizaje, de un tema en específico, analizar las
metodologías básicas(en este caso matemática).
3.4. Antecedente 4:
• Título: Diseño de un sistema de realidad virtual como estrategia
motivadora en el aprendizaje del diseño en ingeniería
• Autor: Méndez Valdivia, Celedonio
• Lugar: Lima-Perú
• Resumen: El propósito de esta investigación es diseñar un sistema de
realidad virtual que permita motivar el proceso de aprendizaje en la
materia de Diseño en Ingeniería de los estudiantes del tercer ciclo de
la Escuela de Ingeniería Civil de una Universidad, a través del diseño
de un ambiente de realidad virtual, en el que uno o más estudiantes
pueden realizar prácticas de diseño experimental de estructuras de
edificación como: casas, departamentos, puentes en base a un plano y
el uso de sólidos primitivos: esfera, cono, pirámide, prisma, cilindro,
etc.
• Aporte: Nos permite reconocer distintos métodos de estrategia
motivadoras en el aprendizaje, enseñanza.
3.5. Antecedente 5:
• Título: Método aprendizaje basado en problemas para desarrollar
capacidades matemáticas en programación lineal nivel secundaria
Huamanga Ayacucho.
• Autor: Huamán Mitma, Oscar
• Lugar: Ayacucho-Perú
• Resumen:La investigación busca mejorar el desarrollo adecuado de
las capacidades matemáticas en los estudiantes del quinto año “B”, del
colegio “José Gabriel Condorcanqui” Huamanga Ayacucho.
Metodológicamente el estudio corresponde al enfoque cualitativo
educacional de tipo aplicada proyectiva, donde se utiliza los métodos
empíricos, teóricos y matemáticos, se tomó en cuenta una muestra de
38 estudiantes y un docente seleccionado con la técnica de muestreo
no probabilístico de grupos intactos donde se aplicó diversas técnicas
como: encuesta y observación como instrumento la guía de entrevista,
prueba pedagógica y cuestionario abierto.
• Aporte: Utilizar un método de aprendizaje de desarrollo práctico como
es la resolución de problemas.
6
4. Justificación
4.1. Justificación Económica

El beneficio económico que obtendrá la I.E. RNC al hacer uso de un S.O.
dedicado para facilitar la enseñanza a los niño es que se requerirá menos
docentes para enseñar a los niños a programar.
4.2. Justificación social

El presente proyecto se justifica socialmente porque ayudará a sociedad
ah forjar a profesionales con diferentes enfoques de uso en la tecnología,
y paradigmas para resolver los problemas profesionales que dominen el
pensamiento computacional y lo sepan llevar a los campos de la
medicina, la biología, el diseño y las artes.
4.3. Justificación Tecnológica

La implementación del proyecto busca brindar una ventaja tecnológica en
la I.E. RNC, siendo la primera institución educativa en trujillo en
implementar un sistema operativo dedicado a la enseñanza en
programación en niños.
4.4. Justificación Académica

La implementación del proyecto busca brindar un nuevo enfoque de
enseñanza y brindar a los alumnos una nueva visión en el uso de la
información, debido beneficio que obtendrán los niños al obtener un
mejor conocimiento de las bases de la programación, beneficiando a la
institución en reputación y calidad, ante la sociedad.
7
5. Objetivos
5.1. Objetivo general

• Mejorar la curva de aprendizaje de programación en niños de la I. E.
"RAFAEL NARVÁEZ CADENILLAS
5.2. Objetivos Específico

• Aumentar el interés por la programación en los niños de primaria de la I.E.
RNC
• Disminuir el temor por la programación de los niños de primaria de la I.E.
RNC
• Aumentar la calidad de enseñanza en el área de programación dentro de la
I.E RNC mediante la interacción con un sistema Operativo interactivo.
6. Hipótesis y Variables
6.1. Hipótesis
El diseño de un de un sistema operativo con características inteligentes logrará
mejorar la curva de aprendizaje de programación en niños de la Institución Educativa
Rafael Narváez Cadenillas con el Diseño de un sistema operativo con características
inteligentes.
6.2. Variables
a. Variable dependiente.
Mejora de la curva de aprendizaje de programación
b. Variable Independiente.
Sistema Operativo con características inteligentes
8
CAPÍTULO II:
7. MARCO TEÓRICO
7.1. Sistema Operativo:

Un sistema operativo (SO o, frecuentemente, OS —del inglés operating system—)
es el software principal o conjunto de programas de un sistema informático que
gestiona los recursos de hardware y provee servicios a los programas de aplicación
de software, ejecutándose en modo privilegiado respecto de los restantes (aunque
puede que parte de él se ejecute en espacio de usuario).
Ilustración 1: Interacción entre el sistema operativo con el resto de las partes.
Nótese que es un error común muy extendido denominar al conjunto completo de

herramientas sistema operativo, es decir, la inclusión en el mismo término de
programas como el explorador de ficheros, el navegador web y todo tipo de
herramientas que permiten la interacción con el sistema operativo. Otro ejemplo para
comprender esta diferencia se encuentra en la plataforma Amiga, donde el entorno
gráfico de usuario se distribuía por separado, de modo que, también podía
reemplazarse por otro, como era el caso de directory Opus o incluso manejarlo
arrancando con una línea de comandos y el sistema gráfico. De este modo,
comenzaba a funcionar con el propio sistema operativo que llevaba incluido en una
ROM, por lo que era cuestión del usuario decidir si necesitaba un entorno gráfico
para manejar el sistema operativo o simplemente otra aplicación. Uno de los más
9
prominentes ejemplos de esta diferencia, es el núcleo Linux, usado en las llamadas
distribuciones Linux, ya que, al estar también basadas en Unix, proporcionan un
sistema de funcionamiento similar. Este error de precisión, se debe a la
modernización de la informática llevada a cabo a finales de los 80, cuando la
filosofía de estructura básica de funcionamiento de los grandes computadores se
rediseñó a fin de llevarla a los hogares y facilitar su uso, cambiando el concepto de
computador multiusuario, (muchos usuarios al mismo tiempo) por un sistema
monousuario (únicamente un usuario al mismo tiempo) más sencillo de gestionar.
Véase AmigaOS, beOS o Mac OS como los pioneros de dicha modernización,
cuando los Amiga fueron bautizados con el sobrenombre de Video Toasters por su
capacidad para la Edición de vídeo en entorno multitarea round robin, con gestión de
miles de colores e interfaces intuitivos para diseño en 3D.
Ilustración 2:Logos de diferentes sistemas operativos
7.2. Software Libre:

Es la denominación del Software que respeta la Libertad de los usuarios sobre su
producto adquirido y, por tanto, una vez obtenido puede ser usado, copiado,
estudiado, cambiado y redistribuido libremente.
Según la Free Software Foundation, el software libre se refiere a la Libertad de los
usuarios para ejecutar, copiar, distribuir, estudiar, cambiar y mejorar el Software; de
modo más preciso, se refiere a cuatro libertades de los usuarios del software: la
libertad de usar el programa, con cualquier propósito; de estudiar el funcionamiento
del programa, y adaptarlo a las necesidades; de distribuir copias, con lo cual se
puede ayudar a otros y de mejorar el programa y hacer públicas las mejoras, de
modo que toda la comunidad se beneficie.
10
El software libre suele estar disponible gratuitamente, o al precio de costo de la
distribución a través de otros medios; sin embargo, no es obligatorio que sea así, por
lo tanto no hay que asociar software libre a "software gratuito" (denominado
usualmente Freeware), ya que, conservando su carácter de libre, puede ser
distribuido comercialmente ("software comercial").
Ilustración 3: Logo de diferentes software libres
7.3. Kernel Linux:

Linux es un núcleo mayormente libre semejante al núcleo de Unix. Linux es uno de
los principales ejemplos de software libre y de código abierto. Linux está licenciado
bajo la GPL v2 y la mayor parte del software incluido en el paquete que se distribuye
en su sitio web es software libre. Está desarrollado por colaboradores de todo el
mundo. El desarrollo del día a día tiene lugar en la Linux Kernel Mailing List Archive.
Ilustración 4: Linus Torvalds
11
El núcleo Linux fue concebido por el entonces estudiante de ciencias de la
computación finlandés Linus Torvalds en 1991. Linux consiguió rápidamente
desarrolladores y usuarios que adoptaron códigos de otros proyectos de software
libre para usarlos con el nuevo núcleo de sistema. A día de hoy miles de
programadores de todo el mundo contribuyen en su desarrollo.
Linux es multiprogramado, dispone de memoria virtual, gestión de memoria,

conectividad en red y permite bibliotecas compartidas. Linux es multiplataforma y es
portable a cualquier arquitectura siempre y cuando esta disponga de una versión de
GCC compatible.
7.3.1. Núcleo de sistema operativo

A. Núcleo
En el archivo Léeme de Linux se indica que es un clon del sistema operativo

Unix. Sin embargo Linux es un núcleo semejante al núcleo de un sistema
operativo Unix. De hecho inicialmente se publicó como núcleo semejante a
Minix, que a su vez era semejante a Unix pero con una concepción de
micronúcleo en vez de monolítica.
Un micronúcleo contiene una funcionalidad mínima en comparación con un

núcleo monolítico tradicional.
Ilustración 5: El núcleo Monolítico de Linux.
12
B. Sistema operativo
En ciertos textos, el sistema operativo es llamado indistintamente como

núcleo o kernel, pero debe tenerse en cuenta que la diferencia entre kernel y
sistema operativo solo es aplicable si el núcleo es monolítico, lo cual fue muy
común entre los primeros sistemas. En caso contrario, es incorrecto llamar al
sistema operativo núcleo.
La parte de un sistema operativo que se ejecuta sin privilegios o en espacio

de usuario es la biblioteca del lenguaje C, que provee el entorno de tiempo
de ejecución, y una serie de programas o herramientas que permiten la
administración y uso del núcleo y proveer servicios al resto de programas en
espacio de usuario, formando junto con el núcleo el sistema operativo.
En un sistema con núcleo monolítico como Linux la biblioteca de lenguaje C

consiste en una abstracción de acceso al núcleo. Algunas bibliotecas como la
biblioteca de GNU proveen funcionalidad adicional para facilitar la vida del
programador y usuario o mejorar el rendimiento de los programas.
En un sistema con micronúcleo la biblioteca de lenguaje C puede gestionar

sistemas de archivos o controladores además del acceso al núcleo del
sistema.
A los sistemas operativos que llevan Linux se les llama de forma genérica
distribuciones Linux. Estas consisten en una recopilación de software que
incluyen el núcleo Linux y el resto de programas necesarios para completar
un sistema operativo. Las distribuciones más comunes son de hecho
distribuciones GNU/Linux o distribuciones Android. El hecho de que
compartan núcleo no significa que sean compatibles entre sí. Una aplicación
hecha para GNU/Linux no es compatible con Android sin la labor adicional
necesaria para que sea multiplataforma.
Las distribuciones GNU/Linux usan Linux como núcleo junto con el entorno
de tiempo de ejecución del Proyecto GNU y una serie de programas y
herramientas del mismo que garantizan un sistema funcional mínimo. La
mayoría de distribuciones GNU/Linux incluye software adicional como
entornos gráficos o navegadores web, así como los programas necesarios
13
para permitirse instalar a sí mismas. Los programas de instalación son
aportados por el desarrollador de la distribución. Se les conoce como
gestores de paquetes. Los creadores de una distribución también se pueden
encargar de añadir configuraciones iniciales de los distintos programas
incluidos en la distribución.
Las distribuciones Android incluyen el núcleo Linux junto con el entorno de

ejecución y herramientas del proyecto AOSP de Google. Cada fabricante de
teléfonos dispone de su propia distribución de Android a la cual modifica,
elimina o añade programas extra: interfaces gráficas, tiendas de aplicaciones
y clientes de correo electrónico son algunos ejemplos de programas
susceptibles de ser añadidos, modificados o eliminados. Además de las
distribuciones de los fabricantes de teléfonos existen grupos de
programadores independientes que también desarrollan distribuciones de
Android. LineageOS y Replicant son dos ejemplos de distribuciones Android
independientes.
C. Arquitectura
Actualmente Linux es un núcleo monolítico híbrido. Los controladores de

dispositivos y las extensiones del núcleo normalmente se ejecutan en un
espacio privilegiado conocido como anillo 0 (ring 0), con acceso irrestricto al
hardware, aunque algunos se ejecutan en espacio de usuario. A diferencia
de los núcleos monolíticos tradicionales, los controladores de dispositivos y
las extensiones al núcleo se pueden cargar y descargar fácilmente como
módulos, mientras el sistema continúa funcionando sin interrupciones. A
diferencia de los núcleos monolíticos tradicionales, los controladores también
pueden ser pre-volcados (detenidos momentáneamente por actividades más
importantes) bajo ciertas condiciones. Esta habilidad fue agregada para
gestionar correctamente interrupciones de hardware y para mejorar el
soporte de multiprocesamiento simétrico.
El hecho de que Linux no fuera desarrollado siguiendo el diseño de un

micronúcleo (diseño que, en aquella época, era considerado el más
apropiado para un núcleo por muchos teóricos informáticos), fue motivo de
una famosa y acalorada discusión entre Linus Torvalds y Andrew S.
Tanenbaum.
14
Ilustración 6: Diagrama del núcleo 2.4.0.
7.4. Bases de la programación:

La programación permite activar una amplia variedad de estilos de aprendizaje
(Stager, 2003) y desarrollar el pensamiento algorítmico. El reto enorme que recae
hoy sobre los sistemas educativos consiste en lograr que se generen las estrategias
adecuadas para que los estudiantes se desarrollen como pensadores creativos.
Según Polya (1957), cuando se resuelven problemas, intervienen cuatro
operaciones mentales:
Ilustración 7: Interpretación dinámica y cíclica de las etapas planteadas por Polya para resolver problemas
1) Entender el problema
2) Trazar un plan
3) Ejecutar el plan (resolver)
15
4) Revisar En la práctica seguiremos los siguientes pasos:
a. Leer el enunciado hasta comprender los datos proporcionados y las
preguntas a resolver.
b. Escribir los datos proporcionados por el
enunciado teniendo siempre en cuenta las unidades
c. Indicar las magnitudes o preguntas que debemos resolver y sus
unidades
d. Buscar una o varios posibles planteamientos
e. Desarrollar el planteamiento elegido para solucionar el problema
f. Comprobar si la solución obtenida es lógica.
Ilustración 8: Ciclo Fases de Programación
Si en lugar de un problema de matemáticas, física, química, tecnología, ... estamos

ante un problema informático el esquema pasa a ser:
Numerosos autores de libros sobre programación, plantean cuatro fases para
elaborar un procedimiento que realice una tarea específica. Estas fases concuerdan
con las operaciones mentales descritas por Polya para resolver problemas:
1. Analizar el problema (Entender el problema)
2. Diseñar un algoritmo (Trazar un plan)
3. Traducir el algoritmo a un lenguaje de programación (Ejecutar el plan)
4. Depurar el programa (Revisar)
La comprensión lingüística del problema (entender el significado del enunciado) es

fundamental. En una primera lectura del enunciado del problema obtenemos una
16
primera idea general de lo que nos pide el ejercicio, mientras que en una segunda
lectura debemos plantearnos cuestiones como:
• ¿Puedo definir mejor el problema?
• ¿Qué palabras del problema me son desconocidas?
• ¿Cuáles son las palabras clave del problema?
• ¿He resuelto antes algún problema similar?
• ¿Qué información es importante?
• ¿Qué información puedo omitir?
En esta etapa se debe hacer una representación precisa del

problema (Rumbaugh, 1996); especificar lo más exactamente posible lo que hay
que hacer (no cómo hay que hacerlo). Otro aspecto fundamental es determinar la
información proporcionada:
• ¿Qué información es importante?
• ¿Qué información no es relevante?
• ¿Cuáles son los datos de entrada? (conocidos)
• ¿Cuál es la incógnita?
• ¿Qué información me falta para resolver el problema? (datos
desconocidos)
• ¿Puedo agrupar los datos en categorías?
En cuanto a las restricciones es necesario saber que elementos puedo utilizar y

cuales no. Una vez conocido y analizado el enunciado para conocer no sólo el
problema a resolver, sin o también los datos que nos proporciona el enunciado y
las restricciones planteadas, ya empezamos a plantear las ecuaciones,
fórmulas, necesarias para la resolución del problema. En la medida de lo posible, es
aconsejable dividir el problema original en otros más pequeños y fáciles de
solucionar, hasta que los pasos para alcanzarlas se puedan determinar con bastante
precisión. Esto es lo que en programación se denomina diseño descendente o top-
down (Joyanes, 2001). En resumen, al programar lo que hacemos es describir
de forma muy explícita, ordenada y clara las instrucciones que debe seguir
nuestro ordenador para llevar a cabo una determinada acción. Estas
instrucciones tenemos que escribirlas en un lenguaje que el ordenador entienda y
pueda ejecutar. Al conjunto ordenado de instrucciones que llevan a la solución
de un problema lo conocemos como Algoritmo.
17
A. Técnicas de representación
1. Diagramas de flujo
Es quizás la forma de representación más antigua. Algunos autores suelen

llamarlos también como diagramas de lógica o flujogramas.Un diagrama de flujo
utiliza cajas estándar
Ilustración 9: Elementos de un diagrama de flujo
18
2. Pseudocódigo
Es la técnica que permite expresar la solución de un problema

mediante un algoritmo escrito en palabras normales de un idioma (por ejemplo,
el español), utilizando palabras imperativas. Es común encontrar en
pseudocódigo palabras como: Inicie, lea, imprima, sume, divida, calcule,
finalice. No hay un léxico obligado para el pseudocódigo, pero con el uso
frecuente se han establecido algunos estándares.
Ilustración 10: Pseudocódigo
B. ¿Qué es un algoritmo?
Por algoritmo, se entiende a un conjunto finito de instrucciones que se deben

seguir para resolver un problema. No obstante, desde el punto de vista de la
programación de ordenadores, la definición del algoritmo como la especificación
de una serie de pasos, es incompleta. Debe observarse que los ordenadores son
equipos que tienen limitaciones físicas en cuanto a capacidad de
almacenamiento y procesamiento. Por consiguiente debemos refinar un poco
más nuestra definición de algoritmo para hacerla aplicable de manera efectiva en
el ámbito de la informática.
El algoritmo es un conjunto de pasos, instrucciones o acciones que se deben

seguir para resolver un problema. Existen una gran cantidad de algoritmos, hay
que escoger el más efectivo. Hay dos tipos de algoritmos que son los cualitativos
y cuantitativos, cualitativos son todos aquellos pasos o instrucciones descritos
por medio de palabras que sirven para llegar a la obtención de una respuesta o
solución de un problema, y cuantitativos son todos aquellos pasos o
19
instrucciones que involucran cálculos numéricos para llegar a un resultado
satisfactorio.
1. Características:
• Tiene que ser preciso.

• Tiene que estar bien definido.
• Tiene que ser finito.
• La programación es adaptar el algoritmo al ordenador.
• El algoritmo es independiente según donde lo implemente.
2. Definición:
Un algoritmo se entiende como una sucesión finita de pasos que debe
cumplir las siguientes especificaciones:
a. Cada paso del algoritmo debe estar bien definido: Esto significa
que la definición de un paso debe ser suficientemente clara, para que
una persona pueda entenderla y realizarla. Si bien no se puede dar un
criterio determinístico para decidir si un paso está bien definido,
debemos apelar al sentido común para decidir que un paso está
especificado sin ambigüedades.
b. Un algoritmo debe tener un principio y un fin: Un programa es un
algoritmo escrito con un objetivo: conseguir un resultado. No tiene
sentido crear un programa que espere ~ segundos (infinitos
segundos) y luego escriba en pantalla "Hola Mundo!", del mismo
modo que un algoritmo debe tener un principio bien definido (tampoco
tiene sentido el algoritmo "haz nada, y luego escribe Hola Mundo!")
20
7.5. Estructura de Datos
En programación, una estructura de datos es una forma de organizar un conjunto de
datos elementales con el objetivo de facilitar su manipulación. Un dato elemental es
la mínima información que se tiene en un sistema.
Una estructura de datos define la organización e interrelación de éstos y un conjunto

de operaciones que se pueden realizar sobre ellos. Las operaciones básicas son:
• Alta, adicionar un nuevo valor a la estructura.

• Baja, borrar un valor de la estructura.
• Búsqueda, encontrar un determinado valor en la estructura para realizar una
operación con este valor, en forma SECUENCIAL o BINARIO (siempre y
cuando los datos estén ordenados).
Otras operaciones que se pueden realizar son:
• Ordenamiento, de los elementos pertenecientes a la estructura.

• Apareo, dadas dos estructuras originar una nueva ordenada y que contenga a
las apareadas.
Cada estructura ofrece ventajas y desventajas en relación a la simplicidad y eficiencia

para la realización de cada operación. De esta forma, la elección de la estructura de
datos apropiada para cada problema depende de factores como la frecuencia y el
orden en que se realiza cada operación sobre los datos.
Ilustración 11: Ejemplo de tabla de hash
21
A. Tipos de datos elementales:
• Binarios
• Bit
• Byte
• Numéricos
• Entero
• Real
• Coma fija
• Coma flotante
• Alfanuméricos
• Carácter
• Cadena
• Booleanos
B. CONJUNTOS
Los conjuntos son una de las estructuras básicas de las matemáticas, y por tanto de la
informática. No se va a entrar en la definición de conjuntos ni en sus propiedades. Se
supondrá que el lector conoce algo de teoría de conjuntos. Con lo más básico es
suficiente.
En realidad las estructuras de datos que se han implementado hasta ahora no son más
que elementos diferentes entre sí (en general) en los que se ha definido una relación.
Que pueden estar ordenados entre sí. Obviando las propiedades de las estructuras, se
ve que forman un conjunto, y su cardinal es el número de elementos que contenga la
estructura. En los conjuntos no existen elementos repetidos, y esto se respeta en las
implementaciones que se ofrecen a continuación.
En este tema definiremos unas implementaciones que permitan aplicar el álgebra de

conjuntos, ya sea unión, intersección, pertenencia entre otras.
22
1. PILAS
Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo
de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en
entrar, primero en salir) que permite almacenar y recuperar datos. Se aplica en
multitud de ocasiones en informática debido a su simplicidad y ordenación implícita
en la propia estructura.
Ilustración 12: Ejemplo de Pila
Ilustración 13: Diagrama de Flujo de una Pila
23
Implementación:
1 /*
2 * C++ - Pilas/Stack
3 * Copyright 2014 Martin Cruz Otiniano
4 * Description : Apila elemento, Desempila elemento, Mostrar pila, Destruir
Pila
5 * Site : martincruz.me
6 */
7
8 #include <iostream>
9 using namespace std;
10
11 struct nodo{
12 int nro;
13 struct nodo *sgte;
14 };
15
16 typedef nodo *ptrPila; // creando nodo tipo puntero( tipo de dato )
17
18 /* Apilar elemento
19 ------------------------------------------------------------------------*/
20 void push( ptrPila &p, int valor )
21 {
22 ptrPila aux;
23 aux = new(struct nodo); // apuntamos al nuevo nodo creado
24 aux->nro = valor;
25
26 aux->sgte = p ;
27 p = aux ;
28 }
29
30 /* Desapilar elemento(devuelve elemento)
31 ------------------------------------------------------------------------*/
32 int pop( ptrPila &p )
33 {
34 int num ;
35 ptrPila aux;
36
37 aux = p ;
38 num = aux->nro; // asignamos el primer vamor de la pila
39
40 p = aux->sgte ;
41 delete(aux);
42
43 return num;
24
44 }
45
46 /* Muestra elementos de la pila
47 ------------------------------------------------------------------------*/
48 void mostrar_pila( ptrPila p )
49 {
50 ptrPila aux;
51 aux = p; // apunta al inicio de la lista
52
53 while( aux !=NULL )
54 {
55 cout<<"\t"<< aux->nro <<endl;
56 aux = aux->sgte;
57 }
58 }
59
60 /* Eliminar todos los elementos de la pila
61 ------------------------------------------------------------------------*/
62 void destruir_pila( ptrPila &p)
63 {
64 ptrPila aux;
65
66 while( p != NULL)
67 {
68 aux = p;
69 p = aux->sgte;
70 delete(aux);
71 }
72 }
73
74 /* Menu de opciones
75 ------------------------------------------------------------------------*/
76 void menu()
77 {
78 cout<<"\n\t IMPLEMENTACION DE PILAS EN C++\n\n";
79 cout<<" 1. APILAR "<<endl;
80 cout<<" 2. DESAPILAR "<<endl;
81 cout<<" 3. MOSTRAR PILA "<<endl;
82 cout<<" 4. DESTRUIR PILA "<<endl;
83 cout<<" 5. SALIR "<<endl;
84
85 cout<<"\n INGRESE OPCION: ";
86 }
87
25
88 /* Funcion Principal
89 ------------------------------------------------------------------------*/
90 int main()
91 {
92 ptrPila p = NULL; // creando pila
93 int dato;
94 int op;
95 int x ; // numero que devuelve la funcon pop
96
97 system("color 0b");
98
99 do
100 {
101 menu(); cin>> op;
102
103 switch(op)
104 {
105 case 1:
106
107 cout<< "\n NUMERO A APILAR: "; cin>> dato;
108 push( p, dato );
109 cout<<"\n\n\t\tNumero " << dato << " apilado...\n\n";
110 break;
111
112
113 case 2:
114
115 x = pop( p );
116 cout<<"\n\n\t\tNumero "<< x <<" desapilado...\n\n";
117 break;
118
119
120 case 3:
121
122 cout << "\n\n MOSTRANDO PILA\n\n";
123 if(p!=NULL)
124 mostrar_pila( p );
125 else
126 cout<<"\n\n\tPila vacia..!"<<endl;
127 break;
128
129
130 case 4:
131
26
132 destruir_pila( p );
133 cout<<"\n\n\t\tPila eliminada...\n\n";
134 break;
135
136 }
137
138 cout<<endl<<endl;
139 system("pause"); system("cls");
140
141 }while(op!=5);
142
143
144 return 0;
145 }
Algoritmo 1:Implementación de una Pila en C++
2. COLA
a) Colas FIFO
• Definición:
Son aquellas que solo tiene 2 operaciones, Push(Inserción) y

Pop(Eliminación). Push solo se puede efectuar por un extremo llamado
Frente y Pop por el extremo Llamado Final. Sin embargo, se le pueden
aplicar todas las operación al igual que a las listas.
Ilustración 14: Ejemplos de Cola
Implementación:
1
2 * C++ - Colas/Queue
4 * Description : Encola elemento, Desesencola elemento, Mostrar cola, Vaciar
cola
5 * Site : martincruz.me
6 */
27
7
10
11
12 /* Estructura de los nodos de la cola
13 ------------------------------------------------------------------------*/
14 struct nodo
15 {
16 int nro;
18 };
19
20
21 /* Estructura de la cola
22 ------------------------------------------------------------------------*/
23 struct cola
24 {
25 nodo *delante;
26 nodo *atras ;
27 };
28
29
30 /* Encolar elemento
31 ------------------------------------------------------------------------*/
32 void encolar( struct cola &q, int valor )
33 {
34 struct nodo *aux = new(struct nodo);
35
36 aux->nro = valor;
37 aux->sgte = NULL;
38
39 if( q.delante == NULL)
40 q.delante = aux; // encola el primero elemento
41 else
42 (q.atras)->sgte = aux;
43
44 q.atras = aux; // puntero que siempre apunta al ultimo elemento
45
46 }
47
48 /* Desencolar elemento
49 ------------------------------------------------------------------------*/
50 int desencolar( struct cola &q )
28
51 {
52 int num ;
53 struct nodo *aux ;
54
55 aux = q.delante; // aux apunta al inicio de la cola
56 num = aux->nro;
57 q.delante = (q.delante)->sgte;
58 delete(aux); // libera memoria a donde apuntaba aux
59
60 return num;
61 }
62
63 /* Mostrar Cola
64 ------------------------------------------------------------------------*/
65 void muestraCola( struct cola q )
66 {
67 struct nodo *aux;
68
69 aux = q.delante;
70
71 while( aux != NULL )
72 {
73 cout<<" "<< aux->nro ;
74 aux = aux->sgte;
75 }
76 }
77
78 /* Eliminar todos los elementos de la Cola
79 ------------------------------------------------------------------------*/
80 void vaciaCola( struct cola &q)
81 {
82 struct nodo *aux;
83
84 while( q.delante != NULL)
85 {
86 aux = q.delante;
87 q.delante = aux->sgte;
88 delete(aux);
89 }
90 q.delante = NULL;
91 q.atras = NULL;
92
93 }
94
29
95 /* Menu de opciones
96 ------------------------------------------------------------------------*/
97 void menu()
98 {
99 cout<<"\n\t IMPLEMENTACION DE COLAS EN C++\n\n";
100 cout<<" 1. ENCOLAR "<<endl;
101 cout<<" 2. DESENCOLAR "<<endl;
102 cout<<" 3. MOSTRAR COLA "<<endl;
103 cout<<" 4. VACIAR COLA "<<endl;
105
107 }
108
110 ------------------------------------------------------------------------*/
111 int main()
112 {
113 struct cola q;
114
115 q.delante = NULL;
116 q.atras = NULL;
117
118
119 int dato; // numero a encolar
120 int op; // opcion del menu
121 int x ; // numero que devuelve la funcon pop
122
124
125 do
126 {
128
129 switch(op)
130 {
131 case 1:
132
133 cout<< "\n NUMERO A ENCOLAR: "; cin>> dato;
134 encolar( q, dato );
135 cout<<"\n\n\t\tNumero " << dato << " encolado...\n\n";
136 break;
137
138
30
139 case 2:
140
141 x = desencolar( q );
142 cout<<"\n\n\t\tNumero "<< x <<" desencolado...\n\n";
143 break;
144
145
146 case 3:
147
148 cout << "\n\n MOSTRANDO COLA\n\n";
149 if(q.delante!=NULL) muestraCola( q );
150 else cout<<"\n\n\tCola vacia...!"<<endl;
151 break;
152
153
154 case 4:
155
156 vaciaCola( q );
157 cout<<"\n\n\t\tHecho...\n\n";
158 break;
159
160 }
161
164
165 }while(op!=5);
166
167
168 return 0;
169 }
Algoritmo 2:Implementación de una Cola en C++
3. LISTAS
a. Listas enlazadas lineales
a. Listas simples enlazadas
La lista enlazada básica es la lista enlazada simple la cual tiene un enlace

por nodo. Este enlace apunta al siguiente nodo en la lista, o al valor NULL
o a la lista vacía, si es el último nodo.
Una lista enlazada simple contiene dos valores: el valor actual del nodo y
un enlace al siguiente nodo
31
Ilustración 15: Ejemplo de Listas simples enlazadas
Implementación:
1 /*
2 * C++ - Listas Enlazadas simples en c++
4 *
5 * Description: Inserta, elimina, busca, reporta
6 * Site: martincruz.me
7 */
8
9
11 #include <stdlib.h>
13
14 struct nodo{
15 int nro; // en este caso es un numero entero
17 };
18
19 typedef struct nodo *Tlista;
20
21 void insertarInicio(Tlista &lista, int valor)
22 {
23 Tlista q;
24 q = new(struct nodo);
25 q->nro = valor;
26 q->sgte = lista;
27 lista = q;
28 }
29
30 void insertarFinal(Tlista &lista, int valor)
31 {
32 Tlista t, q = new(struct nodo);
33
34 q->nro = valor;
35 q->sgte = NULL;
36
37 if(lista==NULL)
32
38 {
39 lista = q;
40 }
41 else
42 {
43 t = lista;
44 while(t->sgte!=NULL)
45 {
46 t = t->sgte;
47 }
48 t->sgte = q;
49 }
50
51 }
52
53 int insertarAntesDespues()
54 {
55 int _op, band;
56 cout<<endl;
57 cout<<"\t 1. Antes de la posicion "<<endl;
58 cout<<"\t 2. Despues de la posicion "<<endl;
59
60 cout<<"\n\t Opcion : "; cin>> _op;
61
62 if(_op==1)
63 band = -1;
64 else
65 band = 0;
66
67 return band;
68 }
69
70 void insertarElemento(Tlista &lista, int valor, int pos)
71 {
72 Tlista q, t;
73 int i;
75 q->nro = valor;
76
77 if(pos==1)
78 {
79 q->sgte = lista;
80 lista = q;
81 }
33
82 else
83 {
84 int x = insertarAntesDespues();
85 t = lista;
86
87 for(i=1; t!=NULL; i++)
88 {
89 if(i==pos+x)
90 {
91 q->sgte = t->sgte;
92 t->sgte = q;
93 return;
94 }
95 t = t->sgte;
96 }
97 }
98 cout<<" Error...Posicion no encontrada..!"<<endl;
99 }
100
101 void buscarElemento(Tlista lista, int valor)
102 {
103 Tlista q = lista;
104 int i = 1, band = 0;
105
106 while(q!=NULL)
107 {
108 if(q->nro==valor)
109 {
110 cout<<endl<<" Encontrada en posicion "<< i <<endl;
111 band = 1;
112 }
113 q = q->sgte;
114 i++;
115 }
116
117 if(band==0)
118 cout<<"\n\n Numero no encontrado..!"<< endl;
119 }
120
121 void reportarLista(Tlista lista)
122 {
123 int i = 0;
124
125 while(lista != NULL)
34
126 {
127 cout <<' '<< i+1 <<") " << lista->nro << endl;
128 lista = lista->sgte;
129 i++;
130 }
131 }
132
133
134 void eliminarElemento(Tlista &lista, int valor)
135 {
136 Tlista p, ant;
137 p = lista;
138
139 if(lista!=NULL)
140 {
141 while(p!=NULL)
142 {
143 if(p->nro==valor)
144 {
145 if(p==lista)
147 else
148 ant->sgte = p->sgte;
149
150 delete(p);
151 return;
152 }
153 ant = p;
154 p = p->sgte;
155 }
156 }
157 else
158 cout<<" Lista vacia..!";
159 }
160
161 void eliminaRepetidos(Tlista &lista, int valor)
162 {
163 Tlista q, ant;
164 q = lista;
165 ant = lista;
166
167 while(q!=NULL)
168 {
169 if(q->nro==valor)
35
170 {
171 if(q==lista) // primero elemento
172 {
174 delete(q);
175 q = lista;
176 }
177 else
178 {
179 ant->sgte = q->sgte;
180 delete(q);
181 q = ant->sgte;
182 }
183 }
184 else
185 {
186 ant = q;
187 q = q->sgte;
188 }
189
190 }// fin del while
191
192 cout<<"\n\n Valores eliminados..!"<<endl;
193 }
194
195 void menu1()
196 {
197 cout<<"\n\t\tLISTA ENLAZADA SIMPLE\n\n";
198 cout<<" 1. INSERTAR AL INICIO "<<endl;
199 cout<<" 2. INSERTAR AL FINAL "<<endl;
200 cout<<" 3. INSERTAR EN UNA POSICION "<<endl;
201 cout<<" 4. REPORTAR LISTA "<<endl;
202 cout<<" 5. BUSCAR ELEMENTO "<<endl;
203 cout<<" 6. ELIMINAR ELEMENTO 'V' "<<endl;
204 cout<<" 7. ELIMINAR ELEMENTOS CON VALOR 'V' "<<endl;
206
208 }
209
210
212 ---------------------------------------------------------------------*/
213
36
214 int main()
215 {
216 Tlista lista = NULL;
218 int _dato; // elemenento a ingresar
219 int pos; // posicion a insertar
220
221
223
224 do
225 {
226 menu1(); cin>> op;
227
228 switch(op)
229 {
230 case 1:
231
232 cout<< "\n NUMERO A INSERTAR: "; cin>> _dato;
233 insertarInicio(lista, _dato);
234 break;
235
236
237 case 2:
238
239 cout<< "\n NUMERO A INSERTAR: "; cin>> _dato;
240 insertarFinal(lista, _dato );
241 break;
242
243
244 case 3:
245
246 cout<< "\n NUMERO A INSERTAR: ";cin>> _dato;
247 cout<< " Posicion : "; cin>> pos;
248 insertarElemento(lista, _dato, pos);
249 break;
250
251
252 case 4:
253
254 cout << "\n\n MOSTRANDO LISTA\n\n";
255 reportarLista(lista);
256 break;
257
37
258
259 case 5:
260
261 cout<<"\n Valor a buscar: "; cin>> _dato;
262 buscarElemento(lista, _dato);
263 break;
264
265 case 6:
266
267 cout<<"\n Valor a eliminar: "; cin>> _dato;
268
269 eliminarElemento(lista, _dato);
270 break;
271
272 case 7:
273
274 cout<<"\n Valor repetido a eliminar: "; cin>> _dato;
275
276 eliminaRepetidos(lista, _dato);
277 break;
278
279 }
280
283
284 }while(op!=8);
285
286
287 system("pause");
288 return 0;
289 }
Algoritmo 3:Implementación de una Lista Enlazada Simple Lineal en C++
b. Lista Doblemente Enlazada
Un tipo de lista enlazada más sofisticado es la lista doblemente enlazada

o lista enlazadas de dos vías. Cada nodo tiene dos enlaces: uno apunta
al nodo anterior, o apunta al valor NULL o a la lista vacía si es el primer
nodo; y otro que apunta al siguiente nodo siguiente, o apunta al valor
NULL o a la lista vacía si es el último nodo.
38
Una lista doblemente enlazada contiene tres valores: el valor, el link al
nodo siguiente, y el link al anterior.
En algún lenguaje de muy bajo nivel, ofrece una vía para implementar
listas doblemente enlazadas, usando una sola palabra para ambos
enlaces, aunque el uso de esta técnica no se suele utilizar.
Ilustración 16: Ejemplo de Lista Doblemente Enlazada
b. Listas enlazadas circulares
En una lista enlazada circular, el primer y el último nodo están unidos juntos. Esto se
puede hacer tanto para listas enlazadas simples como para las doblemente
enlazadas. Para recorrer un lista enlazada circular podemos empezar por cualquier
nodo y seguir la lista en cualquier dirección hasta que se regrese hasta el nodo
original. Desde otro punto de vista, las listas enlazadas circulares pueden ser vistas
como listas sin comienzo ni fin. Este tipo de listas es el más usado para dirigir buffers
para "ingerir" datos, y para visitar todos los nodos de una lista a partir de uno dado.
Ilustración 17: Ejemplo de Listas enlazadas circulares
Una lista enlazada circular que contiene tres valores enteros

a. Listas enlazadas circulares simples
Cada nodo tiene un enlace, similar al de las listas enlazadas simples, excepto
que el siguiente nodo del último apunta al primero. Como en una lista enlazada
simple, los nuevos nodos pueden ser solo eficientemente insertados después de
uno que ya tengamos referenciado. Por esta razón, es usual quedarse con una
referencia solamente al último elemento en una lista enlazada circular simple,
esto nos permite rápidas inserciones al principio, y también permite accesos al
primer nodo desde el puntero del último nodo.
Implementación:
1 /*
2 * C++ - Unir 2 listas circulares simples
39
4 * Description: Une un una lista L1 con L2 y muestra la L1 que es la final
5 * Site: martincruz.me
6 */
7
9 #include <stdlib.h>
11
12 struct nodo{
13 int nro; // en este caso es un numero entero
15 };
16
17 typedef struct nodo *TlistaC;
18
19 TlistaC lista1, lista2, fin1, fin2;
20
21 void mostrarListas()
22 {
23 TlistaC aux;
24 aux = lista1;
25
26 if(lista1!=NULL)
27 {
28 cout<<"\n\n Lista 1 :\n\n";
29 do
30 {
31 cout<<" "<<aux->nro;
32 aux = aux->sgte;
33 }while(aux!=lista1);
34 }
35 else
36 cout<<"\n\n\tLista vacia...!"<<endl;
37
38 aux = lista2;
39 if(lista2!=NULL)
40 {
42 do
43 {
45 aux = aux->sgte;
40
47 }
48 else
50 }
51
52 void insertar(TlistaC &lista, TlistaC &fin, int valor)
53 {
54 TlistaC q;
56 q->nro = valor;
57
58
59 if(lista==NULL)
60 {
61 lista = q;
62 lista->sgte = lista;
63 fin = q ;
64 }
65 else
66 {
67 fin->sgte = q;
68 q->sgte = lista;
69 fin = q;
70 }
71 }
72
73 void ingresarListas()
74 {
75 int tam1, tam2, dato;
76
77 cout<<"\n Tamanio de lista 1 : "; cin>> tam1;
78 cout<<endl;
79
80 for(int i=0; i<tam1; i++)
81 {
82 cout<<"\tElemento "<<i+1<<": "; cin>> dato;
83 insertar(lista1, fin1, dato);
84 }
85
86 cout<<"\n Tamanio de lista 2 : "; cin>> tam2;
87 cout<<endl;
88
89 for(int i=0; i<tam2; i++)
90 {
41
91 cout<<"\tElemento "<<i+1<<": "; cin>> dato;
92 insertar(lista2, fin2, dato);
93 }
94 }
95
96 void unirListas()
97 {
98 fin1->sgte = lista2;
99 fin2->sgte = lista1;
100
101 cout<<"\n\n\tListas circulares L1 y L2 unidas..."<<endl;
102 }
103
104 void mostrarLista1()
105 {
106 TlistaC aux;
107 aux = lista1;
108
109 if(lista1!=NULL)
110 {
112 do
113 {
115 aux = aux->sgte;
117 }
118 else
120 }
121 void menu()
122 {
123 cout<<"\n\t\tUNIR LISTAS CIRCULARES\n\n";
124 cout<<" 1. INGRESAR LISTAS "<<endl;
125 cout<<" 2. MOSTRAR LISTAS "<<endl;
126 cout<<" 3. UNIR LISTAS "<<endl;
127 cout<<" 4. MOSTRAR LISTA 1 "<<endl;
129
131 }
132
133
42
135 ---------------------------------------------------------------------*/
136
137 int main()
138 {
139 TlistaC lista = NULL;
141
142 TlistaC lista1 = lista2 = NULL;
143
145
146 do
147 {
149
150 switch(op)
151 {
152 case 1:
153 ingresarListas( );
154 break;
155
156 case 2:
157 mostrarListas();
158 break;
159
160 case 3:
161 unirListas();
162 break;
163
164 case 4:
165 mostrarLista1();
166 break;
167
168 }
169
172
173 }while(op!=5);
174
175 return 0;
176 }
Algoritmo 4:Implementación de una Lista Simple Circular en C++
43
b. Lista Enlazada Doblemente Circular
En una lista enlazada doblemente circular, cada nodo tiene dos enlaces,
similares a los de la lista doblemente enlazada, excepto que el enlace anterior
del primer nodo apunta al último y el enlace siguiente del último nodo, apunta al
primero. Como en una lista doblemente enlazada, las inserciones y eliminaciones
pueden ser hechas desde cualquier punto con acceso a algún nodo cercano.
Aunque estructuralmente una lista circular doblemente enlazada no tiene ni
principio ni fin, un puntero de acceso externo puede establecer el nodo apuntado
que está en la cabeza o al nodo cola, y así mantener el orden tan bien como en
una lista doblemente enlazada.
c. Nodos Centinelas
A veces las listas enlazadas tienen un nodo centinela (también llamado falso
nodo o nodo ficticio) al principio y/o al final de la lista, el cual no es usado para
guardar datos. Su propósito es simplificar o agilizar algunas operaciones,
asegurando que cualquier nodo tiene otro anterior o posterior, y que toda la lista
(incluso alguna que no contenga datos) siempre tenga un "primer y último" nodo.
7.6. Metodología Kendall & Kendall
Ilustración 18: Metodología Kendall & Kendall
44
FASE I: Identificación de problemas, oportunidades y objetivos
Ilustración 19: Fase 1 - Identificar el problema
• Observación directa del entorno.

• Aplicación de entrevista para recolectar información.
• Sintetizar la información recolectada para construir objetivos.
• Estimar el alcance del proyecto.
• Identificar si existe una necesidad, problema u oportunidad argumentada.
• Documentar resultados.
• Estudiar los riesgos del proyecto.
• Presentar un informe de vialidad.
En la primera fase el analista es el encargado de identificar los problemas de la

organización, detallarlos, examinar, evaluar las oportunidades y objetivos.
El analista debe identificar y evaluar los problemas existentes en la organización de
manera crítica y precisa. Mayormente los problemas son detectados por alguien más
y es cuando el analista es solicitado a fin de precisarlos. Las oportunidades son
situaciones que el analista considera susceptibles de mejorar utilizando sistemas de
información computarizados, lo cual le da mayor seguridad y eficacia a las
organizaciones además de obtener una ventaja competitiva. El analista debe
identificar los objetivos, es decir, el analista debe averiguar lo que la empresa trata
de conseguir, se podrá determinar si algunas funciones de las aplicaciones de los
sistemas de información pueden contribuir a que el negocio alcance sus objetivos
aplicándolas a problemas u oportunidades específicos. Los usuarios, los analistas y
los administradores de sistemas que coordinan el proyecto son los involucrados en
la primera fase. Las actividades de esta fase son las entrevistas a los encargados de
45
coordinar a los usuarios, sintetizar el conocimiento obtenido, estimar el alcance del
proyecto y documentar los resultados. El resultado de esta fase en un informe de
viabilidad que incluye la definición del problema y un resumen de los objetivos. La
administración debe decidir si se sigue adelante o si se cancela el proyecto
propuesto.
FASE II: Determinación de los requerimientos de información.
Ilustración 20: Fase 2 - Determinar los requerimientos
• Revisión de los objetivos.

• Identificar el dominio.
• Investigar la razón por la cual se implementa el sistema actual.
• Recolectar información sobre los procedimientos y operaciones que se
desempeñan actualmente.
• Detallar específicamente: Quiénes son los involucrados, cuál es la
actividad, regla y restricciones del negocio, entorno de desarrollo de
las actividades, momentos oportunos de desarrollo de cada función, la
manera en que se desempeñan los procedimientos actuales.
• Elaborar una lista detallada y organizada de todos los procedimientos.
• Separar requerimientos funcionales y no funcionales. Adicionar al informe de
la primera fase, esta nueva información.
En esta fase el analista se esfuerza por comprender la información que necesitan los
usuarios para llevar a cabo sus actividades. Entre las herramientas que se utilizan
para determinar los requerimientos de información de un negocio se encuentran
46
métodos interactivos como las entrevistas, los muestreos, la investigación de datos
impresos y la aplicación de cuestionarios; métodos que no interfieren con el usuario
como la observación del comportamiento de los encargados de tomar las decisiones
y sus entornos e oficina, al igual que métodos de amplio alcance como la
elaboración de prototipos.
Esta fase es útil para que el analista confirme la idea que tiene de la organización y
sus objetivos.
Los implicados en esta fase son el analista y los usuarios, por lo general los
trabajadores y gerentes del área de operaciones.
El analista necesita conocer los detalles de las funciones del sistema actual:
El quién (la gente involucrada), el qué (la actividad del negocio), el dónde (el entorno
donde se desarrollan las actividades), el cuándo (el momento oportuno) y el cómo (la
manera en que se realizan los procedimientos actuales) del negocio que se estudia.
Al término de esta fase, el analista debe conocer el funcionamiento del negocio y
poseer información muy completa acerca de la gente, los objetivos, los datos y los
procedimientos implicados.
FASE III: Análisis de las necesidades.
Ilustración 21: Fase 3 - Análisis de necesidades
• Evaluar las dos fases anteriores.

• Modelar las entradas, los procesos y las salidas de las funciones ya
identificadas.
• Elaborar diccionario de datos y sus especificaciones.
• Elaborar diagramas de procesos de cada función.
47
• Elaborar propuesta del sistema con todos los diagramas de operaciones y de
procesos.
• Realizar el análisis del riesgo sobre el realizado en las fases anteriores,
tomando en cuenta el aspecto económico, técnico y operacional (estudio de
factibilidad)
• Estimar en un diagrama de Gantt el tiempo que tomará desarrollar el
sistema.
En esta fase el analista evalúa las dos fases anteriores, usa herramientas y técnicas
como el uso de diagramas de flujo de datos para graficar las entradas, los procesos y
las salidas de las funciones del negocio en una forma gráfica estructurada.
A partir de los diagramas de flujo de datos se desarrolla un diccionario de datos que
enlista todos los datos utilizados en el sistema, así como sus respectivas
especificaciones.
El analista prepara en esta fase, una propuesta de sistemas que sintetiza sus
hallazgos, proporciona un análisis de costo/beneficio de las alternativas y ofrece, en
su caso, recomendaciones sobre lo que se debe hacer.
FASE IV: Diseño del sistema recomendado.
Ilustración 22: Fase 4 - Diseño del sistema
• Evaluar las tres fases anteriores.

• Realizar el diseño lógico de todo el sistema.
• Elaborar procedimientos precisos para la captura de los datos que van a
ingresar al sistema de información.
• Elaborar el diseño de la base de datos.
48
• Diseñar las diferentes interfaces de usuarios de cada operación,
procedimiento y/o función.
• Diseñar controles y procedimientos de respaldos que protejan al sistema y a
los datos.
• Producir los paquetes específicos de programas para los programadores.
• Elaborar una lista de las funciones genéricas y de las que será obligatorio
crear.
En esta fase el analista utiliza la información recopilada en las primeras fases para
realizar el diseño lógico del sistema de información.
El analista diseña procedimientos precisos para la captura de datos que aseguran
que los datos que ingresen al sistema de información sean correctos.
Facilita la entrada eficiente de datos al sistema de información mediante técnicas
adecuadas de diseño de formularios y pantallas.
La concepción de la interfaz de usuario forma parte del diseño lógico del sistema de
información.
La interfaz conecta al usuario con el sistema y por tanto es sumamente importante.
También incluye el diseño de archivos o bases de datos que almacenarán gran parte
de los datos indispensables para los encargados de tomar las decisiones en la
organización.
En esta fase el analista interactúa con los usuarios para diseñar la salida (en
pantalla o impresa) que satisfaga las necesidades de información de estos últimos.
Finalmente, el analista debe diseñar controles y procedimientos de respaldo que
protejan al sistema y a los datos y producir paquetes de especificaciones de
programa para los programadores.
Cada paquete debe contener esquemas para la entrada y la salida, especificaciones
de archivos y detalles del procesamiento.
49
FASE V: Desarrollo y documentación del software.
Ilustración 23: Fase 5 - Desarrollo y Documentación
• Evaluar los procedimientos que va a ser desarrollados por el programador.

• Mostrar y explicar cada procedimiento, función y operación al programador.
• Elaborar manuales de procedimientos internos del sistema.
• Elaborar manuales externos de ayuda a los usuarios del sistema.
• Elaborar demostraciones para los usuarios y la interacción con distintas
interfaces.
• Elaborar actualizaciones para los diferentes procedimientos. Elaborar un
informe con el tiempo que se llevó construir cada procedimiento.
En la quinta fase del ciclo del desarrollo de sistemas, el analista trabaja de manera
conjunta con los programadores para desarrollar cualquier software original
necesario. Entre las técnicas estructuradas para diseñar y documentar software se
encuentran los diagramas de estructuras, los diagramas de Nassi-Shneiderman y el
pseudocódigo.
Durante esta fase el analista trabaja con los usuarios para desarrollar
documentación efectiva para el software, como manuales de procedimientos, ayuda
en línea y sitios web que incluyan respuestas a preguntas frecuentes en archivos
“léame” que se integrarán al nuevo software.
La documentación indica a los usuarios cómo utilizar el sistema y qué hacer en caso
de que surjan problemas derivados de este uso. Los programadores desempeñan un
rol clave en esta fase porque diseñan, codifican y eliminan errores sintácticos de los
programas de cómputo.
50
FASE VI: Prueba y mantenimiento del sistema.
Ilustración 24: Fase 6 - Pruebas y mantenimiento
• Realizar la programación de las pruebas del sistema.

• Realizar un instrumento para evaluar el sistema de información.
• El programador deberá elaborar un resumen de las pruebas del sistema.
• El analista deberá realizar un informe de sus pruebas y discutirlo con el
programador.
• Elaborar la planificación de las horas del mantenimiento del sistema.
Elaborar la lista de las operaciones que pudieran sufrir modificaciones
de códigos.
Antes de poner en funcionamiento el sistema es necesario probarlo es mucho

menos costoso encontrar los problemas antes que el sistema se entregue a los
usuarios.
Una parte de las pruebas la realizan los programadores solos, y otra la llevan a cabo
de manera conjunta con los analistas de sistemas. Primero se realizan las pruebas
con datos de muestra para determinar con precisión cuáles son los problemas y
posteriormente se realiza otra con datos reales del sistema actual.
El mantenimiento del sistema de información y su documentación empiezan en esta
fase y se llevan de manera rutinaria durante toda su vida útil.
51
FASE VII: Implementación y evaluación del sistema.
Ilustración 25: Fase 7 - Implementación y evaluación
• Planificar gradualmente la conversión del sistema anterior.

• Instalar los equipos de hardware necesarios para el funcionamiento del
software creado.
• Capacitar por medio de talleres a los usuarios en el manejo de equipos y
software creados.
• Evaluar la adaptabilidad de los usuarios al sistema.
Esta es la última fase del desarrollo de sistemas, y aquí el analista participa en la

implementación del sistema de información. En esta fase se capacita a los usuarios
en el manejo del sistema. Parte de la capacitación la imparten los fabricantes, pero
la supervisión de ésta es responsabilidad del analista de sistemas.
Se menciona la evaluación como la fase final del ciclo de vida del desarrollo de
sistemas principalmente en áreas del debate. En realidad, la evaluación se lleva a
cabo durante cada una de las fases.
El trabajo de sistemas es cíclico, cuando un analista termina una fase del desarrollo
de sistemas y pasa a la siguiente, el surgimiento de un problema podría obligar a
regresar a la fase previa y modificar el trabajo realizado.
52
REFERENCIAS BIBLIOGRÁFICAS
[1]. http://tesis.pucp.edu.pe/repositorio/handle/20.500.12404/4985
[2]. http://repositorio.ucv.edu.pe/handle/UCV/13510
[3]. http://renati.sunedu.gob.pe/handle/sunedu/346570
[4]. http://cybertesis.uni.edu.pe/handle/uni/13750
[5]. http://repositorio.usil.edu.pe/handle/USIL/2051
[6]. http://www.aulatecnologia.com/INFORMATICA/scratch/teoriaScratch.pdf
[7]. https://es.wikipedia.org/wiki/N%C3%BAcleo_Linux#N%C3%BAcleo_de_sistema
_operativo
[8]. https://www.ecured.cu/Software_libre
[9]. https://es.wikipedia.org/wiki/Sistema_operativo
[10]. https://www.monografias.com/trabajos66/estructura-datos/estructura-datos.shtml
53

Proyecto TSO

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Proyecto TSO

Caricato da

Copyright:

Formati disponibili

UNIVERSIDAD NACIONAL DE TRUJILLO

FACULTAD DE CIENCIAS FISICAS Y MATEMATICAS

“Diseño de un sistema operativo con características

Proyecto de Investigación de Tópicos Especiales en

2. Formulación del Problema

4.1. Justificación Económica

4.2. Justificación social

4.3. Justificación Tecnológica

4.4. Justificación Académica

5.1. Objetivo general

5.2. Objetivos Específico

7.1. Sistema Operativo:

Ilustración 1: Interacción entre el sistema operativo con el resto de las partes.

Nótese que es un error común muy extendido denominar al conjunto completo de

Ilustración 2:Logos de diferentes sistemas operativos

7.2. Software Libre:

Ilustración 3: Logo de diferentes software libres

7.3. Kernel Linux:

Ilustración 4: Linus Torvalds

Linux es multiprogramado, dispone de memoria virtual, gestión de memoria,

7.3.1. Núcleo de sistema operativo

En el archivo Léeme de Linux se indica que es un clon del sistema operativo

Un micronúcleo contiene una funcionalidad mínima en comparación con un

Ilustración 5: El núcleo Monolítico de Linux.

En ciertos textos, el sistema operativo es llamado indistintamente como

La parte de un sistema operativo que se ejecuta sin privilegios o en espacio

En un sistema con núcleo monolítico como Linux la biblioteca de lenguaje C

En un sistema con micronúcleo la biblioteca de lenguaje C puede gestionar

Las distribuciones Android incluyen el núcleo Linux junto con el entorno de

Actualmente Linux es un núcleo monolítico híbrido. Los controladores de

El hecho de que Linux no fuera desarrollado siguiendo el diseño de un

7.4. Bases de la programación:

Ilustración 8: Ciclo Fases de Programación

Si en lugar de un problema de matemáticas, física, química, tecnología, ... estamos

La comprensión lingüística del problema (entender el significado del enunciado) es

En esta etapa se debe hacer una representación precisa del

En cuanto a las restricciones es necesario saber que elementos puedo utilizar y

Es quizás la forma de representación más antigua. Algunos autores suelen

Ilustración 9: Elementos de un diagrama de flujo

Es la técnica que permite expresar la solución de un problema

Ilustración 10: Pseudocódigo

Por algoritmo, se entiende a un conjunto finito de instrucciones que se deben

El algoritmo es un conjunto de pasos, instrucciones o acciones que se deben

• Tiene que ser preciso.

Una estructura de datos define la organización e interrelación de éstos y un conjunto

• Alta, adicionar un nuevo valor a la estructura.

Otras operaciones que se pueden realizar son:

• Ordenamiento, de los elementos pertenecientes a la estructura.

Cada estructura ofrece ventajas y desventajas en relación a la simplicidad y eficiencia

Ilustración 11: Ejemplo de tabla de hash

En este tema definiremos unas implementaciones que permitan aplicar el álgebra de

Ilustración 12: Ejemplo de Pila

Ilustración 13: Diagrama de Flujo de una Pila

Son aquellas que solo tiene 2 operaciones, Push(Inserción) y

Ilustración 14: Ejemplos de Cola

La lista enlazada básica es la lista enlazada simple la cual tiene un enlace

b. Lista Doblemente Enlazada

Un tipo de lista enlazada más sofisticado es la lista doblemente enlazada

Ilustración 16: Ejemplo de Lista Doblemente Enlazada

b. Listas enlazadas circulares

Ilustración 17: Ejemplo de Listas enlazadas circulares

Una lista enlazada circular que contiene tres valores enteros

7.6. Metodología Kendall & Kendall