Algoritmos y estructuras de datos.

MATERIA: ALGORITMOS Y ESTRUCTURAS DE DATOS

SEMANA: 1

TEMAS SEMANA 1:
a) Uso de arreglos
b) Métodos de ordenamiento y búsqueda.

 ¿Cómo se declara y crea un arreglo?

Un arreglo es un grupo de variables que contienen valores y todos son del
mismo tipo. Las instancias de los arreglos ocupan espacio en memoria. En el
lenguaje de programación C#, al igual que los objetos, los arreglos se crean
con la palabra reservada new.
Para crear una instancia de un arreglo, se especifica el tipo y el número de
elementos del arreglo; al hacer la instancia, devuelve una referencia que
puede almacenarse en una variable de tipo arreglo.
El siguiente ejemplo muestra la sintaxis del lenguaje de programación C# para
la declaración y creación de arreglos. Lo que hace es crear un objeto arreglo
que contiene 7 elementos de tipo entero, y almacena la referencia al arreglo
en la variable Mi_vector:
int[] Mi_vector = new int[7];

Esta tarea también puede realizarse en dos pasos:

Int[] Mi_vector; //declara la variable tipo arreglo

Mi_vector = new int[7]; // crea el arreglo y lo asigna a la variable tipo
arreglo
 Algoritmos y estructuras de datos.

En la declaración, los corchetes que van después del tipo de variable int,
indican que Mi_vector es una variable que hará referencia a un arreglo de
valores int.

 ¿Cómo se recupera la información de un arreglo?

La manera para acceder a los datos guardados en el arreglo es por medio de
un ciclo for, en el cual se utiliza un contador para controlar el índice del arreglo
al que se hará referencia.
El siguiente ejemplo muestra la sintaxis del lenguaje de programación C# para
acceder a los datos del arreglo e imprimirlos en pantalla:

for (int contador = 0; contador < Mi_vector.Length; contador++)

Console.WriteLine(contador, Mi_vector[contador]);

Una aplicación práctica en donde podemos ver el uso de arreglos es cuando

guardamos el sueldo de 5 empleados:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace PruebaVector1
{
class PruebaVector1
{
private int[] sueldos; //Declaramos un vector

public void Cargar()

{
sueldos = new int[6]; //Inicializamos el vector en 5
for (int f = 1; f <= 5; f++)
{
Console.Write("Ingrese sueldo del operario "+f+": ");
String linea;
linea = Console.ReadLine();
 Algoritmos y estructuras de datos.

sueldos[f] = int.Parse(linea); //Asignamos los 5 sueldos al

vector
}
}
//Muestra los sueldos de los operarios en el vector sueldos[f]
public void Imprimir()
{
Console.Write("Los 5 sueldos de los aperarios \n");
for (int f = 1; f <= 5; f++)
{
Console.Write("["+sueldos[f]+"] ");
}
Console.ReadKey();
}
//main principal
static void Main(string[] args)
{
PruebaVector1 pv = new PruebaVector1();
pv.Cargar();
pv.Imprimir();
}
}
}

Si ejecutamos el código, tendremos una salida similar a la siguiente:

 Algoritmos y estructuras de datos.

 ¿Cuál es la diferencia entre las propiedades de arreglos Rank y

Length?
Existen varias propiedades que se usan en los arreglos, por ejemplo Rank y
Length.
La propiedad Rank devuelve el número de dimensiones de un arreglo, al cual
se le conoce como rango. Por ejemplo, un arreglo unidimensional devuelve 1,
un arreglo bidimensional devuelve 2, y así sucesivamente.
El siguiente ejemplo muestra la manera en que devuelve la dimensión del
arreglo:

Console.WriteLine(“Rango del arreglo Mi_vector: ”, Mi_vector.Rank);

La salida será:

Rango del arreglo Mi_vector: 1

La propiedad Length se usa para acceder a la longitud o cantidad de elementos

del arreglo.
El siguiente ejemplo muestra la sintaxis en lenguaje de programación C# para
obtener la longitud del arreglo que se declara:
int[] arreglo1 = new int[5];
int long1 = arreglo1.Length;
Console.WriteLine(“Longitud del arreglo: ” + long1);

En este ejemplo la salida será:

Longitud del arreglo: 5

El siguiente ejemplo crea e inicializa un arreglo y muestra sus propiedades y
elementos:

using System;

public class SamplesArray2

{
public static void Main()
 Algoritmos y estructuras de datos.

{
// Creates and initializes a new three-dimensional Array of type Int32.
Array myArr = Array.CreateInstance(typeof(Int32), 2, 3, 4);
for (int i = myArr.GetLowerBound(0); i <= myArr.GetUpperBound(0);
i++)
{
for (int j = myArr.GetLowerBound(1); j <= myArr.GetUpperBound(1);
j++)
{
for (int k = myArr.GetLowerBound(2); k <=
myArr.GetUpperBound(2); k++)
{
myArr.SetValue((i * 100) + (j * 10) + k, i, j, k);
}
}
}

// Displays the properties of the Array.

Console.WriteLine("El arreglo tiene {0} dimension(es)y un total de {1}
elementos.", myArr.Rank, myArr.Length);
Console.WriteLine("\tLength\tLower\tUpper");
for (int i = 0; i < myArr.Rank; i++)
{
Console.Write("{0}:\t{1}", i, myArr.GetLength(i));
Console.WriteLine("\t{0}\t{1}", myArr.GetLowerBound(i),
myArr.GetUpperBound(i));
}

// Displays the contents of the Array.

Console.WriteLine("El arreglo contiene los siguientes valores:");
PrintValues(myArr);
}

public static void PrintValues(Array myArr)

{
 Algoritmos y estructuras de datos.

System.Collections.IEnumerator myEnumerator =
myArr.GetEnumerator();
int i = 0;
int cols = myArr.GetLength(myArr.Rank - 1);
while (myEnumerator.MoveNext())
{
if (i < cols)
{
i++;
}
else
{
Console.WriteLine();
i = 1;
}
Console.Write("\t{0}", myEnumerator.Current);
}
Console.WriteLine();
}
}

Este código produce la siguiente salida:

El arreglo tiene 3 dimension(es) y un total de 24 elementos.
Length Lower Upper
0: 2 0 1
1: 3 0 2
2: 4 0 3
El arreglo contiene los siguientes valores:
0 1 2 3
10 11 12 13
20 21 22 23
100 101 102 103
110 111 112 113
120 121 122 123
 Algoritmos y estructuras de datos.

 ¿Para qué sirven los arreglos multidimensionales?

Los arreglos multidimensionales pueden ser de dos o más dimensiones. Los
bidimensionales o de dos dimensiones se utilizan con frecuencia para
representar tablas de valores, que consisten en información ordenada en
filas y columnas. En estos arreglos, para identificar una tabla en particular,
se debe especificar dos índices.
La sintaxis en el lenguaje de programación C# para declarar y crear un
arreglo bidimensional es:
int[ , ] a; //declara la variable tipo arreglo de dos dimensiones
a = new int[6, 6]; // crea el arreglo de 6 filas y 6 columnas y lo asigna a la
variable tipo arreglo