Fund. de Prog. 4 PDF

Seamos realistas y hagamos lo
imposible. .
Ernesto Che Guevara
Arreglos
Objetivo
Familiarizar al alumno con el manejo de estructuras de datos
aplicando todas las sentencias antes aprendidas mediante el uso
de los arreglos de datos ya sea unidimensionales o
bidimensionales, además de observar diversos tipos de
operaciones que se pueden desarrollar sobre estos.
En esta unidad
Estructura de Datos.
Arreglos de Datos
Arreglos Unidimensionales.
Arreglos Bidimensionales.
Estructuración de algoritmos
Instituto de Educación Superior Tecnológico Privado
1. Estructura de Datos
En las unidades anteriores se ha visto como se trata a los datos de manera simple es
decir aquellos datos cuyo valor son de tipo numérico, cadena o lógico. Todos estos
aplicados a variables simples que solamente podían almacenar un valor a la vez como
por ejemplo:
X : Entero CAD : Cadena
X = 10 CAD = “Hola José”
X = 40 CAD = “Nos vemos en la tarde”
X = - 21 CAD = “Verónica es aplicada”
En ninguno de los casos mostrados podíamos asignar a cualquier variable dos o mas
valores al mismo tiempo, es que nace entonces la necesidad de estudiar otro tipo de
datos que si permite ese tipo de manejo para los datos: “Los Datos Estructurados”.
Los datos estructurados se agrupan en dos bloques: Simples o Estáticos y Compuestos o
Dinámicos; estos permiten al almacenamiento de gran cantidad de datos dependiendo la
necesidad del usuario se hará uso de uno u otro.
Datos Estructurados
Simples o Estáticos Compuestos o

Dinámicos
Arreglos Listas
Unidimensionales Pilas
Bidimensionales Colas
Registros Listas Enlazadas
Conjuntos Árboles
Algunas de las características de ambos tipos de datos radica en que a los datos
simples o estáticos se les tiene que asignar el número de elementos que deberán admitir o
en todo caso esta predefinido, para acceder a los valores se hace a través de un índice
definido; mientras que los datos compuestos o estáticos no tiene límites, están limitados
únicamente por los recursos del computador en donde trabajen, para acceder a los valores
se hace a través de los denominados punteros.
Pag. 147
Fundamentos de programación
2. Arreglos de Datos
Son aquellas estructuras que permiten almacenar grandes cantidades de información
en una sola estructura, a la que se debe referenciar mediante un nombre e indicar el
índice para poder ya sea obtener, guardar, actualizar o eliminar un valor.
Estas estructuras poseen un conjunto finito de datos, son de tamaño fijo y ordenado de
elementos (valores) homogéneos.
Se dice:
a) Finito.- Por que posee un último elemento, es decir no puede expresarse como de
valores ilimitados.
b) Tamaño fijo.- Por que en tiempo de diseño se expresa el número de elementos

por el que estará compuesto, en algunos casos se puede volver a redimensionar en
arreglo.
c) Homogéneo.- Porque todos los elementos deben ser de un mismo tipo de dato.
Concepto general de arreglo

Un arreglo lineal es un conjunto finito de datos similares, que tienen el mismo nombre
de variable, para hacer referencia a ello se utiliza el nombre de variable seguido por su
índice.
El índice es un conjunto de n números consecutivos, normalmente 1,2,3, …,n.
Si al array se le nombra con la letra X, los elementos de X se puede denotar de tres
formas diferentes:
Por medio de la notación subindizada: X1, X2, X3, … , Xn
Utilizada generalmente en las ciencias matemáticas
A través de la notación patentizada: X(1), X(2), X(3), … , X(n)
O utilizando corchetes X[1], X[2], X[3], … , X[n]
Estas dos últimas se utilizan en ciencias de la computación.
Los arreglos en general se dividen en: Unidimensionales, Bidimensionales,
Tridimensionales
Arreglo estático unidimensional

Es un conjunto finito de elementos del mismo tipo, que tienen un mismo nombre de
variable. El nombre va acompañado de un índice que indica el número de orden del
elemento dentro del arreglo.
Pag. 148
Si tenemos un arreglo con el nombre de variable X, de n elementos, que almacena

números, este arreglo se denota como sigue:
X(1), X(2), X(3), X(4) … X(n) que son las referencias a los elementos del arreglo.
Gráficamente se representa, como se muestra en la gráfica
Ejemplo Gráfico
X
1 12 Inicio del Vector
2 4
3 5
4 77 Vector X para
n valores
5 -8
n 15 Final del Vector
Índices del
vector X Valores
almacenados
en el vector X
Arreglo estático bidimensional

variable. El nombre va acompañado de dos índices que indica el número de orden del
elemento dentro del arreglo. Este arreglo se expande tanto en filas como en columnas.
Si tenemos un arreglo con el nombre de variable Y de 2 filas por 3 columnas de
elementos, que almacena nombres de personas, este arreglo se denota como sigue:
Y(1,1), Y(1,2), Y(1,3)
Y(2,1), Y(2,2), Y(2,3)
Que son las referencias a los elementos del arreglo
Referencia a los elementos del arreglo.

Los elementos de un arreglo bidimensional se referencian con un subíndice para la fila y
otra para la columna.
Pag. 149
Arreglo estático tridimensional

variable. El nombre va acompañado de tres índices que indica el número de orden del
elemento dentro del arreglo. Este arreglo se expande filas, columnas y fondo.
Si tenemos un arreglo con el nombre de variable Z de 2 filas , 3 columnas y 2 fondos de
Z(1,1,1), Z(1,2,1), Z(1,3,1)
Z(2,1,2), Z(2,2,2), Z(2,3,2)
Que son las referencias a los elementos del arreglo
Los elementos de un arreglo tridimensional se referencian con un subíndice para la fila,

otra para la columna y una última para el fondo.
Representación de un arreglo unidimensional

Supongamos que tenemos un arreglo unidimensional al que se le ha denominado
“Deporte”, el cual tiene 5 elementos, y guarda datos de tipo texto. Este arreglo puede
dibujarse como se muestra en la gráfica.
Pag. 150
Representación de los arreglos lineales en memoria

Siguiendo con el ejemplo anterior como se muestra un arreglo lineal almacenado en la
memoria del computador. La memoria de un computador consiste en una secuencia de
celdas direccionables. Si el siguiente cuadro fuera la memoria podemos observar que un
arreglo se almacena en direcciones consecutivas.
Arreglos Valor de la variable

Nombre de la variable
Del gráfico se observan:
Los arreglos: Deporte, Fruta y Pais.
Las variables: A, B, C, D, E.
Declaración de un arreglo unidimensional

La declaración de un arreglo permite definir la estructura que tendrá el arreglo, tipo de
arreglo, tipo de dato del arreglo y número de elementos del arreglo. Para indicar la
cantidad de elementos del arreglo usted puede especificar el límite inferior y superior.
Sintaxis:
Dim Nombre ( Dimensión) As TipoDeDato
Pag. 151
Donde
Nombre: Es el nombre del arreglo
Dimensión: Define el número de elementos del arreglo
TipodeDato: Define el tipo de dato: Integer, string, date, etc.
También puede declarar

Dim Nombre( Li to Ls) As TipoDeDato
Dónde:
Li. Es el límite inferior del arreglo
Ls. Es el límite superior del arreglo
Si no define el límite inferior del arreglo por defecto es cero.
Los nombres de arreglos deben ser diferentes de los nombres de variables.
Ejemplos.
Dim X (10) As Integer
Declara un arreglo de 11 elementos, denotados como:
X(0), X(1), X(2), … , X(10)
El tipo de dato para todos los elementos del arreglo es entero. Gráficamente se muestra
como sigue:
Dim Y(1 to 10) As Integer

Y(1), Y(2), Y(3), … , Y(10)
El tipo de dato para todos los elementos del arreglo es entero. Gráficamente se muestra
como sigue:
Dim Z(1 to 5) as string

Z(1), Z(2), Z(3),Z(4),Z(5)
El tipo de dato para todos los elementos del arreglo es cadena. Gráficamente se muestra
como sigue:
Dim A(4 to 8) as string
Pag. 152

A(4), A(5), A(6),A(7),A(8)
El tipo de dato para todos los elementos del arreglo es cadena. Gráficamente se muestra
como sigue:
Operaciones sobre vectores

Sea el Vector:
X
1 2 3 4 5 6 7
14 4 1
a) Asignación. Consiste en guardar un dato a través de una operación.

Ejemplo:
X [4] = 66
X
1 2 3 4 5 6 7
14 4 1 66
b) Escritura. Consiste en guardar un dato a través de una operación de captura

de datos.
Ejemplo:
...
Capturar (X [5])
...
Se asumirá que el valor ingresado es 12
X
1 2 3 4 5 6 7
14 4 1 66 12
c) Lectura. Consiste en obtener los datos almacenados anteriormente en un

vector.
Ejemplo:
X
1 2 3 4 5 6 7
14 4 1 66 12
Pag. 153
...
W = X [2]
...
mostrar (W)
En la pantalla se observará el valor de W: 4
Que era el valor de X [2] en el vector respectivo.
Ejercicio de aplicación No. 1

Crear un algoritmo que permita el ingreso de 20 números a un arreglo X.
Solución:
1. Análisis.
i. ¿Qué te piden que realices?
Ingresar 20 números a un arreglo.
ii. ¿Qué datos necesito conocer?
Los números que se almacenarán.
2. Planteamiento Lógico.
Este es un problema básico que solo mostrará como se desarrolla el ingreso de
datos a un vector.
3. Definición de variables de entrada.

No se requieren variables de ingreso, este es directo al vector.
4. Definición de variables de salida.
No existe variable de salida ya que se trata de un simple ingreso de datos a un
vector.
5. Diseño de la Solución.
5.1 Pseudocódigo
INICIO
Declaración de variables
i: entero
X: arreglo[1 ..20] – entero
Para i = 1 hasta 20
Escribir(„Ingrese el número a guardar en el vector:‟)
Capturar( X[i])
Fin_Para
FIN
Pag. 154
5.2 Diagrama de Flujo
INICIO
Declaración de variables i: entero

Para i=1
Hasta 20
X[i]
FIN
5.3 Diseño del Formulario
5.4 Codificación del Programa

Public Class Form1
Dim X(0 To 19) As Integer
Dim i As Byte
Private Sub Button2_Click
Dim i As Integer
DataGridView1.RowCount = 1
DataGridView1.Item(0, 0).Value = "Indice"
DataGridView1.RowCount = DataGridView1.RowCount + 1
DataGridView1.Item(0, 1).Value = "Número"
For i = 1 To 19
X(i) = ListBox1.Items(i - 1)
DataGridView1.ColumnCount = DataGridView1.ColumnCount + 1
DataGridView1.Item(i, 0).Value = i
Pag. 155
DataGridView1.Item(i, 1).Value = X(i)

DataGridView1.Columns(i).Width = 30
Next i
End Sub
Dim i As Integer
ListBox1.Items.Clear()
For i = 1 To 20
ListBox1.Items.Add(Str(Math.Round(Rnd() * 100, 0)))
Next i
End Sub
Private Sub SAlir_Click
If MsgBox("Desea salir?", vbInformation + vbYesNo, "SALIDA") = vbYes Then
End
End If
End Sub
Private Sub Nuevo_Click
End Sub
End Class

Se van a ingresar dos notas de 100 alumnos, deberá hallar el promedio y almacenarlo en
un arreglo; una vez realizado ello, tendrá que recorrer el arreglo y determinar cuantos
alumnos aprobaron y cuantos desaprobaron. Diseñe el algoritmo.
Solución:
1. Análisis.
Calcular el promedio de motas de 100 alumnos y almacenarlo en un vector, luego
contabilizar cuantos aprobaron y cuantos desaprobaron.
Las notas de los alumnos.
El ingreso de las notas permitirá hallar el promedio el cual se almacenará en el
vector y finalmente se hará un recorrido al vector de modo que se pueda saber
cuantos alumnos aprobaron y cuantos desaprobaron.
Pag. 156

Se requerirá 2 variables para capturar las notas.
Se usarán las variables de tipo contador AP y DS para los aprobados y desaprobados
respectivamente.
5.1 Pseudocódigo
INICIO
N1, N2: entero
PR: real
X: arreglo[1 ..100] – real
Para i = 1 hasta 100
Escribir(„Ingrese la primera nota:‟)
Capturar( N1)
Escribir(„Ingrese la segunda nota:‟)
Capturar( N2)
PR = (N1 + N2)/2
X[i] = PR
Fin_Para
AP = 0
DS = 0
Si (X[i] >= 10.5) entonces
AP = AP + 1
Sino
DS = DS + 1
Fin_Si
Fin_Para
Mostrar(„El número de aprobados fue:‟, AP)
Mostrar(„El número de desaprobados fue:‟, DS)
FIN
Pag. 157
INICIO
i: entero
Para i=1
Hasta 20
N1, N2
PR = (N1 + N2)/2
X[i] = PR
AP = 0
DS = 0
Para i=1
Hasta 20
X[i] >= 10.5
DS = DS + 1 AP = AP + 1
AP, DS
FIN
Pag. 158

Public Class Form2
Dim N1 As Byte
Dim N2 As Byte
Dim PR As Single
Dim AP As Integer
Dim DS As Integer
Private Sub cmdgenerar_Click
For i = 0 To 19
N1 = Rnd() * 20
N2 = Rnd() * 20
PR = Format((N1 + N2) / 2, 0.0#)
DataGridView1.Item(0, i).Value = N1
DataGridView1.Item(1, i).Value = N2
DataGridView1.Item(2, i).Value = PR
X(i) = PR
Next i
End Sub
Private Sub cmdprocesar_Click
AP = 0
DS = 0
For i = 0 To 19
If (X(i) > 10) Then
AP = AP + 1
Else
DS = DS + 1
End If
Next i
TextBox1.Text = AP
TextBox2.Text = DS
End Sub
Private Sub cmdsalir_Click
End
End If
Pag. 159
End Sub
Private Sub cmdNuevo_Click
TextBox1.Text = 0
TextBox2.Text = 0
End Sub
End Class

Realizar un algoritmo que permita el ingreso de N números a un arreglo unidimensional,
calcular e imprimir el promedio de todos los números que se ingresarán al vector, tenga en
cuenta que solo se guardarán aquellos números que estén entre 10 y 80.
Solución:
1. Análisis.
Ingresar números a un arreglo, los cuales deben estar en el rango de 10 a 80.
La cantidad de números a ingresar y después los números que se ingresarán al
vector.
Inicialmente se debe recordar que los vectores deben estar definidos en un número
exacto de elementos que se almacenarán en este caso dice el problema que el número de
elementos a ingresar no se sabe así que habrá que definir un rango máximo para poder
empezar a trabajar después se deberá validar ese caso.
Ejemplo:
Se ha definido un arreglo de 1000 espacios, por lo tanto al momento de especificar el
número de elementos a ingresar no podrá sobrepasar los 1000 números (validar).
Luego se deberán ingresar los números que se almacenarán en el vector, tenga en cuenta
que solo se graban en el vector aquellos números que estén en el rango de 10 a 80 al
mismo tiempo se deberán ir acumulando para finalmente hallar el promedio de estos
números almacenados en el vector.

Se deberá saber el número de elementos a leer (N), y los números (NUM) que se
pretenden almacenar en el vector.
Pag. 160

La variable en donde se observará el promedio de los números que cumplieron con la
condición será: PR.
5. Diseño de la Solución. INICIO
5.1 Pseudocódigo
AC, C, i, N, NUM: entero
INICIO PR: real
Declaración de variables X: arreglo[1 ..500] – entero
AC, C, i, N, NUM: entero
PR: real
Hacer N
Escribir(„Ingrese el número de
elementos a evaluar:‟)
Capturar(N) N<=500
Hasta que (N <= 500)
AC = 0
C=0 AC = 0
Para i = 1 hasta N C=0
Escribir(„Ingrese número a
evaluar:‟)
Capturar( NUM) Para i=1
Hasta N
Si (NUM>=10 and NUM<=80)
entonces
C=C+1
X[C] = NUM NUM
AC = AC + X[C]
Fin_Si
Fin_Para NUM>=10 and
NUM<=80
PR = AC / C
Mostrar(„El promedio de los números
almacenados en el vector es:‟, PR) C=C +1
FIN X[C] = NUM
AC = AC + X[C]
PR=AC/C
PR
FIN
Pag. 161

Public Class Form1
Dim C As Byte
Dim i As Byte
Dim AC As Integer
Dim PR As Single
Private Sub cmdgenerar_Click
Dim i As Integer
For i = 1 To Val(TextBox1.Text)
ListBox1.Items.Add(Str(Format(Rnd() * 200, 0)))
Next i
End Sub
Private Sub cmdcarga_Click
AC = 0
C = 0
For i = 1 To Val(TextBox1.Text)
If (Val(ListBox1.Items(i - 1)) >= 10 And Val(ListBox1.Items(i - 1)) <= 80) Then
C = C +1
X(C) = ListBox1.Items(i - 1)
AC = AC + X(C)
ListBox2.Items.Add(Str(X(C)))
End If
Next i
If (C <> 0) Then
PR = AC / C
Else
MsgBox("El vector no tiene datos")
End If
TextBox2.Text = PR
End Sub
Private Sub TextBox1_KeyPress
TextBox1.KeyPress
If e.KeyChar.ToString = 13 Then
cmdgenerar.Focus()
Pag. 162
End If
End Sub
Private Sub TextBox1_LostFocus
If (Val(TextBox1.Text) < 1 Or Val(TextBox1.Text) > 500) Then
MsgBox("error de ingreso")
TextBox1.Text = 1
TextBox1.Focus()
End If
End Sub
Private Sub Button1_Click ListBox1.Items.Clear()
TextBox1.Text = 0
TextBox2.Text = 0
End Sub
End
End If
End Sub
End Class

Desarrolle un algoritmo que permita ingresar 50 números a un arreglo X y 50 números a
otro arreglo Y, una vez cargados los dos vectores, deberá hallar cual fue el mayor
número almacenado en el arreglo X y cual fue el menor número almacenado en el
arreglo Y; finalmente sumarlos y mostrarlos.
Solución:
1. Análisis.
Hallar el mayor y menor numero ingresado en dos vectores X y Y, luego sumarlos
y mostrarlos.
Los 50 números que se ingresarán en X y Y.
Deberá cargar los vectores X y Y con 50 números cada uno, luego desarrollar el
código que permita obtener el mayor y menor número de los vectores para
finalmente sumarlos y mostrarlos.

La captura de los números será de manera directa a los vectores respectivos.
En la variable S se guardará la suma del mayor (MY) y menor(MN) número de los
vectores respectivos.
Pag. 163
5. Diseño de la Solución. INICIO

5.1Pseudocódigo
INICIO MY, MN, i, S: entero
Declaración de variables X: arreglo[1 ..50] – entero
Y: arreglo[1 ..50] – entero
MY, MN, i, S: entero
Y: arreglo[1 ..50] – entero Para i=1
Para i = 1 hasta 50 Hasta 50
Escribir(„Ingrese número para el vector
X:‟)
Capturar(X[i])
Escribir(„Ingrese número para el vector
Y:‟) X[i], Y[i]
Capturar(Y[i])
Fin_Para
MY = X[1]
MN = Y[1]
Para i = 2 hasta 50 MY = X[1]
Si (MY < X[i]) entonces MN = Y[1]
MY = X[i]
Fin_Si Para i=2
Si (MN > Y[i]) entonces Hasta 50
MN = Y[i]
Fin_Si
Fin_Para
S = MY + MN MY < X[i]
Mostrar(„La suma del mayor y menor
elemento es:‟, S)
FIN MY = X[i]
MN > Y[i]
MN = Y[i]
S = MY + MN
AP, DS
FIN
Pag. 164
5.2Diseño del Formulario
5.3Codificación del Programa

Public Class Form1
Dim Y(0 To 49) As Integer
Dim i As Byte
Dim Mayor As Integer
Dim MN As Integer
Dim S As Integer
Private Sub cmdcargar_Click
Randomize()
Dim i As Integer
DataGridView1.Item(0, 0).Value = "X(i)"
DataGridView1.Item(0, 1).Value = "Y(i)"
For i = 1 To 49
DataGridView1.Item(i, 0).Value = Format(Rnd() * 100, 0)
X(i) = DataGridView1.Item(i, 0).Value
Y(i) = DataGridView1.Item(i, 1).Value
Next i
End Sub
Dim i As Integer
Mayor = X(1)
MN = Y(1)
For i = 1 To 49
If (Mayor < X(i)) Then
Mayor = X(i)
End If
If (MN > Y(i)) Then
MN = Y(i)
End If
Next i
TextBox1.Text = Mayor
TextBox2.Text = MN
S = Mayor + MN
TextBox3.Text = S
End Sub
Pag. 165

End
End If
End Sub
Private Sub Button3_Click Dim i As Integer
For i = 1 To 49
DataGridView1.Item(i, 0).Value = ""
DataGridView1.Item(i, 1).Value = ""
Next i
TextBox1.Text = 0
TextBox2.Text = 0
TextBox3.Text = 0
End Sub
Private Sub Form1_Load
DataGridView1.ColumnCount = 50
End Sub
End Class
Métodos de Ordenamiento
Los métodos de ordenamiento tienen por finalidad mostrar a los elementos de un vector
ordenados ya sea en forma ascendente o descendente. Para lograr ello se cuentan con
diversos métodos entre los mas conocidos encontramos:
1) Método de la Inserción (Burbuja)

Este método consiste en ir preguntando empezando desde el primer elemento del
vector con el resto de elementos hasta llegar al final, si la pregunta (ya sea si es
mayor o no) es afirmativa se deberá de intercambiar los elementos evaluados en las
posiciones respectivas, sin alterar el resto de elementos; tenga en cuenta que las
preguntas se realizan desde el inicio hasta el final con los elementos que quedan.
Gráficamente se observaría de la siguiente manera:
X
1 2 3 4 5
14 4 1 66 5
X[1]>X[2] si es mayor, intercambio
X
1 2 3 4 5
4 14 1 66 5
X
1 2 3 4 5
1 14 4 66 5
Pag. 166
X[1]>X[4] no es mayor
X
1 2 3 4 5
1 14 4 66 5
X
1 2 3 4 5
1 4 14 66 5
X
1 2 3 4 5
1 4 14 66 5
X
1 2 3 4 5
1 4 5 66 14
X
1 2 3 4 5
1 4 5 14 66
Por lo tanto el vector quedaría de la siguiente manera: (ordenado de forma
ascendente).
X
1 2 3 4 5
1 4 5 14 66
El Pseudocódigo asociado a este método de ordenamiento es:
Para i = 1 hasta 4
Para j = i + 1 hasta 5
Si (X[i] > X[j]) entonces
AUX = X[j]
X[j] = X[i]
X[i] = AUX
Fin_Si
Fin_Para
Fin_Para
Pag. 167
En general:
Para i = 1 hasta n – 1
Para j = i + 1 hasta n
AUX = X[j]
X[j] = X[i]
X[i] = AUX
Fin_Si
Fin_Para
Fin_Para
Si desea ordenar en forma descendente se deberían cambiar el operador de relación

de la pregunta SI, es decir “>” por “<”.
2) Método de Shell
Consiste en ir comparando los elementos no contiguos sino por saltos de mayor
tamaño y de esa manera se consigue un ordenamiento mas rápido, para ello se debe
fijar el tamaño de los saltos constantes que deberán de ser de mas de una posición.
Es denominado también de ordenamiento por disminución incremental, fue
nombrado así debido a su inventor Donald Shell.
Ordena subgrupos de elementos separados K unidades (respecto de su posición en
el arreglo) del arreglo original. El valor K es llamado incremento.
Después de que los primeros K subgrupos han sido ordenados (generalmente
utilizando INSERCION DIRECTA), se escoge un nuevo valor de K más pequeño,
y el arreglo es de nuevo partido entre el nuevo conjunto de subgrupos. Cada uno de
los subgrupos mayores es ordenado y el proceso se repite de nuevo con un valor
más pequeño de K.
Eventualmente el valor de K llega a ser 1, de tal manera que el subgrupo consiste
de todo el arreglo ya casi ordenado.
Al principio del proceso se escoge la secuencia de decrecimiento de incrementos; el
último valor debe ser 1.
"Es como hacer un ordenamiento de burbuja pero comparando e intercambiando
elementos."
Cuando el incremento toma un valor de 1, todos los elementos pasan a formar parte
del subgrupo y se aplica inserción directa.
El método se basa en tomar como salto N/2 (siendo N el número de elementos) y
luego se va reduciendo a la mitad en cada repetición hasta que el salto o distancia
vale 1.
El Pseudocódigo asociado a este método de ordenamiento es:
Pag. 168
Algoritmo Shell Sort

INICIO
A : arreglo[1..100] – entero
Inter, N, i, Temp, SW: entero
Escribir(„Ingrese número de elementos de la matriz:‟)
Capturar(N)
Inter = N + 1
Hacer
Inter = Inter Div 2
Hacer
SW = 0
i =1
Hacer
Si (A[i] < A[i + Inter]) entonces
Temp = A[i]
A[i] = A[i + Inter]
A[i + Inter] = Temp
SW = 1
Fin_Si
i =i +1
Hasta que (i + Inter = N + 1)
Hasta que (SW = 0)
Hasta que (Inter = 1)
FIN

Desarrolle un algoritmo que permita ingresar 100 números, en un arreglo X se deberán
ir almacenando aquellos que son múltiplos de 3; finalmente ordenar el arreglo.
Solución:
1. Análisis.
Ingresar 100 números de los cuales solo los que son múltiplos de 3 se guardan en
un arreglo X, para finalmente ordenarlos.
Conocer cuales los 100 números.
Pag. 169
Se deberá cargar los números en el arreglo, teniendo en cuenta que solo
ingresan los que son múltiplos de 3 (resto de la división 0), finalmente se
deberá ordenarlos.

El ingreso será directamente en el vector X.
No existen variables de salida, ya que el tratamiento de los datos es directo en
el vector.
5.1 Pseudocódigo
INICIO
N, i, j, C, AUX: entero
C=0
Escribir(„Ingrese número:‟)
Capturar(N)
Si (N mod 3) = 0 then
C=C+1
X [C] = N
Fin_Si
Fin_Para
Para i = 1 hasta C – 1
Para j = i + 1 hasta C
AUX = X[j]
X[j] = X[i]
X[i] = AUX
Fin_Si
Fin_Para
Fin_Para
FIN
Pag. 170
INICIO
C=0
Para i=1
Hasta 100
N mod 3 = 0
C=C +1
X [C] = N
Para i=1
Hasta C-1
Para j=i+1
Hasta C
X[i] > X[j]
AUX = X[j]
X[j] = X[i]
X[i] = AUX
FIN
Pag. 171

Public Class Form1
Dim AUX As Integer
Dim C As Byte
Dim i As Byte
Dim j As Byte

Dim i As Integer
For i = 1 To 100
ListBox1.Items.Add(Format(Rnd() * 100, 0))
Next i
End Sub
End
End If
End Sub
Private Sub cmdnuevo_Click
End Sub
Dim i, j As Integer
For i = 1 To C - 1
For j = i + 1 To C
If (X(i) > X(j)) Then
AUX = X(j)
X(j) = X(i)
X(i) = AUX
End If
Next j
Next i
For i = 1 To C
ListBox3.Items.Add(X(i))
Pag. 172
Next i
End Sub
Dim i As Integer
C = 0
For i = 1 To 99
If ListBox1.Items(i - 1) Mod 3 = 0 Then
C = C + 1
X(C) = ListBox1.Items(i - 1)
ListBox2.Items.Add(X(C))
End If
Next i
End Sub
End Class

Diseñe un algoritmo que permita ingresar 40 números a cada uno de los arreglos X y Y,
luego en un tercer arreglo se deberá cargar la suma solamente de aquellos números que
sean múltiplos de 2 teniendo en cuenta que estos deberán estar en las mismas posiciones
(índices). Adicionalmente ordenar el vector creado.
Ej:
X
1 2 3 ... 40
1 4 5 66
Y
1 2 3 ... 40
4 2 2 6
Z
1 2
6 72
Solución:
1. Análisis.
Ingresar números a 2 arreglos, luego se deberán analizar para finalmente crear
un tercer arreglo en base a los anteriores.
Cargar los 2 arreglos a analizar con 40 números cada uno.
Pag. 173
Para poder cargar el tercer arreglo se deberá observar si los números que se
encuentran en las mismas posiciones de cada arreglo son pares, solo en ese caso se
suman y se guarda el resultado en el tercer arreglo (ver ejemplo).

El ingreso será directamente a los vectores X y Y.
No existen variables de salida, ya que el tratamiento de los datos será directamente al
tercer vector.
5.1 Pseudocódigo
INICIO
Z: arreglo[1 ..40] – entero
Para i = 1 hasta 40
Escribir(„Ingrese número para el vector X:‟)
Capturar(X[i])
Escribir(„Ingrese número para el vector Y:‟)
Capturar(Y[i])
Fin_Para
C=0
Para i = 1 hasta 40
Si (X[i] mod 2 = 0) and (Y[i] mod 2 = 0) entonces
C= C + 1
Z[C] = X[i] + Y[i]
Fin_Si
Fin_Para
Para i = 1 hasta C – 1
Para j = i + 1 hasta C
Si (Z[i] > Z[j]) entonces
AUX = Z[j]
Z[j] = Z[i]
Z[i] = AUX
Fin_Si
Fin_Para
Fin_Para
FIN
Pag. 174
INICIO
Z: arreglo[1 ..40] – entero
Para i=1
Hasta 40
X[i], Y[i]
C=0
Para i=1
Hasta 40
X[i] mod 2 = 0 and

Y[i] mod 2 = 0
C=C +1
Z[C] = X[i] + Y[j]
Para i=1
Hasta C-1
Para j=i+1
Hasta C
Z[i] > Z[j]
AUX = Z[j]
Z[j] = Z[i]
Z[i] = AUX
FIN
Pag. 175

Public Class Form2
Dim Z(0 To 39) As Integer
Dim AUX As Integer
Dim i As Byte
Dim j As Byte
Dim C As Byte
Private Sub cmdvectorxy_Click
Dim i As Integer
For i = 0 To 39
X(i) = DataGridView1.Item(i, 0).Value
Y(i) = DataGridView1.Item(i, 1).Value
Next i
End Sub
Dim i As Integer
For i = 0 To 39
Pag. 176
Next i
End Sub
DataGridView1.Rows.Clear()
End Sub
Private Sub cmdvectorz_Click
Dim i As Integer
'DataGridView2.Item(0, 0).Value = "Z(i)"
C = 0
For i = 0 To 39
If (X(i) Mod 2 = 0) And (Y(i) Mod 2 = 0) Then
C = C+ 1
Z(C) = X(i) + Y(i)
DataGridView2.Item(C, 0).Value = Z(C)
End If
Next i
End Sub
End
End If
End Sub
Private Sub cmdordenar_Click
Dim i, j As Integer
If (C > 0) Then
For i = 1 To C - 1
For j = i + 1 To C
If (Z(i) > Z(j)) Then
AUX = Z(j)
Z(j) = Z(i)
Z(i) = AUX
End If
Next j
Next i
For i = 1 To C
DataGridView3.Item(i, 0).Value = Z(i)
Next i
Else
MsgBox("No tiene datos el vector Z")
End If
End Sub
End Class
Pag. 177
II. Arreglos Bidimensionales

Denominado también matriz bidimencional, este tipo de arreglos es utilizado
para poder almacenar datos como si se tratase de tablas, es decir su puede almacenar
grandes volúmenes de datos con la sola definición de una matriz de este tipo.
Si tenemos un arreglo con el nombre de variable X de 2 filas por 3 columnas de
X(1,1), X(1,2), X(1,3)
X(2,1), X(2,2), X(2,3)
Simbología
X [ i, j ]
Donde:
- X : Nombre del vector.
- i : Índice del vector para las filas.
- j : Índice del vector para las columnas.
Ejemplo Gráfico
Columnas
X 1 2 3 4 ... n-1 n
1 3 56 -14 2 1 12
2 5 -8 0 9 22 7 Índices de
3 Columna
7 3 22 3 8 -7
Filas 4 6 21 0 65 19 2
5 15 12 14 42 20 13
...
n-1 4 11 72 4 1 22
n 6 12 86 62 3 54
Índices de
Fila
Pag. 178
Operaciones sobre matrices bidimencionales

Sea la matriz:
X
1 2 3 4
1 3 56 -14 2
2 5 -8 0 9
3 7 3 22 3
4 6 21 0 65
5 15 12 14 42
a) Recorrido por Filas. Consiste en trabajar con los valores de la primera fila y así
sucesivamente con el resto de filas hasta llegar al final.
Ejemplo:
Para f = 1 hasta 5
Para c = 1 hasta 4
Mostrar(„Los valores por filas :‟, X[f,c]
Fin_Para
Fin_Para
b) Recorrido por Columnas. Consiste en trabajar con los valores de la primera
columna y así sucesivamente con el resto de columnas hasta llegar al final.
Ejemplo:
Para c = 1 hasta 4
Para f = 1 hasta 5
Mostrar(„Los valores por columnas :‟, X[f,c]
Fin_Para
Fin_Para

Crear un algoritmo que permita el ingreso de números a un arreglo de 10 filas por 20
columnas.
Solución:
1. Análisis.
Ingresar números a una matriz de 10*20.
Los números que se desean ingresar.
Pag. 179
Este es un problema básico que solo mostrará como se desarrolla el ingreso de datos
a la matriz.

No se requiere de una variable el ingreso es directo a matriz.
No existe variable de salida ya que se trata de un simple ingreso de datos a una
matriz.
5.1 Pseudocódigo
INICIO
f, c: entero
X: arreglo[1 ..10, 1 .. 20] – entero
Para f = 1 hasta 10
Para c = 1 hasta 20
Escribir(„Ingrese el número a guardar en la matriz:‟)
Capturar( X[f,c])
Fin_Para
Fin_Para
FIN

INICIO
F, c : entero
X: arreglo[1 ..10,1 ..20] – entero
Para f=1
Hasta 10
Para c=1
Hasta 20
X[f,c]
FIN
Pag. 180

Public Class Form3
Dim X(0 To 9, 0 To 19) As Integer
Dim f As Byte
Dim c As Byte
Dim c, f As Integer
For c = 1 To 19
For f = 1 To 9
DataGridView1.Item(c - 1, f - 1).Value = Format(Rnd() * 100, 0)
Next
Next
End Sub
Private Sub Form3_Load Dim i As Integer
For i = 0 To 19
Next i
End Sub
End
End If
End Sub
End Sub
End Class
Pag. 181

Desarrolle un algoritmo que permita ingresar: tres notas(nota de practica, nota de
trabajo y examen parcial) de 100 alumnos a una matriz bidimencional, en la misma se
deberá ir calculando el promedio y a medida que se va operando se deberá mostrar un
mensaje: aprobado o desaprobado.
Ej: 13, 15, 14.................... 14.......... “Aprobado”
Solución:
1. Análisis.
Ingresar notas a una matriz y luego calcular el promedio además mostrar una
observación.
Las notas que se pretenden evaluar.
El ingreso será de manera directa a la matriz, luego se deberá ir calculando el
promedio para ser almacenado de manera instantánea para finalmente mostrar
el mensaje dependiendo del promedio obtenido.
La matriz esta compuesta por 4 columnas: 3 para las notas 1 para el promedio
y 100 filas para el ingreso de los datos anteriores.

No se requiere de una variable, el ingreso es directo a matriz.
No existe variable de salida ya que se trata de un simple ingreso de datos a
una matriz.
5.1 Pseudocódigo
INICIO
f: entero
X: arreglo[1 ..100, 1 .. 4] – entero
Para f = 1 hasta 100
Escribir(„Ingrese la nota de practica:‟)
Capturar( X[f,1])
Escribir(„Ingrese la nota de trabajo:‟)
Capturar( X[f,2])
Escribir(„Ingrese la nota de examen:‟)
Capturar( X[f,3])
X[f,4] = (X[f,1] + X[f,2] + X[f,3]) / 3
Si (X[f,4] >= 11) entonces
Pag. 182
Mostrar(„Aprobado‟)
Sino
Mostrar(„Desaprobado‟)
Fin_Si
Fin_Para
FIN

INICIO
F, c : entero
X: arreglo[1 ..100,1 ..4] – entero
Para f=1
Hasta 100
X[f,1], X[f,2], X[f,3]
X[f,4] = (X[f,1] + X[f,2] + X[f,3]) / 3
X[f,4] >= 11
„Desaprobado‟ „Aprobado‟
FIN
Pag. 183

Public Class Form4
Dim f As Byte
Dim c As Byte
Dim f, c As Integer
For f = 0 To 99
For c = 1 To 3
DataGridView1.Item(c - 1, f).Value = Format(Rnd() * 20, 0)
X(f, c) = DataGridView1.Item(c - 1, f).Value
Next c
Next f
End Sub
Private Sub cmdcalcular_Click
For f = 0 To 99
DataGridView1.Item(3, f).Value = Format((X(f, 1) + X(f, 2) + X(f, 3)) / 3, 0)
If Val(DataGridView1.Item(3, f).Value) >= 11 Then
DataGridView1.Item(4, f).Value = "Aprobado"
Else
DataGridView1.Item(4, f).Value = "Desaprobado"
End If
Next f
End Sub
End Sub
End
End If
End Sub
DataGridView1.Columns(0).HeaderText = "Práctica"
DataGridView1.Columns(1).HeaderText = "Trabajo"
DataGridView1.Columns(2).HeaderText = "Examen"
DataGridView1.Columns(3).HeaderText = "Promedio"
DataGridView1.Columns(4).HeaderText = "Estado"
For i = 0 To 3
DataGridView1.Columns(i).DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight
Next i
DataGridView1.Columns(4).DefaultCellStyle.BackColor = Color.Salmon
DataGridView1.Columns(3).DefaultCellStyle.BackColor = Color.AliceBlue
End Sub
End Class
Pag. 184

Diseñar un algoritmo que permita el ingreso de números a una matriz cuadrada de 100
por 100, luego la suma de los elementos que se encuentran en las diagonales principal y
secundaria se deberá almacenar en un vector Y, tenga en cuenta que solamente se
podrán registrar aquellas sumas que sobrepasen el valor de 10.
Debe validar el ingreso de los números a la matriz, estos deberán ser positivos.
Solución:
1. Análisis.
La suma de los valores que se encuentren en las diagonales principal y
secundaria de una matriz cuadrada, dicha suma se debe almacenar en un vector
siempre en cuando este valor sobrepase de 10.
Los números respectivos en la matriz cuadrada.
Se deberá inicialmente validar el ingreso de los números a la matriz ya que tienen
que ser positivos.
Para poder obtener los números de la diagonal principal y secundaria solamente
debe tener cuidado con los índices de fila – columna.
Una vez que se sabe cuales son ahora deberá sumarlos, pero tenga en cuenta que
antes de registrarlos en el vector deberá verificar que este valor sobre pase 10, solo
en ese caso se registrará en el vector.

No existe variable de salida ya que se trata de un simple ingreso de datos a una
matriz.
5.1 Pseudocódigo
INICIO
f, c, R: entero
X: arreglo[1 ..100, 1 .. 100] – entero
Pag. 185

Para c = 1 hasta 100
Hacer
Escribir(„Ingrese el número:‟)
Capturar(X[f,c])
Hasta que (X[f,c] > 0)
Fin_Para
Fin_Para
R=0
Para c = 1 hasta 100
Si (f = c) entonces
Si ((X[f,c] + X[f,101-f]) >10) entonces
R=R+1
Y[R] = X[f,c] + X[f,101-f]
Fin_Si
Fin_Si
Fin_Para
Fin_Para
Para f = 1 hasta R
Mostrar(„numero del vector:‟, Y[f])
Fin_Para
FIN
Pag. 186
INICIO
f, c, R: entero
X: arreglo[1..100,1..100] – entero
Para f=1
Hasta 100
Para c=1
Hasta 100
X[f,c]
X[f,c] > 0
R=0
Para f=1
Hasta 100
Para c=1
Hasta 100
(X[f,c]+X[f,101-f]) >10
f =c
R=R +1
Y[R] = X[f,c] + X[f,101-f]
Para f=1
Hasta R
Y[f]
FIN
Pag. 187

Public Class Form1
Dim f As Byte
Dim c As Byte
Dim R As Byte
Dim c, f As Integer
For f = 1 To 99
For c = 1 To 99
X(f, c) = DataGridView1.Item(c - 1, f - 1).Value
Next c
Next f
End Sub
End Sub
Private Sub cmdcalcular_Click
Dim c, f As Integer
R=0
For f = 1 To 99
For c = 1 To 99
If (f = c) Then
If ((X(f, c) + X(f, 100 - f)) > 10) Then
R=R+1
Y(R) = X(f, c) + X(f, 100 - f)
End If
End If
Next c
Next f
For i = 1 To R
ListBox1.Items.Add(Y(i))
Next i
End Sub
Pag. 188

End
End If
End Sub
For i = 0 To 99
DataGridView1.Columns(i).DefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight
Next i
End Sub
End Class

En una matriz bidimensional de 20 por 30, se ingresarán letras, luego muestre cuantas
veces se repitió la letra “A”, la letra “V” y la letra “E”.
Solución:
1. Análisis.
Ingresar letras a una matriz y luego averiguar cuantas de las letras ingresadas
fueron A, V y E.
Las letras que se ingresarán en la matriz cuadrada.
Se debe ingresar las letras en la matriz, luego ir preguntando si cumple con la
condición es decir si es A, V o E, de modo que se puedan ir contando para mostrar al
final cuantos eran.

Las variable de salida serán 3 contadores: C1, C2 y C3.
5.1 Pseudocódigo
INICIO
Pag. 189
f, c, C1, C2, C3: entero

X: arreglo[1 ..20, 1 .. 30] – caracter
Para f = 1 hasta 20
Para c = 1 hasta 30
Escribir(„Ingrese el carácter alfabético:‟)
Capturar(X[f,c])
Fin_Para
Fin_Para
C1 = 0
C2 = 0
C3 = 0
Para f = 1 hasta 20
Para c = 1 hasta 30
Si (X[f,c] = “A” entonces
C1= C1 + 1
Sino
Si (X[f,c] = “V” entonces
C2= C2 + 1
Sino
Si (X[f,c] = “E” entonces
C3= C3 + 1
Fin_Si
Fin_Si
Fin_Si
Fin_Para
Fin_Para
Mostrar(„Fueron letras A:‟, C1)
Mostrar(„Fueron letras V:‟, C2)
Mostrar(„Fueron letras E:‟, C3)
FIN
Pag. 190

INICIO
f, c, C1, C2, C3: entero

X: arreglo[1 ..20, 1 .. 30] – caracter
Para f=1
Hasta 20
Para c=1
Hasta 30
X[f,c]
C1 = 0; C2 = 0; C3 = 0
Para f=1
Hasta 20
Para c=1
Hasta 30
X[f,c] = “A”
X[f,c] = “V” C1 = C1 + 1
X[f,c] = “E” C2 = C2 + 1
C3 = C3 + 1
C1, C2, C3
FIN
Pag. 191

Public Class Form2
Dim X(0 To 19, 0 To 29) As String
Dim f As Byte
Dim c As Byte
Dim C1 As Byte
Dim C2 As Byte
Dim C3 As Byte
Dim Wlet As Byte
Private Sub CmdSalir_Click()
End
End If
End Sub
Dim c, f As Integer
For f = 1 To 19
For c = 1 To 29
Do
Wlet = Format(Rnd() * 100, 0)
Loop Until (Wlet >= 65 And Wlet <= 90)
DataGridView1.Item(c - 1, f - 1).Value = Chr(Wlet)
Next c
Next f
End Sub
C1 = 0
C2 = 0
C3 = 0
For f = 1 To 19
For c = 1 To 29
If (X(f, c) = "A") Then
C1 = C1 + 1
Else
If (X(f, c) = "V") Then
C2 = C2 + 1
Else
Pag. 192
If (X(f, c) = "E") Then

C3 = C3 + 1
End If
End If
End If
Next c
Next f
TextBox1.Text = C1
TextBox2.Text = C2
TextBox3.Text = C3
End Sub
TextBox1.Text = 0
TextBox2.Text = 0
TextBox3.Text = 0
End Sub
For i = 0 To 29
Next i
End Sub
End Class

Diseñe un algoritmo que permita el ingreso de números a una matriz bidimensional
cuadrada X de 20 por 20, luego la suma de todos los valores de las columnas impares se
deberán almacenar en un vector Y.
Solución:
1. Análisis.
Ingrese números a un matriz de 20 por 20 y aquellos valores que forman parte de
la columna impar de sumaran y se guardan en un vector.
Los números que se guardan en la matriz.
Una vez que se encuentran los números en la matriz, se deberá generar una condición
que involucre a los indices de las columnas y si estos son impares sus valores a
asociados se deben ir acumulando para que una vez que se termina de recorrer la fila
se guarde dicho valor en el vector.
Ej: Sean estos los datos: 12, 15, 7, 16, 12, 5, 0, 17
Pag. 193
Se suman: 12 + 7 + 12 + 0 = 31 (Este valor se almacena en el vector respectivo)

No se requieren de variables de salida, los resultados se almacenan en el vector final.
5.1 Pseudocódigo
INICIO
f, c, AC, M: entero
X: arreglo[1 ..20, 1 .. 20] – entero
Para f = 1 hasta 20
Para c = 1 hasta 20
Escribir(„Ingrese el número:‟)
Capturar(X[f,c])
Fin_Para
Fin_Para
AC = 0
M= 0
Para c = 1 hasta 20
Si (c mod 2 <> 0) entonces
Para f = 1 hasta 20
AC= AC + X[f,c]
Fin_Para
Fin_Si
M= M+ 1
Y[M] = AC
Fin_Para
Para f = 1 hasta 10
Mostrar(„Numero:‟, Y[f])
Fin_Para
FIN
Pag. 194
INICIO
f, c, AC: entero
X: arreglo[1 ..20, 1 .. 20] – entero
Para f=1
Hasta 20
Para c=1
Hasta 20
X[f,c]
AC = 0, M = 0
Para c=1
Hasta 20
c mod 2=0
Para f=1
Hasta 20
AC= AC + X[f,c]
M= M+ 1
Y[f] = AC
Para f=1
Hasta 10
Y[f]
FIN
Pag. 195

Public Class Form3
Dim X(0 To 19, 0 To 19) As Byte
Dim f As Byte
Dim c As Byte
Dim M As Byte
Dim AC As Integer
Dim c, f As Integer
For f = 1 To 19
For c = 1 To 19
Next c
Next f
End Sub
End Sub
Private Sub cmdvisualizar_Click
Dim c, f As Integer
AC = 0
M=0
For c = 1 To 19
If (c Mod 2 <> 0) Then
For f = 1 To 19
AC = AC + X(f, c)
Next f
Y(M) = AC
M=M+1
End If
Next c
For f = 1 To 9
ListBox1.Items.Add(Y(f))
Next f
End Sub
Pag. 196

End
End If
End Sub
Private Sub Form3_Load(ByVal sender As System.Object, ByVal e As
System.EventArgs) Handles MyBase.Load
For i = 0 To 19
Next i
End Sub
End Class
Pag. 197

Fund. de Prog. 4 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Fund. de Prog. 4 PDF

Cargado por

Copyright:

Formatos disponibles

Seamos realistas y hagamos lo

Ernesto Che Guevara

Simples o Estáticos Compuestos o

b) Tamaño fijo.- Por que en tiempo de diseño se expresa el número de elementos

Concepto general de arreglo

Arreglo estático unidimensional

Si tenemos un arreglo con el nombre de variable X, de n elementos, que almacena

n 15 Final del Vector

Arreglo estático bidimensional

Referencia a los elementos del arreglo.

Arreglo estático tridimensional

Los elementos de un arreglo tridimensional se referencian con un subíndice para la fila,

Representación de un arreglo unidimensional

Representación de los arreglos lineales en memoria

Arreglos Valor de la variable

Declaración de un arreglo unidimensional

También puede declarar

Dim Y(1 to 10) As Integer

Dim Z(1 to 5) as string

Dim A(4 to 8) as string

Declara un arreglo de 5 elementos, denotados como:

Operaciones sobre vectores

a) Asignación. Consiste en guardar un dato a través de una operación.

b) Escritura. Consiste en guardar un dato a través de una operación de captura

c) Lectura. Consiste en obtener los datos almacenados anteriormente en un

Ejercicio de aplicación No. 1

3. Definición de variables de entrada.

5.2 Diagrama de Flujo

Declaración de variables i: entero

5.3 Diseño del Formulario

5.4 Codificación del Programa

DataGridView1.Item(i, 1).Value = X(i)

Ejercicio de aplicación No. 2

3. Definición de variables de entrada.

5.2 Diagrama de Flujo

X[i] >= 10.5

5.3 Diseño del Formulario

5.4 Codificación del Programa

Ejercicio de aplicación No. 3

3. Definición de variables de entrada.

4. Definición de variables de salida.

5.2 Diagrama de Flujo

5.3 Diseño del Formulario

5.4 Codificación del Programa

Ejercicio de aplicación No. 4

3. Definición de variables de entrada.

5. Diseño de la Solución. INICIO

5.2Diseño del Formulario

5.3Codificación del Programa

Private Sub Button4_Click

1) Método de la Inserción (Burbuja)

Si desea ordenar en forma descendente se deberían cambiar el operador de relación

Algoritmo Shell Sort

Ejercicio de aplicación No. 5

3. Definición de variables de entrada.

5.2 Diagrama de Flujo

X[i] > X[j]

5.3 Diseño del Formulario

5.4 Codificación del Programa

Private Sub Button1_Click

Ejercicio de aplicación No. 6

3. Definición de variables de entrada.

X[i] mod 2 = 0 and