• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Arreglos
 

Arreglos

on

  • 10,272 views

 

Statistics

Views

Total Views
10,272
Views on SlideShare
7,330
Embed Views
2,942

Actions

Likes
2
Downloads
134
Comments
0

9 Embeds 2,942

http://moodle.ubiobio.cl 2148
http://pva.face.ubiobio.cl 573
http://systelcomp.milaulas.com 95
http://www.edarreglos.blogspot.com 56
http://mtest.ubiobio.cl 31
http://www.slideshare.net 22
http://edarreglos.blogspot.com 9
http://moodle2.0.ubiobio.cl 7
http://edarreglos.blogspot.com.ar 1
More...

Accessibility

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Arreglos Arreglos Presentation Transcript

    • ESTRUCTURA DE DATOS ARREGLOS IUTE – MÉRIDA PROF: DUBERLIS GONZÁLEZ
    • ARRAYS (Arreglos) Un Array es una estructura de datos en la que se almacena una colección de datos del mismo tipo (por ejem. Los salarios de los empleados de una empresa). Un Array es una lista de un número finito de n elementos del mismo tipo, que se caracteriza por: Almacenar los elementos del array en posiciones de memoria continua. Tener un único número de variable (por ejemplo: salarios) que representa a todos los elementos, y éstos a su vez, se diferencian por un índice o subíndice Acceso directo o aleatorio a los elementos individuales del array. Por ejemplo: Salario nombre del array Salario[1] elemento del array Salario[2] 1,2...n subíndice del array . . . Salario[n ] Los arrays se clasifican en: Unidimensionales (vectores o listas) Multidimensionales (tablas o matrices)
    • 1. Arrays Unidimensionales (Vectores)
      • Un array de una dimensión – vector o lista – es un tipo de datos estructurados compuesto de un número de elementos finito, tamaño fijo y elementos homogéneos. Finitos, indica que hay un último elemento, tamaño fijo significa que el tamaño del array debe ser conocido en tiempo de compilación, homogéneo significa que todos los elementos son del mismo tipo.
      • Los elementos del array se almacenan en posiciones contiguas de memoria, a cada una de las cuales se puede acceder directamente.
      • Supongamos que se desea conservar las puntuaciones de los 50 estudiantes de un examen de informática. Para almacenar estas puntuaciones o calificaciones se necesita reservar cincuenta posiciones en memoria, dar un nombre al array, y a cada uno de los 50 estudiantes asignarles su clasificación correspondiente, es decir, dar el índice o subíndice del array.
    • Ejem: 1. Arrays Unidimensionales (Vectores) Calificaciones Calificaciones[1] Calificaciones[2] Calificaciones[3] Calificaciones[50] 7.50 4.75 5.25 6.00 1.1. Declaraciones de Tipo Array Normalmente, la estructura de un array (vector) se describe por la declaración del tipo de array. A continuación se asigna almacenamiento para uno o más arrays de ese tipo.
      • Ejem:
      • Formato
      Type Nombre_array = array [tipo subíndice] of tipo; Nombre_array identificador válido Tipo subíndice puede ser de tipo ordinal: boolean o char, un tipo enumerado o un tipo subrango. Existe un elemento por cada valor del tipo subíndice Tipo describe el tipo de cada elemento del vector; todos los elementos del vector son del mismo tipo.
        • 1. El tipo de dato estándar Real no puede ser utilizado como un tipo subíndice; sin embargo, un subrango de enteros puede ser un tipo subíndice.
        • 2. El tipo de elemento puede ser cualquier tipo definido por el usuario o estándar
    • El subíndice o índice del array debe ser de tipo simple: entero (integer, shortint, Byte, Word), lógico, carácter o enumerado, pero no real. Ejemplos típicos de índices son: 1 .. 10 enteros ‘ C’ .. ‘N’ caracteres true .. false lógicos azul .. marrón enumerados Un elemento del array se identifica por el nombre del array y el subíndice (índice) adecuado contenido entre corchetes. Por ejemplo: Salarios[1] Salarios[2] Salarios[10]
    • 1.2. Variables de tipo Array : Las declaraciones de tipo de dato array no crean ninguna variable específica tipo array. En realidad la declaración type proporciona información perteneciente a un grupo de arrays como un todo. Las variables tipo arrays son creadas utilizando la declaración var, cuyo formato general es: NombreArray nombre elegido para la variable NombreTipo igual nombre que el utilizado en type. Ejemplo: Type Valores = array [-10..10] of real; Var Precios: Valores; El subíndice de la variable array Precios debe ser un entero entre –10 y 10; cada elemento del array contiene un valor real. Var NombreArray : NombreTipo ;
      • Ejemplo:
      • Const
      • Max = 500;
      • Type
      • Texto = array [1..Max] of char;
      • Var
      • Palabras, letras: Texto;
      • La declaración var, en este caso, crea dos variables arrays, cuyos nombres son Palabras y Letras. Consultando las declaraciones const y type se observa que los subíndices de estos arrays deben ser un entero entre 1 y 500; cada elemento de estos arrays contendrán un valor de tipo carácter.
      • El número de elementos de un array viene definido por la diferencia entre los índices mayor y menor más uno.
      • Procedimientos de visualización de datos tipo enumerado:
      • Ejemplo:
      • Dadas las declaraciones:
      • Type
      • Arcoiris = (Rojo, Verde, Azul, Marrón, Blanco, Gris, Negro);
      • Var
      • Color: Arcoiris;
      • Se puede crear un procedimiento EscribirColor, de modo que cuando se le invoque por el nombre y con un determinado color como argumento se visualice dicho color. La sentencia
      • EscribirColor (Argumento)
      • Visualiza el nombre del color que figura en el argumento.
      Tipo Enumerados :
      • Ejemplo:
      • Los datos pueden ser de tipo enumerado
      • Type
      • LucesTráfico = (rojo, verde, amarillo);
      • Var
      • Trafico: Array [1..3] of LucesTráfico;
      • Las declaraciones de arrays pueden aparecer directamente en la sección de variables de la parte de declaración de un programa. Por ejemplo:
      • Var
      • Coordenadas : array [1..15] of real;
      • Numero : array [0..100] of 1..999;
      • CuentaCar : array [‘A’..’Z’] of integer;
      • LineaTexto : array [1..80] of char;
      • Pero, es preferible asociarlas con identificadores tipo, como en
      • Type
      • Letra = ‘A’ .. ’Z’;
      • ArrayReal = array [1..15] of real;
      • Numero = array [0..100] of 1..999;
      • Linea = array [1..80] of char;
      • Y a continuación utilizar estos identificadores tipo para declarar los tipos de arrays
      • Var
      • Coordenadas : ArrayReal;
      • Cantidad : Numero;
      • LineaTexto : Linea;
    • Precaución: 1.3. Uso del Índice de un Array Cada referencia a un array incluye el nombre y el subíndice (índice) encerrado en corchetes, el índice determina qué elemento se procesa. El tipo índice suele ser un subrango. De acuerdo a los datos contenidos en un array, las operaciones básicas que se pueden ejecutar en ellos son: 1.3.1 Asignación de valores a elementos del array. A los componentes de un Array se pueden asignar valores de igual forma que a cualquier otra variable, con tal de que sean del mismo tipo. A[ i ] := 25; Trafico[ 3 ] := Rojo; A[ i ] := c;
        • Las declaraciones de índices no pueden contener variables:
        • Var Demo : array [1..N] of integer; es ilegal
        • A menos que:
        • Si se hubiera definido previamente N como constante (por ejem. N = 10), sí sería válida la declaración.
      • 1.3.2 Índices distintos de enteros:
      • Los índices de un array deben ser un intervalo de tipo simple: entero, lógico, carácter, enumerado o subrango.
      • Ejemplo:
      • Type
      • Linea = array [1..40] of char;
      • Tabla = array [1..30] of Linea;
      • Var
      • Reticula : Tabla;
      • Rango : Linea;
      • Estas declaraciones pueden escribirse también de la siguiente forma:
      • Const
      • Longitud = 40;
      • Altura = 30;
      • Type
      • Horizontal = 1..Longitud;
      • Vertical = 1..Altura;
      • Linea = array [Horizontal] of char;
      • Tabla = array [Vertical] of Linea;
      • Ejemplo:
      • Las declaraciones:
      • Type
      • DiasdeSemana = (Lunes, Martes, Miércoles, Jueves, Viernes,
      • Sabado, Domingo);
      • ConjuntoDias = array [DiasdeSemana] of integer ;
      • Var
      • Cuenta : ConjuntoDias;
      • Establecen un vector (un array unidimensional) con siete posiciones cada una de las cuales puede almacenar un entero.
      Cuenta [Lunes] Cuenta [Miércoles] Cuenta [Martes] Cuenta [Domingo] Cuenta [Sábado] Cuenta [Viernes] Cuenta [Jueves] 345 2214 1614 2817 1432 2460 2112
      • 1.4. Operaciones con Arrays (Vectores)
      • Los vectores (Arrays) no se pueden leer/escribir en una sola operación o sentencia. La lectura o escritura de un array se debe hacer elemento a elemento, y para realizar estas operaciones se deben leer o visualizar los componentes de un array mediante estructuras repetitivas.
      • Ejemplo:
      • El vector Notas contiene las calificaciones obtenidas en un examen por los alumnos de una clase de Turbo Pascal.
      • Type
      • ListadeNotas = array [1..30] of integer;
      • Var
      • Notas : ListadeNotas;
      • 1.4.1 Lectura de un vector:
      • Bucles For
      • for I:= 1 to 100 do
      • ReadLn (Notas[ I ]);
      • Bucles While Bucles Repeat
      • I:= 1; b) I:= 1;
      • While I <= 100 do Repeat
      • Begin Read (Notas[ I ]);
      • Read (Notas[ I ]; I:= I + 1;
      • I:= I + 1; until I > 100;
      • end;
      • En el caso de que el índice del array sea un tipo enumerado, la lectura completa se realiza por la sentencia For.
      • 1.4.2 Escritura de un Vector:
      • Los elementos de un vector pueden ser visualizados situando una sentencia de salida dentro de una estructura repetitiva. Por ejemplo:
      • ReadLn (Numero); {lee la cantidad de números a leer en el vector}
      • Write (Notas [ i ]: 3);
      • Las salidas aparecerán en la misma linea. Esto se puede evitar escribiendo una sentencia writeLn al final del bucle.
      • For I := 1 to Número do
      • WriteLn (Notas [ I ] : 3);
      • WriteLn;