EVAP 7

METODOS DE ORDENAMIENTO

Debido a que las estructuras de datos son utilizadas para almacenar información, para poder recuperar esa información de manera eficiente es deseable que aquella esté ordenada. Existen varios métodos para ordenar las diferentes estructuras de datos básicas.
En general los métodos de ordenamiento no son utilizados con frecuencia, en algunos casos sólo una vez. Hay métodos muy simples de implementar que son útiles en los casos en dónde el número de elementos a ordenar no es muy grande (ej, menos de 500 elementos). Por otro lado hay métodos sofisticados, más difíciles de implementar pero que son más eficientes en cuestión de tiempo de ejecución.

Los métodos sencillos por lo general requieren de aproximadamente n x n pasos para ordenar n elementos.

Los métodos simples son: insertion sort (o por inserción directa) selection sort, bubble sort, y shellsort, en dónde el último es una extensón al insertion sort, siendo más rápido. Los métodos más complejos son el quick-sort, el heap sort, radix y address-calculation sort. El ordenar un grupo de datos significa mover los datos o sus referencias para que queden en una secuencia tal que represente un orden, el cual puede ser numérico, alfabético o incluso alfanumérico, ascendente o descendente.

Se ha dicho que el ordenamiento puede efectuarse moviendo los registros con las claves. El mover un registo completo implica un costo, el cual se incrementa conforme sea mayor el tamaño del registro. Es por ello que es deseable evitar al máximo el movimiento de los registros. Una alternativa es el crear una tabla de referencias a los registros y mover las referencias y no los datos. A continuación se mostrarán los métodos de ordenamiento empezando por el más sencillo y avanzando hacia los mas sofisticados
La eficiencia de los algoritmos se mide por el número de comparaciones e intercambios que tienen que hacer, es decir, se toma n como el número de elementos que tiene el arreglo a ordenar y se dice que un algoritmo realiza O(n2) comparaciones cuando compara n veces los n elementos, n x n = n2. 


ORDENAMIENTO DE BURBUJA

La Ordenación de burbuja (Bubble Sort en inglés) es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmo obtiene su nombre de la forma con la que suben por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más sencillo de implementar.
burbuja 
#include<stdio.h>
#include<conio.h>
int a[3]={3,2,1};
int i,j,aux,n=3;
void main(){
clrscr();
for(i=0;i<=n;i++){
for(j=0;j<n-1;j++){
if(a[j]>a[j+1]){
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
for(i=0;i<3;i++)
{
printf("%d",a);
}
getch();
} 

ORDENAMIENTO SHELL

 El ordenamiento Shell (Shell sort en inglés) es un algoritmo de ordenamiento. El método se denomina Shellen honor de su inventor Donald Shell. Su implementación original, requiere O(n²) comparaciones e intercambios en el peor caso. Un cambio menor presentado en el libro de V. Pratt produce una implementación con un rendimiento de O(n log² n) en el peor caso. Esto es mejor que las O(n²) comparaciones requeridas por algoritmos simples pero peor que el óptimo O(n log n). Aunque es fácil desarrollar un sentido intuitivo de cómo funciona este algoritmo, es muy difícil analizar su tiempo de ejecución. El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos separados por un espacio de varias posiciones. Esto permite que un elemento haga "pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort es un simple ordenamiento por inserción, pero para entonces, ya está garantizado  que los datos del vector están casi ordenados.  shell 
#include<stdio.h>
#include<conio.h>
int a[5];
int n=5;
void main()
{
int inter=(n/2),i=0,j=0,k=0,aux;
clrscr();
for (i=0; i<5; i++)
{
printf("INSERTA UN VALOR DEL INDICE %d", i);
scanf("%d",& a);
}
while(inter>0){
for(i=inter;i<n;i++)
{
j=i-inter;
while(j>=0) {
k=j+inter;
if(a[j]<=a[k]){
j--;
}
else{
aux=a[j];
a[j]=a[k];
a[k]=aux;
j=j-inter;
}
}
}
inter=inter/2;
}
for(i=0;i<5;i++)
{
printf("%d n",a);
getch();
}
}    ORDENAMIENTO POR INSERCION  
El ordenamiento por inserción (insertion sort en inglés) es una manera muy natural de ordenar para un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas numeradas en forma arbitraria. Requiere O(n²) operaciones para ordenar una lista de n elementos.

Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Después, cuando hay k elementos ordenados de menor a mayor, se toma el elemento k+1 y se compara con todos los elementos ya ordenados, deteniéndose cuando se encuentra un elemento menor (todos los elementos mayores han sido desplazados una posición a la derecha) o cuando ya no se encuentran elementos (todos los elementos fueron desplazados y este es el más pequeño). En este punto se inserta el elemento k+1 debiendo desplazarse los demás elementos.

inserccion 
#include<stdio.h>
#include<conio.h>
int a[4]={4,1,7,2};
int n=4;
int i,j,aux;
void main(){
clrscr();
for(i=1;i<n;i++)
{
j=i;
aux=a;
while(j>0 && aux<a[j-1])
{
a[j]=a[j-1];
j--;
}
a[j]=aux;
}
for(i=0;i<4;i++)
{
printf("%d",a);
}
getch();
} 
 ORDENAMIENTO POR SELECCION  
El ordenamiento por selección (Selection Sort en inglés) es un algoritmo de ordenamiento que requiere Ooperaciones para ordenar una lista de n elementos.
Su funcionamiento es el siguiente:

• Buscar el mínimo elemento de la lista
• Intercambiarlo con el primero
• Buscar el mínimo en el resto de la lista
• Intercambiarlo con el segundo

Y en general:

• Buscar el mínimo elemento entre una posición i y el final de la lista
• Intercambiar el mínimo con el elemento de la posición i

De esta manera se puede escribir el siguiente pseudocódigo para ordenar una lista de n elementos indexados desde el 1:

para i=1 hasta n-1
    minimo = i;
    para j=i+1 hasta n
        si lista[j] < lista[minimo] entonces
            minimo = j /* (!) */
        fin si
    fin para
    intercambiar(lista[i], lista[minimo])
fin para 

seleccion 
#include<stdio.h>
#include<conio.h>
int x[4]={1,4,8,6};
int n=4,j=0,i=0;
int temp=0,minimo=0;
void main(){
clrscr();
for(i=0;i<n-1;i++)
{
minimo=i;
for(j=i+1;j<n;j++)
{
if(x[minimo] > x[j])
{
minimo=j;
}
}
temp=x[minimo];
x[minimo]=x;
x=temp;
}
for(i=0;i<n;i++)
{
printf("%d",x);
}
getch();
}
EJERCICIOS METODO DE ORDENAMIENTO EJERCICIO 01

#include <stdio.h>
#define SIZE 7
void main(void) {
  int vector[SIZE];
  int j, i, temp;
  printf("Introduce los %d valores para ordenar:\n", SIZE);
  for(i=0; i<SIZE; i++) {
     printf("%d: ", i+1);
     scanf("%d", &vector[i]);
     printf("\n");
  }
  /* se aplica el algoritmo de la burbuja */
  for(i=0; i<(SIZE-1); i++) {
     for (j=i+1; j<SIZE; j++) {
        if(vector[j]<vector[i]) {
            temp=vector[j];
            vector[j]=vector[i];
            vector[i]=temp;
        }
     }
  }
  printf("El vector ordenado es:\n");
  for(i=0; i<SIZE ; i++) {
     printf("%d ", vector[i]);
  }
  printf("\n");
}

EJERCIO 02

#include <stdio.h>

#include <stdlib.h>

#include <string.h>
 

void OrdenaBurbuja (float v[], int n)

{

int t, h, e;

for (h=1; h<n; h++)

{

for(e=0; e<n;e++)

{

if (v[e]>v[e+1])

{

v[e+1] = t;

v[e] = v[e+1];

t= v[e];

}

}

}

}
 
 

void ImprimirVector(float v[], int n)

{

int i; 

for (i=0; i<n; i++)

{

printf("%f ", v[i]);

}

}
 

int main(int argc, char *argv[])

{

if(strcmp(argv[1], "burbuja")==0)

{

int n, i, m=2, o;

float *v;

{

n=argc-2; 

v =(float *)malloc(n*sizeof(float));

for (i=0; i<n; i++)

{

v[i] = atof(argv[i+2]);

}

}

OrdenaBurbuja(v, n);

ImprimirVector(v, n);

}

system("PAUSE"); 

return 0;

}

EVAP 6

Matrices

Matrices (arrays multidimensionales) Es posible manejar arrays de más de una dimensión, denominados en general matrices. Cada dimensión está representada por un subíndice en la matriz. Por tanto, una matriz bidimensional tiene dos subíndi- ces; una matriz tridimensional tiene tres subíndices; y así sucesivamente. Una matriz puede tener cualquier número de dimensiones, aunque las matrices más utilizadas son las de dos dimensiones.

Un buen ejemplo de matriz es un tablero de ajedrez. Una dimensión representa las ocho filas; la otra dimensión representa las ocho columnas.

Inicialización de matrices Las matrices también se pueden inicializar. La asignación de la lista de valores a los elementos de la matriz se realiza manteniendo el primer índice fijo mientras el segundo varía. Por tanto, si tenemos una matriz  

int matriz1[5][3]; 

los tres primeros elementos irán a matriz1[0], los tres siguientes a matriz1[1], y así sucesivamente.

La matriz anterior se puede inicializar de la siguiente manera:  

int matriz1[5][3] = { 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 }; 

Para mayor claridad, se pueden agrupar los valores entre llaves. Por ejemplo,

  int matriz1[5][3] = { {1,2,3},  {4,5,6}, {7,8,9  {10,11,1  {13,14,15} };

  El compilador ignora las llaves interiores, que hacen más sencillo comprender cómo se distribuyen los va- lores. Cada valor debe separarse con una coma, independientemente de que se utilicen llaves o no. La inicialización completa si que debe encerrarse entre llaves, y debe finalizar con punto y coma.

Matrices

Crea una matriz bidimensional. La primera dimensión contiene los números del 0 al 4. La segunda dimensión consta de los valores que duplican los valores de la primera dimensión.

Creación de una matriz multidimensional

  #include <stdio.h> 

 int main() 

 { 

 int i,j; 

 int matriz[5][2] = { {0,0}, {1,2}, {2,4}, {3,6}, {4,8}};

for (i = 0; i<5; i++)

{ 

      for (j=0; j<2; j++)

{

printf("matriz[%d][%d] = ", i, j);

 printf("%d \t", matriz[i][j]);

       }

   printf("\n");

 }

return 0; 18: } 

Salida del programa

matriz[0][0] = 0     

  matriz[0][1] = 0

 matriz[1][0] = 1      

 matriz[1][1] = 2

 matriz[2][0] = 2     

  matriz[2][1] = 4

 matriz[3][0] = 3      

 matriz[3][1] = 6

matriz[4][0] = 4   

 matriz[4][1] = 8

ejemplo:   

// multidimensional_arrays.cpp
// compile with: /EHsc
// arguments: 3
#include <limits>   // Includes DBL_MAX
#include <iostream>

const int cMkts = 4, cFacts = 2;

// Declare a float that represents the transportation costs
double TransportCosts[][cMkts] = { 
   { 32.19, 47.29, 31.99, 19.11 },
   { 11.29, 22.49, 33.47, 17.29 },
   { 41.97, 22.09,  9.76, 22.55 }  
};

// Calculate size of unspecified dimension
const int cFactories = sizeof TransportCosts /
                  sizeof( double[cMkts] );

double FindMinToMkt( int Mkt, double myTransportCosts[][cMkts], int mycFacts);

using namespace std;

int main( int argc, char *argv[] ) {
   double MinCost;

   if (argv[1] == 0) {
      cout << "You must specify the number of markets." << endl;
      exit(0);
   }
   MinCost = FindMinToMkt( *argv[1] - '0', TransportCosts, cFacts);
   cout << "The minimum cost to Market " << argv[1] << " is: "
       << MinCost << "\n";
}

double FindMinToMkt(int Mkt, double myTransportCosts[][cMkts], int mycFacts) {
   double MinCost = DBL_MAX;

   for( int i = 0; i < cFacts; ++i )
      MinCost = (MinCost < TransportCosts[i][Mkt]) ?
         MinCost : TransportCosts[i][Mkt];

   return MinCost;
}

EVAP5

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 tipo tipo_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 asignándole 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<largo;i++) {

                               suma+=valores[i];

                }

                return suma/largo;

}

Cuando una función recibe un vector por parámetro y cambia su contenido y el cambio es permanente (se ve aún fuera de la función). Esto puede parecer extraño después del énfasis que pusimos en resaltar que todos los parámetros de una función se reciben por valor, pero se aclarará en el siguiente capitulo.

Mientras tanto usemos esto para definir una función que le aplique otra función que recibe por parámetro a cada elemento del vector, guardando el resultado en el mismo vector y una llamada de ejemplo a esta.

void cuadrados(double vector[], int largo)

{

                for (int i=0;i<largo;i++) {

                               vector[i]=cuadrado(vector[i]);

                }

}

double cuadrado (double valor) {

                return valor*valor;

}

EVAP 4

       Funciones ( SUBPROGRAMAS O SUBALGORITMOS)

1. INTRODUCCIÓN A LOS SUBPROGRAMAS O SUBALGORITMOS:

La programación modular es una de las técnicas fundamentales de la programación. Se apoya en el diseño descendente y en la filosofía de “divide y vencerás”, es decir se trata de dividir el problema dado, en problemas más simples en que cada uno de los cuales lo implementaremos en un módulo independiente. A cada uno de estos módulos es a lo que llamamos subalgoritmos o subprogramas.

Hay dos tipos fundamentales de subprogramas: Funciones y procedimientos.

2. FUNCIONES:

Desde el punto de vista matemático, una función es una operación que toma uno o varios operando, y devuelve un resultado. Y desde el punto de vista algorítmico, es un subprograma que toma uno o varios parámetros como entrada y devuelve a la salida un único resultado.

Pascal: En las funciones se puede devolver más de un único resultado mediante parámetros.

C: Se devuelve todo por parámetros.

Este único resultado irá asociado al nombre de la función. Hay dos tipos de funciones:

Internas: Son las que vienen definidas por defecto en el lenguaje.

Externas: Las define el usuario y les da un nombre o identificador.

Para llamar a una función se da su nombre, y entre paréntesis van los argumentos o parámetros que se quieren pasar.

Declaración de una función:

La estructura de una función es semejante a la de cualquier subprograma. Tendrá una cabecera (con el nombre y los parámetros) y un cuerpo(con la declaración de los parámetros de la función y las instrucciones).

Sintaxis:

Funcion <nombre_funcion> (n_parametro: tipo, n_parametro: tipo): tipo funcion

Var <variables locales funcion>

Inicio

<acciones>

retorno <valor>

fin <nombre_funcion>

La lista de parámetros es la información que se le tiene que pasar a la función. Los parámetros luego dentro de la función los podemos utilizar igual que si fueran variables locales definidas en la función y para cada parámetro hay que poner su nombre y tipo.

 La función puede ser llamada desde el programa principal o desde cualquier otro subprograma.

Pasos para hacer la llamada a una función:

  Al hacer la llamada y ceder el control a la función, se asocia (asigna el valor) de cada parámetro real a cada parámetro formal asociado, siempre por orden de aparición y de izquierda a derecha, por lo que siempre que no coincidan los tipos y el número de parámetros formales y reales, se produce un error.

Otra forma de especificar el retorno de una función:

Se le asigna el valor devuelto al nombre de la función.

Función valor

Ejemplo de función:

Una función que calcule la mitad del valor que le paso parámetro. Suponemos que es un valor entero.

Funcion mitad (n: entero): real

Var m: real

Inicio

M n/2

Retorno m

Fin mitad

Algoritmo calc_mitad

Var num: entero

Inicio

Escribir “Introduce un número para hallar su mitad”

Leer num

Escribir “La mitad de “num” es “mitad(num)

Fin

3. PROCEDIMIENTOS:

El inconveniente de una función es que solo puede devolver un único valor, por lo que sí nos interesa devolver 0 o N valores, aunque puedo usarlo para devolver un solo valor, debo usar un procedimiento.

Un procedimiento es un subprograma o un subalgoritmo que ejecuta una determinada tarea, pero que tras ejecutar esa tarea no tienen ningún valor asociado a su nombre como en las funciones, sino que si devuelve información, lo hace a través de parámetros.

Al llamar a un procedimiento, se le cede el control, comienza a ejecutarse y cuando termina devuelve el control a la siguiente instrucción a la de llamada.

Diferencias entre funciones y procedimientos:

  Una función devuelve un único valor y un procedimiento puede devolver 0,1 o N.

  Ninguno de los resultados devueltos por el procedimiento se asocian a su nombre como ocurría con la función.

 Mientras que la llamada a una función forma siempre parte de una expresión, la llamada a un procedimiento es una instrucción que por sí sola no necesita instrucciones.

Esta llamada consiste en el nombre del procedimiento y va entre paréntesis van los parámetros que se le pasan. En algunos lenguajes (como el C), se pone delante la palabra Llamar a (Call) procedimiento (parámetro).

Sintaxis:

Procedimiento <nombre_proc> (<tipo_paso_par> <nombre_par>: tipo_par,...)

Var <variables locales>: tipo

Inicio

<sentencias>

fin <nombre_proc>

La cabecera va a estar formada por el nombre del procedimiento que será un identificador y que debe de ser significativo, y luego entre paréntesis los parámetros o la información que se le pasa al procedimiento. Para cada parámetro hay que indicar el tipo de paso de parámetro. Hay dos tipos fundamentales de paso de parámetros, por valor y por referencia, si no ponemos tipo de paso de parámetros, se toma el tipo de paso de parámetros por valor.

En el cuerpo del procedimiento donde van las sentencias ya no habrá ninguna de tipo <retorno valor>, ahora bien, si el procedimiento devuelve resultados a través de sus parámetros, cosa que solo podrá hacer a través de los parámetros que se pasan por referencia, tendrán que existir sentencias de asignación de valores a estos parámetros pasados por referencia, a través de los cuales se van a devolver los resultados.

Como se llama a un procedimiento:

[llamar a (Call)] nombre_proc (par_reales)

Pasos para hacer la llamada a un procedimiento:

  Se cede el control al procedimiento al que se llama y lo primero que se hace al cederle el control es sustituir cada parámetro formal de la definición por el parámetro actual o real de la llamada asociado a él. Esta asociación entre parámetros formales y reales se hace de izquierda a derecha por orden de colocación y para que se pueda producir esta asociación tienen que existir el mismo número de parámetros formales que reales, y además el tipo tiene que coincidir con el del parámetro formal asociado, sino se cumple alguna de estas condiciones hay un error.

  Si la asociación ha sido correcta comienzan a ejecutarse las instrucciones del procedimiento hasta llegar a la última instrucción. Al llegar a la instrucción se vuelven a asociar los parámetros formales que devuelven los resultados a los parámetros formales asociados en la llamada, es decir, de esta manera algunos de los parámetros reales de la llamada ya contendrán los resultados del procedimiento.

  Finalmente se cede el control a la siguiente instrucción a la que se hace la llamada, pero teniendo en cuenta que en esta instrucción y en las siguientes puedo usar ya los parámetros reales en los que se devolvieron los resultados del procedimiento para trabajar con ellos.

Procedimiento mitad (num:entero,ent-sal M:real)

Inicio

M num/2

Fin mitad

Algoritmo calc_mitad

Var

N: entero

Mit: real

Inicio

Escribir “Introduce un número”

Leer n

Mitad (n,mit)

Escribir “La mitad es”mit

fin

4.  COMUNICACIÓN ENTRE SUBPROGRAMAS: PASO DE PARÁMETROS.

La mejor forma para llevar a cabo la comunicación ente subprogramas, es el paso de parámetros. Trataremos de evitar siempre que sea posible el uso de variables globales.

Cuando llamamos a una función o procedimiento, le pasamos a través de los parámetros la información que necesita, y en el caso de un procedimiento también devolvemos a través de sus parámetros los resultados. Para ello definiremos el tipo del parámetro a principio del subprograma, que es lo que conocemos como parámetros formales, y al hacer la llamada pasamos la información a través de los parámetros reales.

¿Cómo se efectúa la correspondencia entre parámetros formales y reales?:

Existen 2 métodos:

  Correspondencia posicional: En este caso se emparejan los parámetros formales y reales por la posición que ocupan (orden de declaración) y de izquierda a derecha. Para que se pueda realizar esta asociación, tiene que haber el mismo número de parámetros formales y reales, y con el mismo tipo.

F (x:entero,y:real)

Var a:real

F (3,A)

  Correspondencia por nombre implícito: Ahora en la llamada al subprograma se pone explícitamente a que parámetro formal corresponde cada real.

Ahora en la llamada ponemos el nombre del parámetro formal, separado por dos puntos (:) y el nombre del parámetro real que le pasamos, con lo cual ya no importa la posición en la que coloquemos la información.

F (x:3,y:A)

F (y:A,x:3)

Un lenguaje que permite esto es ADA.

Usaremos siempre el primer método (posicional).

Paso de parámetros:

Del modo de paso de parámetros va a depender el resultado que se obtenga.

1. Tipos de parámetros: Según se usen para meter datos o para obtener resultados.

Existen 3 tipos:

  De entrada: Son parámetros que solo aportan información de entrada al subprogama en el que pertenecen como parámetros. Aporta el valor que tienen como entrada al subprograma. En el caso de una función, todos sus parámetros son de este tipo.

Como solo sirven como entrada, solo pueden ser leídos, pero no modificados, y aunque se modificasen dentro de un subprograma, fuera no va a tener efecto esa modificación.

  De salida: Se usan solo y exclusivamente para devolver resultados a través de ellos. Su valor al hacer la llamada al subprograma no nos importa, sino que ese valor solo va a tener importancia cuando termina la ejecución del programa. Un parámetro de este tipo teóricamente nunca se puede leer, solo se va actualizar.

  De entrada y salida: El valor del parámetro tiene importancia tanto a la entrada como a la salida del subprograma, nos aporta información cuando llamamos al subprograma y por otra parte devolvemos a través de él resultados cuando terminamos el subprograma, en este caso, tiene sentido tanto leer como actualizar el parámetro.

Solo ADA es un lenguaje que va a soportar los 3 tipos de paso de parámetro. Se ponen como In, Out, In-Out.

El resto de los lenguajes solo permiten dos tipos de parámetros, de entrada (solo para leer datos) y de entrada-salida (para devolver resultados, aunque también se puede usar para leer datos).

2. Métodos de paso de parámetros:

Paso de parámetros por copia:

Por valor.

Por resultado.

Por valor-resultado.

Paso de parámetros por referencia.

Paso de parámetros por nombre o nominal.

Paso de parámetros por copia:

La característica fundamental de este método de paso de parámetros es que el parámetro formal siempre se considera que tiene asociada una dirección de memoria en la que está almacenado y que por tanto se comporta igual que una variable local del subprograma en que aparece.

En este método lo que importa es el valor del parámetro actual.

  Por valor: Nos interesa el valor del parámetro actual a la entrada, para ello este valor se copia en la dirección de memoria del parámetro formal asociado. En este caso el parámetro real puede se una constante, expresión o variable, y nunca se va a usar para devolver resultado a través de él, por esa razón precisamente puede ser una constante o una expresión, porque al no devolver resultados a través de él no necesita tomar ninguna zona de memoria en la que este almacenado, es más, incluso si el parámetro actual fuera una variable y la modificásemos dentro del subprograma (algo que no deberíamos hacer), fuera del subprograma no tendría ninguna repercusión esta modificación, es decir, esa variable serviría valiendo lo mismo en el programa desde el que se hace la llamada después y antes de hacerla.

El funcionamiento sería el siguiente:

Al hacer la llamada al subprograma se evalúa el valor del parámetro real, y ese es el que se asocia, es decir, el que se guarda o asigna al parámetro formal asociado.

Comenzamos a ejecutar el subprograma y si por casualidad se produce algún cambio en el parámetro formal, el parámetro actual no se verá afectado, es decir, su valor seguirá siendo el mismo en el subprograma desde donde se llama que antes de hacer la llamada al subprograma.

Algoritmo Ej.

Var A:entero 3 3 6

Inicio A del PP X de P

A 3

P (A)

Escribir A

Fin

Procedimiento P(x:entero)

Inicio

X x*2

Escribir x

Fin p

El valor de A sería 3 y el de X sería 6.

  Por valor-resultado: En el valor-resultado nos interesa el valor del parámetro actual tanto a la entrada como a la salida de la ejecución del subprograma.

Esto quiere decir que se cambia el valor del parámetro formal cambiará también el valor de su parámetro real asociado, cosa que no ocurría antes, y esto supone por tanto que ahora el parámetro real tiene que tener asociada obligatoriamente una dirección de memoria, por lo que siempre tendrá que ser una variable (no una constante ni una expresión).

El proceso sería el siguiente:

- Al hacer la llamada al subprograma se evalúa el parámetro real y su valor se copia en el parámetro formal asociado y al terminar la ejecución el valor del parámetro formal se vuelve a copiar en el parámetro real asociado.

Algoritmo Ej.

Var A:entero Se copia

Inicio

A 3

P (A) 3 6 3 6

Escribir A P.Real P.Formal

Fin

Procedimiento P(x:entero)

Inicio Se devuelve

X x*2

Escribir x

Fin p

El valor de la A y la X sería 6.

  Por resultado: Nos interesa el valor del parámetro real solamente a la salida o fin de la ejecución del subprograma en que aparece. Esto significa que al hacer la llamada no se copia el valor del parámetro real en el parámetro formal asociado, sin embargo a la salida se copia el valor del parámetro formal en la dirección del parámetro real asociado, esto significa por tanto, que el parámetro real tiene que tener asociada una expresión que tiene que ser una variable (no puede ser una constante o una expresión).

Algoritmo

Var A:entero

Inicio

A 3 P.Real P.Formal

P (A)

Escribir A

Fin

Procedimiento P(x:entero) Se copia a la salida

Inicio

X 1

X x*2

Escribir x

Fin p

El valor de A y de X es 2.

En la práctica la mayor parte de los lenguajes dentro del tipo de paso de parámetro por copia solo van a soportar el tipo de paso de parámetro por valor, que se usará cuando un parámetro solo lo quiero utilizar como entrada de información al subprograma, pero no para devolver resultados a través de él.

Los otros dos tipos de paso de parámetros por copia (por valor y por valor-resultado), no se implementan normalmente porque los efectos son prácticamente iguales que el paso de parámetros por referencia, es decir, cuando quiero usar un parámetro no solo para pasar información a través de él sino también para devolver resultados o si lo voy a usar sólo para devolver resultados, utilizaré el paso de parámetros por referencia que vamos a ver a continuación.

Para simbolizar que el tipo de paso de parámetros es por valor, en la definición del subprograma no pongo ningún tipo de paso de parámetros para ese parámetro, es decir, no poner ningún tipo significa que por defecto el tipo de paso de parámetros es por valor.

En el caso de las funciones como solamente pueden recibir información de entrada pero nunca pueden devolver información por sus parámetros ya que lo devuelven a través de la sentencia retorno y asociado a su nombre.

El tipo de paso de sus parámetros va a ser siempre por valor.

Paso de parámetros por referencia:

Ahora la característica principal de este tipo de paso de parámetros es que el parámetro formal va a tener también asignada una dirección de memoria en la que se almacena, pero en esa dirección NO SE GUARDA SU VALOR, sino que se almacena la dirección de su parámetro real asociado, es decir, el parámetro formal apunta al parámetro real que tiene asociado y cualquier modificación que se efectúe sobre el parámetro formal tendrá una repercusión directa en el parámetro real asociado ya que lo que modificará será el valor almacenado en la dirección que indica el parámetro formal que es la de su parámetro formal asociado.

El proceso será por tanto el siguiente:

Al hacer la llamada al procedimiento en el parámetro formal que se pasa por referencia, se va a guardar la dirección del parámetro real asociado para que apunte a él.

Durante la ejecución cualquier referencia al parámetro formal se hará accediendo a la dirección apuntada por dicho parámetro, es decir, accediendo directamente al parámetro real asociado, por lo que cualquier cambio en el parámetro formal afectará directamente al parámetro real asociado. De esta manera habremos pasado el resultado.

Para indicar que el tipo de paso de parámetro es por referencia, vamos a utilizar la palabra clave ent-sal precediendo al parámetro que se pasa por referencia.

A estos parámetros también se les llama parámetros variables (porque su valor varía), por eso en Pascal se usa la palabra clave Var para indicarlo.

En otros lenguajes como C, se usan como parámetros punteros para indicar que son direcciones.

Algoritmo EJ

Var A apunta

Inicio

A 3

P1(A) 3 dirección A

Escribir (A)

Fin A del PP X del P1

Procedimiento P1(ent-sal x:entero)

Inicio

X x*2

Fin P1

Por valor el parámetro actual no cambia de valor.

Por referencia el parámetro actual puede cambiar.

Paso de parámetros por nombre:

En este caso, el parámetro formal se sustituye literalmente por el parámetro actual asociado. Esta sustitución literal del parámetro formal por el parámetro actual no se produce hasta que no se usa el parámetro formal.

La ventaja es que si no usamos en ningún momento el parámetro formal dentro del subprograma llamado (cosa poco probable), no se tendrá que hacer ningún tipo de substitución.

Pero el gran inconveniente es que si se usa el parámetro formal, hay que ir a buscar en ese momento la expresión del parámetro real asociado.

El paso de parámetro por nombre es lo que se parece más a la substitución de parámetros en una función matemática.

F (x)= x+2

F (a+1) = a+1*2

F (x)= x+2

F (a+1)= a +1 2 <> (a+1)*2

Algoritmo EJ

Var A: entero

Inicio

A 3

P1(A+1)

Escribir (A)

Fin

Procedimiento P1(ent-sal x: entero)

Inicio

X x*2

Fin P1

Al final solo vamos a usar 2 tipos de paso de parámetros, que son los que usan casi todos los lenguajes: Por valor y por referencia.

Por valor: Solo lo usamos cuando un parámetro solo sirve para información de entrada, no devolvemos nada con él. Por eso este paso puede ser una constante, variable o expresión. Para simbolizarlo en la declaración de variables no ponemos nada.

Por referencia: Lo usamos cuando un parámetro lo usamos como entrada de información y como salida o solo como salida. Por esta razón ahora sí que se va a variar el parámetro formal y por lo tanto no podemos usar constantes ni expresiones, solo variables. Lo simbolizamos con la palabra ent-sal.

5. FUNCIONES Y PROCEDIMIENTOS COMO PARÁMETROS:

En la mayor parte de los lenguajes se permite también que una función o procedimiento pueda ser pasado como parámetro de otro subprograma. En este caso, es decir, cuando el parámetro formal es de tipo función o procedimiento, pasaremos como parámetro real funciones o procedimientos que tengan la misma definición que el que hemos puesto como parámetro formal, y en nuestro caso para indicar que se pasa como parámetro real una función o procedimiento, basta con poner su nombre.

Desde el subprograma al que se pasa como parámetro esa función o procedimiento podemos llamar en cualquier momento a esa función pasada como parámetro que en cada momento podrá ser una distinta dependiendo del parámetro formal asociado.

Funcion <nombre_f> (par:tipo;funcion <n_f>(x:entero,y:carácter):entero

Prodedimiento <nombre_f> procedimiento (x:tipo,...);...

Algoritmo EJ

Var v1,v2: entero

Inicio

V1 1

V2 2

P(v1,f1,v2)

P(v1,f2,v2)

Fin

Procedimiento P(x:entero;funcion F(A:entero;B:carácter):entero;ent-sal y:entero)

Inicio

X 2

Y F(x,'a')

Fin P

Funcion F1(x:entero;y:carácter):entero

Inicio

Escribir y

Retorno (x+1)

Fin

Funcion F2(A:entero;B:carácter):entero

Inicio

Escribir “Hola” B

Retorno A

Fin F2

El paso de funciones y procedimientos como parámetros, nos va a permitir que desde un subprograma podamos llamar a otros, pero teniendo en cuenta que el subprograma llamado no va a ser uno determinado, sino que va a depender en cada momento del subprograma pasado como parámetro real, de esta manera el subprograma puede llamar a un conjunto de n subprogramas que cumplan unas determinadas características, pero solo uno en cada momento.

No hay que confundir el paso de una función como parámetro con la llamada a una función cuando aparece como parámetro real en la llamada a un subprograma. Para diferenciarlo, cuando paso una función como parámetro solo pondré su nombre, en cambio cuando llamo a una función para pasar el valor que devuelve como parámetro pondré el nombre de la función y con sus argumentos para indicar que ahí se puede hacer la llamada. Esto se puede hacer porque la llamada a una función puede aparecer en cualquier expresión en la que apareciese cualquier valor del tipo de datos que devuelve.

Procedimiento P(A:entero)

Inicio

Escribir A

Fin P

Funcion F(x:entero):entero

Inicio

Retorno (x*2)

Fin F

Algoritmo EJ

Var I

Inicio

I 2

P(F(I)) Esto no es pasar una función como parámetro

Fin