#include <string.

h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

#define MAX 100

char *p [ MAX ] , *pop ( void ) ;

int spos = 0 ;
int rpos = 0 ;
void add ( void ) , push ( char *q ) , print ( void ) , remove ( void ) ;

void add ( void )

{
   char s [ 256 ] , *p;

   do {
     printf ( "spos %d: " , spos+ 1 ) ;
     gets ( s ) ;
     if ( *s== 0 ) {
        break ;
     }
     p = ( char * ) malloc ( strlen ( s ) + 1 ) ;
     if ( !p ) {
       printf ( "Out of memory.\n" ) ;
       return ;
     }
     strcpy ( p, s ) ;
     if ( *s ) {
        push ( p ) ;
     }
   } while ( *s ) ;
}

void print ( void )

{
   int t;

   for ( t=rpos; t < spos; ++t )

     printf ( "%d. %s\n" , t+ 1 , p [ t ]) ;
}

void remove ( void )

{
   char *p;

   if (( p=pop ()) ==NULL ) {

      return ;
   }
   printf ( "%s\n" , p ) ;
}

void push ( char *q )

{
   if ( spos==MAX ) {
     printf ( "List Full\n" ) ;
     return ;
   }
   p [ spos ] = q;
   spos++;
}

char *pop ( void )

{
   if ( rpos==spos ) {
     printf ( "No more.\n" ) ;
     return NULL;
   }
   rpos++;
   return p [ rpos- 1 ] ;
}

int main ( void )

{
   char s [ 80 ] ;
   register int t;

   for ( t= 0 ; t < MAX; ++t ) {

      p [ t ] = NULL;
   }

   while ( 1 ) {
     printf ( "Add(A), Print(P), Remove(R), Quit(Q): " ) ;
     gets ( s ) ;
     *s = toupper ( *s ) ;

     switch ( *s ) {
       case 'A' :
         add () ;
         break ;
       case 'P' :
         print () ;
         break ;
       case 'R' :
         remove () ;
         break ;
       case 'Q' :
         exit ( 0 ) ;
     }
   }
   return 0 ;
}

/*
C: The Complete Reference, 4th Ed. (Paperback)
by Herbert Schildt

ISBN: 0072121246
Publisher: McGraw-Hill Osborne Media; 4 edition (April 26, 2000)
*/
/* A circular queue example using a keyboard buffer. */
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>

#define MAX 80

char buf [ MAX+ 1 ] ;

int spos = 0 ;
int rpos = 0 ;

void qstore ( char q ) ;

char qretrieve ( void ) ;

int main ( void )

{
   register char ch;
   int t;

   buf [ 80 ] = '\0' ;

   /* Input characters until a carriage return is typed. */

   for ( ch= ' ' ,t= 0 ; t< 32000 && ch!= '\r' ; ++t ) {
     if ( _kbhit ()) {
       ch = _getch () ;
       qstore ( ch ) ;
     }
     printf ( "%d " , t ) ;
     if ( ch == '\r' ) {
       /* Display and empty the key buffer. */
       printf ( "\n" ) ;
       while (( ch=qretrieve ()) != '\0' ) printf ( "%c" , ch ) ;
       printf ( "\n" ) ;
     }
   }
   return 0 ;
}

/* Store characters in the queue. */

void qstore ( char q )
{
   if ( spos+ 1 ==rpos || ( spos+ 1 ==MAX && !rpos )) {
     printf ( "List Full\n" ) ;
     return ;
   }
   buf [ spos ] = q;
   spos++;
   if ( spos==MAX ) spos = 0 ; /* loop back */
}

/* Retrieve a character. */
char qretrieve ( void )
{
   if ( rpos==MAX ) rpos = 0 ; /* loop back */
   if ( rpos==spos ) return '\0' ;

   rpos++;
   return buf [ rpos- 1 ] ;
}

Cola (estructura de datos)

De Wikipedia, la enciclopedia libre
 Saltar a navegación , búsqueda
Este artículo es sobre las estructuras de cola en la informática. Para las colas en general,
vea la cola (desambiguación) .

Representación de una cola FIFO

Una cola (que se pronuncia / ː Kju / Kew) es un tipo particular de recolección en los que
las entidades de la colección se mantiene en orden y el principal (o única) para las
operaciones de la colección son la adición de las entidades a la posición de los terminales
posteriores y la eliminación de entidades de la posición de conexión anterior. Esto hace
que la cola de una primera In-First-Out (FIFO) estructura de datos . En una estructura de
datos FIFO, el primer elemento añadido a la cola será el primero en ser eliminado. Esto es
equivalente a la obligación de que una vez que se agrega un elemento, todos los elementos
que se agregaron antes tienen que ser quitados antes de que el nuevo elemento puede ser
invocada. Una cola es un ejemplo de una estructura de datos lineales .

Colas de prestación de servicios en ciencias de la computación , el transporte y la

investigación de operaciones en diversas entidades, tales como datos, objetos, personas o
eventos son almacenados y mantenidos para ser procesado más tarde. En estos contextos,
la cola lleva a cabo la función de un tampón .

Las colas son habituales en los programas de ordenador, donde se implementan como
estructuras de datos junto con las rutinas de acceso, como una estructura de datos abstracta
o en idiomas orientados-objeto como clases. implementaciones más comunes son buffers
circulares y listas enlazadas .

Contenido
[hide]

 1 Operaciones
 2 Representación de una cola
 3 cola de la aplicación
 4 Ejemplo en C
  5 Ejemplo C + + código de la lengua con matriz
 6 Ejemplo de programa en Python
 7 Ejemplo de programa Pascal
 8 Ejemplo de clases de C #
 9 Ejemplo de código Java
 10 Ejemplo de código Javascript
 11 Véase también
 12 Referencias
 13 Enlaces externos

[ editar ] Operaciones
Las operaciones habituales de la C + + Biblioteca de plantillas estándar son las siguientes:

bool empty ()
Devuelve True si la cola está vacía, y False en caso contrario.
T & frontal ()
Devuelve una referencia al valor en el frente de una cola no vacía. También hay
una versión de esta función constante, T constante y frontal ().
pop void ()
Elimina el elemento en el frente de una cola no vacía.
sin efecto push (const T & foo)
Inserta el foo argumento en la parte posterior de la cola.
tamaño size_type ()
Devuelve el número total de elementos en la cola.

[ editar ] En representación de una cola

El atributo de la definición de una estructura de cola de datos es el hecho de que permite el
acceso sólo a la parte delantera y trasera de la estructura. Además, los elementos sólo
puede ser removido de la parte delantera y sólo se puede agregar a la espalda. De este
modo, una metáfora apropiada a menudo se utiliza para representar las colas es la idea de
una línea de pago y envío. [1] Otros ejemplos de las colas son personas que viajan por una
escalera mecánica, piezas de la máquina en una cadena de montaje, o los coches en fila en
una gasolinera. El tema recurrente es claro: las colas son esencialmente las mismas como
una cola que se obtendría en una tienda de espera para pagar.

En cada uno de los casos, el cliente o el objeto en la parte delantera de la línea fue el
primero en entrar, mientras que al final de la línea es el último que se ha incorporado. Cada
vez que un cliente termina pagando por sus artículos (o una persona se fuera de la escalera
mecánica, o la pieza de la máquina se retira de la línea de montaje, etc) que el objeto sale
de la cola de la parte delantera. Esto representa la cola de "quitar de la cola" de funciones.
Cada vez que otro objeto o cliente entra en la línea de espera, se unen a la final de la línea y
representan el "poner en cola" función. La cola de "tamaño" de la función que devuelve la
longitud de la línea, y el "vacío" función devolvería true sólo si no había nada en la línea.

[ editar ] la aplicación de cola

Teóricamente, una de las características de una cola es que no tiene una capacidad
específica. Independientemente de cuántos elementos ya están contenidos, un nuevo
elemento siempre se puede añadir. También puede estar vacío, momento en que la
eliminación de un elemento no será posible hasta que un nuevo elemento se ha añadido otra
vez.

matrices de longitud fija son limitados en la capacidad, e ineficaz porque los artículos se
deben copiar a la cabeza de la cola. Sin embargo, conceptualmente son simples y el trabajo
con las lenguas a principios tales como FORTRAN y base que no se han punteros o los
objetos. La mayoría de los idiomas modernos con objetos o punteros puede aplicar o
vienen con las bibliotecas de listas dinámicas. Estas estructuras de datos que no se
especifica límite de capacidad fija, además de las limitaciones de la memoria. Cola de los
resultados de desbordamiento de tratar de aportar un elemento en una cola llena y la cola
de desbordamiento ocurre cuando se trata de quitar un elemento de una cola vacía.

Una cola es una cola limitada limitada a un número fijo de elementos.

[ editar ] Ejemplo en C
En este ejemplo se utiliza un C solos lista enlazada y la memoria dinámica . Es una forma
eficiente de implementar contenedores lineales de acceso.

# Include
# Include <errno.h>
# Include <stdlib.h>

estructura queue_node
{
estructura queue_node * siguiente;
de datos int;
};

struct cola
{
estructura queue_node * primero;
estructura queue_node * última;
};

enqueue int (struct cola * q, el valor const int)

{
struct nodo * queue_node = malloc (sizeof (struct queue_node));
if (nodo == NULL) {
errno = ENOMEM;
return 1;
 }
nodo -> data = valor;
si (q -> primero == NULL) {
q -> primero q = - => último nodo;
Else {}
q -> última - = siguiente nodo>;
q - último nodo =>;
}
nodo -> siguiente = NULL;
return 0;
}

dequeue int (struct cola * q, el valor int *)

{
si (- q> primero) {
* Valor = 0;
return 1;
}
* Valor = q - datos -> primero;
estructura queue_node * tmp = q -> primero;
si (q -> primero == q -> última) {
q -> primero q = - => NULL pasado;
Else {}
q -> primero = q - siguiente> -> siguiente;
}
libre (tmp);
return 0;
}

init_queue vacío (struct cola * q)

{
q -> primero q = - => NULL pasado;
}

queue_empty_p int (const struct cola * q)

{
q volver -> primero == NULL;
}

run_test (void)
{
struct cola de Q;
init_queue (& Q);
srand (time (NULL));

int k = 0 sin firmar;

while (k <100) {
encolar (& Q, (rand ()% 100) + 1); / * Llene con números
aleatorios de 1 a 100 * /
+ + K;
}
k = 1;
while (! queue_empty_p (& Q)) {
de datos int;
quitar de la cola (& Q, y de datos);
printf ("(% d)% d \ n", k, datos);
 + + K;
}
}

int main (void)

{
run_test ();
putchar ('\ n');
return 0;
}

Una salida podría ser:

(1) 72
(2) 31
(3) 48
(4) 88
(5) 33
(6) 100
(7) 26
(8) 72
(9) 65
(10) 95
(11) 63
(12) 72
(13) 83
(14) 72
(15) 30
(16) 54
(17) 44
(18) 52
(19) 89
(20) 37
(21) 96
(22) 55
(23) 32
(24) 58
(25) 39
(26) 71
(27) 80
(28) 10
(29) 21
(30) 3
(31) 74
(32) 44
(33) 86
(34) 21
(35) 32
(36) 70
(37) 72
(38) 9
(39) 41
(40) 37
(41) 56
(42) 4
(43) 8
(44) 38
(45) 75
(46) 89
(47) 92
(48) 70
(49) 40
(50) 80
(51) 58
(52) 87
(53) 86
(54) 89
(55) 45
(56) 77
(57) 12
(58) 76
(59) 86
(60) 84
(61) 30
(62) 60
(63) 28
(64) 15
(65) 32
(66) 11
(67) 85
(68) 4
(69) 71
(70) 25
(71) 40
(72) 26
(73) 80
(74) 99
(75) 64
(76) 6
(77) 87
(78) 7
(79) 28
(80) 78
(81) 38
(82) 85
(83) 64
(84) 23
(85) 26
(86) 60
(87) 99
(88) 37
(89) 87
(90) 37
(91) 20
(92) 17
(93) 48
(94) 47
(95) 31
(96) 79
(97) 9
(98) 67
(99) 82
(100) 80
[ editar ] Ejemplo C + + código de la lengua con matriz
Este ejemplo C + + lenguaje utiliza una matriz de longitud fija y variable global para la
simplicidad conceptual.

/ / Estructura global de datos para simplificar

/ / CppInterview.cpp: Define el punto de partida para la aplicación de
consola.
/ /

# Include "stdafx.h"
# Include <iostream>
# Include "math.h"
# Include <time.h>
using namespace std;
# Define QMAX 10

struct Nodo
{
int valor;
Nodo * siguiente;
};

Nodo * Q [QMAX];
cabeza int = 0;
cola int = 0;

/ / Devuelve 1 si tiene éxito, de lo contrario 0

enqueue int (nodo * p)
{
if (cabeza <cola + Qmax)
{
Q [cola] = p;
cola = (cola + 1)% QMAX;
return 1;
}
más
{
return 0;
}
}

/ / Devuelve 1 si tiene éxito, de lo contrario 0

dequeue int (Nodo ** p)
{
if (cabeza == cola)
{
return 0;
}
* P = Q [cabeza];
Q [cabeza] = NULL;
cabeza + +;
cabeza% = Q máx;
return 1;
 }

PrintQueue void ()
{
int index = cabeza;
int QueueLength = (cola + QMAX - cabeza) QMAX%;
for (int index = cabeza, la cabeza <indice + QueueLength, el
índice + +)
{
cout <<Q [(índice + Qmax)% QMAX] -> valor <<"-";

}
Cout <<endl;
}

vacío PrintArray ()
{
for (int i = 0; i <10; i + +)
{
si (Q [i]! = NULL)
{
cout <<Q [i] -> valor <<"-";
}
más
{
Cout <<"00" <<"-";
}
}
Cout <<endl;
}

/ / Generar números aleatorios 1 a 100

generateRandNum int ()
{
/ / / * Inicializar la semilla aleatoria: * /
/ / Srand (time (NULL));

/ * Generar el número de nodos: * /

rand retorno () 100% + 1;
}

int tmain (int argc, _TCHAR * argv [])

{
int i = 1;
while (i <= 20)
{
int rand = generateRandNum ();
if (rand <= 60)
{
Nodo * n = (Nodo *) malloc (sizeof (Nodo));
n -> valor = generateRandNum ();
n -> siguiente = NULL;
encolar (n);
}
más
{
 Nodo * p;
if (quitar de la cola (& p)! = 0)
{
libre (p);
}
}
/ / PrintQueue ();
Imprimir ();
i + +;
}

return 0;
}

La salida muestra el siguiente aspecto:

68 a 00 - 00 - 00 - 00 - 00 - 00 - 00 - 00 - 00 -
68 a 1 - 00 - 00 - 00 - 00 - 00 - 00 - 00 - 00 -
00-1 - 00 - 00 - 00 - 00 - 00 - 00 - 00 - 00 -
00-1 - 79 - 00-00 - 00 - 00-00 - 00 - 00 -
00-1 - 79 - 63-00 - 00 - 00-00 - 00 - 00 -
00 a 00 - 79 - 63-00 - 00 - 00-00 - 00 - 00 -
00 a 00 - 79 - 63-46 - 00 - 00-00 - 00 - 00 -
00 a 00 - 00 - 63-46 - 00 - 00-00 - 00 - 00 -
00 a 00 - 00 - 63-46 - 62 - 00-00 - 00 - 00 -
00 a 00 - 00 - 00-46 - 62 - 00-00 - 00 - 00 -
00 a 00 - 00 - 00 - 00 - 62-00 - 00 - 00 - 00 -
00 a 00 - 00 - 00 - 00 - 62-28 - 00 - 00 - 00 -
00 a 00 - 00 - 00-00 - 62 - 28-92 - 00 - 00 -
00 a 00 - 00 - 00-00 - 62 - 28-92 - 3 - 00 -
00 a 00 - 00 - 00 - 00 - 62-28 - 92 - 3-93 -
00 a 00 - 00 - 00-00 - 00 - 28-92 - 3 - 93 -
17 a 00 - 00 - 00-00 - 00 - 28-92 - 3 - 93 -
17 a 96 - 00 - 00-00 - 00 - 28-92 - 3 - 93 -
17 a 96 - 27 - 00-00 - 00 - 28-92 - 3 - 93 -
17 a 96 - 27 - 00-00 - 00 - 00-92 - 3 - 93 -
Pulse cualquier tecla para continuar. . .

[ editar ] Ejemplo de programa Python

Un objeto de la lista de Python se puede utilizar como una cola, aunque este uso es
cuestionable debido a la complejidad del tiempo lineal del pop (0) la operación en las listas.
El objeto deque disponibles en el módulo de colecciones es mucho más conveniente como
añadir o estallidos de ambos lados es la complejidad constante de tiempo. Importar el
módulo de la cola de la cola de las clases más avanzadas. El código siguiente muestra una
implementación simple de colas en Python.

clase de cola:
def __init__ (, artículos de auto = None):
si los artículos es None:
elementos = []
auto. __queue = elementos
estaVacio definición (self):
 len retorno (sí. __queue) == 0
enqueue definición (, obj mismo):
auto. __queue. append (obj)
dequeue definición (self):
retorno libre. __queue. pop (0)
mirar definición (self):
retorno libre. __queue [0]

[ editar ] Ejemplo de programa Pascal

Basado en un ejemplo en algoritmos RS.

programa de cola;
tipo
link = ^ nodo;
nodo = record
; Siguiente enlace:
; Entero clave:
final;

var

U: integer;
cola, la cabeza: enlace;

queinit procedimiento; / / Inicializa la cola

comenzar
Nueva (cola);
^ Cola:. Próxima = nulo;
cabeza: la cola =;
final;

procedimiento puso (u: entero); / / u número pone en la cola

var
t: enlace;
comenzar
Nueva (t);
^ Cola;. Key =: u
^ Cola;. Siguiente =: t
cola: t =;
final;

pop función: entero; / / corridas número uno a la vez

var
s: Enlace;
comenzar
pop: cabeza = ^;. clave
s: = cabeza;
cabeza: cabeza = ^;. próxima
dispose (s);
final;

vacía la función: boolean; / / verifica si la cola está vacía

comenzar
 vacío: la cabeza = = cola;
final;

comenzar
queinit;
u: = 1;
puso (u); / / Poner 1 en la cola

u: = 2;
puso (u); / / Ponga 2 en la cola

u: = 3;
puso (u); / / Ponga 3 en la cola
finales.

[ editar ] Ejemplo C # Clase

using System;
utilizando System.Collections.Generic;

QueueExample espacio de nombres

{
públicos cerrados clase Queue <> T: IEnumerable <T>
{
privada clase Node
{
pública nodo anterior;
pública valor T;
}

Primer nodo;
Último nodo;
int cuenta = 0;

public int conde {get {return cuenta;}}

public void Poner en cola (punto T)

{
Nodo nodo = new Nodo {valor = elemento};
if (primero == null)
= Último nodo;
más
primer nodo anterior =.;

= Primer nodo;
cuenta + +;
}

Dequeue pública T ()
{
if (cuenta == 0)
lanzar nuevos InvalidOperationException ("cola está
vacía.");
 Nodo = nodo anterior;
último nodo anterior = anterior.;
última = anterior;
si (== null anterior)
= Null primero;

contar -;
volver nodo de valor.;
}

# Region IEnumerable Miembros <T>

pública IEnumerator <T> GetEnumerator ()
{
Nodo actual = pasado;
for (int i = 0; i cuenta <; i + +)
{
actual = actual anterior.;
rendimiento de retorno de corriente de valor.;
}
}

Del sistema. Colecciones. Sistema IEnumerator. Colecciones.

IEnumerable. GetEnumerator ()
{
devolver este). GetEnumerator (;
}
# Endregion
}
}

[ editar ] Ejemplo de código Java

public class Cola T <> {
privado nodo T <> nodeHead = null;
privado nodo T <> nodeEnd = null;
de largo tamaño privado = 0L;

public void encolar (T x) {

Nodo T <> newNode = new Nodo T <> (x, null);
if (nodeHead == null) {
nodeHead = newNode;
Else {}
nodeEnd newNode siguiente =.;
}
nodeEnd = newNode;
tamaño + +;
}

dequeue T pública () throws IllegalArgumentException {

if (nodeHead == null) {
throw new IllegalArgumentException ();
}
T = nodeHead la cabeza del elemento.;
nodeHead = nodeHead siguiente.;
tamaño -;
 volver la cabeza;
}

de largo tamaño pública () {

devolución de tamaño;
}

clase privada nodo T <> {

Nodo T <> siguiente;
T elemento;

pública Nodo (T elemento, el nodo T <> siguiente) {

. Este elemento = elemento;
el próximo. próxima =;
}
}
}

[ editar ] Ejemplo de código Javascript

Cola function () {
esto]. data = [;

este. estaVacio = function () {

retorno (esta ==. 0 datos. longitud);
};

este. enqueue = function (obj) {

los datos de este.. push (obj);
};

este. dequeue = function () {

devolver este (.) los datos. turnos;
};

este. vistazo = function () {

devolver este]. datos [0;
};

este. claras = function () {

esto]. data = [;
};
}

[ editar ] Véase también

 Deque
 Prioridad de la cola
 La teoría de colas
 Pila - el "frente" de una cola: LIFO (Last In First Out)
  Circular búfer

[ editar ] Referencias
General

 Donald Knuth . El arte digital de la programación, Volumen 1 Algoritmos

fundamentales, tercera edición. Addison-Wesley, 1997. ISBN 0-201-89683-4 .
Sección 2.2.1: pilas, colas, y deques, pp 238-243.
 Thomas H. Cormen , Charles E. Leiserson , Ronald L. Rivest y Clifford Stein .
Introducción a los algoritmos , Segunda edición. MIT Press y McGraw-Hill, 2001.
ISBN 0-262-03293-7 . Artículo 10.1: Las pilas y las colas, pp 200-204.
 William Ford , William Topp . Estructuras de Datos con C + + y STL, Segunda
edición. Prentice Hall, 2002. ISBN 0-13-085850-1 . Capítulo 8: colas y colas de
prioridad, pp 386-390.
 Drozdek Adán . Estructuras de Datos y Algoritmos en C + +, tercera edición.
Thomson Technology Curso, 2005. ISBN 0-534-49182-0 . Capítulo 4: Pilas y
colas, pp 137-169.

Citaciones

1. ^ Ford / Topp p. 385