Algoritmia/Apéndice A: pseudocódigo

De Wikilibros, la colección de libros de texto de contenido libre.
Saltar a: navegación, buscar

Pseudocódigo[editar]

Durante la redacción del libro y a la hora de plantear soluciones a ejercicios propuestos, es frecuente recurrir a mostrar porciones de código que expliquen el funcionamiento del algoritmo en cuestión. Con el fin de evitar entrar en aspectos sintácticos específicos de cada lenguaje de programación, se utilizará un pseudocódigo pre-establecido que provea de forma sencilla los elementos necesarios para poder describir el algoritmo.

Funciones y procedimientos[editar]

Las subrutinas son secciones de código que pueden separarse unas de otras por constituir un bloque más o menos independiente del resto de rutinas del programa. Pueden diferenciarse fundamentalmente dos tipos de subrutinas: funciones, que devuelven un valor, y procedimientos, que no devuelven ningún valor. El comportamiento, en los demás aspectos, es esencialmente el mismo. Las subrutinas pueden recibir una serie de parámetros necesarios para llevar a cabo las tareas para las que se hayan definido.

En el pseudocódigo utilizado en este libro, se puede reconocer una función por el siguiente aspecto:

fun n_funcion (n_p_1:t_p_1, ..., n_p_n:t_p_n) dev v_d:t_v_d
   ... // Instrucciones
   devolver v_d
ffun

donde:

  • n_funcion es el nombre de la función en minúsculas
  • n_p_1 es el nombre del primer parámetro
  • t_p_1 es el tipo del primer parámetro
  • n_p_n es el nombre del enésimo parámetro
  • t_p_n es el tipo del enésimo parámetro
  • v_d es el valor devuelto
  • t_v_d es el tipo del valor devuelto

El siguiente es un ejemplo que muestra una función que suma dos enteros:

fun suma_enteros (x:entero, y:entero) dev z:entero
   z := x + y
   devolver z
ffun

Un procedimiento cualquier descrito en el libro puede reconocerse por la siguiente estructura:

proc n_procedimiento (n_p_1:t_p_1, ..., n_p_n:t_p_n)
   ... // Instrucciones
fproc

donde:

  • n_procedimiento es el nombre del procedimiento en minúsculas
  • n_p_1 es el nombre del primer parámetro
  • t_p_1 es el tipo del primer parámetro
  • n_p_n es el nombre del enésimo parámetro
  • t_p_n es el tipo del enésimo parámetro

El siguiente es un ejemplo que muestra un procedimiento que incrementa un entero en una unidad:

proc suma_uno (x:entero)
   x := x + 1
fproc

Declaración de tipos[editar]

Se sigue la siguiente notación en la declaración de variables:

nombre_variable : tipo_variable

Un ejemplo de tipo autodefinido es el siguiente:

tipo Nodo : reg
               dato : t_dato
               izq : Nodo
               der : Nodo
            freg

Tipos primitivos[editar]

Se consideran tipos primitivos aquellos tipos básicos en cualquier lenguaje de programación, como números enteros, booleanos o caracteres. Algunos ejemplos se muestran a continuación:

var1 : ent     // enteros negativos y positivos
var2 : bool    // booleano -> true / false
var3 : nat     // naturales, de 0 a N
var4 : char    // caracteres
var5 : cadena  // cadenas de caracteres
var6 : 0..100  // intervalo de números entre 0 y 100

Tuplas y arrays[editar]

Una tupla es una asociación de varios elementos, del mismo o distinto tipo. Si son del mismo tipo, pueden considerarse o representarse con arrays. Si son de distinto tipo, pueden representarse también como registros.

(x0, x1, ..., xn) : (ent, ..., ent)  // Tupla de n elementos enteros
(x, b) : (ent, bool)                 // Tupla de un entero y un booleano

Los arrays son agrupaciones de varios elementos del mismo tipo, pudiéndose ser de una (también llamados vectores) o más dimensiones (matrices).

v[1..n] de ent        // Vector de enteros de tamaño n
m[1..n, 1..n] de bool // Matriz de booleanos de tamaño nxn

Registros[editar]

Los registros son agrupaciones de varios elementos, frecuentemente de distintos tipos. Son útiles para crear unidades utilizadas en tipos de datos más complejos, como árboles o tablas.

reg 
   dato : t_dato
   clave : t_clave
freg

Punteros[editar]

Los punteros tratan de representar el uso de memoria dinámica. Se utilizan fundamentalmente a la hora de crear estructuras enlazadas a través de nodos o similares.

tipo nodo : reg
              datos : t_datos
              izq : ^nodo   // Puntero a nodo
              der : ^nodo
            freg

Operadores[editar]

Se utilizan los operadores básicos disponibles en la mayoría de lenguajes de programación.

  • Operadores aritméticos : suma (+), resta (-), multiplicación (*), división (/), división entera (div), módulo (mod), exponenciación (^).
  • Operadores lógicos : igualdad (=), y-lógica (&), o-lógica (|), negación (!), relaciones de orden (<, >, <=, >=).
  • Otros operadores : asignación (:=).

Estructuras de control[editar]

  • Condicional
si exp_booleana entonces
  // instrucciones
si_no
  // instrucciones
fsi
  • Selección de casos
casos exp
  caso 1 -> // instrucciones
  ...
  caso n -> // instrucciones
  si_no ->  // instrucciones
fcasos
  • Bucle con índice
para i:=a hasta b [paso j] hacer
  // instrucciones
fpara
  • Bucle con condición de entrada
mientras exp_booleana hacer
  // instrucciones
fmientras
  • Bucle con condición de salida
repetir
  // instrucciones
mientras exp_booleana