GRAFOS

CONCEPTO

La teoría de grafos (también llamada teoría de las gráficas) estudia las propiedades de los grafos (también llamadas gráficas). Un grafo es un conjunto, no vacío, de objetos llamados vértices (o nodos) y una selección de pares de vértices, llamados aristas (edges en inglés) que pueden ser orientados o no.

Típicamente, un grafo se representa mediante una serie de puntos (los vértices) conectados por líneas (las aristas).



TIPOS


NO DIRIGIDOS

Son aquellos en los cuales los lados no están orientados (No son flechas). Cada lado se representa entre paréntesis, separando sus vértices por comas, y teniendo en cuenta (Vi,Vj)=(Vj,Vi).

DIRIGIDOS

Son aquellos en los cuales los lados están orientados (flechas). Cada lado se representa entre ángulos, separando sus vértices por comas y teniendo en cuenta <Vi ,Vj>!=<Vj ,Vi>. En grafos dirigidos, para cada lado <A,B>, A, el cual es el vértice origen, se conoce como la cola del lado y B, el cual es el vértice destino, se conoce como cabeza del lado.

VERTICES

Un vértice o nodo es la unidad fundamental de la que están formados los grafos. Los vértices son tratados como objetos indivisibles y sin propiedades, aunque puedan tener una estructura adicional dependiendo de la aplicación por la cual se usa el grafo; por ejemplo, una red semántica es un grafo en donde los vértices representan conceptos o clases de objetos.

ARCO

El arco es la union que se se tiene entre dos vertices, cada arco se representa a traves de un par, donde cada elemento determina uno de los vertices.

CAMINOS

Un camino en un grafo es una sucesión finita en la que aparecen alternadamente vértices y aristas de dicho grafo. Otras definiciones básicas son:

Los extremos son los vértices inicial y final del camino.

La longitud de un camino es el numero de aristas que contiene.

Un camino es cerrado si sus extremos coinciden.

Un camino es simple si en la sucesión de vértices no hay ninguno repetido.

Un ciclo es un camino cerrado donde los únicos vértices repetidos son el primero y el ultimo.

Un circuito es un camino cerrado que no repite aristas.

Si en un grafo existe un camino que conecta dos vértices distintos, entonces existe un camino simple con extremos en dichos vértices.

Un grafo es conexo si para cada par de vértices, existe un camino con extremos en dichos vértices.

Tipos de caminos

Camino euleriano:

es un camino o circuito que contiene todas las aristas apareciendo cada una de ellas exactamente una vez. Un grafo que admite dicho circuito se denomina grafo euleriano, y sus vértices o tienen grado par o dos de los vértices tienen grado impar.

Camino hamiltoniano:

es un camino simple que contiene todos los vértices apareciendo cada uno de ellos exactamente una vez. Un ciclo que a su vez es un camino hamiltoniano se denomina ciclo hamiltoniano, y un grafo que contiene un ciclo hamiltoniano se denomina grafo hamiltoniano.

ARBOLES

CONCEPTO

Un arbol es un conjunto finito de 0 o mas nodos v1,v2,...,vn tales que:

1- existe un nodo el cual se distingue de los demas, al mismo lo vamos llamar raiz

2- los demas elementos del conjuntos quedan particionados en m>=0 conjuntos disjuntos T1,T2,...,TN los cuales son arboles.

Los elementos T1,T2,...,TN son llamados subarboles. Vemos aqui la naturaleza recursiva de la estructura arbol, puesto que definimos arbol en termino de arboles.

TIPOSARBOLES BINARIOS

Un árbol binario es una estructura de datos en la cual cada nodo siempre tiene un hijo izquierdo y un hijo derecho. No pueden tener más de dos hijos (de ahí el nombre "binario"). Si algún hijo tiene como referencia a null, es decir que no almacena ningún dato, entonces este es llamado un nodo externo. En el caso contrario el hijo es llamado un nodo interno. Usos comunes de los árboles binarios son los árboles binarios de búsqueda, los montículos binarios y Codificación de Huffman.

Tipos De Arboles Binarios
Un árbol binario es un árbol con raíz en el que cada nodo tiene como máximo dos hijos.
Un árbol binario lleno es un árbol en el que cada nodo tiene cero o dos hijos.
Un árbol binario perfecto es un árbol binario lleno en el que todas las hojas (vértices con cero hijos) están a la misma profundidad (distancia desde la raíz, también llamada altura).
A veces un árbol binario perfecto es denominado árbol binario completo. Otros definen un árbol binario completo como un árbol binario lleno en el que todas las hojas están a profundidad n o n-1, para alguna n. Un árbol binario es un árbol en el que ningún nodo puede tener más de dos subárboles. En un árbol binario cada nodo puede tener cero, uno o dos hijos (subárboles). Se conoce el nodo de la izquierda como hijo izquierdo y el nodo de la derecha como hijo derecho.
ARBOL BINARIO DE BUSQUEDA AUTO-BALANCEABLE
Un árbol binario de búsqueda auto-balanceable o equilibrado es un árbol binario de búsqueda que intenta mantener su altura, o el número de niveles de nodos bajo la raíz, tan pequeños como sea posible en todo momento, automáticamente. Esto es importante, ya que muchas operaciones en un árbol de búsqueda binaria tardan un tiempo proporcional a la altura del árbol, y los árboles binarios de búsqueda ordinarios pueden tomar alturas muy grandes en situaciones normales, como cuando las claves son insertadas en orden. Mantener baja la altura se consigue habitualmente realizando transformaciones en el árbol, como la rotación de árboles, en momentos clave.
ARBOL AVL
Árbol AVL es un tipo especial de árbol binario ideado por los matemáticos rusos Adelson-Velskii y Landis. Fue el primer árbol de búsqueda binario auto-balanceable que se ideó.
Los árboles AVL están siempre equilibrados de tal modo que para todos los nodos, la altura de la rama izquierda no difiere en más de una unidad de la altura de la rama derecha o viceversa. Gracias a esta forma de equilibrio (o balanceo), la complejidad de una búsqueda en uno de estos árboles se mantiene siempre en orden de complejidad O(log n). El factor de equilibrio puede ser almacenado directamente en cada nodo o ser computado a partir de las alturas de los subárboles.

RECORRIDOS

PREORDEN

Sea T un arbol ordenado con raız r . Si T consta solo de r , entonces r es el recorrido preorden de T. Sino, suponga que T1, T2, . . . , Tn son los subarboles en r listados de izquierda a derecha en T. El recorrido en preorden inicia visitando r , continua recorriendo T1 en preorden, luego T2, en preorden, y ası sucesivamente hasta recorrer Tn en preorden.

Procedimiento Preorden ( T: arbol ordenado con raiz)
r = raiz de T
mostrar (r )
Para cada hijo c de r de izquierda a derecha
T(c) = subarbol con c como su raiz
Preorden(T(c))
Fin Para
Fin Procedimiento
INORDEN
Sea T un arbol ordenado con raız r . Si T consta solo de r , entonces r es el recorrido en inorden de T. Sino, suponga que T1, T2, . . . , Tn son los subarboles en r listados de izquierda a derecha en T. El recorrido en inorden inicia recorriendo T1 en inorden y continua visitando r , a continuacion recorre T2 en inorden, luego T3, en inorden, y asi sucesivamente hasta recorer Tn en inorden.
Procedimiento Inorden ( T: arbol ordenado con raiz)
r = raiz de T
Si r es una hoja
mostrar (r )
Sino
l = primer hijo de r de izquierda a derecha
T(l) = subarbol de raiz l
Inorden (T(l))
mostrar (T(l))
Para cada hijo c de r excepto para l y
de izquierda a derecha
T(c) = subarbol de raiz c
Inorden(T(c))
Fin Para
Fin Si
Fin Procedimiento
POSTORDEN
Sea T un arbol ordenado con raız r . Si T consta solo de r , entonces r es el recorrido en postorden de T. Sino, suponga que T1, T2, . . . , Tn son los subarboles en r listados de izquierda a derecha en T. El recorrido en postorden inicia recorriendo T1 en postorden, luego recorre T2 en postorden y ası sucesivamente hasta recorrer Tn en postorden y finaliza visitando r .

Procedimiento Postorden ( T: arbol ordenado con raiz )
r = raiz de T
Para cada hijo c de r de izquierda a derecha
T(c) = subarbol de raiz c
Postorden(T(c))
Fin Para
mostrar (r )
Fin Procedimiento
ARBOL GENEALOGICO
BOSQUES

Un bosque es un conjunto de n ≥ 0 árboles disjuntos. El concepto de bosque esta fuertemente relacionado al de árbol ya que si removemos la raíz de un árbol obtenemos un bosque.
El bosque lo obtenemos eliminando la raiz de este arbol.
PROGRAMA
package javaapplication3;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.tree.*;
import java.util.*;
public class SimpleTree
{ public static void main(String[] args)
{ JFrame frame = new SimpleTreeFrame();
frame.show();
}
}
class SimpleTreeFrame extends JFrame
{
DefaultMutableTreeNode root = new DefaultMutableTreeNode("Mundo");
DefaultMutableTreeNode arge = new DefaultMutableTreeNode("Argentina");
DefaultMutableTreeNode sant = new DefaultMutableTreeNode("Santa Fe");
DefaultMutableTreeNode rafa = new DefaultMutableTreeNode("Rafaela");
DefaultMutableTreeNode rosa = new DefaultMutableTreeNode("Rosario");
DefaultMutableTreeNode safe = new DefaultMutableTreeNode("Santa Fe");
DefaultMutableTreeNode vena = new DefaultMutableTreeNode("Venado Tuerto");
DefaultMutableTreeNode vill = new DefaultMutableTreeNode("Villa Constitucion");
DefaultMutableTreeNode cord = new DefaultMutableTreeNode("Cordoba");
DefaultMutableTreeNode codo = new DefaultMutableTreeNode("Cordoba");
DefaultMutableTreeNode cbro = new DefaultMutableTreeNode("Cura Brochero");
DefaultMutableTreeNode rcua = new DefaultMutableTreeNode("Rio Cuarto");
DefaultMutableTreeNode chac = new DefaultMutableTreeNode("Chaco");
DefaultMutableTreeNode resi = new DefaultMutableTreeNode("Resistencia");
DefaultMutableTreeNode vang = new DefaultMutableTreeNode("Villa Angela");
DefaultMutableTreeNode chil = new DefaultMutableTreeNode("Chile");
DefaultMutableTreeNode regi = new DefaultMutableTreeNode("Region Metropolitana");
DefaultMutableTreeNode schi = new DefaultMutableTreeNode("Santiago de Chile");
public SimpleTreeFrame()
{ setTitle("SimpleTree");
setSize(300, 200);
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent e)
{ System.exit(0);
}
} );
root.add(arge); // Enlazado de nodos
arge.add(sant); // Enlazado de nodos
sant.add(rafa); // Enlazado de nodos
sant.add(rosa); // Enlazado de nodos
sant.add(safe); // Enlazado de nodos
sant.add(vena); // Enlazado de nodos
sant.add(vill); // Enlazado de nodos
arge.add(cord); // Enlazado de nodos
cord.add(codo); // Enlazado de nodos
cord.add(cbro); // Enlazado de nodos
cord.add(rcua); // Enlazado de nodos
arge.add(chac); // Enlazado de nodos
chac.add(resi); // Enlazado de nodos
chac.add(vang); // Enlazado de nodos
root.add(chil); // Enlazado de nodos
chil.add(regi); // Enlazado de nodos
regi.add(schi); // Enlazado de nodos
JTree tree = new JTree(root);
Container contentPane = getContentPane();
contentPane.add(new JScrollPane(tree));
Enumeration hijos = sant.children(); // Enumeracion de hijos
while ( hijos.hasMoreElements() ) // Enumeracion de hijos
{ // Enumeracion de hijos
System.err.println("Hijos de Santa Fe : "+hijos.nextElement()); // Enumeracion de hijos
} // Enumeracion de hijos
boolean hoja = vena.isLeaf(); // Consulta Hoja
System.err.println("Es Venado Tuerto hoja : "+hoja); // Consulta Hoja
Enumeration breadth = root.breadthFirstEnumeration(); // Enumeracion Nodos
while ( breadth.hasMoreElements() ) // Enumeracion Nodos
{ // Enumeracion Nodos
System.err.println("Breadth First : "+breadth.nextElement()); // Enumeracion Nodos
} // Enumeracion Nodos
Enumeration depth = root.depthFirstEnumeration(); // Enumeracion Nodos
while ( depth.hasMoreElements() ) // Enumeracion Nodos
{ // Enumeracion Nodos
System.err.println("Depth First : "+depth.nextElement()); // Enumeracion Nodos
} // Enumeracion Nodos
Enumeration preorder = root.preorderEnumeration(); // Enumeracion Nodos
while ( preorder.hasMoreElements() ) // Enumeracion Nodos
{ // Enumeracion Nodos
System.err.println("Pre Order : "+preorder.nextElement()); // Enumeracion Nodos
} // Enumeracion Nodos
Enumeration postorder = root.postorderEnumeration(); // Enumeracion Nodos
while ( postorder.hasMoreElements() ) // Enumeracion Nodos
{ // Enumeracion Nodos
System.err.println("Post Order : "+postorder.nextElement()); // Enumeracion Nodos
} // Enumeracion Nodos
}
}

PILAS

CONCEPTO

Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.

Para el manejo de los datos se cuenta con dos operaciones básicas: apilar (push), que coloca un objeto en la pila, y su operación inversa, retirar (o desapilar, pop), que retira el último elemento apilado.

En cada momento sólo se tiene acceso a la parte superior de la pila, es decir, al último objeto apilado (denominado TOS, Top of Stack en inglés). La operación retirar permite la obtención de este elemento, que es retirado de la pila permitiendo el acceso al siguiente (apilado con anterioridad), que pasa a ser el nuevo TOS.

Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato sobre una pila de platos, y una operación retirar a retirarlo.

Las pilas suelen emplearse en los siguientes contextos:

• Evaluación de expresiones en notación postfija (notación polaca inversa).
• Reconocedores sintácticos de lenguajes independientes del contexto
• Implementación de recursividad.

CLASIFICACION

Estatica

¿Cómo representar estáticamente una pila?

Sin duda tendremos que utilizar arreglos o registros que como ya sabemos son la base para estructuras de datos más complejas. Considera la siguiente figura:

Vista gráfica

Suponiendo que Dato pertenece a un mismo tipo de datos y CuentaDato corresponde a un entero que se incrementa a medida que un nuevo elemento se incorpora a la pila. Intenta construir la definición de tipo para la estructura Pila.

TYPE
______________________________

______________________________

_____________________________

END;

Dinamica

¿Cómo representar dinámicamente una pila?

Sin duda tendremos que utilizar nodos con punteros. Considera la siguiente figura:

Suponiendo que los punteros que aparecen en la figura son capaces de apuntar a un nodo y que Dato pertenece a cualquiera de los tipos básicos o estructurados, la definición de tipo sería:

TYPE
Puntero=^NodoPila;
NodoPila=Record
Info:AlgunTipo;
sgte:Puntero;
End;

Var tope:Puntero;

APLICACIONES

Las pilas son utilizadas ampliamente para solucionar una amplia variedad de problemas. Se utiliza en compiladores, sistemas operativos y en programas de aplicación. Su implementación se puede hacer mediante Arrays Y Mediante listas enlazadas.

Un ejemplo de sus aplicaciones podrían ser los siguientes:

• Los Navegadores en Internet almacenan en una pila las direcciones de los sitios más recientemente visitados.
• Los editores de texto proporcionan normalmente un botón deshacer que cancela las operaciones de edición recientes y restablece el estado anterior del documento.

PROGRAMAS
1

package pilas;

import java.util.Scanner;

/**

*

* @author ALUMNO

*/

public class PilaEstatica {

public static void main(String[] args) {

int dato;

int pila[]=new int[5];

Scanner captura=new Scanner(System.in);

for(int tope=0;tope<5;tope++)

{

System.out.println("proprcione datos para pila");

dato=captura.nextInt();

pila[tope]=dato;

}

for (int tope=5;tope>=0;tope--)

System.out.println("la pila tiene los siguientes datos:"+pila[tope]);

}

}

2

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/

/**
*
* @author alumno
*/
import java.util.Scanner;
public class Pilas {
public static void main(String[] args) {
int tope=0;
int dato;
int op;
int pila[]=new int[5];
Scanner captura=new Scanner(System.in);
do{
System.out.println("\t Menu \t");
System.out.println("Operaciones Con Pilas");
System.out.println("1.- Insertar");
System.out.println("2.- Eliminar");
System.out.println("3.- Mostrar");
System.out.println("4.- Salir");
System.out.println("\n");
System.out.println("Elija La Operacion Que Desee");
op=captura.nextInt();
switch(op){
case 1:
System.out.println("Inserte Numero");
dato=captura.nextInt();
insertar(dato);
break;
case 2:
break;
case 3:
break;
case 4:
break;
}
}while (op!=4);

public int insertar (int dato){
if(tope>4){
System.out.println("La Pila Esta Llena");
}
else {
tope++;
pila[tope]=dato;
}
return pila [tope];
}

}

COLAS

COLAS

CONCEPTO

Una cola es una estructura de datos, caracterizada por ser una secuencia de elementos en la que la operación de inserción push se realiza por un extremo y la operación de extracción pop por el otro. También se le llama estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.

Las colas se utilizan en sistemas informáticos, transportes y operaciones de investigación (entre otros), dónde los objetos, personas o eventos son tomados como datos que se almacenan y se guardan mediante colas para su posterior procesamiento. Este tipo de estructura de datos abstracta se implementa en lenguajes orientados a objetos mediante clases, en forma de listas enlazadas.

TIPOS

Circular

Una cola circular o anillo es una estructura de datos en la que los elementos están de forma circular y cada elemento tiene un sucesor y un predecesor. Los elementos pueden cosultarse, añadirse y eliminarse unicamente desde la cabeza del anillo que es una posición distinguida. Existen dos operaciones de rotaciones, una en cada sentido, de manera que la cabeza del anillo pasa a ser el elemento sucesor, o el predecesor, respectivamente, de la cabeza actual.

De Prioridades

Una cola de prioridades es una estructura de datos en la que los elementos se atienden en el orden indicado por una prioridad asociada a cada uno. Si varios elementos tienen la misma prioridad, se atenderán de modo convencional según la posición que ocupen.

Bicola

La bicola o doble cola es un tipo de cola especial que permiten la inserción y eliminación de elementos de ambos extremos de la cola. Puede representarse a partir de un vector y dos índices, siendo su representación más frecuente una lista circular doblemente enlazada. Todas las operaciones de este tipo de datos tienen coste constante.

USOS

La particularidad de una estructura de datos de cola es el hecho de que sólo podemos acceder al primer y al último elemento de la estructura. Así mismo, los elementos sólo se pueden eliminar por el principio y sólo se pueden añadir por el final de la cola.

Ejemplos de colas en la vida real serían: personas comprando en un supermercado, esperando para entrar a ver un partido de béisbol, esperando en el cine para ver una película, una pequeña peluquería, etc. La idea esencial es que son todos líneas de espera.

PROGRAMAS

public void inserta(Elemento x) {
Nodo Nuevo;
Nuevo = new Nodo(x, null);
if (NodoCabeza == null) {
NodoCabeza = Nuevo;
} else {
NodoFinal.Siguiente = Nuevo;
}
NodoFinal = Nuevo;
}

public Elemento cabeza() throws IllegalArgumentException {
if (NodoCabeza == null) {
throw new IllegalArgumentException();
}else {
return NodoCabeza.Info;
}
}

public Cola() {
// Devuelve una Cola vacía
NodoCabeza = null;
NodoFinal = null;
}

 

 

RECURSIVIDAD

La recursividad es una función que se llama a sí misma para dividir un problema en problemas más sencillos, el método recursivo debe estar compuesto de una caso base para el cual ya se conoce un resultado y una llamada al mismo método con una versión ligeramente más sencilla del problema inicial
ejemplo 1, factoriales:
Para todo n entero natural, se llama factorial n (n!) al producto de todos los enteros entre 1 y n:

n	n!
1	1	1	1
2	2 × 1	= 2 × 1!	= 2
3	3 × 2 × 1	= 3 × 2!	= 6
4	4 × 3 × 2 × 1	= 4 × 3!	= 24
5	5 × 4 × 3 × 2 × 1	= 5 × 4!	= 120
6	etc	etc

Código:

?

code

1 2 3 4 5 6

public void factoriales(long n){ if(n==1) return 1; else return n*factoriales(n-1); }

El método factoriales se llama a sí mismo disminuyendo cada vez el numero inicial en una unidad hasta que llega a valer 1 y por lo tanto alcanza el caso base, en ese momento se devuelven todas las llamadas recursivas realizas al método factoriales retornando el valor del actual multiplicado por el valor anterior.
ejemplo 2, Fibonachi:
La sucesion de Fibonachi comienza por 0 y 1, y cada numero siguiente es la
suma de los dos anteriores:
0,1,1,2,3,5,8,13,21,34,55,89
Código:

?

code

1 2 3 4 5 6 7

public void fibonachi(long n){ if(n==0 || n==1) return n; else return fibonachi(n-2)+fibonachi(n-1); }

Este método esta compuesto de dos casos bases, y de dos llamadas recursivas al método, a esto se le denomina recursividad mútliple, a diferencia del método factoriales que sólo hace una llamada recursiva y se denomina recursividad simple. En ambos casos es de tipo directa, también es posible efectuar recursión indirectamente: una método puede llamar a otro quien, a su vez, acabe llamando al primero.
A continuación se expone un ejemplo de programa que utiliza recursión indirecta, y nos dice si un número es par o impar. Al igual que el programa anterior, hay otro método mucho más sencillo de determinar si un número es par o impar, basta con determinar el resto de la división entre dos. Por ejemplo: si hacemos par(2) devuelve 1 (cierto). Si hacemos impar(4) devuelve 0 (falso).

Código:

?

code

1 2 3 4 5 6 7 8 9 10 11

int par(int n) { if (n == 0) return 1; return impar(n-1); } int impar(int n) { if (n == 0) return 0; return par(n-1); }

Código:

?

code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int x[]={7,3,4,6,8,9,5}; int n = 7; // Enviamos datos max(n, x); public static int max(int n, int x[]) { if(n == 1) return x[0]; if (x[n-1] > max(n-1, x)) return x[n-1]; else return max(n-1, x); }

Hay que apuntar que el factorial puede obtenerse con facilidad sin necesidad de emplear funciones recursivas, es más, el uso del programa anterior es muy ineficiente, pero es un ejemplo muy claro.
Dado un array constituido de números enteros, devolver la suma de todos los elementos. En este caso se desconoce el número de elementos. En cualquier caso se garantiza que el último elemento del array es -1, número que no aparecerá en ninguna otra posición.
Código:

?

code

1 2 3 4 5 6 7 8 9

private static int sumaArray2(int vector[], int n){ if(n==-1)return 0; else return vector[n]+ sumaArray2(vector, n-1); } static int []array={1,2,3,4,5,6}; System.out.println(sumaArray2(array,array.length-1));

Dado un array constituido de números enteros y que contiene N elementos siendo N >= 1, devolver el elemento mayor.
Código:

?

code

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

static int []array={510,41,300,4,25,6}; private static int mayor(int vector[], int n){ int aux; if(n==-1)return 0; else{ aux = mayor(vector, n-1); if(vector[n]>aux) return vector[n]; else return aux; } } System.out.println(mayor(array,array.length-1));

máximo comun divisor.
Código:

?

code

1 2 3 4 5 6 7 8 9 10

private static long mcd(long a, long b){ if(b==0) return a; else return mcd(b,a%b); } System.out.println(mcd(80,25)); resultado 5; TIPOS Directa Es directa cuando una función se llama a sí misma. Indirecta Recursividad indirecta cuando una función llama a otra función y ésta última llama a la primera. APLICACIONES Los números naturales se pueden definir de la siguiente forma: 0 es un Número natural y el sucesor de un número natural es también un número natural.El factorial de un número natural n, es 1 si dicho número es 0, o n multiplicado por el factorial del número n 1, en caso contrario.