UNIDAD 2 ESTRUCTURAS LINEALES

2.1 Arreglos Definicion

Arreglo: Es un acomodo de espacios (Como en una matriz) en los cuales es una
coleccin de un tipo de dato, y pueden ser unidimensionales, bidimesionales o
multidimensionales
Es un conjunto finito y ordenado de elementos homogneos (del mismo tipo de
datos). Es un tipo de dato estructurado simple o esttico y pueden ser vectores o
tablas (matrices).
En lenguaje C, se pueden definir conjuntos de datos conocidos como arreglos. Por
ejemplo, si deseramos guardar en un arreglo, diez valores enteros, debemos
definir este arreglo de la siguiente manera: int elem[10]; Esta expresin es la
declaracin del arreglo. Donde int es el tipo de datos que almacena el arreglo,
elem es el nombre del arreglo, y el nmero encerrado en los corchetes es el
nmero de valores que contiene el arreglo. Cabe hacer notar que, el ndice para el
primer elemento es 0 y, el valor mximo del ndice es igual a n-1 elementos del
arreglo. En nuestro caso, el ltimo elemento del arreglo elem ser elem[9]. El
programador deber tener cuidado de no indicar elementos inexistentes en el
arreglo, es decir, elementos cuyos ndices son nmeros con signo menores a 0 o
elementos con ndices mayores a los n-1 elementos del arreglo. De no-tener
cuidado, el compilador de C no marcar error alguno, pero se produce un error en
tiempo de ejecucin.
Un arreglo se puede entender mejor representndolo como en la figura 2.1
Figura 2.1. Representacin de un arreglo lineal.
Un punto importante es que, el nombre del arreglo es, por si mismo, un apuntador
a la localidad de memoria que ocupa el primer elemento, es decir, el nombre del
arreglo es una variable que contiene la direccin del primer elemento. Esto se
puede expresar como sigue:
elem = &elem[0]
A continuacin se presenta un programa que emplea arreglos para mostrar una
serie de nmeros y la palabra hola.
int main(void)

{
int y; int numeros[4] = {2, 4, 6, 8}; char palabra[ ] = {h, o, l, a,\0}; for (y=0; y<4;
y++)
printf (nmeros [%d] = %d\n, y, nmeros[y] ); printf(\n);for (y=0; y<4; y++)
printf (%c, palabra[y] ); return (0); } Cul es el resultado de la ejecucin del
programa anterior? En el ejemplo, la forma de inicializacin del arreglo nmeros
solo es soportada por el estndar ANSI.
2.2 Pilas Definicion
Definicion
Las pilas son otro tipo de estructura de datos lineales, las cuales presentan
restricciones en cuanto a la posicin en la cual pueden realizarse las inserciones y
las extracciones de elementos.
Una pila es una lista de elementos en la que se pueden insertar y eliminar
elementos slo por uno de los extremos. Como consecuencia, los elementos de
una pila sern eliminados en orden inverso al que se insertaron. Es decir, el ltimo
elemento que se meti a la pila ser el primero en salir de ella.
En la vida cotidiana existen muchos ejemplos de pilas, una pila de platos en una
alacena, una pila de latas en un supermercado, una pila de papeles sobre un
escritorio, etc.
Debido al orden en que se insertan y eliminan los elementos en una pila, tambin
se le conoce como estructura LIFO (Last In, First Out: ltimo en entrar, primero en
salir).
2.2.2 Operaciones con Pilas
Una Pila se compone de los siguientes elementos:
arreglo de datos
El numero maximo
El numero minimo
El tipo de datos de la pila
los indices Tope y Base de la Pila
Operaciones Elementales

Iniciar
Insertar
Eliminar
Axiomas
Insertar:
Si Tope = Maximo
Mensaje( O Verflow)
de lo Contrario
Tope = Tope +1
Pila Tope = Valor
//Codigo Fuente PILAS
1. include <stdio.h>
2. include <conio.h>
3. include <iostream.h>
int pila[5],cima=1,maxpila=4,c=0,op,x,i,n; char r=n;
void meter(int *pila,int *cima,int maxpila,int item) {
if(*cima==maxpila)
{cout<<\nDesbordamiento<<\n;}
else
{*cima=*cima+1;
pila[*cima]=item;}
}
void sacar(int *pila,int *cima,int *item) { if(*cima==0)
{cout<<\nSubdesbordamiento;}
else

{*item=pila[*cima];
*cima=*cima-1;}
}
int main() {clrscr();
do
{clrscr();
cout<<\n1.-Insertar;
cout<<\n2.-Eliminar;
cout<<\n3.-SALIR;
cout\nInserta una opcion ;cinop;
switch(op)
{case 1:
coutCuantos datos deseas insertar? ;cinn;
if(n>5)
{cout<<\nMemoria insuficiente;
getch();}
else
{for(i=0;i<n;i++)
{cout\nIntroduce un numero ;cinx;
c=c+1;
cout<<\nDatos insertados <<c;
clrscr();
meter(pila,&cima,maxpila,x);}
getch();}
break;

case 2:
sacar(pila,&cima,& x);
cout<<\nEl dato borrado fue <<x;
getch();
break;
case 3:
coutDESEA SALIR (S/N) ;cinr;
break;
default:
cout<<Ingresa numero valido\n;
getch();
break;}
}while(r==n || r==N);
return 0; }
2.2.3 Clases para Implementacion de Pilas
Ejemplo completo sobre la implementacin de pilas manejando Visual Studio .net
2003
//----LIO
1. include stdafx.h
2. using <mscorlib.dll>
using namespace System;
using namespace System::Collections;
public __gc class Ejemplo Stack?{
public:
static void Imprime(I Enumerable? __gc *Mi Coleccion?)

{
System::Collections::I Enumerator? __gc *Mi Enumerador?
= Mi ColeccionGet Enumerator?();
while (Mi EnumeradorMove Next?())
Console::Write(S\t{0}, Mi EnumeradorCurrent);
Console::Write Line?();
}
};
int main() {
Stack __gc *Mi Pila? = new Stack();
Mi PilaPush(SHola);
Mi PilaPush(SMundo);
Mi PilaPush(S!);
// Despliega las propiedades y valores de los pila.
Console::Write Line(SMi Pila);
Console::Write Line(S\tCount: {0},
__box(Mi PilaCount));
Console::Write(S\tValores:);
Ejemplo Stack::Imprime(Mi Pila);
system(pause);
return 0;
}
2.3 Colas Definicion
Una cola es una estructura de datos, caracterizada por ser una secuencia de
elementos en la que la operacin de insercin push se realiza por un extremo y la
operacin de extraccin pop por el otro. Tambin se le llama estructura FIFO (del

ingls First In First Out), debido a que el primer elemento en entrar ser tambin el
primero en salir.
El tipo cola representa la idea que tenemos de cola en la vida real. La cola para
subir al autobs est compuesta de elementos (personas), que dispone de dos
extremos comienzo y fin. Por el comienzo se extraer un elemento cuando haya
comprado el billete para su viaje, y si llega una nueva persona con intencin de
usar el autobs, tendr que colocarse al final y esperar que todos los elementos
situados antes que l abandonen la cola.
2.3.1 Operaciones con Colas
La definicin de la estructura de datos tipo cola queda completa al incluir las
operaciones que se pueden realizar en ella. Las operaciones bsicas que pueden
efectuarse son:
Insertar un elemento en la cola
Eliminar un elemento de la cola
Las inserciones se llevaran a cabo por el FINAL de la cola, mientras que las
eliminaciones se harn por el FRENTE recuerde que el primero en entrar es el
primero en salir.
Considerando que una cola puede almacenar un mximo nmero de elementos y
que adems FRENTE indica la posicin del primer elemento y FINAL la posicin
del ltimo, se presentan a continuacin los algoritmos correspondientes a las
operaciones mencionadas