MATERIA: ADMINISTRACIÓN GERENCIAL
UNIDAD 4 PLANEACION GERENCIAL
INTEGRANTES DEL EQUIPO:
1. KRAUL FLORES CRISTIAN
2. MORENO VÁSQUEZ MIGUEL ÁNGEL
3. RAMOS GARCÍA ÁLVARO DE JESÚS
4. REYES HERNÁNDEZ VICTOR MIGUEL
5. VILLALOBOS PÉREZ BENITA
REPORTE DE INVESTIGACIÓN DEL
PROCESO DE LA PLANIFICACIÓN
ESTRATÉGICA.
INTEGRANTES DEL EQUIPO:
1. ANAHÍ DE LA CRUZ FLORES
2. JOSÉ MANUEL FLORES RAMOS
3. KEREN MERARI SANTIAGO ZÁRATE
4. MIGUEL ÁNGEL MORENO VÁZQUEZ
5. VÍCTOR MIGUEL REYES HERNÁNDEZ
MATERIA: ESTRUCTURA Y ORGANIZACIÓN DE
DATOS
UNIDAD 4 METODOS DE ORDENAMIENTO Y
BUSQUEDA
PROYECTO FINAL
REGISTRO DE ESTUDIANTES
INSTITUTO TECNOLOGICO DE SALINA CRUZ
NOMBRE DEL ALUMNO:
1. ANAHI DE LA CRUZ FLORES
2. JOSE MANUEL FLORES RAMOS
3. KEREN MERARI SANTIAGO ZARATE
4. MIGUEL ÁNGEL MORENO VÁZQUEZ
5. VÍCTOR MIGUEL REYES HERNÁNDEZ
DOCENTE: M.C. SUSANA MONICA ROMAN NAJERA
MATERIA: ESTRUCTURA Y ORGANIZACIÓN DE DATOS
ACTIVIDAD: REPORTE DEL PROYECTO
ESTRUCTURA DE DATOS IMPLEMENTADA EN LA ESCUELA
PRIMARIA “CESAR LINTON”
CARRERA: INGENIERIA EN TECNOLOGIAS DE LA INFORMACION Y DE
LAS COMUNICACIONES
GRADO: 3 SEMESTRE GRUPO: 3E
SALINA CRUZ, OAXACA DICIEMBRE DEL 2014
INDICE
INTRODUCCION ................................................................................................................ 1
OBJETIVO DEL PROYECTO ........................................................................................... 2
JUSTIFICACION DEL PROYECTO ................................................................................ 3
CAPITULO I: ......................................................................................................................... 4
TIPOS DE ESTRUCTURAS IMPLEMENTADAS EN EL PROYECTO: ...................... 4
CAPITULO II ..................................................................................................................... 16
ESCENARIO IMPLEMENTADO EN EL PROYECTO ................................................ 16
CAPITULO III ................................................................................................................... 18
DISEÑO (DIAGRAMAS UML, DIAGRAMAS DE FLUJO, HERRAMIENTA PARA
DISEÑO) ............................................................................................................................ 18
CAPITULO IV .................................................................................................................... 19
CODIFICACION DEL SISTEMA .................................................................................. 19
CONCLUSIONES ............................................................................................................. 29
REFERENCIAS .................................................................................................................. 31
ANEXOS ............................................................................................................................. 32
1
INTRODUCCION
Como veremos a continuación en lo que respecta a proyectos basados en la vida
real, podemos implementar programas que, para lo cual les seria de cierta utilidad
dependiendo de qué es lo que pida el cliente en su momento.
Como Ingenieros en la carrera de tecnologías de la información y comunicación,
debemos de tener en cuenta que saldremos siendo en teoría programadores y que
además en el ámbito que nosotros trabajemos no todos piden un programa en
específico sino que el programador debe de darse cuenta que es lo que necesita
realmente a fondo el cliente para que su empresa o localidad necesita.
Todo esto lleva a un programa de registro de estudiantes, implementando las
estructuras de datos en java y pasándola a un la realidad descrita por el cliente que
pide que se lleve el registro de estos mismos y que para lo cual se podrá notar la
estructuración que lleva este proyecto.
A ciencia cierta antes necesitamos tener conocimientos previos de lo que se hablara
en este proyecto para así tener la idea de lo que se verá más adelante y que además
podamos identificar toda la utilería usada en el mismo.
2
OBJETIVO DEL PROYECTO
Este proyecto tiene como objetivo la creación del registro de estudiantes en una
escuela y que a su vez tiene otro objetivo más que es para la parte estudiantil que
fomenta la práctica de programas en este caso utilizando como ejemplo las
estructuras de datos.
El alumno o la persona que esté interesada en este proyecto, vera una serie de
sucesiones que indican que es lo que se está viendo en cada sección de cada
capítulo que se documentó de forma concisa en este trabajo.
Tiene como factor clave hacer el uso de la programación orientada a objetos en un
lenguaje de programación como java y que a su vez trata de hacer un resumen de
todo lo aprendido en clase hasta el día de hoy y poder tener así una idea más
precisa de lo que se estructura en el proyecto.
No obstante hay que recalcar que el objetivo es inducir al programador a realizar
proyectos reales y que él vaya familiarizando con lo que se podría mas adelante en
un trabajo que haga el uso de sus conocimientos y lo aplique en su determinada
área.
3
JUSTIFICACION DEL PROYECTO
La justificación de este proyecto o más bien el programa fue realizado en la escuela
primaria “Cesar Linton” con clave: 20DPR1702P ubicada la colonia deportiva norte
al lado del kínder preescolar Bertha Domínguez Martínez en Salina Cruz Oaxaca
México.
Como una de las peculiaridades que se tuvo en este proyecto fue buscar la causa
y acción que la escuela buscaba tener a la mano y que como equipo se preguntó al
actual director de la escuela, el cual solicitaba un programa que facilitara el registro
de estudiantes de nuevo ingreso.
Dicha escuela tenía un aproximado de 256 alumnos hasta el dia de hoy y que en el
próximo año buscaba un programa facilitador de registro de nuevos estudiantes.
La escuela nos dio información básica sobre lo que ellos venían trabajando año tras
año y que su problema era el papeleo cada año con cada nuevo estudiante que
entraba y que deseaba una forma más sencilla y explicita de agregar a nuevos
estudiantes a su escuela.
Esto significo para nosotros un reto, de hacer de forma que se entienda el entorno
grafico del programa para que el personal que lo utilice, no tenga confusión a la hora
de los registros.
4
CAPITULO I:
TIPOS DE ESTRUCTURAS IMPLEMENTADAS EN EL
PROYECTO:
Lista Doble
Arreglos
STRING
Métodos
INT
¿QUÉ SON LAS ESTRUCTURAS DE DATOS?
Son una colección de datos que se caracteriza por su organización y las
operaciones que se definen en ellos. Por tanto una estructura de datos vendrá
caracterizada tanto por unas ciertas relaciones entre los datos que la constituyen,
como las operaciones posibles en ella.
Una estructura de datos define la organización e interrelación de estos y un conjunto
de operaciones que se pueden realizar sobre ellos.
Las operaciones básicas son:
5
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
¿Qué ventajas tenemos al emplear las estructuras de datos?
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.
CODIGO-DOBLE CADENA.
Package javaapplication9;
Import javax.swing.JOptionPane;
Import javax.swing.table.DefaultTableModel;
Import java.text.DecimalFormat;
Public class ListaDoble extends javax.swing.JInternalFrame {
Public class Nodo {
String codigo;
String nombre;
String apellido1;
6
String apellido2;
Int DNI;
Int casa;
int celular;
Nodo sig;
Nodo ant;
public Nodo(String cod,String nom,String ape1,String ape2,int dni,int ca,int cel){
codigo=cod;
nombre=nom;
apellido1=ape1;
apellido2=ape2;
DNI=dni;
casa=ca;
celular=cel;
sig=ant=null;
}
}
DefaultTableModel Modelo;
String [] cabecera={"N°","Codigo","Nombres","Ape. Paterno","Ape.
Materno","DNI","Telef.casa","Celular"};
String [][] data={};
public Nodo ini,fin;
public Nodo pFound;
int num=0;
7
public ListaDoble() {
initComponents();
ini=fin=pFound=null;
Modelo=new DefaultTableModel(data,cabecera);
tblRegistro.setModel(Modelo);
}
BOTON HABILITAR
Void habilitar (){
btneliminar.setEnabled(true);
btnactualizar.setEnabled(true);
btnguardar.setEnabled(false);
}
BOTON DESHABILITAR
void deshabilitar(){
btneliminar.setEnabled(false);
btnactualizar.setEnabled(false);
btnguardar.setEnabled(true);
}
BOTON LIMPIAR
8
void limpiar_entradas(){
txtcodigo.setText("");
txtnombre.setText("");
txtapellido1.setText("");
txtapellido2.setText("");
txtdni.setText("");
txtcasa.setText("");
txtcelular.setText("");
txtcodigo.requestFocus();
}
BOTON VACIAR
void vaciar_tabla(){
int filas=tblRegistro.getRowCount();
for(int i=0;i<filas;i++)
Modelo.removeRow(0);
}
void ver_datos(int ind){
String cod,nom,ape1,ape2;
int dni,ca,cel;
METODO
switch(ind){
case 1:{
vaciar_tabla();
9
Nodo aux=ini;
num=0;
while(aux!=null){
cod=aux.codigo;
nom=aux.nombre;
ape1=aux.apellido1;
ape2=aux.apellido2;
dni=aux.DNI;
ca=aux.casa;
cel=aux.celular;
num++;
Object[] fila={num,cod,nom,ape1,ape2,dni,ca,cel};
Modelo.addRow(fila);
aux=aux.sig;
}
}break;
case 2:{
vaciar_tabla();
Nodo aux=fin;
num=0;
while(aux!=null){
cod=aux.codigo;
nom=aux.nombre;
10
ape1=aux.apellido1;
ape2=aux.apellido2;
dni=aux.DNI;
ca=aux.casa;
cel=aux.celular;
num++;
Object[] fila={num,cod,nom,ape1,ape2,dni,ca,cel};
Modelo.addRow(fila);
aux=aux.ant;
}
}break;
}
}
Nodo buscar(Nodo inicio,String cod){
Nodo pos=inicio;
while(pos!=null && !cod.equalsIgnoreCase(pos.codigo))
pos=pos.sig;
return pos;
}
Nodo inserta_final(Nodo inicio,String cod,String nom,String ape1,String ape2,int
dni,int ca,int cel){
Nodo nuevo=new Nodo(cod,nom,ape1,ape2,dni,ca,cel);
11
nuevo.sig=inicio;
if(inicio==null){
fin=nuevo;
fin.sig=null;
}
if(inicio!=null)
inicio.ant=nuevo;
inicio=nuevo;
return inicio;
}
void eliminar(){
Nodo actual;
boolean encontrado = false;
actual=ini;
while((actual!=null)&&(!encontrado)){
encontrado=actual.codigo.equalsIgnoreCase(txtcodigo.getText().trim());
if(!encontrado)
actual=actual.sig;
}
if(actual!=null){
if(actual== ini){
ini=actual.sig;
if(actual.sig!=null)
actual.sig.ant=null;
12
}else if(actual.sig!=null){
actual.ant.sig=actual.sig;
actual.sig.ant=actual.ant;
}else {
actual.ant.sig=null;
fin=actual.ant;
}actual=null;
}
}
BOTON GUARDAR
String cod=txtcodigo.getText();
String nom=txtnombre.getText().toUpperCase();
String ape1=txtapellido1.getText().toUpperCase();
String ape2=txtapellido2.getText().toUpperCase();
int dni=Integer.parseInt(txtdni.getText());
int ca=Integer.parseInt(txtcasa.getText());
int cel=Integer.parseInt(txtcelular.getText());
ini=inserta_final(ini,cod,nom,ape1,ape2,dni,ca,cel);
limpiar_entradas();
ver_datos(1);
}
13
private void btneliminarActionPerformed(java.awt.event.ActionEvent evt) {
eliminar();
limpiar_entradas();
ver_datos(1);
if(ini==null)
JOptionPane.showMessageDialog(this, "La lista esta vacia");
deshabilitar();
}
BOTON CONSULTAR
Private void btnconsultarActionPerformed(java.awt.event.ActionEvent evt) {
String cod=txtcodigo.getText();
if(cod.equalsIgnoreCase("")){
JOptionPane.showMessageDialog(this,"Ingrese en codigo por favor");
}else {
pFound=buscar(ini,cod);
if(pFound!=null){
txtnombre.setText(pFound.nombre);
txtapellido1.setText(pFound.apellido1);
txtapellido2.setText(pFound.apellido2);
txtdni.setText(String.valueOf(pFound.DNI));
txtcasa.setText(String.valueOf(pFound.casa));
txtcelular.setText (String.valueOf (pFound.celular));
habilitar ();
} else {
14
JOptionPane.showMessageDialog (this,” El código: "+cod+" , no está en la
lista...”);
}
}
}
BOTON SALIR
Private void btnsalirActionPerformed (java.awt.event.ActionEvent evt) {
This. Dispose ();
}
BOTON ACTUALIZAR
Private void btnactualizarActionPerformed (java.awt.event.ActionEvent evt) {
pFound.codigo=txtcodigo.getText ();
pFound.nombre=txtnombre.getText ();
pFound.apellido1=txtapellido1.getText ().to Uppercase ();
pFound.apellido2=txtapellido2.getText ().to Uppercase ();
pFound.DNI=Integer.parseInt (txtdni.getText ());
pFound.casa=Integer.parseInt (txtcasa.getText ());
pFound.celular=Integer.parseInt (txtcelular.getText ());
Limpiar entradas ();
Deshabilitar ();
ver_datos (1);
}
BOTON RESTAURAR
Private void btnreestaurarActionPerformed(java.awt.event.ActionEvent evt) {
16
CAPITULO II
ESCENARIO IMPLEMENTADO EN EL PROYECTO
La escuela primaria cesar Linton situada en la colonia deportiva norte de salina cruz,
necesitaba un apoyo con su sistematización de registro de estudiantes de nuevo
ingreso, dado el caso pudimos quedar de acuerdo con elaborar un programa que
no solo sea de fácil manejo para el personal educativo, sino también para la escuela.
Al darnos la tarea de la elaboración del programa nos topamos con muchos errores,
dado que la lógica no estaba bien expresada, lo elaboramos varias veces hasta que
ha quedado de esta manera:
Dado que algunos datos de los estudiantes que se registraran son confidenciales a
nosotros, la escuela decidió manejarla de forma manual y no implementada en el
programa.
17
Una vez finalizado el registro de todos los estudiantes, los docentes de cada grupo
pueden agregar estos registrados en la lista en sus listas de grupo individual. Ese
es el propósito del programa, que cada docente pueda visualizar, eliminar y
restaurar los datos de la lista que aparecerán en la parte inferior.
El motivo por el cual se implementó listas como estructuras de datos fue por eso,
porque en el registro deben presentarse en forma de lista y porque las operaciones
que se pueden hacer con ellas con apropiadas para el concepto.
19
CAPITULO IV
CODIFICACION DEL SISTEMA
La clase que primero se va a construir es la clase main.
- La clase main llama a nuestra clase principal.
- En nuestra clase principal tenemos la entrada a nuestro programa ya que
en la parte usuarios podemos entrar para empezar a insertar los datos de nuestros
estudiantes y aquí creamos nuestra interfaz gráfica y hacemos un llamado a la parte
más importante de nuestro proyecto.
21
- Ahora que ya está creada nuestra clase principal nos vamos con la parte más
importante de nuestro proyecto. A esta clase la llamamos ListaDoble ya que en esta
parte final usamos la implementación de listas dobles para la creación de nuestra
base de datos.
- En esta parte nombramos los nodos de nuestra lista y creamos la parte de la
cabecera que nos pedirá los datos de nuestros alumnos curp, nombres apellido
paterno y materno, teléfono de casa y móvil.
22
- Aquí realizamos lo que es lo importante en una lista doble, su implementación en
la que sus métodos llaman a cada botón de nuestro programa realizando las
acciones que son lo principal en las listas dobles habilitar, deshabilitar, limpiar
entradas, vaciar tabla, ver datos, buscar e insertar final.
25
- Ya por ultimo hacemos la creación de las acciones que realizaran nuestros botones
guardar, eliminan, restaura, actualizar, consultar y salir.
27
-
Pulsar <Crtl+S> para salvar el trabajo realizado hasta ahora
-Una vez salvado nuestro Código lo corremos:
29
CONCLUSIONES
Anahí de la Cruz Flores.
Es esencial para un buen uso de la nueva tecnología informática la organización de
los datos así como su estructura. En este proyecto aplicamos los conocimientos que
adquirimos en el transcurso de este semestre.
Este proyecto lo realizamos para la institución Cesar Linton, con el objetivo de que
dicha institución pueda llevar un control de alumnos, con la finalidad de tener una
base de datos con los siguientes datos de los alumnos: Curp, el nombre, apellido
paterno, apellido materno, teléfono y celular.
El programa utiliza la estructura de datos de lista simple, lista doble, lista circular,
lista circular doble.
Los métodos que utilizamos en el programa fueron los siguientes guardar,
restaurar, actualizar, consultar eliminar y salir.
José Manuel Flores Ramos.
Con esta práctica cumplimos con el objetivo de desarrollar los conocimientos
adquiridos durante el curso. Con nuestra aplicación implementamos las estructuras
de datos lineales ya que nuestra aplicación funciona en base a las técnicas para
recuperación de información en dispositivos de almacenamiento primario y
secundario.
En donde gestionamos los datos de forma óptima usando como implementación
especial las listas dobles y circulares, ya que esto facilita el procesamiento en un
trabajo que podemos aplicar en la vida real.
30
Keren Merari Santiago Zarate.
Como vimos en el transcurso del semestre las estructuras de datos se conocen
como la organización e interrelación y conjunto de operaciones posibles en ella y se
caracterizan tanto por unas ciertas relaciones entre los datos que la constituyen,
como las operaciones.
En este proyecto aplicamos estructuras de datos como son lista doble, arreglos
unidimensional y bidimensional, tipo String , tipo entero, y algunos otros métodos.
El proyecto está basado en el registro de alumnos de una escuela.
El director de la escuela cesar Linton necesitaba un programa que le facilitara la
captura de registro de alumnos. Es por ello la realización de este programa que
representa un caso real.
Miguel Ángel Moreno Vásquez
Con la elaboración de este proyecto pudimos comprender y analizar mucho mejor
lo que son las estructuras de datos que utilizamos en JAVA, en este caso utilizamos
las listas como concepto. Nos enfocamos en el diseño ágil y dinámico para las
personas que lo utilizaran como también en el fácil manejo del código, las funciones
también son fáciles de entender, en si manejamos muchos de los recursos utilizados
durante el curso, dando conocer que hemos cumplido con el objetivo de la materia.
Víctor Miguel Reyes Hernández
Para mí en la realización de este proyecto de trabajo en equipo me hizo observar
aspectos básicos de la programación en la práctica real y que a su vez me hizo
involucrarme aún más con mis compañeros de equipo y asi buscar la forma de
realizar este proyecto más rápidamente sin olvidar claro de lo que estamos viendo.
También fue una conclusión haber llegado a un final en el que el cliente estuviera
satisfecho con los resultados obtenidos y de haber por supuesto tener una
remuneración por el tiempo en el que se trabajó el programa.
31
REFERENCIAS
Anonimo. (Enero de 2010). El rincon del Vago. Recuperado el 6 de Diciembre de
2014, de Algoritmos de busqueda: http://html.rincondelvago.com/algoritmos-de-
busqueda.html
Coronado, S. P. (15 de Septiembre de 2001). C++ con Clase. Recuperado el 8 de
Diciembre de 2014, de Estructuras de Datos: c.conclase.net/edd/?cap=005
Daniel Lopez, Abraham Garcia Soto, Martin Gomez Antonio Jose. (2007 de Enero
de 13). Listas doblemente enlazadas. (J. F. Valdivia, Productor) Recuperado el 8 de
Diciembre de 2014, de Tutor de Estructuras de Datos Interactivo: decsai.ugr.es
lami20j. (23 de Octubre de 2007). Kioskea.net. Recuperado el 8 de Diciembre de
2014, de Listas Doblemente enlazadas: es.kioskea.net/faq/2872-listas-doblemente-
enlzadas
Luis Joyanes Aguilar, Ignacio Zahonero Martinez. (2008). Estructuras de datos en
Java (primera ed.). (J. L. Garcia, Ed.) Aravaca, Madrid, España: Mc Graw Hill.
Recuperado el 13 de Noviembre de 2014
Martinez, J. (15 de Julio de 2006). Metodos de ordenamiento y bisqueda.
Recuperado el 8 de Diciembre de 2014, de Mailxmail:
http://www.mailxmail.com/curso-aprende-programar/metodos-ordenamiento-
busqueda
Perez, S. C. (2004). Introduccion a las estructuras de datos y archivos.
Top Related