------Recursividad--------
Es la capacidad o funcion o procedimiento de un metodo de invocarse a si mismo durante la ejecucion de un programa. Una funcion o procedimiento es recursivo cuando esta definido en funcion de si mismo.
Ejemplo: funcion factorial. Dado un entero positivo llamado n se define su factorial como el producto de todos los enteros entre n y uno.
5!=5*4*3*2*1=120
a) Algoritmo de la funcion factorial.
funcion FACTORIAL(n)
inicio
si n=0 entonces
FACTORIAL=1
sino
FACTORIAL=N*FACTORIAL(n-1)
fin_si
fin_funcion
b) Secuencia de fibbonachi es aquella secuencia de enteros donde cada elemento es la suma de los 2 anteriores. 0,1,1,2,3,5,8,13,21
=definicion recursiva=
if n==0 orh==1 entonces fib(n)=n
if n>=2 entonces fib(n)=fib=(n-2)+fib(n+1)//llamado recursividad
algoritmo.
funcion FIB(n)
Inicio
SI N==0 O N==1 entonces
FIB=n
sino
FIB(n-2)+FIB(n-1)
fin_si
fin_funcion
Ejemplo:
n=2
fib(2)=fib(2-2)+fib(2-1)
=fib(0)+fib(1)
=0+1=1
PROCEDIMIENTOS RECURSIVOS
1.- Funcion factorial
2.- Secuencia de fibbonacci
3.- Torres de hanoi
4.- Busqueda binaria
c) Torres de hanoi
Se tienen 3 torres de n discos de diferentes tamaños. Inicialemente los discos estan ordenados del mayor al menor en la primer torre. El problema consiste en pasar los discos a la tercer torre utilizando la segunda como auxiliar.
Reglas:
1.-En cada movimiento solo pueden mover un disco.
2.-No puede quedar un disco mayor sobre uno menor.
Procedimiento Hanoi(N, ORIGEN, AUXILIAR, DESTINO)
si N=1 entonces
Escribir "Mover un disco de ",ORIGEN,"a",DESTINO
sino
Regresar Hanoi(N-1, ORIGEN,DESTINO,AUXILIAR)//llamada recursiva
Escribir "Mover un disco de", ORIGEN, "a", DESTINO
Regresar Hanoi(N-1, AUXILIAR, ORIGEN,DESTINO)//LLAMADA RECURSIVA
fin_si
fin_procedimineto
NOTA: poner contador para que nos diga cuantos movimientos fueron.
d)busqueda binaria: considere un arreglo de elementos en el cual los objetos se han colocado en cierto orden. Al aplicarle la busqueda en este arreglo, primero compara el elemento que se busca en el que se encuentra en el centro del arreglo. Si son iguales la busqueda termina con exito, sino, si el elemento de en medio es mayor que el que se busca, el proceso de busqueda se repite en la 1er mitad del arreglo, sino, el proceso se repite en la segunda mitad del arreglo.
=algoritmo recursivo de buskeda binaria=
1.- if(low>high)
return -1//no se encontro el elemento x
2.- else mid=(low+high)/2
"3.- if(x==a[mid]) //mid=7/2=3 //5=a[3],5=5"
return (mid) //localizo elemento en la posicion mitad
"4.- else if(x"5.- busqueda(x, a[low], a[mid-1]) //low=0, 3-1, //llamada recursiva"
"6.- else busqueda(x, a[mid+1],a[high]) //a[3+2], a[7] //llamada recursiva"
Ejemplo:
(low)0 1 2 3 4 5 6 7(high)
" a={1,3,4,5,17,18,31,33} "
1ra mitad mid 2da mitad
1ra vez low=0
high=7
x=? 5
Monday, October 13, 2008
Listas
=operaciones en una lista=
1.- Insertar un elemento:
procedimiento insertar()
entero: temp, aux, pos
tipo-elemento: dato
repetir
pedir valor a insertar: dato
temp<-lista[disp].siguiente
lista[disp].elem<-dato
llamada busca_lugar(dato)
si es pos=ini entonces
lista[disp].sig<-ini
ini<-disp
si no
lista[disp].sig<-lista[aux].sig
lista[aux].sig<-disp
fin-si
disp<-temp
preguntar "otra insercion?", otra
mientras(otra=="si")
fin procedimiento
procedimiento busca_lugar(tipo_elemento dato)
entero:encontrado<-0
pos<-ini
aux<-0
mientras pos!=-1 y encontrado!=1 hacer
si lista[pos].eleemtno>dato entonces
encontrado<-1
si no
aux<-pos
pos<-lista[pos].sig
fin-si
fin mientras
fin_procedimiento
2.- recorrido la lista
procedimiento desplegar()
entero: pos
pos<-ini
mientras pos!=-1 hacer
imprimir "elemento", lista[pos].elemento
''Posicion:",pos
pos<-lista[pos].sig
fin mientras
fin procedimiento
NOTA: poner un contador que se incremente cada vez que se inserta un dato y se
decremente cada vez que elimine un dato para comparar y seguir insertando/eliminando.
3.- Eliminar un elemento: procedimiento eliminar()
entero:pos, aux,temp
tipo_elemento:dato
repetir
pedir valor a eliminar:dato
llamar busca_eliminar(dato)
si encontrado=1 entonces
si aux!=0 entonces
lista[aux].sig<-lista[pos].sig
si no
ini<-lista[pos].sig
fin.si
lista[pos].sig<--1
temp<-disp
mientras temp!=0 hacer
si lista[temp].sig!=0 entonces
temp<-lista[temp].sig
sino
lista[temp].sig<-pos
fin si
fin_mientras
fin_si
Pregunta: "otra eliminacion", otra
mientras(otra="si")
fin_procedimiento
funcion busca_eliminar(tipo_elemento:dato)
entero ! encontrado<-0
pos<-ini, aux<-0
mientras pos!=-1 y encontrado!+1 hacer
si lista[pos].elem=dato entonces
encontrado<-1
sino
aux<-pos
pos<-lista[pos].sig
fin_si
fin_mientras
si encontrado=0 netonces
imprmimir "elemento", dato, "no esta en la lista"
sino
imprimir"eleemto", dato, "sera" eliminado
fin_si
regresar encontrado
fin_funcion
4.- Busqueda en un elemento particular
procedimiento buscar()
tipo_elemento:dato
entero:encontrado<-0
pos<-ini
repetir
pedir valor a buscar:dato
minetras pos!=-1 y encontrado !=1 hacer
si lista[pos].elem=dato entonces
encontrado<-1
sino
pos<-lista[pos].sig
fin_si
fin_mientras
si encontrado=0 entonces
imprimir "no esta el elemento", dato, "en la lista"
sino
Imprimir "elemento", dato, "esta en la posicion", pos
fin_si
preguntar "otra busqueda", otra
minetras(otra="si")
fin_procedimineto
5.-Determine el numero de elemento en la lista
procedimiento contar()
entero:n<-0
pos<-ini
minetras pos!=-1 hacer
n<-n+1
pos<-lista[pos].sig
fin_mientras
imprmimir"numero de elementos en la lista", n
fin_procedimiento
ejemplo
elem sig
ini 1 3 5
2 9 -1
3 0 3
disp 4 -1
5 6 2
valor eliminar? 3
busca_eliminar(3)
enc=0
pos=ini,pos=3
aux=0;
mientras 3!=-1 y 0!=1
si L[3].elem=3
3=3
enc=1
mientras 3!=-1 y 1!=1 x sale ciclo
si enc=0,1=0 x
"elemento 3 sera eliminado de la lista"
return enc=1
si enc=1,1=1
SI aux!=0,0!=0 x
ini=L[3].sig
ini=1
L[3].elem=0
L[3].sig=-1
temp=disp,temp=4
mientras temp!=-1,4!=-1
si L[4].sig !=0, 0!=0 x
L[4].sig=3
pregunta otra eliminacion?
1.- Insertar un elemento:
procedimiento insertar()
entero: temp, aux, pos
tipo-elemento: dato
repetir
pedir valor a insertar: dato
temp<-lista[disp].siguiente
lista[disp].elem<-dato
llamada busca_lugar(dato)
si es pos=ini entonces
lista[disp].sig<-ini
ini<-disp
si no
lista[disp].sig<-lista[aux].sig
lista[aux].sig<-disp
fin-si
disp<-temp
preguntar "otra insercion?", otra
mientras(otra=="si")
fin procedimiento
procedimiento busca_lugar(tipo_elemento dato)
entero:encontrado<-0
pos<-ini
aux<-0
mientras pos!=-1 y encontrado!=1 hacer
si lista[pos].eleemtno>dato entonces
encontrado<-1
si no
aux<-pos
pos<-lista[pos].sig
fin-si
fin mientras
fin_procedimiento
2.- recorrido la lista
procedimiento desplegar()
entero: pos
pos<-ini
mientras pos!=-1 hacer
imprimir "elemento", lista[pos].elemento
''Posicion:",pos
pos<-lista[pos].sig
fin mientras
fin procedimiento
NOTA: poner un contador que se incremente cada vez que se inserta un dato y se
decremente cada vez que elimine un dato para comparar y seguir insertando/eliminando.
3.- Eliminar un elemento: procedimiento eliminar()
entero:pos, aux,temp
tipo_elemento:dato
repetir
pedir valor a eliminar:dato
llamar busca_eliminar(dato)
si encontrado=1 entonces
si aux!=0 entonces
lista[aux].sig<-lista[pos].sig
si no
ini<-lista[pos].sig
fin.si
lista[pos].sig<--1
temp<-disp
mientras temp!=0 hacer
si lista[temp].sig!=0 entonces
temp<-lista[temp].sig
sino
lista[temp].sig<-pos
fin si
fin_mientras
fin_si
Pregunta: "otra eliminacion", otra
mientras(otra="si")
fin_procedimiento
funcion busca_eliminar(tipo_elemento:dato)
entero ! encontrado<-0
pos<-ini, aux<-0
mientras pos!=-1 y encontrado!+1 hacer
si lista[pos].elem=dato entonces
encontrado<-1
sino
aux<-pos
pos<-lista[pos].sig
fin_si
fin_mientras
si encontrado=0 netonces
imprmimir "elemento", dato, "no esta en la lista"
sino
imprimir"eleemto", dato, "sera" eliminado
fin_si
regresar encontrado
fin_funcion
4.- Busqueda en un elemento particular
procedimiento buscar()
tipo_elemento:dato
entero:encontrado<-0
pos<-ini
repetir
pedir valor a buscar:dato
minetras pos!=-1 y encontrado !=1 hacer
si lista[pos].elem=dato entonces
encontrado<-1
sino
pos<-lista[pos].sig
fin_si
fin_mientras
si encontrado=0 entonces
imprimir "no esta el elemento", dato, "en la lista"
sino
Imprimir "elemento", dato, "esta en la posicion", pos
fin_si
preguntar "otra busqueda", otra
minetras(otra="si")
fin_procedimineto
5.-Determine el numero de elemento en la lista
procedimiento contar()
entero:n<-0
pos<-ini
minetras pos!=-1 hacer
n<-n+1
pos<-lista[pos].sig
fin_mientras
imprmimir"numero de elementos en la lista", n
fin_procedimiento
ejemplo
elem sig
ini 1 3 5
2 9 -1
3 0 3
disp 4 -1
5 6 2
valor eliminar? 3
busca_eliminar(3)
enc=0
pos=ini,pos=3
aux=0;
mientras 3!=-1 y 0!=1
si L[3].elem=3
3=3
enc=1
mientras 3!=-1 y 1!=1 x sale ciclo
si enc=0,1=0 x
"elemento 3 sera eliminado de la lista"
return enc=1
si enc=1,1=1
SI aux!=0,0!=0 x
ini=L[3].sig
ini=1
L[3].elem=0
L[3].sig=-1
temp=disp,temp=4
mientras temp!=-1,4!=-1
si L[4].sig !=0, 0!=0 x
L[4].sig=3
pregunta otra eliminacion?
Colas
Es una estructura de datos lineal donde las eliminaciones de elementos se realizan con uno de sus extremos denominado front(frente) y las insercuiones de elementos se realizan por el otro extremo denominado final o rear.
Las colas son estructuras de datos FIFO(first-in, firt-out) porque el primer dato que se inserto sera el primero en salir de la cola.
=operaciones en una cola=
1.- Push: Es el metodo por el cual se va a agregar un nuevo dato a la cola tomando en cuenta la capacidad maxima de almacenar en la estructura y la posiciones del frente i final de la cola.
Algoritmo:
push(cola, frente, final, max, elemento)
si frente=0 y final=max-1 entonces
imprimir"la cola esta llena", y salir
si no si frente=nulo(-1) entonces
frente<-0
final<-0
si no
final+1
cola[final]=elemento
salir
*Nota: inicializar al principio del programa:
*tamaño de la cola
*front=-1
*rear=-1
cola frente final
0 k5 -1->0 -1->4
1 k7
2
3
4
ejemplo> se pide insertar un elemento
si frente =-1, frente y final se ponen en 0 y se guarda el elemento en la cola [0]=5 -1=-1
si frente no es -1, final es igual a final +1 y guardar cola[1]=7 fianl=0+1=1
2.-Pop: es el metodo por el cual se va a sacar o eliminar el primer dato de la cola tomando en cuenta solo la poscion de frente.
Algoritmo:
pop(cola, frente, final, max)
si frente!= nulo(-1) entonces
imprimir "eliminando el dato:", cola[frente]
cola[frente]<=0
si frente=final entonces
frente=nulo(-1)
final=nulo(-1)
si no
frente<-frente+1
si no
imprimir "la cola esta vacia"
salir
3.- Recorrido: es el metodo por el cual se despliega el conenido de la cola, si no hay
ni un elemento, despliega "la cola esta vacia".
Algoritmo:
Recorrido(cola, frente, final, max)
si frente != nulo(-1) entonces
apuntador=frente
repetir mientras apuntador<=final
imprimir "elemento: ", cola[apuntador], "posicion:", apuntador
apuntador =apuntador+1
find el ciclo
si no
imprimir "la cola sta vacia"
salir
4.- Busqueda: este metodo utiliza el recorrido para encontrar el elemento deseado i desplegar un mensaje con la posicion en la que se encuentra, siempre y cuando la busqueda sea exitosa, si no
desplegara el mensaje de que no encontro el elemento. En el caso de que no existan elementos en la cola desplegara "la cola esta vacia".
Algoritmo:
busqueda (cola, frente, final, max, elemento)
si frente != nulo(-1) entonces
apuntador<-frente
repetir mientras apuntador<=final
si elemento= cola[apuntador] entonces
imprimir "dato no ncontrado", eleemtnop, "posicion", apuntador
y salir
si no
apuntador<-apuntador+1
fin del ciclo
imprimir "dato", elemento, "no sta en la cola"
si no
imprimir "la cola esta vacia"
salir
Las colas son estructuras de datos FIFO(first-in, firt-out) porque el primer dato que se inserto sera el primero en salir de la cola.
=operaciones en una cola=
1.- Push: Es el metodo por el cual se va a agregar un nuevo dato a la cola tomando en cuenta la capacidad maxima de almacenar en la estructura y la posiciones del frente i final de la cola.
Algoritmo:
push(cola, frente, final, max, elemento)
si frente=0 y final=max-1 entonces
imprimir"la cola esta llena", y salir
si no si frente=nulo(-1) entonces
frente<-0
final<-0
si no
final+1
cola[final]=elemento
salir
*Nota: inicializar al principio del programa:
*tamaño de la cola
*front=-1
*rear=-1
cola frente final
0 k5 -1->0 -1->4
1 k7
2
3
4
ejemplo> se pide insertar un elemento
si frente =-1, frente y final se ponen en 0 y se guarda el elemento en la cola [0]=5 -1=-1
si frente no es -1, final es igual a final +1 y guardar cola[1]=7 fianl=0+1=1
2.-Pop: es el metodo por el cual se va a sacar o eliminar el primer dato de la cola tomando en cuenta solo la poscion de frente.
Algoritmo:
pop(cola, frente, final, max)
si frente!= nulo(-1) entonces
imprimir "eliminando el dato:", cola[frente]
cola[frente]<=0
si frente=final entonces
frente=nulo(-1)
final=nulo(-1)
si no
frente<-frente+1
si no
imprimir "la cola esta vacia"
salir
3.- Recorrido: es el metodo por el cual se despliega el conenido de la cola, si no hay
ni un elemento, despliega "la cola esta vacia".
Algoritmo:
Recorrido(cola, frente, final, max)
si frente != nulo(-1) entonces
apuntador=frente
repetir mientras apuntador<=final
imprimir "elemento: ", cola[apuntador], "posicion:", apuntador
apuntador =apuntador+1
find el ciclo
si no
imprimir "la cola sta vacia"
salir
4.- Busqueda: este metodo utiliza el recorrido para encontrar el elemento deseado i desplegar un mensaje con la posicion en la que se encuentra, siempre y cuando la busqueda sea exitosa, si no
desplegara el mensaje de que no encontro el elemento. En el caso de que no existan elementos en la cola desplegara "la cola esta vacia".
Algoritmo:
busqueda (cola, frente, final, max, elemento)
si frente != nulo(-1) entonces
apuntador<-frente
repetir mientras apuntador<=final
si elemento= cola[apuntador] entonces
imprimir "dato no ncontrado", eleemtnop, "posicion", apuntador
y salir
si no
apuntador<-apuntador+1
fin del ciclo
imprimir "dato", elemento, "no sta en la cola"
si no
imprimir "la cola esta vacia"
salir
Estructuras lineales estaticas i dinamicas
-----Pila-------
tope=top va guardando la posicion del ultimo elemento
***(el tope empieza con -1 la primera vez)
Es un conjunto ordenado de elementos en el cual se pueden agregar y eliminar datos con uno de sus extremos llamado tope de la pila.
La pila es una estructura de datos Lifo porke el ultimo dato ke se inserta es el primero que se elimina.
LIFO: last in-first out
=operaciones en una pila=
1-Push: Es el metodo atraves del cual se va a agregar un dato nuevo a la fila tomando en cuenta la capacidad maximade almacenar de la estructura.
Algoritmo:
Push(Pila, Top, Max,Elemento)
Si Top != Max-1 entonces
Top<- Top+1
Pila[Top]<- elemento
si no
IMPRIMIR "la pila esta llena"
pila top elemento
0 9 3 7
1 7 k4 k8
2 10
+
3 8
4 3
3!=4
2+1+3
pila[3]=8, pila[4]=3
2-Pop(eliminar): es el metodo por el cual se va a eliminar el ultimo dato de la pila basandose en la posicion de top.Si no hay elementos en la pila desplegara el mensaje la pila esta vacia.
Algoritmo
Pop(pila, Top)
***4!=-1
Si top!=Nulo(-1) entonces
imprimir "elemento:", pila[top3],"sera eliminado"
Pila[top]<- 0
top<-top-1
si no
imprimir "la pila esta vacia"
salir.
MENU OPERACIONES EN UNA PILA
1.- Insertar datos en la pila
2.-Eliminar datos en la pila
3.- Desplegar datos de la pila
4.-Buscar datos en la pila
5.-Fin del programa
Caracteristicas del programa
1.- top inicializa con -1 al iniciar el programa
2.- Pedir el tamaño maximo de la pila y enviarlo al constructor para establecer el tamaño maximo de la pila.
3.-Pedir desde el menu el dato a insertar y enviarlo como parametro al metodo al metodo push.
4.-Hacer el programa que maneje datos de tipo double y de tipo string.
Continuacion operaciones en una pila
3.-Recorrido:
Es el metofo atravez del cual se hace un recorrido a la pila para desplegar los elemento apartir de la posicion del tope de la pila y se repite hasta que la variable auxiliar sea igual a nulo (-1).
Algoritmo
Recorrido (pila, top)
si top!= nulo(-1) entonces
apuntador<- top
repetir mientras apuntador!=nulo
imptrimir "elemento", Pila[apuntador], "posicion:", apuntador
Apuntador<-apuntador-1
fin del ciclo
si no
imprimir "la pila esta vacia"
salir
Pila Top
0 10 3
1 9
2 8
3 7
4
5
3!=-1
var
ap=3
3!=-1 2!=-1 1!=-1
pila[3] 7,8,9
ap=3-1=2 2-1=1 1-1=0 0-1=-1
la pila esta vacia.
4.- Busqueda. Es el metodo que se utiliza para localizar un elemento en particular en la pila. Si esta resulta exitosa desplegara el elemento y la posicion en el que se encuentra, si no, desplegara el mensaje de que el elemneto no fue encontrado.
Algoritmo
busqueda(pila, top, element)
si top!=nulo(-1) entonces
apuntador<- top
repetir mientras apuntador !=nulo
si pila[apuntador]=elemento entonces
imprimir "el dato", "elemento", "fue encontrando en la posicion", apuntador
y salir
si no
apuntador<-apuntador-1
fin del ciclo
imprimir "dato", elemento, "no esta en la pila"
si no
imprimir "la pila esta vacia"
salir.
ejemplo:
elemento 8
ap=3
3!=-1 2!=1
pila[3]=8, 7=8x pila[0]=8, 8=8
elemento+8, apuntado=2
ap=3-1=2
elemento=5
la pila esta vacia.
tope=top va guardando la posicion del ultimo elemento
***(el tope empieza con -1 la primera vez)
Es un conjunto ordenado de elementos en el cual se pueden agregar y eliminar datos con uno de sus extremos llamado tope de la pila.
La pila es una estructura de datos Lifo porke el ultimo dato ke se inserta es el primero que se elimina.
LIFO: last in-first out
=operaciones en una pila=
1-Push: Es el metodo atraves del cual se va a agregar un dato nuevo a la fila tomando en cuenta la capacidad maximade almacenar de la estructura.
Algoritmo:
Push(Pila, Top, Max,Elemento)
Si Top != Max-1 entonces
Top<- Top+1
Pila[Top]<- elemento
si no
IMPRIMIR "la pila esta llena"
pila top elemento
0 9 3 7
1 7 k4 k8
2 10
+
3 8
4 3
3!=4
2+1+3
pila[3]=8, pila[4]=3
2-Pop(eliminar): es el metodo por el cual se va a eliminar el ultimo dato de la pila basandose en la posicion de top.Si no hay elementos en la pila desplegara el mensaje la pila esta vacia.
Algoritmo
Pop(pila, Top)
***4!=-1
Si top!=Nulo(-1) entonces
imprimir "elemento:", pila[top3],"sera eliminado"
Pila[top]<- 0
top<-top-1
si no
imprimir "la pila esta vacia"
salir.
MENU OPERACIONES EN UNA PILA
1.- Insertar datos en la pila
2.-Eliminar datos en la pila
3.- Desplegar datos de la pila
4.-Buscar datos en la pila
5.-Fin del programa
Caracteristicas del programa
1.- top inicializa con -1 al iniciar el programa
2.- Pedir el tamaño maximo de la pila y enviarlo al constructor para establecer el tamaño maximo de la pila.
3.-Pedir desde el menu el dato a insertar y enviarlo como parametro al metodo al metodo push.
4.-Hacer el programa que maneje datos de tipo double y de tipo string.
Continuacion operaciones en una pila
3.-Recorrido:
Es el metofo atravez del cual se hace un recorrido a la pila para desplegar los elemento apartir de la posicion del tope de la pila y se repite hasta que la variable auxiliar sea igual a nulo (-1).
Algoritmo
Recorrido (pila, top)
si top!= nulo(-1) entonces
apuntador<- top
repetir mientras apuntador!=nulo
imptrimir "elemento", Pila[apuntador], "posicion:", apuntador
Apuntador<-apuntador-1
fin del ciclo
si no
imprimir "la pila esta vacia"
salir
Pila Top
0 10 3
1 9
2 8
3 7
4
5
3!=-1
var
ap=3
3!=-1 2!=-1 1!=-1
pila[3] 7,8,9
ap=3-1=2 2-1=1 1-1=0 0-1=-1
la pila esta vacia.
4.- Busqueda. Es el metodo que se utiliza para localizar un elemento en particular en la pila. Si esta resulta exitosa desplegara el elemento y la posicion en el que se encuentra, si no, desplegara el mensaje de que el elemneto no fue encontrado.
Algoritmo
busqueda(pila, top, element)
si top!=nulo(-1) entonces
apuntador<- top
repetir mientras apuntador !=nulo
si pila[apuntador]=elemento entonces
imprimir "el dato", "elemento", "fue encontrando en la posicion", apuntador
y salir
si no
apuntador<-apuntador-1
fin del ciclo
imprimir "dato", elemento, "no esta en la pila"
si no
imprimir "la pila esta vacia"
salir.
ejemplo:
elemento 8
ap=3
3!=-1 2!=1
pila[3]=8, 7=8x pila[0]=8, 8=8
elemento+8, apuntado=2
ap=3-1=2
elemento=5
la pila esta vacia.
Unidad II Manejo de Memoria
Manejo de memoria
Todas las variables, arreglos y objetos en general tienen una duración determinada en el transcurso de un programa. Son creados y destruidos para su uso y después para que la memoria sea liberada para que la utilicen otros objetos.
En C# existen tres formas de usar la memoria para almacenar valores:
a) Memoria Estática: Es la utilizada por variables globales y las declaradas de tipo Static. Estos objetos tienen asignada la misma dirección de memoria desde el comienzo hasta el final del programa.
b) Memoria Automática: Es la utilizada por Argumentos en una función y por las variables locales. Cada entrada en la función crea estos objetos y son destruidos al salir de ella.
c) Memoria Dinámica: Es también llamado almacenamiento libre porque en este caso el programador es el que solicita memoria para crear los objetos y es el responsable de liberar la memoria cuando ya no la necesita para ser reutilizada.
La reserva y liberación para variables globales, estáticas, locales y argumentos son realizadas en forma implícita por el programa, la única que requiere intervención del programador es la reserva y liberación de memoria dinámica.
Todas las variables, arreglos y objetos en general tienen una duración determinada en el transcurso de un programa. Son creados y destruidos para su uso y después para que la memoria sea liberada para que la utilicen otros objetos.
En C# existen tres formas de usar la memoria para almacenar valores:
a) Memoria Estática: Es la utilizada por variables globales y las declaradas de tipo Static. Estos objetos tienen asignada la misma dirección de memoria desde el comienzo hasta el final del programa.
b) Memoria Automática: Es la utilizada por Argumentos en una función y por las variables locales. Cada entrada en la función crea estos objetos y son destruidos al salir de ella.
c) Memoria Dinámica: Es también llamado almacenamiento libre porque en este caso el programador es el que solicita memoria para crear los objetos y es el responsable de liberar la memoria cuando ya no la necesita para ser reutilizada.
La reserva y liberación para variables globales, estáticas, locales y argumentos son realizadas en forma implícita por el programa, la única que requiere intervención del programador es la reserva y liberación de memoria dinámica.
Manejo de memoria dinamica
-memoria dinamica:
La reserva de memoria dinamica se hace en tiempo de ejecucion despues de leer los datos de conocer el tamaño exacto del problema a resolver, como consecuencia se adapta mejor a las necesidades de cada caso pero en contrapartida es un poco mas dificil programar.Tanto la creacion como la construccion de los objetos esta en manos deñ programador a traves de los operadores new y delete, el sitio donde se almacenan los objetos suele denominarse heap o free store, traducido como monticulo o memoria libre. No es necesario considerar la liberacion de la memoria dinamica puesto que framework se encarga de liberar todas las referencias que no se esten usando y compactar la memoria para mejorar el rendimiento.
Tipos valo en c#
*tipos predefinidos(int, float...)
*Estructuras(struct)
*Enumeraciones(enum)
Tipos-referencia en c#
*objetos
*string
*todas las clases
En c# todas las clases son tratadas sintacticamente como referencias y no permite elegir como reservar memoria par un instante en particular, en cambio obliga a que un valor int entero sea un tipo valor siempre.
La reserva de memoria dinamica se hace en tiempo de ejecucion despues de leer los datos de conocer el tamaño exacto del problema a resolver, como consecuencia se adapta mejor a las necesidades de cada caso pero en contrapartida es un poco mas dificil programar.Tanto la creacion como la construccion de los objetos esta en manos deñ programador a traves de los operadores new y delete, el sitio donde se almacenan los objetos suele denominarse heap o free store, traducido como monticulo o memoria libre. No es necesario considerar la liberacion de la memoria dinamica puesto que framework se encarga de liberar todas las referencias que no se esten usando y compactar la memoria para mejorar el rendimiento.
Tipos valo en c#
*tipos predefinidos(int, float...)
*Estructuras(struct)
*Enumeraciones(enum)
Tipos-referencia en c#
*objetos
*string
*todas las clases
En c# todas las clases son tratadas sintacticamente como referencias y no permite elegir como reservar memoria par un instante en particular, en cambio obliga a que un valor int entero sea un tipo valor siempre.
Monday, September 15, 2008
Seleccion de un algoritmo
Cuando se resuelve un rpoblema y hay la necesidad de elegir entre varios algoritmos que nos puedan dar un resultado, existen dos objetivos que suelen contradecirse para elegir uno:
a) Que el algoritmo se afacil de enternder, codificar y depurar.
b) Que el algoritmo use eficientemente todos los recursos de la computadora y se ejecuta con la mayor rapidez posible.
El primer punto se debe elegir cuando se escribe un programa que se va a usar una o pocas veces ya que el costo del tiempo del programa no se da tan reelevante ya que solo se ejecutaa en pocas ocaciones.
El punto b es mas importante cuandos e presenta un problema cuya solucion se va a usar muchas veces, ya que el costo de ejecucion del programa minimizara al costo de escritura.
En conclusion siempre sera mas ventajoso (desde el punto de vista economico) tener un algoritmo complejo siempre y cuando el tiempo de ejecucion del rpograma sea significativamente menor.
a) Que el algoritmo se afacil de enternder, codificar y depurar.
b) Que el algoritmo use eficientemente todos los recursos de la computadora y se ejecuta con la mayor rapidez posible.
El primer punto se debe elegir cuando se escribe un programa que se va a usar una o pocas veces ya que el costo del tiempo del programa no se da tan reelevante ya que solo se ejecutaa en pocas ocaciones.
El punto b es mas importante cuandos e presenta un problema cuya solucion se va a usar muchas veces, ya que el costo de ejecucion del programa minimizara al costo de escritura.
En conclusion siempre sera mas ventajoso (desde el punto de vista economico) tener un algoritmo complejo siempre y cuando el tiempo de ejecucion del rpograma sea significativamente menor.
Complejiad en el espacio
Complejidad espacial:
Es la memoria que utiliza un programa para su ejecución. Lo que implica que su eficiencia y memoria de un algoritmo lo indica la cantidad de espacio requerido para ejecutarlo, es decir, espacio en la memoria que ocupan todas las variables propias del algoritmo.
Ejemplo:
Algoritmo de busqueda en arboles
Función búsqueda_arboles(problema)
Devuelve solución/fallo
Inicializa árbol de búsqueda con estado inicial
Ciclo hacer
Si no hay candidatos para expandir
Entonces devolver fallo
En otro caso escoger nada para expandir
Si el nodo es el objetivo
Si
Entonces devolver solución
En otro caso expandir nodo
Es la memoria que utiliza un programa para su ejecución. Lo que implica que su eficiencia y memoria de un algoritmo lo indica la cantidad de espacio requerido para ejecutarlo, es decir, espacio en la memoria que ocupan todas las variables propias del algoritmo.
Ejemplo:
Algoritmo de busqueda en arboles
Función búsqueda_arboles(problema)
Devuelve solución/fallo
Inicializa árbol de búsqueda con estado inicial
Ciclo hacer
Si no hay candidatos para expandir
Entonces devolver fallo
En otro caso escoger nada para expandir
Si el nodo es el objetivo
Si
Entonces devolver solución
En otro caso expandir nodo
1.3.1 Tiempo de ejecución de un algoritmo.
Esta función se puede medir físicamente calculando con un reloj o se puede calcular sobre el código contando las instrucciones o ejecutar y multiplicándolo por el tiempo requerido por cada instrucción.
Reglas practicas para calcular la complejidad de un algoritmo
1.- Sentencia sencilla: se requiere la sentencia de asignación, entrada o salida de datos siempre y cuando no trabajen sobre estructuras cuyo tamaño esta relacionado con N (número de datos). Como requiere un tiempo constante de ejecución, su complejidad s de orden O (1).
2.- Secuencia de sentencias: su complejidad esta dada por la suma de las complejidades individuales de acuerdo al tipo de sentencia que se trate, tomándose n cuenta el orden más alto.
3.- Decisión (if): la solución sele ser de orden constante O (1), sumando en la peor rama posible ya sea la de then o else.
4.-Bucles (ciclos): a) en los ciclos con contador explicito existen dos casos que el tamaño N forme parte e los limites del ciclo o no.
Ej. Caso 1:
For (int i=0; i
Entonces K*0=O (1) constante
Caso 2:
For (int i=0; i>N; i++)
{S1;}
Entonces N*O (1)=O(n) Lineal
b) Evolución de variable DE CONTROL NO LINEAL (WHILE)
En los ciclos multiplicativos como while y do while el incremento o decremento de la variable de control no es lineal, lo que hace incrementar el orden de complejidad como en:
Ejemplo:
C=1; //incremento
While(c
S1;
C=2*C;
}
Entonces complejidad O (log n) Logarítmica.
Ejemplo:
C=n; //decremento
While(c>1)
{S1;
C=c/2;
}
Complejidad O (log n)
5.- Llamadas a procedimientos: la complejidad de llamar a un procedimiento esta dada por la complejidad del contenido del procedimiento en si, es decir, su complejidad depende del tipo de instrucciones o sentencias que existan en el cuerpo del procedimiento. En conclusión la complejidad de un procedimiento tiende a complicarse si se trata de procedimiento recursivos.
Ejemplo:
Función factorial (no recursiva)
int factorial (int n)//sentencia entrada O (1)
{
int fact=1; //sentencia asignación O(n)
for (int i=0; 1>O; i--)// ciclo contador explicito O(n)
fact=fact*i; //sentencia de asignación O (1)
Return fact; //sentencia salida O (1)
}
Entonces: complejidad lineal O(n) por el ciclo for o numero de iteraciones igual a n.
ORDENES DE COMPLEJIDAD
O (1) Constante ideal
O(n) Lineal eficiente
O (log n) Logarítmico eficiente
O(n log n) casi logarítmico eficiente
O(n^k) polinomial tratable
O (K^n) Exponencial intratable
O (n!) Factorial ingtratable
Monday, September 8, 2008
NOTACION ASINTOTICA OMEGA GRANDE
La funcion omega grande se usa para especificar una cota inferior para la velocidad de crecimineto de una funcion f(n) cuando esta en funcion de n. Y se usa la notacion:
T(n) es
que se lee T(n) es omega grande de g(n) para un numero infinito de valores de n.
Ejemplo: Verificar la funcion
para todos los valores n>=0
1+2>=1+3>=1
T(n) es
Ejemplo: Verificar la funcion
1+2>=1+3>=1
Tuesday, September 2, 2008
Aritmetica de la notacion O
*Notacion asintotica "O" grande: se usa para hacer referencia a la velocidad de crecimiento de los valores de una funcion. La utilidad de aplicar esta notacion a un algoritmo es encontrar el limite superior del tiempo de ejecucion, es decir, el peor caso.
=Definicion= |g(n)|<=|c.f(n)|, para todo n>n0.
Esto signofica que la funcion g(n) pertenece o es valida para f(n) si i solo si existen las constantes c y n0 tales que para n>=n0 T(n)<=cn
El orden de magnitud de la funcoin sera el orden del termino de la funcion mas grande respecto de n.
Ej. 1: Suponga que T(n)=(n+1)al cuadr cuando n0=1 y c=4 para n>=1. Verifique la funcion usando la "O" grande.
(n+1)2 <=cn2
(1+1)2<=4(1)2
2~2<4
4<=4
Existe una notación similar para indicar la mínima cantidad de recursos que un algoritmo necesita para alguna clase de entrada. La cota inferior de un algoritmo, denotada por el símbolo Ω, pronunciado “Gran Omega” u “Omega”, tiene la siguiente definición:
• T(n) está en el conjunto Ω (g(n)), si existen dos constantes positivas c y n0 tales que
|T(n)| ≥ c|g(n)| para todo n > n0.
• Ejemplo: Si T(n)=c1n2+c2n para c1 y c2 > 0, entonces:
|c1n2+c2n|≥|c1n2|≥c1|n2|
Por lo tanto, T(n) está en
Ω(n2).
=Definicion= |g(n)|<=|c.f(n)|, para todo n>n0.
Esto signofica que la funcion g(n) pertenece o es valida para f(n) si i solo si existen las constantes c y n0 tales que para n>=n0 T(n)<=cn
El orden de magnitud de la funcoin sera el orden del termino de la funcion mas grande respecto de n.
Ej. 1: Suponga que T(n)=(n+1)al cuadr cuando n0=1 y c=4 para n>=1. Verifique la funcion usando la "O" grande.
(n+1)2 <=cn2
(1+1)2<=4(1)2
2~2<4
4<=4
Existe una notación similar para indicar la mínima cantidad de recursos que un algoritmo necesita para alguna clase de entrada. La cota inferior de un algoritmo, denotada por el símbolo Ω, pronunciado “Gran Omega” u “Omega”, tiene la siguiente definición:
• T(n) está en el conjunto Ω (g(n)), si existen dos constantes positivas c y n0 tales que
|T(n)| ≥ c|g(n)| para todo n > n0.
• Ejemplo: Si T(n)=c1n2+c2n para c1 y c2 > 0, entonces:
|c1n2+c2n|≥|c1n2|≥c1|n2|
Por lo tanto, T(n) está en
Ω(n2).
Sunday, August 31, 2008
Teoria de complejidad computaional
Concepto de complejidad de algoritmo
Es la parte de la teoría de la computación que estudia los recursos necesarios durante el cálculo para resolver un problema.
Estos recursos son: el tiempo y el espacio.
-Clases de complejidad.
Los problemas de decisión (aquellos donde las respuesta es si o no) se clasifican en conjunto de complejidad comparable que son llamados clases de complejidad.
a) Clase de complejidad P: Es el conjunto de los problemas de decisión que pueden ser resueltos en tiempo polinomio por una maquina de turins lo que corresponde a problemas que pueden ser resueltos aun en el peor de los casos
Ej. Camino optimo de un cartero, saber si un número entero es primo, decidir si una frase pertenece a un conjunto dado de frases.
b) Clase de complejidad NP: conjunto de los problemas de decisión que pueden ser determinados por una maquina de turins no determinista en tiempo polinomio. Los problemas de esta clase tienen la propiedad de que su solución puede ser verificada.
Ej. El problema del agente viajero, El problemas de satisfacción booleana.
c) Clase de complejidad NP-Completo: Es el subconjunto de los problemas de decisión de Np que destacan por su extrema complejidad y que decimos que se hayan en la frontera externa de la clase NP.
Ej. La suma de subconjuntos dado un conjunto S de enteros, ¿existe un subconjunto no dado cuyos elementos sumen 0?, ¿Dos grafos son isomórficos si se puede transformar uno en el otro simplemente renombrando sus vértices?
¿Las clases P y Np son diferentes o no?
El Clay Mathematics Institute ofrece 1 millón de dólares a quien sea capaza de responder satisfactoriamente a esa pregunta.
Es la parte de la teoría de la computación que estudia los recursos necesarios durante el cálculo para resolver un problema.
Estos recursos son: el tiempo y el espacio.
-Clases de complejidad.
Los problemas de decisión (aquellos donde las respuesta es si o no) se clasifican en conjunto de complejidad comparable que son llamados clases de complejidad.
a) Clase de complejidad P: Es el conjunto de los problemas de decisión que pueden ser resueltos en tiempo polinomio por una maquina de turins lo que corresponde a problemas que pueden ser resueltos aun en el peor de los casos
Ej. Camino optimo de un cartero, saber si un número entero es primo, decidir si una frase pertenece a un conjunto dado de frases.
b) Clase de complejidad NP: conjunto de los problemas de decisión que pueden ser determinados por una maquina de turins no determinista en tiempo polinomio. Los problemas de esta clase tienen la propiedad de que su solución puede ser verificada.
Ej. El problema del agente viajero, El problemas de satisfacción booleana.
c) Clase de complejidad NP-Completo: Es el subconjunto de los problemas de decisión de Np que destacan por su extrema complejidad y que decimos que se hayan en la frontera externa de la clase NP.
Ej. La suma de subconjuntos dado un conjunto S de enteros, ¿existe un subconjunto no dado cuyos elementos sumen 0?, ¿Dos grafos son isomórficos si se puede transformar uno en el otro simplemente renombrando sus vértices?
¿Las clases P y Np son diferentes o no?
El Clay Mathematics Institute ofrece 1 millón de dólares a quien sea capaza de responder satisfactoriamente a esa pregunta.
Subscribe to:
Posts (Atom)