Instituto Tecnológico Superior de Felipe Carrillo Puerto
Ingeniería En Sistemas Computacionales
Informe técnico General
Unidad 1 introducción a la Estructura de Datos
Actividad 1 Arreglo Bidimensional
#include<iostream>
using namespace std;
int numeros[4][4];
void leer(){
for(int L=0; L<4; L++){
for(int C=0; C<4; C++){
cout<<"Introduzca un número";
cin>>numeros[L][C];
}
}
}
void dp(){
cout<<"\nLa diagonal principal";
for(int i=0; i<4; i++){
cout<<numeros[i][i];
}
}
void di(){
int cont=3;
cout<<"\nLa diagonal invertida";
for(int i=0; i<4; i++){
cout<<numeros[i][cont];
cont = cont-1;
}
}
void f3(){
cout<<"\nLa fila 3:";
for(int c=0; c<4; c++){
cout<<numeros[2][c];
}
}
void cusr(){
int c;
cout<<"\nIntroduzca el número de la columna a imprimir";
cin>>c;
cout<<"\nLinea deseada:";
c = c-1;
for(int L=0; L<4; L++){
cout<<numeros[L][c];
}
}
int main (int argc, char *argv[]) {
leer();
dp();
di();
f3();
cusr();
return 0;
}
Conclusión
En este primer programa ejecuta y analiza un arreglo bidimensional de 4x4 como se
observa al principio, se declaró las variables y el programa se encarga de ejecutar
los comandos en el cual se le solicitara al usuario ingresar los datos del arreglo y
que a su vez imprimirá en la pantalla los datos. Una vez listo se arrojara la diagonal
principal, la diagonal invertida, e imprimirá la fila 3 y por ultimo imprimirá una
columna que el usuario solicite.
Actividad 2 Calificaciones
#include<iostream>
using namespace std;
int arg [4][3];
int arg2 [4];
int main () {
int F,C;
int may=0, sum=0, men=0;
for(F=0; F<4; F++)
{
for(C=0; C<3; C++)
{
cout<<"Ingrese las calificaciones del alumno:";
cin>>arg[F][C];
cout<<endl;
}
cout<<endl;
}
//sum=0;//almacenando lo que ya tiene el arreglo
for(F=0; F<4; F++){
for(C=0; C<3; C++){
sum= sum+arg[F][C];
}
//almacenando el promedio
arg2[F]= sum/3;
sum=0;
}
may=0;
for(F=0; F<4; F++){
if (arg2[may]<arg2[F]){
may=F;
}
}
cout<<"El alumno con mayor promedio esta en la posicion:
"<<may+1<<endl;
cout<<"Su promedio es: "<<arg2[may]<<endl;
men=0;
for(F=0; F<4; F++){
if (arg2[men]>arg2[F]){
men=F;
}
}
cout<<"el alumno con menor promedio esta en la posicion:
"<<men+1<<endl;
cout<<"su promedio es: "<<arg2[men];
return 0;
}
Conclusión
En este programa se capturan las calificaciones de tres unidades de diferentes
alumnos del instituto. El programa se encarga de sacar los promedios de los alumnos
y almacenarlos en otro arreglo, este imprimirá las calificaciones del alumno con
mayor promedio y las calificaciones del alumno con menor promedio.
Actividad 3 Nombre y Edades
#include<iostream>
using namespace std;
struct alumno{
string nombre;
int edad;
};
alumno a1, a2;
void pedir(){
cout<<"Introduzca el nombre del alumno\n";
cin>>a1.nombre;
cout<<"Introduzca la edad del alumno\n";
cin>>a1.edad;
cout<<"Introduzca el nombre del alumno\n";
cin>>a2.nombre;
cout<<"Introduzca la edad del alumno\n";
cin>>a2.edad;
}
void comparacion(){
if( a1.edad > a2.edad ){
cout<<"La edad mayor es: "<<a1.edad;
}else{
if(a2.edad > a1.edad){
cout<<"La edad mayor es: "<<a2.edad;
}else{
cout<<"Tienen la misma edad."<<endl;
}
}
}
void suma(){
int sum;
sum = a1.edad + a2.edad;
cout<<" La suma de las edades es: "<<sum;
}
int main (int argc, char *argv[]) {
pedir();
comparacion();
suma();
return 0;
}
Conclusión
Este programa solicita al usuario un nombre y una edad de dos personas, para que
este pueda analizar e imprima la suma de las dos edades y muestre en pantalla la
edad mayor.
Actividad 4 Operaciones Básicas
#include<iostream>
using namespace std;
int num1,num2;
int sum (int x, int y){return (x+y);}
int res(int x, int y){return(x-y);}
int div (int x, int y){return(x/y);}
void pedir();
int main (int argc, char *argv[]) {
int n1;
int opera;
cout<< "escriba el numero de acceso de la operacion que desea
realizar:\n";
cout<<"sumar: 1 \n";
cout<<"restar: 2 \n";
cout<<"dividir: 3 \n";
cin>>opera;
if(opera==1){
pedir();
cout<<"La suma de los numeros es: "<<sum(num1,num2);
}
else {
if (opera==2){
pedir();
cout<<"La resta de los numeros es: "<<res(num1,num2);
}
}
if (opera==3){
pedir ();
cout<<"La division de los numeros es: "<<div(num1,num2);
}
}
void pedir(){
cout<<"ingrese el primer valor: \n";
cin>>num1;
cout<<"ingrese el segundo valor: \n";
cin>>num2;
}
Conclusión
Este programa realiza las operaciones básicas como sumar, restar y dividir, le ofrece
al usuario una serie de opciones en la cual podrá elegir qué operación realizar. El
programa se encargara de realizar la operación deseada según los datos que el
usuario haya ingresado.
Unidad 2 Recursividad
unidad 3 Estructuras Lineales
Actividad 1 Serie Fibonacci
La serie de Fibonacci es una sucesión de números, en
la cual cada número se calcula sumando los dos
números anteriores a él.
Este programa le permite al usuario ingresar la
cantidad de números que desea sumar. Hacemos uso
del comando for el cual llevara el conteo y ejecutara la
suma de los números que el usuario ingreso, utilizamos
y empleamos el uso de la función Fibonacci e
imprimirá en pantalla los números ingresados con la
suma ya realizada.
#include <cstdlib> #include <iostream> using namespace std; int fibonacci(int n) { if (n<2) return n; else return fibonacci(n-1) + fibonacci(n-2); } int main() { int num=0,res=0; cout<<"Serie de fibonacci:\n"; cout<<"Introduce la cantidad de numeros: "; cin>>num; for(int i=0;i<=num;i++) { res = fibonacci(i); cout<<"\t"<<res<<"\t"; } cout<<endl; system("PAUSE"); return EXIT_SUCCESS; }
Actividad 2 Recursividad
#include <cstdlib> #include <iostream> using namespace std; int suma ( ); void lectura ( ); int n1, n2; int main(int argc, char *argv[]) { lectura ( ); cout<<"\nEl resultado es: "<<suma(); cout<<endl; system("PAUSE"); return EXIT_SUCCESS;
} void lectura ( ) { cout<<"Dame un numero: "; cin>>n1; cout<<"Dame otro numero: "; cin>>n2; } int suma ( ) { return(n1+n2); }
La recursividad se utiliza para realizar el llamado a
una función desde una misma función. Es ahí donde
implementamos las estructuras de repetición o los
ciclos.
Este programa hace el llamado de la misma función
suma. El usuario ingresa dos números. Antes
declaramos nuestras variables, el caso de n1 y n2 y
realizamos la lectura. Hacemos la suma y utilizamos
el método return y aplicamos el método de
recursividad sumando los dos números.
Actividad 3 Apuntadores
#include <iostream> #include <stdLib.h> using namespace std; typedef struct nodo elemento; struct nodo { int edad; elemento*sig; }; int main(int argc, char *argv[]) { elemento *p; //Declaracion del apuntador p=(elemento*)malloc(sizeof(elemento*)); cout<<"Ingresa Edad: "; cin>>p->edad; cout<<"La edad es: "<<p->edad<<" y esta alojada en direccion "<<p; return 0; }
Empleamos el uso de apuntadores y almacenamos
nuestros datos en un espacio de memoria el cual
esta registrada en una dirección. Este programa
tiene una estructura diferente a otros; utilizamos la
estructura nodo elemento o la estructura nodo que
nos permite realizar operaciones de
almacenamiento de datos.
Declaramos el apuntador y utilizamos el método
malloc para efectuar la operación. Este almacenara
el dato ingresado y arrojara la dirección de memoria
en la que guardo el dato.
Unidad 4 Estructuras no Lineales
Arboles
Arboles binarios
Distintos
Similares
Equivalentes
Equilibrado
Completo
Arboles Multicaminos
B
B+
B*
R
2-4
un arbol es una estructura de datos homogenea, dinamica y no lineal, en la que cada nodo (elemento) puede tener
varios nodos posteriores pero solo pueden tener un nodo anterior
Unidad 5Metodos de Ordenamiento
QuickShort
#include<iostream>
#define largo 100
using namespace std;
//int largo=100;
void leeCadena(int cant,int n[])
{
int i;
for(i=0;i<cant;i++)
{
cout<<"Ingresa numero "<<i+1<<": ";
cin>>n[i];
}
}
void muestraCadena(int cant,int n[])
{
int i;
for(i=0;i<cant;i++)
{
cout<<n[i]<<endl;
}
}
void quicksort(int a[], int primero, int ultimo){
int i, j, central;
int pivote;
central = (primero + ultimo)/2;
pivote = a[central];
i = primero;
j = ultimo;
do {
while (a[i] < pivote) i++;
while (a[j] > pivote) j--;
if (i<=j){
int tmp;
tmp = a[i];
a[i] = a[j];
a[j] = tmp; /* intercambia a[i] con a[j] */
i++;
j--;
}
}while (i <= j);
if (primero < j){
quicksort(a, primero, j);/* mismo proceso con sublista izqda */
}
if (i < ultimo){
quicksort(a, i, ultimo); /* mismo proceso con sublista drcha */
}
}
int main (int argc, char *argv[]) {
int A[largo],n;
do{
cout<<"Cantidad de numeros a ingresar: ";cin>>n;
if(n<=0||n>largo)
cout<<"Debe ingresar un valor > a 0 y < a
"<<largo<<endl;
}while(n<=0||n>largo);
leeCadena(n,A);
quicksort(A,0,n-1);
muestraCadena(n,A);
return 0;
}
Radix
#include <iostream>
using namespace std;
int main() {
cout << "Cuantos numeros deseas ordenar??? ";
int n; cin >> n;
int a[n];
for(int i=0;i<n;i++)
{
cout << "Ingrese valor" << (i+1) << " : ";
cin >> a[i];
}
int e=1, d=3;
int i, j, k, m, digit, linea, col;
int length = sizeof(a)/sizeof(int);
int cola[length][10];
int c[10];
for(m=1;m<=d;m++)
{
for(i=0;i<10;i++)
{
c[i]=-1;
}
for(i=0;i<length;i++)
{
digit=(a[i]/e)%10;
c[digit]++;
linea=c[digit];
col=digit;
cola[linea][col]=a[i];
}
k=-1;
for(i=0;i<10;i++)
{
if(c[i]!=-1)
{
for(j=0;j<=c[i];j++)
{
k++;
a[k]=cola[j][i];
}
}
}
e=e*10;
cout << endl;
cout << "Arreglo ordenado" << endl;
for(int i=0;i<n;i++)
{
cout << a[i] << " ";
}
cout << endl;
return 0;
}
ShellShort
#include <iostream>
#define largo 100
using namespace std;
void leeCadena(int cant,int n[])
{
int i;
for(i=0;i<cant;i++)
{
cout<<"Ingresa numero "<<i+1<<": ";
cin>>n[i];
}
}
void muestraCadena(int cant,int n[])
{
int i;
for(i=0;i<cant;i++)
{
cout<<n[i]<<endl;
}
}
void ordenShell(int A[],int n)
{
int i, j, inc, temp;
inc =n/2;
while (inc > 0)
{
for (i=inc; i < n; i++)
{
j = i;
temp = A[i];
while ((j >= inc) && (A[j-inc] > temp))
{
A[j] = A[j - inc];
j = j - inc;
}
A[j] = temp;
}
inc/= 2;
}
}
int main (int argc, char *argv[]){
int A[largo],n;
do{
cout<<"Cantidad de numeros a ingresar: ";cin>>n;
if(n<=0||n>largo)
cout<<"Debe ingresar un valor > a 0 y < a
"<<largo<<endl;
}while(n<=0||n>largo);
leeCadena(n,A);
ordenShell(A,n);
muestraCadena(n,A);
return 0;
}
Unidad 6 Métodos de Búsqueda
Binaria
//Busqueda binaria
//en un arreglo.
#include <iostream>
using namespace std;
void leerArreglo(int arreglo[], int tam){
for(int i = 0; i<tam; i++){
cout << "Inserte un número:\n";
cin >> arreglo[i];
}
}
void mostrarArreglo(int arreglo[], int tamano){
for (int i = 0 ; i < tamano ; i++)
cout << "arreglo[" << i << "]=" << arreglo[i] << endl;
}
void ordenarArreglo(int arreglo[], int tamano){
for (int i = 0; i< tamano ; i++){
for (int j = i+1; j< tamano ; j++){
if (arreglo[i] > arreglo[j]){
int tmp = arreglo[i];
arreglo[i] = arreglo[j];
arreglo[j] = tmp;
}
}
}
}
int busquedaBinaria(int arreglo[], int tamano, int clave){
int Iarriba = tamano-1;
int Iabajo = 0;
int Icentro;
while (Iabajo <= Iarriba)
{
Icentro = (Iarriba + Iabajo)/2;
if (arreglo[Icentro] == clave)
return Icentro;
else
if (clave < arreglo[Icentro])
Iarriba=Icentro-1;
else
Iabajo=Icentro+1;
}
return -1;
}
int main()
{
int tam, clave;
cout <<"Inserte la cantida de datos a insertar en el arreglo";
cin>> tam;
int arreglo[tam];
leerArreglo(arreglo, tam);
ordenarArreglo(arreglo,tam);
cout << "Elementos del arreglo: " << endl;
mostrarArreglo(arreglo,tam);
cout << "Indique un valor a buscar y se le devolvera el indice:
" << endl;
cin >> clave;
cout<< "Su valor se encuentra en
arreglo["<<busquedaBinaria(arreglo,tam,clave)<<"]" << endl;
cout << "Fin del programa :)" << endl;
return 0;
}//fin de main
Secuencial
#include <iostream>
using namespace std;
int busqueda_lineal(int arreglo[], int buscado, int tam){
for(int i=0;i<tam;i++){
if(buscado==arreglo[i]){
cout << "Elemento encontrado\n";
cout << "Se encuentra en la posición " << i+1 <<
endl;
}
}
}
void imprimir(int arreglo[],int tam) {
for(int i=0;i<tam;i++){
cout<< arreglo[i]<<" ";
}
}
void leer(int tam, int arreglo[]){
for(int i=0; i<tam; i++){
cout<<"Ingresa un dato";
cin>>arreglo[i];
}
}
int main( ){
int tam;
int buscado;
cout << "Ingresa el tamaño del array" << endl;
cin >> tam;
int arreglo[tam];
leer(tam, arreglo);
imprimir(arreglo, tam);
cout << "\nIngresa el elemento a buscar ";
cin >>buscado;
busqueda_lineal(arreglo, buscado, tam);
return 0;
}
Unidad 7 Análisis de los Algoritmos
Un algoritmo es una secuencia de pasos lógica para encontrar la solución de un
problema.
Todo algoritmo debe contar con las siguientes
características: preciso, definido y finito. Por Preciso, entenderemos que cada paso
del algoritmo tiene una relación con el anterior y el siguiente; un algoritmo es
Definido, cuando se ejecuta más de una vez con los mismos datos y el resultado es
el mismo; y Finito, indica que el algoritmo cuenta con una serie de pasos definidos
o que tiene un fin.
Hablando de estructuras de datos podemos decir que los algoritmos según su
función se dividen en:
- Algoritmos de ordenamiento y
- Algoritmos de búsqueda.
Un algoritmo de ordenamiento, es el que pone los elementos de una lista o vector
en una secuencia (ascendente o descendente) diferente a la entrada, es decir, el
resultado de salida debe ser una permutación (reordenamiento) de la entrada que
satisfaga la relación de orden requerida.
Un algoritmo de búsqueda, es aquel que está diseñado para encontrar la solución
de un problema boleano de existencia o no de un elemento en particular dentro de
un conjunto finito de elementos (estructura de datos), es decir al finalizar el algoritmo
este debe decir si el elemento en cuestión existe o no en ese conjunto, además, en
caso de existir, el algoritmo podría proporcionar la localización del elemento dentro
del conjunto.
Complejidad en el espacio
La mayoría de los problemas que se plantean en la actualidad se pueden resolver
con algoritmos que difieren en su eficiencia. Dicha diferencia puede ser irrelevante
cuando el número de datos es pequeño pero cuando la cantidad de datos es mayor
la diferencia crece. Ejemplo: Suma de 4 y 10 primero números naturales.
1+2+3+4 = 10
1+2+3+4+5+6+7+8+9+10 = 55
3 3
tiempo
9 3
4*(4+1)/2 = 10
10*(10+1)/2 = 55
La complejidad de un algoritmo o complejidad computacional, estudia los recursos
y esfuerzos requeridos durante el cálculo para resolver un problema los cuales se
dividen en: tiempo de ejecución y espacio en memoria. El factor tiempo, por lo
general es más importante que el factor espacio, pero existen algoritmos que
ofrecen el peor de los casos en un menor tiempo que el mejor de los casos, lo cual
no es la mejor de las soluciones.
Eficiencia de los Algoritmos
El tiempo de ejecución de un algoritmo, se refiere a la suma de los tiempos en los
que el programa tarda en ejecutar una a una todas sus instrucciones, tomando en
cuanta que cada instrucción requiere una unidad de tiempo, dicho tiempo se puede
calcular en función de n (el numero de datos), lo que se denomina T(n)
Si hacemos un análisis de forma directa al programa para determinar el tiempo de
ejecución del mismo, debemos definir el conjunto deoperaciones primitivas, que son
independientes del lenguaje de programación que se use. Algunas de las funciones
primitivas son las siguientes:
- Asignación de un valor a una variable.
- Llamada a un método.
- Ejecución de una operación aritmética.
- Comparar dos números.
- Poner índices a un arreglo.
- Seguir una referencia de objeto.
- Retorno de un método.
En forma específica, una operación primitiva corresponde a una instrucción en el
lenguaje de bajo nivel, cuyo tiempo de ejecución depende del ambiente de hardware
y software, pero es constante. Ejemplo. Método que retorna el número mayor de un
arreglo de n elementos.
public int Mayor()
{
int may=arr[0];
for(ind=0; ind<arr.length; ind++)
if(arr[ind]>may)
may=arr[ind];
return may;
}
