que es una cola 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 consultarse, añadirse y eliminarse únicamente 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.

cuales son sus características:

• 1. 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. 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 También es llamado estructura FIFO (del inglés First In First Out), debido a que el primer elemento en entrar será también el primero en salir.
• 2. REPRESENTACIÓN DE LAS CO Un elemento se inserta en la cola (parte final) de la lista y se suprime o elimina por la frente (parte inicial, cabeza) de la lista. Las aplicaciones utilizan una cola para almacenar elementos en su orden de aparición o concurrencia
• 3. Los elementos se eliminan (se quitan) de la cola en el mismo orden en que se almacenan y, por consiguiente, una cola es una estructura de tipo FIFO (First Input First Output) porque el primer elemento que entra a la cola es el primero que sale. Las colas se representan por listas enlazadas o por arrayas. Se necesitan dos punteros: frente (f) y final(r), y la lista o arraya de “n” elementos
• 4. OPERACIONES BÁSICAS DE LAS CO Las operaciones básicas de las colas son:  Crear: se crea la cola vacía.  Encolar (añadir, entrar, push): se añade un elemento a la cola. Se añade al final de esta.  Desencolar (sacar, salir, pop): se elimina el elemento frontal de la cola, es decir, el primer elemento que entró.  Frente (consultar, front): se devuelve el elemento frontal de la cola, es decir, el primero elemento que entró.
• 5. APLICACIONES DE LAS COLAS. Esta estructura de datos se usa en muchos sistemas operativos, por ejemplo Unix, para llevar el control de la ejecución de procesos, cada proceso en el sistema es almacenado en una lista y esta se va recorriendo, dándole un pequeño tiempo del microprocesador a cada proceso, durante la fracción de segundo de cada proceso este asume que tiene el control total del procesador.
• 6. COLA CIRCULAR O ANILLO 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 consultarse, añadirse y eliminarse únicamente desde la cabeza del anillo que es una posición distinguida. Esta avanza en el sentido de las agujas del reloj. En la figura mostrada muestra una cola circular con un solo dato almacenado. La variable “final” es la posición en donde se hizo la última inserción. Después que se ha producido una inserción, final se mueve circularmente a la derecha.
• 7. COLA DE PRIORIDADE Una cola de prioridades se utiliza para 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. Este tipo especial de colas tienen las mismas operaciones que las colas, pero con la condición de que los elementos se atienden en orden de prioridad.
• 8. DOBLE COLA (BICOLA 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. Existen dos tipos de la doble cola: · Doble cola de entrada restringida: acepta inserciones solo al final de la cola. · Doble cola de salida restringida: acepta eliminaciones solo al frente de la cola
• 9. TIPO COLA IMPLEMENTADO COMO ARREG La figura de arriba, muestra la forma de implementar una cola, como arreglo, en la que cada casilla, representa una estructura compuesta por el tipo de dato a guardar (o bien otra estructura). Las variables q.rear y q.front, se van modificando cada vez que añadimos o eliminamos datos de nuestra cola. Para determinar la cantidad de elementos en cualquier momento utilizamos la expresión: Cant=q.rear-q.front+1

como se emplea:

Anillo en Maude

fmod ANILLO {X :: TRIV} is
        sorts AnilloNV{X} Anillo{X} .
        subsort AnilloNV{X} < Anillo{X} .

        op crear : -> Anillo{X} [ctor] .
        op insertar : X$Elt Anillo{X} -> AnilloNV {X} [ctor] .

 -> Anillo{X} .
        ops rotarDch rotarIzq : Anillo{X} -> Anillo{X} .
        op cabeza : AnilloNV{X} -> X$Elt .
        op esVacio? : Anillo{X} -> Bool .
        op aLaCola : X$Elt Anillo{X} -> Anillo{X} .
        op elimCola : Anillo{X} -> Anillo{X} .
        op cola : AnilloNV {X} -> X$Elt .

        var A : Anillo{X} .
        vars E E2 : X$Elt .

        eq eliminar(crear) = crear .
        eq eliminar(insertar(E, A)) = A .

        eq cabeza(insertar(E, A)) = E .

        eq esVacio?(crear) = true .
        eq esVacio?(insertar(E, A)) = false .

        eq cola(insertar(E, crear)) = E .
        eq cola(insertar(E, insertar(E2, A))) = cola(insertar(E2, A)) .

        eq elimCola(crear) = crear .
        eq elimCola(insertar(E, crear)) = crear .
        eq elimCola(insertar(E, insertar(E2, A))) = insertar(E, elimCola(insertar(E2, A))) .

        eq aLaCola(E, crear) = insertar(E, crear) .
        eq aLaCola(E, insertar(E2, A)) = insertar(E2, aLaCola(E, A)) .

        eq rotarDch(crear) = crear .
        eq rotarDch(insertar(E, A)) = aLaCola(E, A) .

Anillo en Pseudolenguaje

FUNC CrearCola() : TCola
VARIABLES
cola: TCola
INICIO
        cola.frente <- MAXCOLA
        cola.final <- MAXCOLA
        RESULTADO <- cola
FIN

PROC DestruirCola(&cola: TCola)
INICIO
//No hay q hacer nada
FIN

FUNC ColaLlena(cola: TCola): LÓGICO
INICIO
        RESULTADO <- (cola.final MOD MAXCOLA) + 1 = cola.frente
FIN

FUNC ColaVacia(cola: TCola): LÓGICO
INICIO
        RESULTADO <- cola.final = cola.frente
FIN


PROC MeterCola (&cola: TCola; &e: Telemento; &error: Terror)
VARIABLES
fin: NATURAL
INICIO
        SI ColaLlena(cola) ENTONCES
                error <- ErrorColaLlena
        EN OTRO CASO
                error <- NoError
                fin <- (cola.final MOD MAXCOLA) + 1
                cola.final <- fin
                cola.elementos[fin] <- e
        FINSI
FIN

PROC SacarCola (&cola: TCola; &e: Telemento; &error: Terror)
VARIABLES
        ini: NATURAL
INICIO
        SI ColaVacia(cola) ENTONCES
                error <- ErrorColaLlena
        EN OTRO CASO
                error <- NoError
                ini <- (cola.frente MOD MAXCOLA) + 1
                cola.frente <- ini
                e <- cola.elementos[ini]
        FINSI
FIN

estructuras de C#

Estructuras de Control  C#

 Introducción

Antes de escribir un programa que de solución a un problema, es necesario tener una idea detallada del problema, así como la comprensión de los bloques para la construcción de diagramas de flujo.

Cualquier problema de computación puede resolverse ejecutando una serie de acciones en un orden especifico, a esto se le conoce con el nombre de algoritmo y depende de dos cosas principales:

1.- Las acciones a ejecutar

2.- El orden en el que se ejecutan las acciones.

Definicion de Pseudocodigo: Es un lenguaje informal que ayuda a los programadores a desarrollar algoritmos sin tener que preocuparse por los estrictos detalles de la sintaxis de un lenguaje de programación. El pseudocódigo es semejante al lenguaje cotidiano, es amigable con el usuario y ayuda a organizar un programa.

Estructuras de Control

Por lo general, en un programa las instrucciones se ejecutan una después de otra en el orden en que están escritas, este proceso se conoce como ejecución secuencial. Varias instrucciones en Java y C# permiten al programador especificar que la siguiente instrucción a ejecutarse tal vez no sea la siguiente secuencia. Esto se conoce como transferencia de control.

Java tiene solo tres estructuras de control: la secuencia de estructura, la estructura de selección (tres tipos) y la estructura de repetición (tres tipos), en C# tenemos la estructura de selección (tres tipos) y la estructura de repetición (cuatro tipos). Cada programa se forma combinando tantas estructuras de secuencia, selección y repetición como sea apropiado para el algoritmo que implemente el programa.

Estructura de Selección if Simple

Esta intruccion sirve para elegir entre entre los cursos alternativos de acción, por ejemplo:

Supongamos el siguiente pseudocódigo:

Si la edad de un individuo es mayor a 18

Imprimir “Mayor de edad”

Codigo en Java

if (edad > 18 )

System.out.println(“Mayor de edad”);

Codigo en C#

if (edad > 18)

Console.WriteLine(“Mayor de edad”);

Estructura de Selección if… else…

La estructura de selección if… else permite al programador especificar una acción cuando la condición es verdadera y otra cuando la condición es falsa, como en el siguiente pseudocodigo:

Si edad de una persona es mayor a 18

Imprimir “Mayor de Edad”

De lo contrario

Imprimir “Menor de Edad”

Codigo en Java

if (edad > 18)

System.out.println(“Mayor de Edad”);

else

System.out.println(“Menor de Edad”);

Codigo C#

if (edad > 18)

Console.WriteLine (“Mayor de Edad”);

else

Console.WriteLine (“Menor de Edad”);

Instrucciones if… else Anidadas

Un programa puede evaluar varios caso colocando if… else… anidados, por ejemplo el siguiente pseudocódigo:

Si la calificación del estudiante es mayor o igual a 90

Imprimir “Excelente”

De lo contrario

Si la calificación es mayor o igual a 70

Imprimir “Aceptable”

De lo contrario

Imprimir “Reprobado”

Codigo Java

if ( calificación >= 90 )

System.out.println(“Excelente”);

else

if (calificación >= 70 )

System.out.println(“Aceptable”);

else

System.out.println(“Reprobado”);

Codigo C#

if ( calificación >= 90 )

Console.WriteLine(“Excelente”);

else

if (calificación >= 70 )

Console.WriteLine (“Aceptable”);

else

Console.WriteLine (“Reprobado”);

Hay que tener cuidado de no caer en el error de no adidar correctamente el else, en Java y C# el ultimo else es asociado con el if que precede inmediatamente. Por ejemplo el siguiente código en Java.

if ( x > 5 )

if( y > 5 )

System.out.println(“x e y son > 5”);

else

System.out.println(“x es >= 5”);

En realidad el compilador lo interpreta de la siguiente manera:

if ( x > 5 )

if( y > 5 )

System.out.println(“x e y son > 5”);

else

System.out.println(“x es >= 5”);

Para lograr que la instruccion se ejecute como se pensaba en un principio se utiliza las {} para indicar que la intruccion else se ejecuta con la primer sentencia if.

if ( x > 5 ){

if( y > 5 )

System.out.println(“x e y son > 5”);

}

else

System.out.println(“x es >= 5”);

Tambien es forzoso usar las {} cuando se ejecutan mas de una instruccion dentro de cada if… else

Por ejemplo:

if (edad > 18){

Console.WriteLine(“Ya eres mayor de edad”);

Console.WriteLine(“Y puedes sacar tu licencia de manejo”);

}

else{

Console.WriteLine(“Aun eres menor de edad”);

Console.WriteLine(“No puedes sacar tu licencia de manejo hasta después de los 18 anios”);

}

NOTA: Cuando no ponga los dos ejemplos para Java y C# quiere decir que la sintaxis es parecida en este caso lo único que diferencia es System.out.println y Console.WriteLine, ya que tienen el mismo fin.

Instrucción de Selección Multiple switch

La instrucción switch permite tomar una decisión en base a los posibles valores de una variable o expresión, cada acción se asocia con un valor integral constante (es decir un valor de tipo byte, short, int o char pero no long) que la variable o expresión pueda asumir.

Por ejemplo pedir la orden de un menú en base a lista formada por los menus 1, 2, 3

Codigo Java

switch (myOpcion) { //inicio de switch

case 1:

System.out.println(“-Sopa de letras \n –Pechuga empanizada\n –Gelatina \n -Agua de fruta”);

break;

case 2:

System.out.println(“-Crema de zanahoria \n –Costillas en salsa roja\n –Helado \n -Agua de fruta”);

break;

case 3:

System.out.println(“-Torta de Milaneza \n –Papas a la francesa\n –Refresco de cola”);

break;

default:

System.out.println(“Debe de elegir un menú de la lista”);

} //fin de switch

Codigo C#

switch opcion (myOpcion) { //inicio de switch

case 1:

Console.WriteLine(“-Sopa de letras \n –Pechuga empanizada\n –Gelatina \n -Agua de fruta”);

break;

case 2:

Console.WriteLine (“-Crema de zanahoria \n –Costillas en salsa roja\n –Helado \n -Agua de fruta”);

break;

case 3:

Console.WriteLine (“-Torta de Milaneza \n –Papas a la francesa\n –Refresco de cola”);

break;

default:

Console.WriteLine (“Debe de elegir un menú de la lista”);

} //fin de switch

Nota: Para Java no se pone la instruccion break despues de default, en C# si.

Estructura de Repeticion while

Una estructura de repetición (también llamada estructura ciclo) permite al programador especificar que un programa debe repetir una acción mientras cierta condición sea verdadera. Por ejemplo el siguiente pseudocódigo para una persona que sale de compras:

Mientras existan mas artículos en mi lista de compras

Comprar el siguiente articulo y quitarlo de mi lista

Ahora veamos un ejemplo:

Encontrar la primera potencia que sea mayor a 1000, suponiendo que la variable la inicializamos en 2.

int producto = 2;

while( producto <= 1000 )

producto = 2 * producto;

//Java

System.out.println(producto);

//C#

Console.WriteLine(producto);

Instrucción de Repeticion do… while

Es similar a la instrucción while, y la única diferencia es que en la istruccion while la condición se evalua al principio, por lo que si la condición es falsa el ciclo no se ejecuta y en la condición do…while por lo menos se ejecuta una vez el ciclo ya que la condición se evalua al final. Cuando termina una estructura do… while el programa continua inmediatamente después de la instrucción while.

El siguiente ejemplo imprime de el numero 0 al 9, notemos como si inicializamos la variable en 10 el ciclo se ejecuta por lo menos una vez.

int myVariable = 0;

do {

System.out.println(myVariable);

//C#

//Console.WriteLine(myVariable);

myVariable++;

} (while myVariable < 10);

Notemos que debemos de terminar con punto y coma (;) al finalizar la condición del while.

Instrucción for

La instrucción for es la instrucción de iteración mas potente. El código de control de la instrucción for se divide en tres partes:

1. Un indicador. Que fija las condiciones iniciales de la instrucción de bucle for.


2. Una condición que especifica la expresión booleana que mantiene ejecutándose la instrucción for.


3. Un iterador que especifica las instrucciones que se ejecutan al final de cada paso por las instrucciones incrustadas

A continuación vemos un ejemplo que imprime también los números del 0 al 9:

int myVariable;

For(myVariable = 0; myVariable < 10; myVariable++)

{

System.out.println(myVariable);

//C#

//Console.WriteLine(myVariable);

}

El iniciador, la condicion y el iterador de un bucle for son opcionales. Si prefiere no usar alguna de estas partes, simplemente escriba un punto y coma sin especificar la instrucción. Por ejemplo:

int myVariable = 0;

For(; myVariable < 10; myVariable++)

{

Console.WriteLine(myVariable);

//Java

//System.out.println(myVariable);

}

//------------------------

//O también

int intVaribale;

For (myVariable = 0; ; myVariable++ )

{

Console.WriteLine(myVariable);

//Java

//System.out.println(myVariable);

myVariable++;

}

Hay que tener cuidado cuando se omita la parte de la condición en un bucle for. El siguiente código es un ejemplo de los problemas que pueden surgir.

for(int myVariable = 0; ; myVariable++)

{

Console.WriteLine(myVariable);

}

Este código se ejecuta hasta que myVariable provoca un error porque contiene un numero demasiado largo para ser almacenado.

Instrucción foreach (Solo C#)

Se puede usar la instrucción foreach para repetir varias veces los elementos de una colección. Las matrices de C# admiten la instrucción for each y pueden usarse para trabajar fácilmente con cada elemento de la matriz.

La sintaxis es la siguiente:

Foreach (tipoDato nombreVariable in Colleccion)

{

}

Por ejemplo:

int[] myArray;

myArray[0] = 0;

myArray[1] = 1;

myArray[2] = 2;

myArray[3] = 3;

myArray[4] = 4;

foreach( int ArrayElement in myArray)

{

Console.WriteLine(ArrayElement);

}

Instrucciones de salto para moverse por el código

Hago mención de estas instrucciones ya que por lo regular se utilizan en estructuras de ciclos o repetición.

La instrucción break

Como ya vimos en la estructura switch la instrucción break sirve para salir de un bloque de instrucciones en el que se encuentre.

int myVariable = 0;

while(myVariable < 10)

{

Console.WriteLine(myVariable);

//Java

//System.out.println(myVariable);

if( myVariable == 5 )

break;

myVariable++;

}

El código anterior se sale cuando myVariable = 5, Imprime en pantalla del 0 al 4

La instrucción break suele usarse con bloques de instrucciones switch, while, do… while, for y foreach(solo C#).

La Instrucción continue

La instrucción continue devuelve el control a la expresión booleana que controla una instrucción de iteración, por ejemplo:

int myVariable;

For (myVariable = 0; myVariable < 10; myVariable++ )

{

if (myVariable == 5)

continue;

Console.WriteLine(myVariable);

//Java

//System.out.println(myVariable);

}

El codigo anterior imprime del 0 al 9, excepto el 5, es decir “Si el valor de myVariable es 5”, continua con la siguiente iteración sin ejecutar ninguna instrucción después del continue”. Al igual que break, continue se usa en instrucciones switch, while, do… while, for y foreach(solo C#).

Instrucción goto (C#)

La instrucción goto transfiere sin condiciones el control a una instrucción etiquetada. Puede etiquetarse cualquier instrucción de C#. Las etiquetas de instrucción son identificadores que preceden a una instrucción. Despues de una etiqueta se colocan dos puntos(:). Un identificador de etiqueta sigue a la palabra clave goto y la instrucción goto transfiere el control a la instrucción designada por el identificador de etiqueta. Por ejemplo:

int myVariable = 0;

while(myVariable < 10 )

{

Console.WriteLine(myVariable);

if ( myVariable == 5 )

goto done;

myVariable++;

}

done: Console.WriteLine(“Fuera del ciclo”);

El código anterior escribe del 0 al 4 y a continuación la leyenda “Fuera del ciclo”

break etiquetado(Java)

En Java tambien tenemos una opcion para poder hacer lo que se hace con goto de C#. A continuacion muestro un ejemplo:

String salida = "";

alto: { //bloque etiquetado

// contar 10 filas

for ( int fila = 1; fila <=10; fila++){

for ( int columna = 1; columna <= 5; columna++) {

if ( fila == 5 ) // si la fila es 5.

break alto; //saltar al final del bloque alto

salida += "* ";

} // fin de for interno

salida += "\n";

} // fin de for externo

// la siguiente linea se evita

salida += "\nLos ciclos terminaron normalmente";

} // fin del bloque etiquetado

// en el codigo anterior cuando fila es 5 se ejecuta break de la etiqueta y termina tanto el bloque interno del for como el externo, el for externo nunca se completa

ESTRUCTURAS DE PROGRAMACION

PROGRAMACION CON C#, C++, VISUAL ESTUDIO ETC..