trabajo

1. Instituto Tecnológico Superior de Felipe Carrillo Puerto
ING. Sistemas Computacionales
Estructura de Datos
Informe técnico General
Alumno: Jorge Manuel Aké Pech
Profe (a): MTI. Niels Henryk Aranda Cuevas
3er Semestre Grupo “A”
Unidad 1 introducción a la Estructura de Datos

2. 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;
}
Esta codificación ejecuta y analiza un arreglo bidimensional de 4x4 como vemos al principio
declaramos nuestras variables el programa se encarga de ejecutar los comandos el cual solicitara al

3. usuario ingresar los datos del arreglo y este imprimirá a la pantalla la diagonal principal, la diagonal
invertida, 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;
}
En este programa se almacenan calificaciones de tres unidades de diferentes alumnos del instituto. El
programa se encarga de realizar los promedios de los alumnos y almacenarlos en otro arreglo, este

4. 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 alumnon";
cin>>a1.nombre;
cout<<"Introduzca la edad del alumnon";
cin>>a1.edad;
cout<<"Introduzca el nombre del alumnon";
cin>>a2.nombre;
cout<<"Introduzca la edad del alumnon";
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;
}
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);}

5. 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;
}
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.

6. unidad 3 Estructuras Lineales
Actividad 1 Serie Fibonacci
#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;
}
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.

7. 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.

8. 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){

9. 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[]) {

10. 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;
}

11. 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;

12. }
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] << " ";

13. }
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;
}

14. }
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;
}
}

15. 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;
}

16. 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;
}
}
}

17. }
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);

18. 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 encontradon";
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]<<" ";
}

19. }
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;
}

20. 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.

21. 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.

22. - 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;
}

24. 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.

25. Unidad 4 Estructuras no Lineales