Upload
eliu-osseas-puc-puc
View
57
Download
4
Embed Size (px)
Citation preview
INSTITUTO TECNOLOGICO SUPERIOR DE FELIPE CARRILLO PUERTO
INGENIERIA EN SISTEMAS COMPUTACIONALES
ESTRUCTURA DE DATOS
INFORME TECNICO
UNIDAD 1-INTRODUCCION A LAS ESTRUCTURAS DE DATOS
DOCENTE : NIELS HENRIK ARANA CUEVAS
ALUMO: ELIU OSSEAS PUC PUC
TERCER SEMESTRE GRUPO B
AULA J-4
ContenidoIntroducción programa 1: imprime línea, la diagonal y la diagonal invertida................................3
Conclusión:.....................................................................................................................................5
ARREGLOS BIDIMENSIONALES.......................................................................................................5
PROGRAMA 1:................................................................................................................................5
CONCLUSION:...............................................................................................................................10
DATOS ABSTRACTOS....................................................................................................................11
LEE DOS NOMBRES Y DOS EDADES Y SUMA LAS EDADES.............................................................11
INTRODUCCION:...............................................................................................................................11
PROGRAMA 2: MUESTRA 3 NOMBRES, LA EDAD DE LOS 3, MAYOR Y MENOR EDAD DE LOS 3 Y EL PROMEDIO DE LOS 3................................................................................................................13
INTRODUCCION:...............................................................................................................................13
CONCLUSION:...............................................................................................................................16
FUNCIONES..................................................................................................................................16
PROGRAMA 1: PIDE DOS NUMEROS Y REALIZA LA SUMA............................................................16
CONCLUSION:...............................................................................................................................18
PROGRAMA 2: IMPRIME DOS NÚMEROS, LA SUMA, LA RESTA, LA DIVISIÓN Y LA RESTA DE AMBOS.........................................................................................................................................18
CONCLUSION:...............................................................................................................................21
CONCLUSION GENERAL................................................................................................................22
Introducción programa 1: imprime línea, la diagonal y la diagonal invertida
En este primer programa nos va a permitir imprimir valores que están en una matriz, en la cual primeramente se imprimirán los valores que están en su fila principal seguidamente de su diagonal principal y por ultimo su diagonal invertida.
Primeramente el programa dice que va a ser una matriz de tres por tres y que va a contener valores de tipo entero contenidos en u arreglo como se muestra en el programa. Seguidamente tenemos un ciclo for en la cual le damos una condición en donde le va a dar valores a i que se estarán igualando a cero que seguidamente se imprimirán al final. Seguidamente con la condición cumplida el programa imprimirá los valores que están en la condición mencionada. De igual manera mas adelante tenemos lo que es imprimir la diagonal invertida el cual de declaran las variables y con el for le damos la condición y al final y le asignamos las variables que utilizaremos y seguidamente se imprime los valores de la diagonal invertida.
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char** argv) {
int a[3][3],dip,dinv,liu;
for(int i=0;i<=2;i++){
for(int j=0;j<=2;j++){
cout<<"ingrese elementos: ";
cin>>a[i][j];
}
}cout<<"La Matriz es:\n";
// Imprimiendo el arreglo en formato matricial
for(int i=0;i<3;i++){
for(int j=0; j<=2;j++){
cout<<a[i][j];
}
}
cout<<"\n";
cout<<"La diagonal principal es: \n ";
for(int i=0;i<=2;i++){
for(int j=0;j<=2;j++){
if(i==j){
dip=a[i][j];
cout<<dip;
}
}
}
cout<<"\n";
cout<<"La diagonal invertida es: \n ";
for(int i=0;i<=2;i++){
for(int j=0;j<=2;j++){
if((i+j)==2){
dinv=a[i][j];
cout<<dinv;
}
}
}
cout<<"\n";
cout<<"La linea 1 es: \n ";
for(int i=0;i<=2;i++){
liu=a[1][i];
cout<<liu;
}
return 0;
Conclusión:En este primer programa aprendimos el uso de los arreglos en el cual sabemos que un arreglo es un conjunto de valores en el cual podemos expresar de diferentes formas una de ellas es en una matriz. En este programa que analizamos vimos el uso de los arreglos ya que le decíamos al programa que estaremos trabajando con una matriz de 3 x 3 declaramos las variables a utilizar le poníamos la condición, ya sea que queramos imprimir una fila, una columna, la diagonal principal, o la diagonal invertida. En este caso el programa visto imprime la diagonal principal, y la diagonal invertida en donde en este caso cando le asignamos las variables i y j que representan las filas y las columnas, el programa imprimirá los valores de la matriz cuando i y j sean iguales o en donde se intersecten esos valores será lo que el programa imprimirá.
Introducción:
ARREGLOS BIDIMENSIONALESPROGRAMA 1:
Primero se inicializan las variables que se deban utilizar pero más importante el
arreglo, que debe tener la sintaxis tipo nombre [ ] [ ]; luego se pide al
usuario que ingrese los valores del mismo arreglo se promedian las calificaciones
del alumno así como de las unidades y se guardan en arreglo unidimensionales.
Se realiza las comparaciones entre el arreglo unidimensional de unidades para
determinar cuál es el mayor y se imprime en pantalla, posterior a ello se hace las
comparaciones en el vector de alumnos para determinar al alumno de mejor
calificación y al peor. Por último se vuelve a imprimir los datos correspondientes.
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own
getch, system("pause") or input loop */
int main(int argc, char** argv) {
float ca[2][5];
int f, c, SU=0, SA=0, MU=0, MA=0, MeA=0;
float PAL[2];
float PRU[5];
//Leer calificaciones
for(f=0;f<2;f++){
for(c=0;c<5;c++){
cout<<"Ingrese la calificacion del alumno
["<<f<<"] en la unidad ["<<c<<"]: \t";
cin>> ca[f][c];
}
}
cout<<"\n";
//Promedio de alumno
for(f=0;f<2;f++){
for(c=0;c<5;c++){
SA=SA + ca[f][c];
}
PAL[f]=SA/5;
SA=0;
}
//Promedio de unidades
for (c=0; c<5; c++){
for (f=0; f<2; f++){
SU = SU + ca[f][c];
}
PRU[c] = SU/2;
SU = 0;
}
//Unidad mayor
for (f=0; f<5; f++){
if(PRU[MU] < PRU[f]){
MU = f;
}
}
cout << "La unidad mayor es: " << MU << "\n"<< endl;
//mayor promedio alumno
for (f=0; f<2; f++){
if(PAL[MA] < PAL[f]){
MA = f;
}
}
//imprimir calificaciones del alumno mayor
cout << "Calificaciones del mejor alumno son: \n";
for (f=0; f < 5; f++){
cout<<ca[MA][f]<<"\t"<<"\n";
}
cout<<"\n";
//menor promedio alumno
for (f=0; f<2; f++){
if(PAL[MeA] > PAL[f]){
MeA = f;
}
}
//imprimir calificaciones del alumno con menor promedio
cout << "Calificaciones del peor alumno es: \n";
for (f=0; f < 5; f++){
cout<< ca[MeA][f] <<"\t" << "\n";
}
return 0;
}
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main() {
float alu[5][3], cal, prom[5], pu[3], su;
int i, j;
int mayu=0;
int maypro = 0;
int menpro = 0;
for (i=0; i<5; i++){
for (j=0; j<3; j++){
cout << "Introduce la calificacion del alumno"<<endl;
cin >> alu[i][j];
}
}
for (i=0; i<5; i++){
for (j=0; j<3; j++){
su = su + alu[i][j];
}
prom[i] = su/3;
su = 0;
}
for (j=0; j<3; j++){
for (i=0; i<5; i++){
su = su + alu[i][j];
}
pu[j] = su/5;
su = 0;
}
for (i=0; i<3; i++){
if(pu[mayu] < pu[i]){
mayu = i;
}
}
cout << "El mejor aprovechamiento es en la unidad: " << mayu << endl;
for (i=0; i<5; i++){
if(prom[maypro] < prom[i]){
maypro = i;
}
}
for (i=0; i < 3; i++)
{cout << "Calificaciones del mejor alumno son: " << alu[maypro][i] << endl;
}
for (i=0; i<5; i++){
if(prom[menpro] > prom[i]){
menpro = i;
}
}
for (i=0; i < 3; i++){
cout << "Calificaciones del peor alumno es: " << alu[menpro][i] << endl;
}
return 0;
}
CONCLUSION:En este programa se requiere un análisis un tanto más profundo del tema
requiere un mayor entendimiento de su realización para que nuestro programa
funcione y no nos genere problemas y se ejecute correctamente ya que si no se
sabe cómo realizar las iteraciones entre los arreglos bidimensionales y
unidimensionales se nos va a ser más complicado su entendimiento. Uno de los
puntos que en que me ha resultado un tanto mas inospito es del porque se inicia
la cuenta con el 0 y no con el uno para un mayor entendimiento, . Y bueno como
en un principio se nos había pedido un valor o un arreglo de una gran escala o un
gran número de datos pues solamente hay que verificar si funciona con un arreglo
no tan grande.
DATOS ABSTRACTOSLEE DOS NOMBRES Y DOS EDADES Y SUMA LAS EDADES
INTRODUCCION:El funcionamiento de este programa va de esta manera, primero se declaran un
tipo de dato abstracto con el nombre alumno que sus tipos de datos han de ser de
tipo cadena y el otro de tipo entero. Una vez hecho esto dentro de la función main
que es la principal, se declara las variables a utilizar en este caso a1 y a2. Luego
se procede a pedir datos al usuario de tipo cadena para el nombre y de tipo entero
para la edad, después las siguientes líneas de código nos indican que esos tipos
de datos enteros de edades se deben de sumar y se deben de mostrar en pantalla
que es lo que se está logrando al final. Cabe mencionar que para el uso de esos
datos abstractos se pone el nombre de la variable ya creada en el main seguida
de un punto y el tipo de dato abstracto que se encuentre en el struct.
#include <iostream>
using namespace std;
struct alumno {
string nombre;
int edad;
};
int main(int argc, char** argv) {
alumno a1, a2;
//primer alumno
cout<<"Teclea el nombre del primer alumno:";
cin>>a1.nombre;
cout<<"Teclea la edad del primer alumno:";
cin>>a1.edad;
cout<<"\n";
//segundo alumno
cout<<"Teclea el nombre del segundo alumno:";
cin>>a2.nombre;
cout<<"Teclea la edad del segundo alumno:";
cin>>a2.edad;
cout<<"\n";
//suma de las edades
cout<<"L suma de las dos edades es:"<<a1.edad+a2.edad<<endl;
return 0;
}
Se debe utilizar el siguiente formato para la creación de un tipo de dato abstracto:
struct alumno {
string nombre;
int edad;
};
Si observamos al final de la segunda llave se pone un punto y coma cosa que no
es común si se usase un for.
Cuando usemos o convoquemos el dato abstracto lo debemos realizar con el
siguiente formato:
Variable.nombre del dato abstracto creado.
Los datos abstractos son muy útiles cuando se habla de datos en los cuales se
requieran diversos campos, como por ejemplo, el campo nombre, edad, genero,
etc.
PROGRAMA 2: MUESTRA 3 NOMBRES, LA EDAD DE LOS 3, MAYOR Y MENOR EDAD DE LOS 3 Y EL PROMEDIO DE LOS 3
INTRODUCCION:Los datos abstractos de manera práctica o en este código se refiere a un dato hecho por el programador y como su nombre lo indica puede contener varios tipos de datos para ser abstracto. En este programa se muestra en el código: "struct alumno {" la forma en la que esta ha de declararse fuera del método principal main. Ahí mismo dentro del tipo de dato abstracto se colocan los tipos de datos o más bien las variables que hemos de ocupar. En el método principal main se declaran las variables que sean fáciles de identificar al momento de convocar o usar el dato abstracto. En las siguientes líneas de cogido se solicita el nombre y la edad del primer alumno, y como ya hemos definido un dato abstracto con varios datos simplemente colocamos después de la variable en el método main un punto: a1.nombre, con eso hemos de usar la variable abstracta definida en el inicio del programa. Y bueno una vez solicitados todos los datos al usuario se procede a imprimirlos, esto al final de cuentas nos permite una mejor organización d nuestros datos. Una vez solicitados nuestros datos al usuario en este programa se utilizó las condicionales if(){}else{}. Para la comparación del que tiene la mayor edad y del que tiene la menor edad y una suma muy simple para poder sacar el promedio, ahora sí solamente ubicamos la variable para imprimirlas en pantalla.
#include <iostream>
using namespace std;
struct alumno {
string nombre;
int edad;
};
//variable promedio
float prom;
int main(int argc, char** argv) {
alumno a1, a2, a3;
//primer alumno
cout<<"Teclea el nombre del primer alumno:";
cin>>a1.nombre;
cout<<"Teclea la edad del primer alumno:";
cin>>a1.edad;
cout<<"\n";
//segundo alumno
cout<<"Teclea el nombre del segundo alumno:";
cin>>a2.nombre;
cout<<"Teclea la edad del segundo alumno:";
cin>>a2.edad;
cout<<"\n";
//tercer alumno
cout<<"Teclea el nombre del tercer alumno:";
cin>>a3.nombre;
cout<<"Teclea la edad del tercer alumno:";
cin>>a3.edad;
cout<<"\n";
//mayor edad
if((a1.edad>a2.edad) && a1.edad>a3.edad){
cout<<"La edad mayor es:"<<a1.edad<<endl;
}
else{
if((a2.edad>a1.edad) && a2.edad>a3.edad){
cout<<"La edad mayor es:"<<a2.edad<<endl;
}
else
{
if((a3.edad>a2.edad) && a3.edad>a1.edad){
cout<<"La edad mayor
es:"<<a3.edad<<endl;
}
//la edad del menor
if((a1.edad<a2.edad) && a1.edad<a3.edad){
cout<<"La edad menor es:"<<a1.edad<<endl;
}
else{
if((a2.edad<a1.edad) && a2.edad<a3.edad){
cout<<"La edad menor es:"<<a2.edad<<endl;
}
else
{
if((a3.edad<a2.edad) && a3.edad<a1.edad){
cout<<"La edad menor
es:"<<a3.edad<<endl;
}
}
return 0;
}
}
}
//El promedio de las edades
prom=(a1.edad+a2.edad+a3.edad)/3;
cout<<"El promedio de las 3 edades es:"<<prom<<endl;
}
CONCLUSION:Los datos abstractos se crean por el usuario para su mejor entendimiento
No se debe confundir o usar variables con el mismo nombre que se encuentran en
el dato abstracto y en el método main.
Lo aprendido en este apartado fue de la forma en el cual se comienza a crear un
dato abstracto utilizando la palabra reservada de java struct, cosa en la
programación orientada a objetos es muy diferente o un tanto mas complejo que
en este lenguaje de programación. Otros aprendizajes significativo fue la forma de
utilizar tal fato abstracto usando un punto para su llamado y posterior utilización.
es conveniente no usar mismas variables para su utilización en el método main.
FUNCIONESPROGRAMA 1: PIDE DOS NUMEROS Y REALIZA LA SUMA
INTRODUCCION:
Este pequeño programa realiza a base de funciones la lectura de dos números, la
suma de los mismos y la impresión de los resultados. Pero como funciona, es
muy bueno, primero iniciamos las funciones con el nombre que deseemos ponerle.
Creamos nuestras variables globales o locales, en el main se convocan las
funciones que vamos a crear, se crean las funciones leer, sumar e imprimir.
Bueno en cada función como su nombre lo indica realiza una acción que al
momento de ser llamados en el main se han de ejecutar siempre y cuando sean
llamados claro. Y conclusión tenemos que lo que hizo este programa fue nada
mas que sumar dos números, lo cual se podría realizar sin funciones pero la
importancia de este es el orden.
#include <iostream>
using namespace std;
//inicializacion de funciones
void leer();
void sumar();
void imprimir();
//varibles globales
int suma, n1, n2;
//llamado de funciones
int main(int argc, char** argv) {
leer();
sumar();
imprimir();
return 0;
}
//funcion lectura de datos
void leer()
{
cout<<"Ingrese un numero:";
cin>>n1;
cout<<"Ingrese otro numero:";
cin>>n2;
}
//funcion suma de datos
void sumar()
{
suma=n1+n2;
}
//funcion salida de datos
void imprimir()
{
cout<<"La suma de los dos numeros es:"<<suma;
}
CONCLUSION:Bueno hasta ahora sabemos que las funciones nos permiten organizar, entender
y corregir mejor los programas más extensos con la cual lidiemos. Además de que
no regresan un valor, estas funciones también podrían regresar un valor cuando
se hable de parámetros en ellos. Cuando una función es invocada se le pasa el
control a la misma, una vez que esta finalizó con su tarea el control es devuelto al
punto desde el cual la función fue llamada.
PROGRAMA 2: IMPRIME DOS NÚMEROS, LA SUMA, LA RESTA, LA DIVISIÓN Y LA RESTA DE AMBOS.
INTRODUCCION:
En este caso en particular el programa no usa parámetros para simplemente se
usa un void para indicar que no devuelve ningún valor. Primeramente se
inicializaron las funciones con el formato void seguido de un paréntesis y punto y
coma de la categoría o función que debe realizar. Como las variables se han de
ocupar en todas las funciones entonces se declaran arriba del método o función
principal main y en el caso de que no se usen para todas las funciones pues en si
se definen en donde se deba utilizar. Siguiendo se crean las funciones
inicializadas ahora después de los dos paréntesis se agrega un par de corchetes
cerrados que es donde la cual el código o instrucción que realiza se almacenará
ahí mismo. Una vez creado las funciones, dentro del método principal se convocan
o llaman a las funciones anteriores para realzar su función y dependiendo del
código que deba aparecer en pantalla realizarán lo que se llama su acción.
#include <iostream>
#include <conio.h>
using namespace std;
//lee todas las funciones
void lee (void);
void sum (void);
void res(void);
void multi(void);
void div(void);
void imprimir(void);
//variables globales
int n1, n2, s,r,m;
float d;
//metodo principal
int main(int argc, char** argv) {
lee ();
sum ();
res ();
multi ();
div();
imprimir ();
return 0;
}
//para leer
void lee (){
cout<<"Ingrese en numero 1:";
cin>>n1;
cout<<"Ingrese en numero 2:";
cin>>n2;
}
//para sumar
void sum (){
s=n1+n2;
}
//para restar
void res(){
r=n1-n2;
}
//para multiplicar
void multi(){
m=n1*n2;
}
//para dividir
void div(){
d=n1/n2;
}
//para imprimir
void imprimir(){
cout<<"La suma de los dos numeros es: "<<s<<endl;
cout<<"La resta de los dos numeros es: "<<r<<endl;
cout<<"La multiplcacion de los dos numeros es: "<<m<<endl;
cout<<"La division de los dos numeros es: "<<d<<endl;
CONCLUSION:Se debiera seguir el orden de inicialización de funciones, creación de funciones y
llamado de funciones.
Se recomienda dominar el uso de funciones con parámetros.
Se debe entender que función hace honor a su nombre.
Comprender que las funciones son útiles cuando el programa es muy extenso y se
debe utilizar una misma instrucción para cierta actividad.
Se optimiza la búsqueda de errores y ahorro mas de tiempo en corregir el
programa
Las funciones pueden utilizarse con todos los tipos de datos en c++
No se puede usar funciones con el mismo nombre.
CONCLUSION GENERALEn esta unidad 1 analizamos los arreglos unidimensionales y bidimensionales es
muy importante entender muy bien todo lo ha aprendido hasta ahora porque mas
adelante nos servira en un momento de la programación o más bien será con lo
que más hemos de trabajar. aprendimos como se declaran los arreglos
unidimensionales y bidimensionales las cuales tienen una diferencia de ser un
vector y una matriz respectivamente. Y un dato que es de vital importancia es que
siempre vamos a utilizar un for para las filas y otro for para las columnas, o de
hecho para el análisis de dichos arreglos siempre se van a usar siempre
basándonos en las coordenadas. Otro punto muy importante es bueno mencionar
y no mencione en las conclusiones anteriores en el código Using namespace std;
que nos ha de servir para el ingreso y salida de datos de no ser así siempre va a
anteceder un std::cout o un std::cin cuando queramos introducir datos lo cual nos
hace perder un poco de tiempo. despues realizamos un énfasis en los tipos de
datos abstractos que si bien queda comprendido que es el programador quien los
crea siempre utilizando los tipos de datos del lenguaje e iniciando con ello con un
struct{} y adentro de los corchetes van los tipos de datos, por ultimo vimos las
funciones que son similares a los datos abstractos, con la diferencia de que en las
funciones se realizan como su nombre lo indica funciones u operaciones que al
final son convocados en el método principal main para ser utilizados.