Investigacion Arrelos, Vectores Y Matrices

ÍNDICE  Fundamentos de Programación  1 Arreglos …………………………………………….……………………………………....2           

1.1 Estructura de Datos……………………….……………………………………………....2 1.2 ¿Qué es un Arreglo?........................…….…………………………………………...….2 1.3 Declaración de Arreglos………………….……………………………………………....3 1.4 Manejo de Arreglos……………………….…………………………………………..…...3 1.5 Leer e Imprimir un Arreglo….………….……………………………………………......4 1.6 Ejercicio………………………………………………………………………………..….…4 1.7 Inicialización……………………………….………………………………………………..6 1.8 Búsqueda en un Arreglo………….…….………………………………………………..6 1.9 Solución Dato a buscar:………………….………………………………………………..7 1.10 Operador sizeof……………………………………………………………………………7 1.11 ¿Cómo calcular el tamaño de un arreglo?.............................................................7

 2 Vectores……………………………………………......................................... 8  3 Matrices……………………..…………………………………………..………. 11  3.1 Las matrices son objetos……………………………………………………………..13    

3.2 Inicializar matrices………………….…………………………………………….……13 3.3 Matrices unidimensionales……….……………………………..….……………..…13 3.4 Matrices multidimensionales…...…………………………………………………....14 3.5 Matriz escalonada……….……………………………………………...…………...…14

 4 Bibliografía…….………………………………………………...……..........… 15

Fundamentos de Programación Arreglos 1.1 Estructura de Datos Se puede considerar un conjunto de datos, Como una sola entidad… Como un solo tipo de dato… De esta forma, se reduce la complejidad de un problema. Un programa está formado por: Estructuras de control y llamadas a funciones (el algoritmo de nuestro programa). Datos, con sus respectivos tipos, ya sean estos atómicos o complejos, juntos forman una jerarquía (la estructura de datos del programa). PROGRAMA = ALGORITMO + ESTRUCTURA DE DATOS 1.2 ¿Qué es un Arreglo? Basándonos en los tipos de datos atómicos, podemos crear otros más complejos. Un arreglo es una colección, o grupo de datos, donde: Cada dato tiene su posición (primero, segundo, tercero…) Y todos los datos del grupo son del mismo tipo, es decir, o todos son enteros, o todos son reales, etc. La mejor forma de visualizar un arreglo es: Como un grupo de cajas, una detrás de otra Donde cada caja representa un dato del arreglo o un elemento. Podemos concluir que un arreglo tiene: Tamaño: cuantas cajas va a tener, el número de datos. Tipo: cuál es el tipo de todos los datos del arreglo. Nombre: el único nombre bajo el cual vamos a dirigirnos al mismo. Jamás olvidar que un arreglo tiene un tipo NO EXISTEN ARREGLOS “MEZCLADOS”

1.3 Declaración de Arreglos Al declarar una variable cualquiera siempre indicamos: tipo y nombre. Por ejemplo: int a; Para declarar un arreglo, se debe indicar Tipo Nombre y Tamaño Un arreglo de 10 elementos enteros, se declara: int ArregloEnteros[10]; Y lo podemos visualizar: Cada elemento del grupo va a estar identificado por un valor numérico, llamado índice . En C el primer elemento de un arreglo tiene el índice 0. Siempre, para indicar el tamaño de un arreglo, se utilizara una constante , jamás una variable. Jamás olvidar, el tamaño de un arreglo es una constante 0 1 2 3 4 5 6 7 8 9 ArregloEnteros 1.4 Manejo de Arreglos Tenemos ahora 10 enteros bajo un mismo nombre ¿Cómo accedemos a uno de esos datos? Usamos el nombre del arreglo y el índice que identifica al elemento: nombre_arreglo[indice] Si se desea asignar el valor de 2 al primer elemento del arreglo: arregloEntero[0] = 2; arregloEntero[1] = 9; arregloEntero[4] = 1: Cada elemento es en efecto una variable del tipo declarado para el arreglo Es muy importante recordar que: El índice de un elemento, no es el valor (contenido) de dicho elemento. El índice puede ser cualquier expresión que retorne un valor entero.

Para asignar a todos los elementos del arreglo, un mismo valor, lo mas práctico es usar un lazo for: for(i = 0; i < 10; i++) { arregloEntero[ i ] = 0; } 0 1 2 3 4 5 6 7 8 9 ArregloEnteros 2 9 1 1.5 Leer e Imprimir un Arreglo Acabamos de ver un ejemplo para acceder a todos los elementos de una arreglo de una forma práctica. Si tenemos 10 elementos en un arreglo, y queremos pedir que los ingresen por teclado, debemos repetir el ingreso 10 veces: for(i = 0; i < 10; i++) { scanf(“%d”,&a); arregloEnteros[i] = a; } Así mismo, para imprimir todos los elementos de un arreglo, deberíamos repetir el proceso de imprimir, pero diez veces: for(i = 0; i < 10; i++) { printf(“Elemento %d:%d ”, i, ArregloEnteros[i]); }

1.6 Ejercicio Programa que permite el ingreso de las notas de un curso de 20 alumnos. Una vez ingresados, debe mostrarse el promedio de las mismas. #include <stdio.h>

#define MAX 20 void main(){ double notas[MAX]; double total, promedio; int i,a; total = 0; for(i = 0; i < MAX; i++) { printf("Ingrese Alumno %d:",i+1); scanf(“%d”,&a); notas[i]=a; } for(i = 0; i < MAX; i++) { total = total + notas[i]; } promedio = (double)total / (double)MAX; printf("Promedio: %.2f",promedio); getch(); } El usuario del programa no tiene por qué saber que los índices van desde 0, se le pueden mostrar desde 1 En lugar de almacenar valores en los elementos de un arreglo, algunas aplicaciones usan los arreglos para almacenar “índices”, que permiten llevar estadísticas, de un dato en particular. Por ejemplo: Se pidió a 40 estudiantes que calificaran la calidad de la comida de la cafetería en una escala del 1 al 10 (1 es terrible y 10 excelente). Escriba un programa en C que pida las 40 respuestas y luego muestre un resumen del resultado. Arreglos Para Tabular Un arreglo en C también se puede inicializar de las siguientes formas: Crear un arreglo de 3 elementos Inicializando cada elemento:

int A[]={11,2,8}; ó int A[3]={11,2,8}; Inicializando todos los elementos con el mismo valor: int A[3]={0}; Inicialización de un Arreglo En C, los elementos de un arreglo pueden ser de cualquier tipo Esto quiere decir que los elementos de un arreglo pueden ser a su vez, arreglos. Arreglos de arreglos, se conocen como arreglos multidimensionales. El mas común de estos, es el de dos dimensiones, conocido también como Matriz o Tabla . Un ejemplo de una matriz, es un tablero de tres en raya. Este es un arreglo de 3 elementos, donde cada elemento es un arreglo, de tres elementos también. Arreglos Multidimensionales int A[3][3]; A[0] A[1] A[2] A[0][0] A[1][0] A[2][0] A[0]1] A[1][1] A[2][1] A[0][2] A[1][2] A[2][2] 1.7 Inicialización Un arreglo multidimensional también se puede inicializar static double MatrizIdentidad[3][3] = { {1,0,0}, {0,1,0} {0,0,1} }; Así podemos inicializar todos los elementos de una matriz desde el inicio, sin necesidad de usar lazos anidados. 1.8 Búsqueda en un Arreglo Se refiere al proceso para encontrar un elemento particular en un arreglo. Una de las estrategias más comunes y simples para buscar un dato en un arreglo es:

Revisar uno por uno los elementos del mismo, este método se conoce como búsqueda lineal . Escribir una función que determine si un valor dado se encuentra en un arreglo de elementos enteros, y si es así, indique su posición1.9 Solución Dato a buscar: 58 int EncontrarElemento(int valor, int arreglo[ ] ,int n) { for(i=0; i <10; i++) { if (valor = = arreglo [ i ] ) return(i); } return(-1); } 19 12 1 2 58 100 3 4 45 25 A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7] A[8] A[9] 1.10 Operador sizeof Un char ocupa un byte. ¿Cuantos bytes ocupa un entero? ¿un real? ¿una cadena? Depende de cada máquina Podemos averiguarlo usando el operador sizeof. sizeof(int) devuelve el número de bytes que necesita un dato de tipo int. CUIDADO : sizeof es un operador, no una función. 1.11 ¿Cómo calcular el tamaño de un arreglo? Si inicializamos una arreglo sin indicar su ancho… ¿Cómo podemos saber el ancho, para futuros usos en el programa? sizeof(Arreglo) devuelve 32 sizeof(Arreglo[0]) devuelve el desfase: sizeof(Arreglo)/sizeof(Arreglo[0]) devuelve 4, justo el número de elementos del arreglo. 1000 1008 1016 1024 1032 Arreglo[0] Arreglo[1] Arreglo[2] Arreglo[3] Arreglo[4]

2 Vectores

Los vectores son una forma de almacenar datos que permiten contener una serie de valores del mismo tipo, cada uno de los valores contenidos tiene una posición asociada que se usará para accederlos. Está posición o índice será siempre un número entero positivo. En C la cantidad de elementos que podrá contener un vector es fijo, y en principio se define cuando se declara el vector. Los vectores se pueden declarar de la siguiente forma: tipo_elemento nombre[largo]; Esto declara la variable nombre como un vector de tipo_elementos que podrá contener largo cantidad de elementos, y cada uno de estos elemento podrá contener un valor de tipotipo_elemento. Por ejemplo: double valores[128]; En este ejemplo declaramos un vector de 128 elementos del tipo double, los índices de los elementos irían entre 0 (para el primer elemento y 127 para el último). De la misma forma que con las otras declaraciones de variables que hemos visto se le puede asignar un valor iniciar a los elementos. O también se pueden declarar: tipo_elemento nombre[largo]={valor_0, valor_1, valor_2}; En caso estamos asignadole valores a los primeros 3 elementos del vector nombre. Notar que largo debe ser mayor o igual a la cantidad de valores que le estamos asignando al vector, en el caso de ser la misma cantidad no aporta información, por lo que el lenguaje nos permite escribir: tipo_elemento nombre[]={valor_0, valor_1, valor_2}; Que declarará nombre como el vector de largo 3. Para acceder a un elemento accederemos a través de su posición. Es decir: tipo_elemento elemento; ...

elemento = nombre[2]; Asumiendo que tenemos el vector anterior definido estaríamos guardando valor_2 en elemento. Veamos algunos ejemplos: /* * Ejemplo : El producto escalar de dos vectores */ #include <stdio.h> double producto_escalar(double v1[], double v2[], int d); int main() { const int largo = 3; double vector_1[] = {5,1,0}; double vector_2[] = {-1,5,3}; double resultado = producto_escalar(vector_1, vector_2, largo); // imprime el resultado printf("(%f, %f, %f) . (%f, %f, %f) = %f\n", vector_1[0], vector_1[1], vector_1[2], vector_2[0], vector_2[1], vector_2[2], resultado); return 0; } /* producto escalar entre dos vectores */ double producto_escalar(double v1[], double v2[], int d) { double resultado = 0; int i; for (i=0; i < d; i++) { resultado += v1[i] * v2[i]; } return resultado; } En el ejemplo anterior usamos los vectores de C para representar vectores matemáticos y calcular el producto escalar entre ellos. Una peculiaridad que se puede notar es que al recibir un arreglo en una función no se especifica el largo, volveremos a esto en un capítulo posterior.

Otra función clásica es la búsqueda de un máximo o mínimo, que podemos escribirla de la siguiente manera: int buscar_maximo(double valores[], int num_valores) { int maximo_pos = 0; for (int i = 1; i < num_valores; i++) { if (valores[i] > valores[maximo_pos]) { maximo_pos = i; } } return maximo_pos; } Otro ejemplo sencillo, calcular el promedio de los valores. double promedio(double valores[], int largo) { double suma=0; for (int i=0;i
... cuadrados(elementos,num_elem); ... De la misma forma que venimos usando vectores de tipos básicos, podemos tener vectores de vectores, estos se declaran de la siguiente forma: int matriz[3][7]; int tabla[3][4]={ { 1, 2, 3, 4}, { 5, 6, 7, 8}, /* los espacios y saltos de líneas no son tomados en cuenta */ { 9,10,11,12} }; double v[2][2][2]; ... printf("tabla[0][1]: %i\n", tabla[0][3]); // Imprime 4 printf("tabla[2][0]: %i\n", tabla[2][0]); // Imprime 9 ... En este ejemplo tabla es un vector de longitud 3, cuyos elementos son vectores de longitud 4 de elementos de tipo int. En resumen, suponiendo que v[n] es un vector de cualquier tipo de dato con n cantidad de posiciones, al vector v se le aplican las siguientes reglas: 1. La primera posición siempre será v[0] 2. La última posición es v[n-1] 3. En versiones previas a C99 n es una constante definida antes de la declaración de v[n]

3 Matrices En las matrices de C#, los índices empiezan en cero. Las matrices de C# funcionan de forma similar a como lo hacen en la mayoría de los lenguajes populares; existen, sin embargo, algunas diferencias que se deben conocer. Cuando se declara una matriz, los corchetes ([]) deben ir después del tipo, no después del identificador. Colocar los corchetes después del identificador no es sintácticamente válido en C#. int[] table; // not int table[]; Otro detalle es que el tamaño de la matriz no forma parte de su tipo, como ocurre en el lenguaje C. Esto permite declarar una matriz y asignarle cualquier matriz de objetos int, independientemente de la longitud de la matriz.

int[] numbers; // declare numbers as an int array of any size numbers = new int[10]; // numbers is a 10-element array numbers = new int[20]; // now it's a 20-element array Declarar matrices C# admite matrices de una dimensión, matrices multidimensionales (matrices rectangulares) y matrices de matrices (matrices escalonadas). El siguiente ejemplo muestra cómo declarar diferentes tipos de matrices: Matrices unidimensionales: int[] numbers; Matrices multidimensionales: string[,] names; Matrices de matrices (escalonadas): byte[][] scores; La declaración de matrices (como se muestra arriba) no crea realmente las matrices. En C#, las matrices son objetos (se explica más adelante en este tutorial) cuyas instancias deben crearse. Los siguientes ejemplos muestran cómo crear matrices: Matrices unidimensionales: int[] numbers = new int[5]; Matrices multidimensionales: string[,] names = new string[5,4]; Matrices de matrices (escalonadas): byte[][] scores = new byte[5][]; for (int x = 0; x < scores.Length; x++) { scores[x] = new byte[4]; } También se pueden utilizar matrices más grandes. Por ejemplo, se puede utilizar una matriz rectangular de tres dimensiones: int[,,] buttons = new int[4,5,3];

Incluso, se pueden combinar matrices rectangulares y escalonadas. Por ejemplo, el siguiente código declara una matriz unidimensional que contiene matrices tridimensionales de matrices bidimensionales de tipo int: int[][,,][,] numbers; Ejemplo El siguiente es un programa completo en C# que declara y crea instancias de las matrices comentadas anteriormente. // arrays.cs using System; class DeclareArraysSample { public static void Main() { // Single-dimensional array int[] numbers = new int[5]; // Multidimensional array string[,] names = new string[5,4]; // Array-of-arrays (jagged array) byte[][] scores = new byte[5][]; // Create the jagged array for (int i = 0; i < scores.Length; i++) { scores[i] = new byte[i+3]; } // Print length of each row for (int i = 0; i < scores.Length; i++) { Console.WriteLine("Length of row {0} is {1}", i, scores[i].Length); } } } Resultado Length of row 0 is 3 Length of row 1 is 4 Length of row 2 is 5 Length of row 3 is 6 Length of row 4 is 7

3.1 Las matrices son objetos En C#, las matrices son realmente objetos. System.Array es el tipo base abstracto de todos los tipos de matrices. Las propiedades y otros miembros de la clase System.Array se pueden utilizar cuando sea necesario. Un ejemplo de esto sería utilizar la propiedad Length para obtener la longitud de una matriz. El siguiente código asigna la longitud de la matriz numbers, que es 5, a una variable denominada LengthOfNumbers: int[] numbers = {1, 2, 3, 4, 5}; int LengthOfNumbers = numbers.Length; La clase System.Array proporciona muchos otros métodos y propiedades útiles, como métodos para ordenar, buscar y copiar matrices. Usar foreach con matrices C# dispone de la instrucción foreach. Esta instrucción proporciona un modo simple y limpio de iterar en los elementos de una matriz. Por ejemplo, el siguiente código crea una matriz denominada numbers y la recorre mediante la instrucción foreach: int[] numbers = {4, 5, 6, 1, 2, 3, -2, -1, 0}; foreach (int i in numbers) { System.Console.WriteLine(i); } Con matrices multidimensionales, se puede utilizar el mismo método para recorrer los elementos, por ejemplo: int[,] numbers = new int[3, 2] {{9, 99}, {3, 33}, {5, 55}}; foreach(int i in numbers) { Console.Write("{0} ", i); } El resultado de este ejemplo es: 9 99 3 33 5 55 Sin embargo, con matrices multidimensionales, utilizar un bucle for anidado proporciona más control sobre los elementos de la matriz.

3.2 Inicializar matrices C# proporciona métodos simples y sencillos para inicializar matrices en el momento de la declaración encerrando los valores iniciales entre llaves ({}). Los siguientes ejemplos muestran diferentes modos de inicializar diferentes tipos de matrices. Nota Si no inicializa una matriz en el momento de la declaración, sus miembros se inicializan automáticamente con el valor inicial predeterminado para el tipo de matriz. Además, si declara la matriz como campo de un tipo, se establecerá con el valor predeterminado null cuando cree la instancia del tipo.

3.3 Matrices unidimensionales int[] numbers = new int[5] {1, 2, 3, 4, 5}; string[] names = new string[3] {"Matt", "Joanne", "Robert"}; El tamaño de la matriz se puede omitir, como se indica a continuación: int[] numbers = new int[] {1, 2, 3, 4, 5}; string[] names = new string[] {"Matt", "Joanne", "Robert"}; También se puede omitir el operador new si se utiliza un inicializador como el siguiente: int[] numbers = {1, 2, 3, 4, 5}; string[] names = {"Matt", "Joanne", "Robert"};

3.4 Matrices multidimensionales int[,] numbers = new int[3, 2] { {1, 2}, {3, 4}, {5, 6} }; string[,] siblings = new string[2, 2] { {"Mike","Amy"}, {"Mary","Albert"} }; El tamaño de la matriz se puede omitir, como se indica a continuación: int[,] numbers = new int[,] { {1, 2}, {3, 4}, {5, 6} }; string[,] siblings = new string[,] { {"Mike","Amy"}, {"Mary","Albert"} }; También se puede omitir el operador new si se utiliza un inicializador como el siguiente: int[,] numbers = { {1, 2}, {3, 4}, {5, 6} }; string[,] siblings = { {"Mike", "Amy"}, {"Mary", "Albert"} };

3.5 Matriz escalonada (matriz de matrices) Las matrices escalonadas se pueden inicializar como en el siguiente ejemplo: int[][] numbers = new int[2][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} }; El tamaño de la primera matriz se puede omitir, como se indica a continuación:

int[][] numbers = new int[][] { new int[] {2,3,4}, new int[] {5,6,7,8,9} }; O bien int[][] numbers = { new int[] {2,3,4}, new int[] {5,6,7,8,9} }; Observe que no existe sintaxis de inicialización para los elementos de una matriz escalonada. Acceso a miembros de matrices El acceso a los miembros de una matriz es sencillo y similar al de los miembros de una matriz de C o C++. Por ejemplo, el siguiente código crea una matriz denominada numbers y, a continuación, asigna un 5 al quinto elemento de la matriz: int[] numbers = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0}; numbers[4] = 5; El siguiente código declara una matriz multidimensional y asigna el valor 5 al miembro ubicado en [1, 1]: int[,] numbers = { {1, 2}, {3, 4}, {5, 6}, {7, 8}, {9, 10} }; numbers[1, 1] = 5; La siguiente es una declaración de una matriz escalonada de una sola dimensión que contiene dos elementos. El primer elemento es una matriz de dos enteros, mientras que el segundo es una matriz de tres enteros: int[][] numbers = new int[][] { new int[] {1, 2}, new int[] {3, 4, 5} }; La siguiente instrucción asigna 58 al primer elemento de la primera matriz y 667 al segundo elemento de la segunda matriz: numbers[0][0] = 58; numbers[1][1] = 667;

4 Bibliografía Arreglos http://es.slideshare.net/javi2401/arreglos-en-c-presentation Vectores http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Vectores Matrices https://msdn.microsoft.com/es-ec/library/aa288453(v=vs.71).aspx