Informe Del Proyecto Quimica Orgánica Móvil

A
Tabla de Contenido
Descripcin del proyecto............................................................................ 2
Objetivos........................................................................................................ 2
Objetivo General........................................................................................... 2
Objetivos Especficos.................................................................................... 3
Alcance del Proyecto................................................................................... 3
Descripcin de las estructuras de datos utilizados en el proyecto.....3
Caractersticas de una Lista de Doble Enlace...............................................3
Programacin Esttica VS Programacin Dinmica...............................3
Paso a paso del proceso del programa.....................................................4
Conclusiones............................................................................................... 12
Dificultades................................................................................................. 13
Recomendaciones y sugerencias.............................................................13
Cdigo fuente.............................................................................................. 14
Bibliografa.................................................................................................. 32
Aplicacin Qumica Orgnica

Descripcin del proyecto
Los estudiantes de hoy en da, en su mayora, tienen en las manos el
poder de personalizar diferentes herramientas tecnolgicas que
lleguen a satisfacer sus necesidades acadmicas. Es fascinante
poder configurar un celular o un ordenador a gusto de cada uno para
facilitar las actividades diarias que se deben realizar en los colegios o
universidades.
Es importante recalcar que actualmente existen un sin nmero de
aplicaciones para lograr mejorar continuamente el nivel acadmico y
profesional, ya sea desde un simple block de notas hasta aprender
diferentes idiomas.
Esta aplicacin est pensada como alternativa para aprender de
forma interactiva nomenclatura de Qumica Orgnica. Se basa en
tener una lista precargada de estructuras qumicas con las siguientes
caractersticas:
Nombre de la estructura.
Cantidad de Carbonos.
Cantidad de Hidrgenos.
Cantidad de Oxgenos.
Nombre Cientfico o Comercial.
Informacin relevante.
Con esta base de datos se pretende que el usuario acceda a la

informacin de cada estructura orgnica para revisarla en cualquier
momento y de esa forma llegar a recordar, en su mayora, aspectos
acerca de esta y que se familiarice con la nomenclatura, que en
algunos casos suele ser tedioso aprenderlas.
La aplicacin permite revisar una por una la informacin de cada
estructura como tambin mostrar toda la lista, adems cuenta con
una cuenta de usuario donde se puede crear una nueva estructura,
eliminar y modificar cualquiera de ellas.
Objetivos
Objetivo General
Crear una aplicacin de Qumica Orgnica para acceder a su
informacin de forma instantnea, que muestre todas y cada
una de las estructuras precargadas con sus respectivos datos.

Adems, estar sujeta a cambios realizados por el usuario como
aadir una nueva estructura, eliminar
y modificar una
estructura ya existente.
Objetivos Especficos
Comprender el funcionamiento de una Lista Doblemente
Enlazada.
Crear las clases (PrincipalQuimica, NodoQuimica,
ListaQuimica, Cuenta) con sus respectivos atributos y
mtodos para crear objetos que lleguen a interactuar
entre s.
Verificar el correcto funcionamiento del programa.
Alcance del Proyecto

La primera versin de este programa logra almacenar estructuras
precargadas por el programador, mostrar la informacin
correspondiente de todas y cada una de las estructuras. Tambin
permite, a travs una cuenta, que el usuario agregue una estructura,
en la cual se le pide llenar todos los datos para cargarla,
conjuntamente puede eliminar cualquier estructura y modificarla.
Posteriormente puede observar todos los cambios realizados en la
lista.
Descripcin de las estructuras de datos utilizados en el

proyecto
En este proyecto se emple TAD Lista de Doble Enlace. Este tipo de
estructura fue seleccionado porque permite un recorrido en ambos
sentidos gracias al almacenamiento de dos referencias por nodos.
Este tipo de lista no necesita un nodo especial para acceder a ella,
puede recorrerse en ambos sentidos a partir de cualquier nodo.
Es importante recordar que un nodo puede almacenar diferentes
tipos de datos como nmeros enteros (int), nmeros decimales
(doubles o floats), valor booleano (boolean), carcter (char) o una
cadena de texto (String).
Caractersticas de una Lista de Doble Enlace

Recorrido secuencial en ambos sentidos (de izquierda a derecha
y de derecha a izquierda).
No es necesario que un puntero (inicio) se encuentre en la
cabeza de lista.
Posee dos referencias por cada nodo.
Se puede insertar y borrar de forma ms sencilla cualquier
nodo de la lista.
Programacin Esttica VS Programacin Dinmica

Ventajas de la Estructura esttica:
El tamao ocupado en la memoria se define antes de que el
programa se ejecute.
Se puede acceder directamente a cualquier casilla mediante una
coordenada.
Desventajas de la Estructura esttica:
No se puede modificar el tamao de la estructura durante la
ejecucin del programa.
Una variable hace referencia a un nico valor dentro de una
casilla de la memoria.
Puede presentar un desperdicio de memoria cuando el tamao no
es el adecuado.
Ventajas de la Estructura dinmica
No tiene limitaciones en el tamao de la memoria ocupada.
Se puede modificar el tamao durante la ejecucin de un
programa.
Con la ayuda de un tipo de dato, conocido como puntero, se
puede construir estructuras dinmicas para la resolucin de
problemas.
Desventajas de la Estructura dinmica:
No se conoce con anticipacin el espacio de memoria que se va a
ocupar.
Conclusin: Se puede observar que una Estructura dinmica posee
mayor ventajas en cuanto a su aplicacin en programas.
Paso a paso del proceso del programa

NodoQuimica
Donde:
Nombre
=
nombre de la estructura qumica.
NumCarbonos = cantidad de carbonos de la estructura
qumica.
NumHidrogenos = cantidad de hidrgenos de la estructura
qumica.
NumOxigenos = cantidad de oxgenos de la estructura
qumica.
Informacion = informacin relevante de la estructura
qumica.
Numero = nmero de la estructura qumica otorgado por el
programa.
Mtodo Aadir.Este mtodo permite crear la lista con datos (estructuras
qumicas) precargados por el programador en forma de pila.
Para crear el primer nodo de la lista
Paso 1:
Paso 2:
Crear el nuevo nodo con los
respectivos datos de la estructura. El campo nmero ser
llenado automticamente por el programa.
mvil
Paso
con
3: Enlazar inicio y
el nuevo nodo.
Para crear un nodo despus del primer nodo de la lista

Paso 1: Se toma en cuenta que inicio y mvil ya no
apuntan a null, por el contrario apuntan al primer nodo de la
lista.
Paso 2: Crear el nuevo nodo con los respectivos datos de la

estructura.
Paso
primer nodo con el segundo nodo.
3:
Enlazar
el
Vista de varios nodos enlazados
Mtodo insertar.El mtodo insertar est destinado para el usuario. Mediante este
mtodo el usuario puede insertar una estructura qumica (nodo)
en cualquier lugar de la lista; es decir puede insertar un nodo

antes del primer nodo, en medio de dos nodos o un nodo al final
de la lista. Solo es necesario conocer la posicin en la que el
usuario desea insertar la estructura. Es obligacin del usuario
llenar todos los campos que el programa le pide para su correcta
ejecucin y posterior almacenamiento.
Paso 1: Para poder acceder al mtodo el usuario debe
introducir de forma correcta el nombre de su cuenta y su
contrasea.
Para
del primer nodo de la lista
insertar un nodo antes
Paso 2: El usuario debe llenar todos los datos que el programa

le pide, incluyendo la categora ndice para poder almacenar
todos los datos en un nuevo nodo. Con este ndice el
programa logra posicionar el nodo en el lugar que desea el
usuario. En este caso se va a suponer que el usuario coloco en
nmero 1 en la categora ndice.
Paso 3: Enlazar el nuevo nodo con el primer nodo de la lista.
Paso 4: Despus de hacer el enlace el ndice se actualiza con

cada nodo respectivamente.
Para insertar un nodo en medio de dos nodos

Paso 2: Despus del correcto llenado y almacenamiento de
los datos del nuevo nodo, el usuario debe introducir el
ndice para posicionar el nuevo nodo dentro de la lista. En
esta oportunidad el ndice tendr un valor de 3.
Paso 3: Enlazar el nuevo nodo con ndice 3 (definido por el

usuario) en medio del nodo 2 y 3 de la lista.
Paso 4: Despus de hacer el enlace el ndice se actualiza

con cada nodo respectivamente.
Para insertar un nodo al final de la lista

Paso 2: Despus de llenar los datos del nodo correctamente
y su correspondiente almacenamiento, el usuario debe
especificar el ndice donde desea colocar el nodo. En esta
ocasin el ndice ser el nmero 4. El nuevo nodo ser
insertado al final de la lista de 3 estructuras qumicas.
Paso 3: Enlazar el nuevo nodo con el ultimo nodo de la lista.
Paso 4: Posterior al enlace el programa vuelve a enumerar

todos los nodos.
Para insertar un primer nodo sin tener estructuras

precargadas por el programador
Paso 1: En el caso que no existan estructuras precargadas
por el programador, y el usuario desee insertar el primer
nodo de la lista se siguen estos pasos.
Paso 2: Crear el nuevo nodo y completar la informacin

correspondiente para cada campo del nuevo nodo. Cabe
resaltar que el ndice que coloque el usuario puede ser
cualquier nmero, el programa sabe que como se trata del
primer nodo se modificar ese campo con el nmero
correcto. En este caso por tratarse del primer nodo ser el

nmero 1.
Paso 3: Enlazar los punteros inicio y mvil con el primer

nodo de la lista creado por el usuario.
Conclusiones
Se puede asegurar que se logr alcanzar el objetivo del proyecto con
gran xito. Esta primera versin del programa FunChemestry
cumple con los siguientes requisitos:
Todas las estructuras creadas por el programador se
encuentran
correctamente
almacenadas,
teniendo
las
siguientes caractersticas en cada estructura (nodo):
Nombre de la estructura.
Cantidad de Carbonos.
Cantidad de Hidrgenos.
Cantidad de Oxgenos.
Nombre Cientfico o Comercial.
Informacin relevante.
En este programa el usuario debe acceder a una cuenta para
poder realizar la insercin de un nuevo nodo, la eliminacin y
modificacin de un nodo cualquiera.
El usuario puede insertar un nuevo nodo en cualquier parte de
la lista de estructuras.
El usuario puede eliminar un nodo cualquiera existente en la
lista.
El usuario puede modificar un nodo existente en la lista.
Todas las estructuras creadas por el programador y creadas por

el usuario pueden ser mostradas en la lista.
Adems esta primera versin cuenta con otras herramientas:

El programa puede mostrar una estructura a la vez. Y posee las
opciones de avanzar al siguiente nodo o retroceder al anterior
nodo de la lista.
El programa cuenta con un mini Quizz para entretenimiento
del usuario que consiste bsicamente en realizar una pregunta
al azar acerca de una estructura qumica y el usuario debe
responderla. Se cuenta la cantidad de aciertos que tiene el
usuario.
Dificultades
Las dificultades que se presentaron en el programa son las
siguientes:
Atrapar los posibles errores cometidos por el usuario que se
lleguen a presentar durante la ejecucin del programa.
En el mtodo insertar se presentaron algunas dificultades
como ser: la verificacin del ndice que ingrese el usuario
debe ser vlido para el programa.
En el caso que no exista una lista precargada por el
programador, el primer nodo que cree el usuario ser el primer
nodo de la lista. Si el usuario desea posicionar un nodo antes
del primer nodo se debe validar con el ndice = 1 para que el
programa logre incorporar el nuevo nodo antes del primero de
la lista. Para insertar un nodo que exceda la cantidad de
estructuras creadas previamente fue necesario condicionar el
mtodo para lograrlo.
En los mtodos eliminar y modificar fue necesario contar la
cantidad de estructuras creadas, porque si se obtena el valor
de
0 estructuras creadas ambos mtodos no lograran
ejecutarse y el programa entrara en un error.
Es importante resaltar que en los mtodos eliminar y modificar
el ndice que introduce el usuario debe pertenecer a un nodo ya
existente, caso contrario se generara un error.
Realizar el juego tambin presento sus desafos, como hacer la
coincidencia del nodo del campo con la respuesta introducida
por el usuario o generar un nodo al azar y asegurarse que no

vuelva a repetirse en la misma partida.
Usar de forma adecuada la Clase Scanner.
Recomendaciones y sugerencias
Para mejorar y optimizar el programa en sus siguientes versiones se
tiene las siguientes recomendaciones:
Brindarle al nodo un campo donde el usuario logre introducir la
cadena de la estructura qumica que desea.
Que el programa cuente de forma automtica la cantidad de
carbonos, oxgenos e hidrgenos. Incluso que almacene otros
elementos qumicos de la cadena y los contabilice.
Mostrar la cadena de la estructura en una imagen.
Minimizar la cantidad de lneas de cdigo.
Proporcionar una interfaz grfica para el programa.
Atrapar errores generados por el usuario en cadenas de texto.
Cdigo fuente
Cdigo fuente de la Clase: ListaQuimica
import java.util.Scanner;
public class ListaQuimica {
//Para comenzar debemos crear dos atributos para los Nodos de la Lista.
//Estos nodos los usaremos como punteros para que puedan desplazarse
//por la lista y asi poder realizar distintas operaciones.
//El atributo (puntero) inicio se mantendra siempre en el primer nodo de la lista.
//es decir sera la cabeza de la lista.
//El atributo (puntero) movil se desplazara a lo largo de la lista.
private NodoQuimica inicio;
private NodoQuimica movil;
//En el constructor inicializamos los punteros en NULL.
ListaQuimica() {
inicio = null;
movil = null;
}
//Este metodo permite crear una lista con datos precargados (que se encuentran
en el MAIN)
//en seis diferentes campos de cada Nodo.
//Los respectivos campos son: nombre de la estructura quimica, numero de
carbonos,
3
//numero de hidrogenos, numero de oxigenos, nombre cientifico de la estructura
(si es que la tiene)
//e informacion relevante.
public void anadir(String nombre, int numCarbonos, int numHidrogenos, int
numOxigenos, String nombreCientifico,
String informacion) {
NodoQuimica nuevo = new NodoQuimica();
// Cargar con datos el nuevo nodo.
nuevo.nombre = nombre;
nuevo.numCarbonos = numCarbonos;
nuevo.numHidrogenos = numHidrogenos;
nuevo.numOxigenos = numOxigenos;
nuevo.nombreCientifico = nombreCientifico;
nuevo.informacion = informacion;
nuevo.preguntado = false;
nuevo.ant = null;
nuevo.sig = null;
nuevo.numero = 1;
de la lista.
// Este anadir funciona como una cola.

// Dentro del if se encuentran las instrucciones para crear el PRIMER nodo
if (inicio == null) {
inicio = nuevo;
movil = nuevo;
// El else nos sirve para crear mas nodos despues del primero.
} else {
NodoQuimica ultimo = inicio;
// Ultimo es un puntero auxiliar que parte del inicio y llega hasta el
ultimo nodo.
while (ultimo.sig != null) {

ultimo = ultimo.sig;
}
// Enlazar el nuevo nodo con el ultimo nodo de la lista.
nuevo.ant = ultimo;
ultimo.sig = nuevo;
//Se crea un indice para ennumerar todos los nodos.

int i = 0;
NodoQuimica aux = inicio;
while(aux != null){
i++;
aux.numero = i;
aux = aux.sig;
}
}
3
// El metodo mostrar sirve para mostrar en la consola todos los nodos
precargados ya creados.
public void mostrar() {
if (inicio == null)
System.out.println("\nLa lista esta vacia.\n");
else {
//Creamos un puntero auxiliar que recorra todos los nodos de
lista para mostrarlos.
while (aux != null) {
System.out.println(aux.numero + ")");
System.out.println("El nombre de la estructura es: "
aux.nombre);
System.out.println("Numero
de
carbonos:
"
aux.numCarbonos);
de
hidrogenos:
"
aux.numHidrogenos + " ");
de
oxigenos:
"
aux.numOxigenos + " ");
System.out.println("Nombre
Cientifico:
"
aux.nombreCientifico + " ");
System.out.println("Informacion
relevante:
"
aux.informacion + " ");
System.out.println("-----------------------");
la
+
+
+
+
+
+
aux = aux.sig;
System.out.println();
}
}
vez.
//MostrarUno es un metodo que permite mostrar en la consola un solo nodo a la
public void mostrarUno() {

if(inicio == null){
System.out.println("\nLa lista esta vacia.\n");
}
else {
if (movil != null) {
System.out.println(movil.numero + ")");
System.out.println("El nombre de la estructura es: " +
movil.nombre);
de
carbonos:
"
+
movil.numCarbonos);
de
hidrogenos:
"
+
movil.numHidrogenos + " ");
de
oxigenos:
"
+
movil.numOxigenos + " ");
System.out.println("Nombre
Cientifico:
"
+
movil.nombreCientifico + " ");
System.out.println("Informacion
relevante:
"
+
movil.informacion + " ");
}
}
3
}
public void mostrarPrimero() {
movil = inicio;
mostrarUno();
}
public void siguiente() {
if (movil.sig != null) {
movil = movil.sig;
mostrarUno();
} else {
System.out.println("No existe un siguiente.");
}
}
public void anterior() {
if (movil.ant != null) {
movil = movil.ant;
mostrarUno();
} else {
System.out.println("No existe un anterior.");
}
}
//Metodo destinado para el usuario
public void insertar(String nombre, int numCarbonos, int numHidrogenos, int
numOxigenos, String nombreCientifico,
String informacion, double indice) {
//Verificar que el indice es un numero mayor a cero
if (indice <= 0 ) {
System.out.println("Advertencia: Indice invalido");
System.out.println("
Verificar
que
el
indice
agregado es mayor a cero y no excede la cantidad predeterminada de estructuras.");
} else {
NodoQuimica nuevo = new NodoQuimica();
// Cargar con datos el nuevo nodo
nuevo.nombre = nombre;
nuevo.numCarbonos = numCarbonos;
nuevo.numHidrogenos = numHidrogenos;
nuevo.numOxigenos = numOxigenos;
nuevo.nombreCientifico = nombreCientifico;
nuevo.informacion = informacion;
nuevo.preguntado = false;
nuevo.ant = null;
nuevo.sig = null;
nuevo.numero = 1;
if (inicio == null) {
3
inicio = nuevo;
movil = nuevo;
} else if(indice == 1) {
inicio.ant = nuevo;
nuevo.sig = inicio;
inicio = nuevo;
movil = nuevo;
}
else if (indice > 1 && indice < cantidadNodos()) {
NodoQuimica ultimo = inicio;
NodoQuimica anterior = inicio;
while(ultimo.numero != indice){
anterior = ultimo;
ultimo = ultimo.sig;
}
ultimo.ant = nuevo;
nuevo.sig = ultimo;
nuevo.ant = anterior;
anterior.sig = nuevo;
}
else if(indice > cantidadNodos()){
NodoQuimica buscarultimo = inicio;
while(buscarultimo.sig != null){
buscarultimo = buscarultimo.sig;
}
nuevo.ant = buscarultimo;
buscarultimo.sig = nuevo;
}
int i = 0;
while(aux != null){
i++;
aux.numero = i;
aux = aux.sig;
}
}
public int cantidadNodos (){

int contador = 0;
if(inicio != null){
while(aux != null){
contador ++;
aux = aux.sig;
}
return contador;
3
}
else{
}
return contador;
public void eliminar(int indice) {

if (indice <= 0 || indice > cantidadNodos()) {
System.out.println("\n Verificar que el indice agregado es mayor a
cero y no excede la cantidad predeterminada de estructuras.\n");
} else {
NodoQuimica siguiente = inicio;
NodoQuimica anterior = inicio;
if(indice == 1){
inicio = inicio.sig;
inicio.ant = null;
}
else if (indice > 1 && indice < cantidadNodos()){
while(movil.numero != indice){
movil = movil.sig;
}
anterior = movil.ant;
siguiente = movil.sig;
anterior.sig = siguiente;
siguiente.ant = anterior;
}
else if(indice == cantidadNodos()){
anterior = inicio;
while(movil.numero != indice){
anterior = movil;
movil = movil.sig;
}
}
anterior.sig = null;
}
int i = 0;
while(aux != null){
i++;
aux.numero = i;
aux = aux.sig;
}
}
public void modificarNombre(int indice, String newnombre){

} else {
while (aux.numero != indice){
aux = aux.sig;
}
aux.nombre = newnombre;
}
}
public void modificarCarbonos(int indice, int newnumCarbonos){
} else {
aux = aux.sig;
}
aux.numCarbonos = newnumCarbonos;
}
public void modificarnumHidrogenos (int indice, int newnumHidrogenos){

} else {

aux = aux.sig;
}
aux.numHidrogenos = newnumHidrogenos;
}
public void modificarnumOxigenos (int indice, int newnumOxigenos){
3
} else {

aux = aux.sig;
}
aux.numOxigenos = newnumOxigenos;
}
public void modificarNombreCientifico (int indice, String newnombrecientifico)
{
} else {
aux = aux.sig;
}
aux.nombreCientifico = newnombrecientifico;
}
}
public void modificarInformacion (int indice, String newInformacion){
} else {
aux = aux.sig;
}
aux.nombre = newInformacion;
}
public void seleccionarNodoGame(){

int numeroNodos = cantidadNodos();
do{
3
int nodoAzar = (int)(Math.random() * numeroNodos);
movil = inicio;
for(int i = 0; i < nodoAzar; i++){
movil = movil.sig;
}
}while(movil.preguntado == true);
movil.preguntado = true;
}
public int seleccionarPreguntaGame(){

Scanner teclado = new Scanner(System.in);
int respuestaInt;
String respuestaString;
int preguntaAzar = (int)(Math.random() * 5);
if (preguntaAzar==0) {
System.out.println( "Cual es la cantidad de Carbonos de: " +
movil.nombre );
System.out.println(movil.numCarbonos);
respuestaInt = teclado.nextInt();
proxima!");
if ( respuestaInt == movil.numCarbonos ) {
System.out.println("Respuesta correcta! Felicidades!");
return 1;
}
else {
System.out.println("Respuesta incorrecta. Suerte para la
}
return 0;
} else if(preguntaAzar== 1){

System.out.println("Cual es la cantidad de Hidrogenos de: " +
movil.nombre);
System.out.println(movil.numHidrogenos);
proxima!");
if(respuestaInt == movil.numHidrogenos){
return 1;
}
else{
}
return 0;

System.out.println("Cual es la cantidad de Oxigenos de: " +
movil.nombre);
3
System.out.println(movil.numOxigenos);
if(respuestaInt == movil.numOxigenos){
return 1;
}
else{
proxima!");
return 0;

System.out.println("Cual es el nombre cientifico
movil.nombre);
System.out.println(movil.nombreCientifico);
de:
"
respuestaString = teclado.nextLine();
teclado.nextLine();
if(respuestaString.equals( movil.nombreCientifico)){
return 1;
}
else{
proxima!");
return 0;
}
System.out.println("A que familia pertenece esta estructura: " +
movil.nombre);
System.out.println(movil.informacion);
respuestaString = teclado.nextLine();
teclado.nextLine();
if(respuestaString.equals( movil.informacion)){
return 1;
}
else{
proxima!");
return 0;
}
return 0;
}
public void ponerCamposPreguntadosEnFalse( ){
3
while (aux != null){
aux.preguntado = false;
aux = aux.sig;
}
}
public void game() {
int puntaje = 0;
ponerCamposPreguntadosEnFalse( );
for(int i = 0 ; i < 10 ; i++ ) {
seleccionarNodoGame( );
int puntos = seleccionarPreguntaGame( );
puntaje = puntaje + puntos;
}
System.out.println( "Haz conseguido " + puntaje + " puntos de las 10
preguntas" );
ms!");
if(puntaje <= 5){

System.out.println("Por lo visto no te fue bien :( debes estudiar
}
else {
}
System.out.println("Muchas felicidades! Sigue adelante! ");
Cdigo fuente de la Clase: PrincipalQuimica

import java.util.Scanner;
public class PrincipalQuimica {
public static void main(String[] args) {
ListaQuimica estructura = new ListaQuimica();
Scanner teclado = new Scanner(System.in);
char opcion = ' ';
int menuActual = 0;
Cuenta cuenta = new Cuenta();
estructura.anadir("Pentano", 5, 12, 0, "No tiene nombre cientifico",
"Alcano");
"Alcano");
estructura.anadir("2-metilbutano", 5, 12, 0, "No tiene nombre cientifico",
estructura.anadir("2,2 - dimetilpropano", 5, 12, 0, "No tiene nombre

cientifico", "Alcano");
estructura.anadir("4-isopropil-2-metilheptano", 11, 24, 0, "No tiene
nombre cientifico", "Alcano");
3
estructura.anadir("4-etil-6-isopropilnonano", 14, 30, 0, "No tiene nombre
cientifico", "Alcano");
estructura.anadir("3-isopropil-5-metil-2-hexeno", 10, 20, 0, "No tiene
nombre cientifico", "Alqueno");
estructura.anadir("6-bromo-4-sec-butil-1-octeno", 12, 24, 0, "No tiene
estructura.anadir("6-ter-butil-7-cloro-5-propil-e-hepteno", 14, 28, 0, "No
tiene nombre cientifico", "Alqueno");
estructura.anadir("5-etil-3-isobutil-2-octeno", 14, 28, 0, "No tiene nombre
cientifico", "Alqueno");
estructura.anadir("6-bromo-4-sec-butil-1-hexeno", 10, 19, 0, "No tiene
estructura.anadir("3-n-butil-5-cloro-1-heptino", 11, 19, 0, "No tiene
nombre cientifico", "Alquino");
estructura.anadir("etino", 2, 2, 0, "Aceitileno", "Alquino");
estructura.anadir("4-metil-2-hexino", 7, 12, 0, "No tiene nombre
cientifico", "Alquino");
estructura.anadir("4,8-dimetil-5-neopentil-6-vinil-3-nonen-1-dino", 18, 30,
0, "No tiene nombre cientifico",
"Alquino");
estructura.anadir("5-etinil-2,4-dimetil-1,3-octadien-7-ino", 12, 14, 0, "No
tiene nombre cientifico",
"Alquino");
estructura.anadir("4-alil-3,7-dietil-6-vinil-3,6-nonadien-1,8-diino", 18, 22,
0, "No tiene nombre cientifico",
"Alquino");
estructura.anadir("sec-butilciclobutano", 8, 18, 0, " No tiene nombre
cientifico", "Ciclicos Alifaticos");
estructura.anadir("Biciclopentano", 9, 18, 0, "No tiene nombre cientifico",
"Ciclicos Alifaticos");
estructura.anadir("7-ter-butil-1-etil-3-metil-1,5-coclooctadieno", 15, 31, 0,
"No tiene nombre cientifico",
estructura.anadir("1-(3-butenil)-3-metil-1-ciclobuteno", 9, 15, 0, "No tiene
nombre cientifico",
estructura.anadir("4-etinil-7-neopentil-2-vinil-1,3,5-cicloheptatrieno", 16,
26, 0,
"No tiene nombre cientifico", "Ciclicos Alifaticos");
do {
if (menuActual == 0) {
menuPrincipal();
opcion = teclado.next().charAt(0);
switch (opcion) {
case 'm':
estructura.mostrar();
break;
case 'u':
3
estructura.mostrarPrimero();
menuActual = 1;
break;
case 'p':
menuActual = 2;
break;
case 'i':
menuActual = 3;
break;
case 'c':
break;
default:
System.out.println("\nOpcion invalida. Ingresar otra
por favor.");
}
} else if (menuActual == 1) {
if (estructura.cantidadNodos() != 0){
menuMostrarUno();
switch (opcion) {
case 'a':
estructura.anterior();
break;
case 's':
estructura.siguiente();
break;
case 'b':
menuActual = 0;
break;
default:
System.out.println("\nOpcion
Ingresar otra por favor.");

}
invalida.
else{
System.out.println("Antes
operacion debe crear nuevos nodos para llenar la lista.");
menuActual = 0;
}
if(estructura.cantidadNodos()!= 0){
menuMostrarGame();
de
realizar
esta
switch (opcion){
case 'c':
estructura.game();
break;
case 'b':
menuActual = 0;
break;
default:
System.out.println("\nOpcion
Ingresar otra por favor.");

}
else{
crear estructuras quimicas.");
invalida.
}
System.out.println("Antes de iniciar el juego debe
menuActual = 0;
menuCuenta();
String usuario = teclado.next();
String contrasena = teclado.next();
if (cuenta.verificarCuenta(usuario, contrasena) == true) {
menuActual = 4;
}
else{
menuActual = 0;
}
if (estructura.cantidadNodos() != 0){
menuUsuario();
switch (opcion) {
case 'i':
System.out.print("Ingresar el nombre de la
nueva cadena: ");
carbonos: ");
Hidrogenos: ");
Oxigenos: ");
String nombre = teclado.next();

System.out.print("Ingresar el numero
de
int numCarbonos = teclado.nextInt();

de
int numHidrogenos = teclado.nextInt();

de
3
int numOxigenos = teclado.nextInt();
System.out.print("Ingresar
el
nombre
cientifico: ");
String nombreCientifico = teclado.next();

informacion
relevante: ");
teclado.nextLine();
String informacion = teclado.nextLine();
int indice;
do{
para el nuevo nodo:");
System.out.println("Ingresar un indice
try{
indice = teclado.nextInt();
}
catch(Exception errorAtrapado){
System.out.println("Debe
introducir una numero entero :(");
indice= -1;
teclado.nextLine();
}
} while(indice <= 0);
estructura.insertar(nombre,
numHidrogenos, numOxigenos, nombreCientifico, informacion, indice);
break;
numCarbonos,
case 'e':
int indices;
do{
System.out.println("Ingresar el indice
de la estructura que desea eliminar:");
try{
indices = teclado.nextInt();
}
indices= -1;
teclado.nextLine();
}
} while(indices <= 0);
estructura.eliminar(indices);
break;
case 'm':
int indicess;
do{
de la estructura que desea modificar:");
System.out.println("Ingresar el indice
try{
indicess = teclado.nextInt();
}
indicess= -1;
teclado.nextLine();
}
} while(indicess <= 0);
menuModificar();
if(opcion == 'a'){
System.out.print("Ingresar el nuevo
nombre de la cadena: ");

nuevonombre);
String nuevonombre = teclado.next();

estructura.modificarNombre(indicess,
} else if(opcion == 'b'){

System.out.print("Ingresar la nueva
cantidad de carbonos: ");
int
nuevonumCarbonos
teclado.nextInt();
estructura.modificarCarbonos(indicess,nuevonumCarbonos);
} else if (opcion == 'c'){

cantidad de Hidrogenos: ");
int
nuevonumHidrogenos
teclado.nextInt();
estructura.modificarnumHidrogenos(indicess, nuevonumHidrogenos);
} else if(opcion == 'd'){

cantidad de Oxigenos: ");
int
nuevonumOxigenos
teclado.nextInt();
estructura.modificarnumOxigenos(indicess,nuevonumOxigenos);
}else if(opcion == 'e'){

System.out.print("Ingresar el nuevo
nombre cientifico: ");
String
teclado.next();
nuevonombreCientifico
estructura.modificarNombreCientifico(indicess,nuevonombreCientifico);
} else if(opcion == 'f'){

informacion relevante: ");
nueva
teclado.nextLine();
String
nuevaInformacion
teclado.nextLine();
estructura.modificarInformacion(indicess,nuevaInformacion);
} else if(opcion == 'g')

menuActual = 4;
break;
case 'b':
menuActual = 0;
break;
default:
System.out.println("Opcion invalida. Ingresar
otra por favor.");
}
}
else{
menuUsuarioListaVacia();
cadena: ");
switch (opcion) {
case 'i':
System.out.print("Ingresar el nombre de la nueva
String nombre = teclado.next();
System.out.print("Ingresar el numero de carbonos:
");
Hidrogenos: ");
int numCarbonos = teclado.nextInt();

el
numero
de
int numHidrogenos = teclado.nextInt();

System.out.print("Ingresar el numero de Oxigenos:
");
int numOxigenos = teclado.nextInt();

System.out.print("Ingresar el nombre cientifico: ");
String nombreCientifico = teclado.next();
3
System.out.print("Ingresar informacion relevante:
");
teclado.nextLine();
String informacion = teclado.nextLine();
int indice;
do{
el nuevo nodo:");
System.out.println("Ingresar un indice para

try{
indice = teclado.nextInt();
}
una numero entero :(");
introducir
indice= -1;
teclado.nextLine();
}
} while(indice <= 0);
estructura.insertar(nombre,
numHidrogenos, numOxigenos, nombreCientifico, informacion, indice);
break;
}
}
}
System.out.println();
} while (opcion != 'c');
System.out.println("Gracias por usar FunChemestry");
teclado.close();
}
public static void menuPrincipal() {
System.out.println("FunChemestry");
System.out.println("----------");
System.out.println("(m) Mostrar Todas Las Estructuras");
System.out.println("(u) Mostrar una estructura");
System.out.println("(p) Play Game");
System.out.println("(i) Ingresar a la Cuenta");
System.out.println("(c) Cerra app");
System.out.println("Elija una opcion: ");
}
public static void menuMostrarUno() {
System.out.println("(a) Anterior Estructura");
System.out.println("(s) Siguiente Estructura");
System.out.println("(b) Menu principal");
}
public static void menuCuenta() {
numCarbonos,
3
System.out.println("Ingrese
el
nombre
de
usuario
luego
la
contrasea");
}
public static void menuUsuario() {
System.out.println("(i) Insertar un nuevo nodo");
System.out.println("(e) Eliminar un nodo");
System.out.println("(m) Modificar un nodo");
}
public static void menuUsuarioListaVacia (){
System.out.println("Ingrese por teclado la latra i.");
System.out.println("(i) Insertar un nuevo nodo");
}
public static void menuModificar(){
System.out.println("Ingrese la opcion que desea modificar:");
System.out.println("(a) Nombre de la estructura");
System.out.println("(b) Cantidad de Carbonos");
System.out.println("(c) Cantidad Hidrogenos");
System.out.println("(d) Cantidad Oxigenos");
System.out.println("(e) Nombre cientifico");
System.out.println("(f) Informacion Relevante");
System.out.println("(g) Menu anterior");
}
public static void menuMostrarGame(){
System.out.println("MiniQuizz");
System.out.println("En este juego usted debe reponder 10 preguntas
generadas al azar. " +
"Con cada pregunta correcta se incrementa un punto. Se realizaran 10
preguntas. Exito!");
System.out.println("(c) Comenzar el juego");
}
}
Cdigo fuente de la Clase: NodoQuimica

public class NodoQuimica {
String nombre;
int numCarbonos;
int numHidrogenos;
int numOxigenos;
String nombreCientifico;
String informacion;
int numero;
boolean preguntado;
3
NodoQuimica ant;
NodoQuimica sig;
}
Cdigo fuente de la Clase: Cuenta

public class Cuenta {
private String usuario;
private String contrasena;
Cuenta() {
usuario = "Carlita";
contrasena = "carlita";
}
public
boolean
verificarCuenta(String
usuarioIntroducido,
contrasenaIntroducida) {
boolean verificado = false;
if
(usuarioIntroducido.equals(usuario)
contrasenaIntroducida.equals(contrasena)) {
verificado = true;
}
return verificado;
}
}
String
Bibliografa
http://edatosucb.galeon.com/Exposiciones.htm
http://samirspindola.blogspot.com/2011/04/memoria-estatica-ydinamica.html
http://estructura-quique.blogspot.com/2012/10/estructuraestatica-y-estructura.html
Programacin en Java, autor: Luis Joyanes Aguilar.
&&

Informe Del Proyecto Quimica Orgánica Móvil

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

Informe Del Proyecto Quimica Orgánica Móvil

Caricato da

Copyright:

Formati disponibili

A

Aplicacin Qumica Orgnica

Con esta base de datos se pretende que el usuario acceda a la

una de las estructuras precargadas con sus respectivos datos.

Alcance del Proyecto

Descripcin de las estructuras de datos utilizados en el

Caractersticas de una Lista de Doble Enlace

Programacin Esttica VS Programacin Dinmica

Paso a paso del proceso del programa

Para crear un nodo despus del primer nodo de la lista

Paso 2: Crear el nuevo nodo con los respectivos datos de la

Vista de varios nodos enlazados

en cualquier lugar de la lista; es decir puede insertar un nodo

insertar un nodo antes

Paso 2: El usuario debe llenar todos los datos que el programa

Paso 3: Enlazar el nuevo nodo con el primer nodo de la lista.

Paso 4: Despus de hacer el enlace el ndice se actualiza con

Para insertar un nodo en medio de dos nodos

Paso 3: Enlazar el nuevo nodo con ndice 3 (definido por el

Paso 4: Despus de hacer el enlace el ndice se actualiza

Para insertar un nodo al final de la lista

Paso 3: Enlazar el nuevo nodo con el ultimo nodo de la lista.

Paso 4: Posterior al enlace el programa vuelve a enumerar

Para insertar un primer nodo sin tener estructuras

Paso 2: Crear el nuevo nodo y completar la informacin

correcto. En este caso por tratarse del primer nodo ser el

Paso 3: Enlazar los punteros inicio y mvil con el primer

Todas las estructuras creadas por el programador y creadas por

Adems esta primera versin cuenta con otras herramientas:

por el usuario o generar un nodo al azar y asegurarse que no

// Este anadir funciona como una cola.

while (ultimo.sig != null) {

//Se crea un indice para ennumerar todos los nodos.

//MostrarUno es un metodo que permite mostrar en la consola un solo nodo a la

public void mostrarUno() {

public int cantidadNodos (){

public void eliminar(int indice) {

if (indice <= 0 || indice > cantidadNodos()) {

public void modificarnumHidrogenos (int indice, int newnumHidrogenos){

while (aux.numero != indice){

while (aux.numero != indice){

public void seleccionarNodoGame(){

public int seleccionarPreguntaGame(){

} else if(preguntaAzar== 1){

} else if(preguntaAzar== 2){

} else if(preguntaAzar== 3){

if(puntaje <= 5){

System.out.println("Muchas felicidades! Sigue adelante! ");

Cdigo fuente de la Clase: PrincipalQuimica

estructura.anadir("2-metilbutano", 5, 12, 0, "No tiene nombre cientifico",

estructura.anadir("2,2 - dimetilpropano", 5, 12, 0, "No tiene nombre

Ingresar otra por favor.");

Ingresar otra por favor.");

String nombre = teclado.next();

int numCarbonos = teclado.nextInt();

int numHidrogenos = teclado.nextInt();

String nombreCientifico = teclado.next();

para el nuevo nodo:");

introducir una numero entero :(");

de la estructura que desea eliminar:");

introducir una numero entero :(");

introducir una numero entero :(");

nombre de la cadena: ");