ARREGLOS:

UNIDIMENSIONALES Y BIMENSIONALES

ALGORITMO Y PROGRAMACION BASICA

INTEGRANTES:
JESUS DAVID GUERRA PINEDA
CAMILO RUZ ORTIZ
JUAN DAVID BARRIO CARO
IGNACIO DE JESUS RIVERA CONDE
GUILLERMO SALGADO

UNIVERSIDAD DE CARTAGENA
FACULTAD DE INGENIERIA DE SOFTWARE
PRIMER SEMESTRE
MAGANGUE-BOLIVAR
NOVIEMBRE 2019
Contenido
1. introducción...............................................................................................................................3
1. Arreglo unidimensional..............................................................................................................4
2.1 ejemplo de pseint...............................................................................................................5
3 Arreglos bidimensionales...........................................................................................................7
4 TDA PILA.....................................................................................................................................8
4.1 IMPLEMENTACIÓN CON VECTORES....................................................................................9
5 TDA COLA.................................................................................................................................10
5.1 IMPLEMENTACION CON VECTORES DE COLA...................................................................11
6 ALGORITMOS DE BÚSQUEDA...................................................................................................13
6.1 BÚSQUEDA SECUENCIAL...................................................................................................13
6.2 BÚSQUEDA BINARIA.........................................................................................................15
7 ORDENAMIENTO DE COMPONENTES.......................................................................................16
7.1 ORDENAMIENTO ASCENDENTE........................................................................................16
7.2 EL ORDENAMIENTO POR SELECCIÓN................................................................................17
7.3 EL ORDENAMIENTO POR INSERCIÓN................................................................................18
7.4 EL ORDENAMIENTO DE SHELL..........................................................................................19
8 Cadena de caracteres...............................................................................................................20
9 conclusión................................................................................................................................21
 1. introducción
A medida de este trabajo estaremos explicando sobre lo que son arreglos
(unidimensionales, bidimensionales) daremos a conocer ciertos ejemplos de dichos temas
mencionado anteriormente. en los cuales se hablará acerca de cada uno de los procesos que
se tiene que realizar como lo son pila, cola, búsquedas, ordenamiento y secuencias a
Atraves de cada uno de los conceptos y ejercicios que aprenderemos a medida que
avancemos conoceremos cada uno de sus conceptos y procesos.

1. Arreglo unidimensional
Un arreglo unidimensional es un tipo de datos estructurado que está formado de una
colección finita y ordenada de datos del mismo tipo. Es la estructura natural para modelar
listas de elementos iguales. El tipo de acceso a los arreglos unidimensionales es el acceso
directo, es decir, podemos acceder a cualquier elemento del arreglo sin tener que consultar
a elementos anteriores o posteriores, esto mediante el uso de un índice para cada elemento
del arreglo que nos da su posición relativa. Para implementar arreglos unidimensionales se
debe reservar espacio en memoria, y se debe proporcionar la dirección base del arreglo, la
cota superior y la inferior.
En C++ los arreglos se declaran de la siguiente forma:
Tipodedato nombredelarreglo[tamañodelarreglo];
Como podemos ver, es similar a declarar una variable convencional, solo que se coloca
entre corchetes el número de posiciones del arreglo, por lo que todas las posiciones serán
del mismo tipo.
Al trabajar arreglos hacemos referencia a cada posición del arreglo a través de su número
de índice, el cual comienza a partir del cero, de tal forma que para almacenar el número 10
en la posición 6 de un arreglo escribiríamos:
x[5]=10;
Parra llenar todos los elementos del arreglo es común emplear un ciclo que nos permita
recorrer el arreglo desde la primera hasta la última posición, tal y como podemos ver en el
siguiente ejemplo:

En este ejemplo hemos declarado un arreglo de tipo entero de 10 posiciones llamado x,

observe que en el ciclo que empleamos para llenar el arreglo el contador “i” va del 0 al 9,
esto es porque las posiciones de los arreglos en C++ se comienzan a numerar a partir del
cero.
Después, podemos observar dos líneas en donde presentamos de forma directa el primer
elemento del arreglo y el último elemento del arreglo.
Para terminar el ejemplo podemos ver un ciclo for en el que usamos printf para presentar
todos los elementos del arreglo, como se puede observar cualquier operación sobre el
arreglo completo o sobre una sección de este, deberá hacerse a través de un ciclo for.

2.1ejemplo de pseint

Algoritmo arreglos
acum<-0;
//pedimos el tamaño
Escribir "digite el numero del vector (arreglo)"
Leer t;
//creamos el arreglo y le pasamos el pamaño ingresado
Dimension vector[t];
//llenamos el arreglo con un ciclo para
Para i<-1 Hasta t Con Paso 1 Hacer
//pedimos los numeros
Escribir "digite un numero";
Leer num;
vector[i]<-num;//le damos al vector los numeros ingresados
acum<-acum+vector[i];//acumulamos los numeros y los
sumamos
Fin Para
//imprimimos todos los datos del arreglo
Para i<-1 Hasta t Con Paso 1 Hacer
Escribir "la suma de:",vector[i]
Fin Para
//resultado total
Escribir "Es:",acum;
FinAlgoritmo

Algoritmo arreglo
//pedimos la cantidad
Escribir "digite el numero de pais"
Leer n;
//creamos el arreglo y le pasamos el tamaño ingresado
Dimension paises[n]
//llenamos el arreglo con un ciclo para
Para i<-1 Hasta n Con Paso 1 Hacer
Escribir "digite pais",i;//pedimos los paises
leer nombre;
paises[i]<-nombre;//le pasamos al arreglo los paises
ingresados
Fin Para
//pedimos la posicion
Escribir "digite la posicion";
Leer pos;
//mostramos el pais que se encuentra en la posicion digitada
Escribir "El pais que hay en la posicion
",pos,"es:",paises[pos];

FinAlgoritmo

3 Arreglos bidimensionales
Son estructuras de datos que agrupan muchos datos del mismo tipo, en donde cada
elemento se puede trabajar individualmente y se puede hacer referencia con un mismo
nombre. Se usan para representar datos que pueden verse como una tabla con filas y
columnas.

Ejemplo:

#include <stdio.h>
int main()
{
int fila, columna;
int matriz[2][2];
for(fila=0; fila<2; fila++)
for(columna=0; columna<2; columna++)
printf(“%d”, matriz[fila][columna]);
return 0;
}

Es un arreglo de dos dimensiones. Son estructuras de datos que agrupan muchos datos del
mismo tipo, en donde cada elemento se puede trabajar individualmente y se puede
referenciar con un mismo nombre. Se usan para representar datos que pueden verse como
una tabla con filas y columnas.
Para referenciar un elemento de la matriz, debe darse un nombre de la matriz y el índice de
la fila y de la columna que el elemento ocupa en dicha matriz. Es importante que los índices
de las matrices tanto de las filas como de las columnas empiezan en 0 y terminan en tamaño
fila-1 y tamaño columna-1 respectivamente.
A las matrices se le asignan automáticamente valores iniciales predeterminados a cada uno
de sus elementos, de acuerdo a los siguientes criterios:
 Si el tipo del arreglo es numérico, a sus elementos se les asigna el valor cero.
 Si el tipo del arreglo es char, a sus elementos se les asigna el valor ‘\u0000′.
 Si el tipo del arreglo es bool, a sus elementos se les asigna el valor false.
 Si el tipo del arreglo es una clase, a sus elementos se les asigna el valor null.
4 TDA PILA
una pila es una lista ordenada de elementos en la que todas las inserciones y supresiones se
realizan por un mismo extremo denominado tope o cima de la pila.
Estructura LIFO (Last In First Out): “último en entrar primero
en salir”

Operaciones básicas
PUSH: apilar, meter
POP: desapilar, sacar
TOP: cima, tope

Crear_pila(P: pila, ok: lógico)

Borrar_pila(P: pila, ok: lógico)
Vacía?(P: pila, resp: lógico)
Llena?(P: pila, resp: lógico)
Push(P: pila, X: elemento, resp: lógico)
Pop(P: pila, X: elemento, resp: lógico)
Top(P: pila, X: elemento, resp: lógico)
 4.1IMPLEMENTACIÓN CON VECTORES

Operación Pop
Algoritmo POP (P: PILA, X: ELEMENTO, ok:
lógico) es Operación Top
INICIO Algoritmo TOP (P: PILA, X: ELEMENTO,
Vacia(P, resp);
ok:lógico) es
si resp entonces
ok:= falso; {no hay resp: lógico;
elementos q sacar}
sino INICIO
X:= P.arreglo[P.tope];
P.tope:= P.tope -1; Vacia?(P, resp);
ok:= cierto; si resp entonces
finsi;
FIN ok:= falso; {pila vacía}
sino
ok:= cierto;
X:= P.arreglo[P.tope];
finsi;
FIN

Operación Push
Algoritmo PUSH (P: Pila, X: ELEMENTO,
ok: lógico) es
resp: lógico;
INICIO
Llena?(P,resp);
si resp entonces
ok:= falso;
sino
P.tope:= P.tope + 1;
P.arreglo[P.tope]:= X;
ok:= cierto;
finsi;
FIN
5 TDA COLA
una cola es una lista ordenada de elementos en la que todas las inserciones se realizan por
un extremo (frente o principio) y las supresiones se realizan por el otro (final).
Estructura FIFO (First In First Out): “primero en entrar primero en salir”

Operaciones básicas
QUEUE: encolar, meter
DEQUEUE: desencolar,
sacar

Crear_cola(C: cola, ok: lógico)

Borrar_cola(C: cola, ok: lógico)
Vacía?(C: cola, resp: lógico)
Llena?(C: cola, resp: lógico)
Queue(C: cola, X: elemento, resp: lógico)
Dequeue(C: cola, X: elemento, resp: lógico)
Tamaño(C: cola, N: numérico)
 5.1 IMPLEMENTACION CON VECTORES DE COLA

Si el principio de la cola es fijo en la primera posición del vector y el final es variante para
eliminar un elemento de la cola hay que desplazar todos los demás una posición (Dequeue()
es ineficiente).

Si principio y final de la cola son variantes, no hacen falta desplazamientos.

Problema: la cola puede desbordarse teniendo celdas libres.
 Principalmente: gestión de recursos

Sistemas de tiempo compartido: los recursos (CPU, memoria, …) se asignan a los procesos
que están en cola de espera en el orden en el que fueron introducidos.

Colas de impresión: al intentar imprimir varios documentos a la vez o la impresora está

ocupada, los trabajos se almacenan en una cola según el orden de llegada.

Simulación por computadora de situaciones reales: una cola de clientes en un supermercado

o el tiempo de espera para ser atendidos por un operador de una línea telefónica.

Operación QUEUE Operación Dequeue

Algoritmo QUEUE(C: COLA, X:
ELEMENTO, resp: lógico) es Algoritmo DEQUEUE(C: COLA, X:
INICIO ELEMENTO, resp: lógico) es
Llena?(C,resp);
si resp = cierto entonces {la cola INICIO
está llena} Vacía?(C,resp);
Escribir “Cola llena”;
resp := falso; si resp = cierto entonces {la
sino {la cola no está llena, por cola está vacía}
lo que procedemos a añadir el Escribir “Cola vacía”;
elemento}
C.ult := (C.ult + 1) mod MAX; resp := falso;
{hacemos que ult avance de sino {hay al menos un
forma circular} elemento}
C.arreglo[C.ult] := X;
C.tam := C.tam +1; {pues X := C.arreglo[C.prim];
ahora hay un elemento más en la C.prim := (C.prim + 1) mod
cola}
MAX;
finsi;
6 ALGORITMOS DE BÚSQUEDA

Los procesos de búsqueda involucran recorrer un arreglo completo con el fin de encontrar
algo. Lo más común es buscar el menor o mayor elemento (cuando es puede establecer un
orden), o buscar el índice de un elemento determinado.
Para buscar el menor o mayor elemento de un arreglo, podemos usar la estrategia, de
suponer que el primero o el último es el menor (mayor), para luego ir comparando con cada
uno de los elementos, e ir actualizando el menor (mayor). A esto se le llama Búsqueda
Lineal.
Algoritmos de Búsqueda
Para encontrar un dato dentro de un arreglo, para ello existen diversos algoritmos que
varían en complejidad, eficiencia, tamaño del dominio de búsqueda.

Algoritmos de Búsqueda:
Búsqueda Secuencial
Búsqueda Binaria

6.1BÚSQUEDA SECUENCIAL
Consiste en ir comparando el elemento que se busca con cada elemento del arreglo hasta
cuándo se encuentra.
• Busquemos el elemento ‘u’

EJEMPLO: Búsqueda Secuencial

• Búsqueda del menor
menor = a[0];
for (i=1;i<n;i++)
if ( a[i]<menor )
menor=a[i];

• Búsqueda del mayor

mayor= a[n-1];
for (i=0;i<n-1;i++)
if ( a[i]>mayor )
mayor=a[i];

• Búsqueda de elemento
encontrado=-1;
for (i=0;i<n;i++)
if ( a[i]==elemento_buscado )
encontrado=i;

6.2BÚSQUEDA BINARIA
Dados un entero X y un array A de n enteros que se encuentran ordenados y en memoria,
encontrar un i talque A[i] == X o retornar 0 si X no se encuentra en el array (consideramos
los elementos del array de 1 a N. La estrategia consiste en comparar X con el elemento del
medio del array, si es igual entonces encontramos el elemento, sino, cuando X es menor
que el elemento del medio aplicamos la misma estrategia al array a la izquierda del
elemento del medio y si X es mayor que el elemento del medio aplicamos la misma
estrategia al array a la derecha de dicho elemento

Para simplificar el codigo definimos A[0]=X.

int busqueda binaria(int A[],int X,int n)

{
 int izq=1,medio,der=n;

A[0]=X;

do {

medio = (izq+der) / 2;

if(izq > der)

medio=0;

else if A[medio] < X

izq = medio +1;

else der=medio-1;

while (A[medio] != X);

return medio; }

7 ORDENAMIENTO DE COMPONENTES

7.1ORDENAMIENTO ASCENDENTE

Existen numerosos algoritmos para ordenar. A continuación, se verán algunos

algoritmos de ordenamiento.
Ordenamiento Burbuja (bublesort): Idea: vamos comparando elementos adyacentes y
empujamos los valores más livianos hacia arriba (los más pesados van quedando abajo).
Idea de la burbuja que asciende, por lo liviana que es.

7.2EL ORDENAMIENTO POR SELECCIÓN

El ordenamiento por selección mejora el ordenamiento burbuja haciendo un sólo
intercambio por cada pasada a través de la lista. Para hacer esto, un ordenamiento por
selección busca el valor mayor a medida que hace una pasada y, después de completar la
pasada, lo pone en la ubicación correcta. Al igual que con un ordenamiento burbuja,
después de la primera pasada, el ítem mayor está en la ubicación correcta. Después de la
segunda pasada, el siguiente mayor está en su ubicación. Este proceso continúa y requiere
n−1 pasadas para ordenar los n ítems, ya que el ítem final debe estar en su lugar después de
la (n−1)-ésima pasada.

La Figura muestra todo el proceso de ordenamiento. En cada paso, el ítem mayor restante
se selecciona y luego se pone en su ubicación correcta. La primera pasada ubica el 93, la
segunda pasada ubica el 77, la tercera ubica el 55, y así sucesivamente.

7.3EL ORDENAMIENTO POR INSERCIÓN

El ordenamiento por inserción, aunque sigue siendo O(n2), funciona de una manera
ligeramente diferente. Siempre mantiene una sub-lista ordenada en las posiciones inferiores
de la lista. Cada ítem nuevo se “inserta” de vuelta en la sub-lista previa de manera que la
sub-lista ordenada sea un ítem más largo.
La Figura muestra el proceso de ordenamiento por inserción. Los ítems sombreados
representan las sub-listas ordenadas a medida que el algoritmo lleva a cabo cada pasada.

Comenzamos asumiendo que una lista con un ítem (posición 0) ya está ordenada. En cada
pasada, una para cada ítem desde 1 hasta n−1, el ítem actual se comparara contra los de la
sublista ya ordenada. A medida que revisamos en la sublista ya ordenada, desplazamos a la
derecha los ítems que sean mayores. Cuando llegamos a un ítem menor o al final de la
sublista, se puede insertar el ítem actual.

7.4EL ORDENAMIENTO DE SHELL

El ordenamiento de Shell, a veces llamado “ordenamiento de incremento decreciente”,

mejora el ordenamiento por inserción al romper la lista original en varias sublistas más
pequeñas, cada una de las cuales se ordena mediante un ordenamiento por inserción. La
manera única en que se eligen estas sublistas es la clave del ordenamiento de Shell. En
lugar de dividir la lista en sublistas de ítems contiguos, el ordenamiento de Shell usa un
incremento i, a veces denominado brecha, para crear una sublista eligiendo todos los ítems
que están separados por i ítems.

Este proceso se puede en la Figura La lista tiene nueve ítems. Si usamos un incremento de
tres, hay tres sublistas, cada una de las cuales puede ordenarse mediante un ordenamiento
por inserción. Después de completar estos ordenamientos, obtenemos la lista que se
muestra en la Figura 7. Aunque esta lista no está completamente ordenada, ha ocurrido algo
muy interesante. Al ordenar las sublistas, hemos acercado los ítems a donde realmente
pertenecen.
8 Cadena de caracteres
Es una secuencia ordenada de longitud arbitraria de elementos que pertenecen a un

cierto lenguaje formal o alfabeto; análogas a una frase o a una oración. En general, una

cadena de caracteres es una sucesión de caracteres:

(letras, números, espacio, signos o símbolos).

En programación, si no se ponen restricciones al alfabeto, una cadena podrá estar

formada por cualquier combinación finita de todo el juego de caracteres disponibles (las

letras de la 'a' a la 'z' y de la 'A' a la 'Z', los números del '0' al '9', el espacio en blanco ' ',

símbolos diversos '!', '@', '%', etc).

En este ámbito se utilizan normalmente como un tipo de dato predefinido, para palabras,

frases o cualquier otra sucesión de caracteres. En este caso, se almacenan en un vector de

datos, o matriz de datos de una sola fila (array en inglés). Las cadenas se pueden almacenar

físicamente seguidas o enlazados letra a letra.

Generalmente son guardados un carácter a continuación de otro por una cuestión de

eficiencia de acceso.

Un caso especial de cadena es la que contiene cero caracteres, a esta cadena se la llama

cadena vacía.

Las cadenas de caracteres pueden ser:

 De naturaleza dinámica: pueden alterar su longitud durante el tiempo de ejecución,

 De naturaleza estática: su longitud es fija a lo largo del tiempo de ejecución.
9 conclusión
En este trabajo se dio a conocer acerca de los arreglos unidimensionales y bidimensionales
en los que aprendimos como se utilizan y para que nos sirven, sus ejemplos característicos
que nos ayudan a programar y resolver problemas informáticos y de la vida cotidiana.