BUSCADOR

BIDIMENSIO
NAL

Buscador utilizado para facilitar el

acceso a cierta informacin
clasificada

Grupo

EVIL US

INTEGRANTES:
BYRON MORENO
JONATHAN CHAPI
FLIX HERDOIZA
JONATHAN LAVA
SONIA GUAMN

FACULTAD DE INGENIERIA
CIENCIAS FSICAS Y
MATEMTICAS
INGENIERIA
INFORMTICA

PERIODO
2014 - 2015

Contenido

pg.

INTRODUCCION............................................................................................................ 1
Objetivo General:............................................................................................................. 2
Objetivos Especficos........................................................................................................ 2
Justificacin.................................................................................................................... 2
Conceptualizacin............................................................................................................ 3
Arreglos Bidimensionales................................................................................................ 3
Cmo se define un arreglo bidimensional en java?................................................................3
Cmo se guardan los elementos en un arreglo bidimensional?.............................................3
Cmo se accede a los datos almacenados en un arreglo bidimensional?......................................4
Cmo

se recorren los arreglos bidimensionales con ciclos repetitivos?..............................5

Arreglos bidimensionales (matrices)................................................................................... 7

Arreglos bidimensionales................................................................................................ 8
Crear arreglos bidimensionales......................................................................................... 8
Operaciones con arreglos bidimensionales.........................................................................10
Obtener elementos de un arreglo bidimensional...................................................................11
Otras operaciones....................................................................................................... 12
Reducciones por fila y por columna..................................................................................14
CONCLUSIONES.......................................................................................................... 15
RECOMENDACIONES.................................................................................................. 15
Bibliografa................................................................................................................... 16
Referencias:............................................................................................................... 16

INTRODUCCION
Cuando se habla de un algoritmo, tambin se habla de una secuencia ordenada de pasos
implcitos para llegar algn objetivo u orden principal, entonces al hablar de mtodos o
algoritmos de bsqueda dentro del tema se halla implcito el subtema de orden.
Debido a esto es que tanto el ordenamiento como la bsqueda son procesos que van de la mano,
porque para realizar un tipo o ejecutar un mtodo de bsqueda tenemos que basarnos en haber
antes realizado o creado un ordenamiento lgico de informacin variables o constantes en dicho
programa.
Una bsqueda no sera efectiva por si sola sin basarse en un ordenamiento adecuado pues
todo proceso tiene una secuencia en la cual es muy importante tanto el programa en si, como la
estructura del mismo. Una bsqueda puede ser utilizada para diferentes procesos dentro de la
estructura de un algoritmo pero su mejor aplicacin es para arreglos. Ms que mtodos son
algoritmos, algoritmos bien conocidos en el mundo de la programacin.

Quizs los mtodos de bsqueda no son tan regularmente utilizados o estudiados por
diferentes falencias que poseen, por lo que se los reemplaza por varias lneas ms de cdigos, sin
embargo, el hecho de que algo est bien hecho no significa que est hecho de la mejor manera, o
sea, de la manera ms eficiente. En otras palabras aunque puede parecer que un algoritmo se
ejecute de manera regular y con xito no quiere decir que su estructura o funcionamiento sea el
ms adecuado y eficiente, se dice esto porque al hablar de lneas y lneas de programacin
estructurada, tambin se dice que el algoritmo es algo largo, tedioso e incluso puede llegar a ser
hasta muy confuso, pero que tal si ste se puede llegar a simplificar con funciones o mtodos ms
factibles y de fcil utilizacin.

Precisamente es en este proyecto de lo que se hablara de uno de los mtodos utilizados y

creados para ejecutarse como bsqueda el mtodo Bidimensional, mtodo que est orientado a
procesos de ordenamiento pero muy eficaz para transformar una bsqueda tediosa en una muy
eficaz y rpida.

Objetivo General:
Dar a conocer el mtodo de bsqueda bidimensional para arreglos en codificacin de
algoritmos que facilite al usuario la bsqueda de cualquier tipo de informacin de manera ms
rpida eficaz y precisa.

Objetivos Especficos
-

Explicar de una manera legible la conceptualizacin del mtodo.

Esclarecer la estructura que debe tener un ordenamiento para que pueda ser eficaz este
mtodo.
Demostrar el funcionamiento del mtodo en el algoritmo en los lenguajes de
programacin JAVA, C++ y VISUAL BASIC.
Realizar una comparacin terica entre el mtodo bidimensional y los dems mtodos de
bsqueda ya presentados.

Justificacin
El presente proyecto tiene la finalidad de explicar la factibilidad de uso de buscadores
aplicando el mtodo bidimensional, que es uno de los buscadores empleados por el programador
para el usuario, para facilitar su navegacin y que una bsqueda pueda ser ms rpida y eficaz de
la informacin requerida.

Conceptualizacin
Arreglos Bidimensionales
Son estructuras de tamao fijo organizadas por filas y columnas.
Estas estructuras almacenan valores del MISMO TIPO de dato.
Cada posicin se identifica por la fila y la columna
Por lo general, estas estructuras se conocen con el nombre de matrices.

Cmo se define un arreglo bidimensional en java?

Si se va a definir un arreglo bidimensional de tipo entero de 3 filas y 5 columnas, llamado
matriz, sera as:
int matriz [][] = new in

];

Si se va a definir un arreglo bidimensional de tipo real de 2 filas y 2 columnas llamado matriz,

sera as:
double matriz [][]=new double[2][2];

Cmo se guardan los elementos en un arreglo bidimensional?

Se utiliza el nombre de la matriz, seguido de parntesis cuadrado con el nmero de la fila y
posteriormente otro parntesis cuadrado con el nmero de la columna.

Cmo se accede a los datos almacenados en un arreglo bidimensional?

Cmo

se recorren

los

arreglos bidimensionales con ciclos repetitivos?

Arreglos bidimensionales (matrices)

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.
Declaracin:
Tipo dato nombre matriz [ndice fila] [ndice columna]
Uso:
Nombre_matriz [subndice1] [subndice2]
int matriz [2][2]
char mapa [100] [100]
int certamen [60] [4]
Declara una matriz de 3 filas por 4 columnas:
int matriz [3][4];
Declaracin e iniciacin:
int matriz [2] [2]= {1,2,3,4}
1
2
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 tamao fila1 y tamao columna-1 respectivamente.
A las matrices se le asignan automticamente valores iniciales predeterminados a cada uno de sus
elementos, de acuerdo a los siguientes criterios:

Si el tipo del arreglo es numrico, 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.
7

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;
}

Arreglos bidimensionales
Los arreglos bidimensionales son tablas de valores. Cada elemento de un arreglo
bidimensional est simultneamente en una fila y en una columna.
En matemticas, a los arreglos bidimensionales se les llama matrices, y son muy utilizados en
problemas de Ingeniera.
En un arreglo bidimensional, cada elemento tiene una posicin que se identifica mediante dos
ndices: el de su fila y el de su columna.

Crear arreglos bidimensionales

Los arreglos bidimensionales tambin son provistos por NumPy, por lo que debemos comenzar
importando las funciones de este mdulo:
from numpy import *

Al igual que los arreglos de una dimensin, los arreglos bidimensionales tambin pueden ser
creados usando la funcin array, pero pasando como argumentos una lista con las filas de la
matriz:
a = array([[5.1, 7.4, 3.2, 9.9],
[1.9, 6.8, 4.1, 2.3],
[2.9, 6.4, 4.3, 1.4]])
Todas las filas deben ser del mismo largo, o si no ocurre un error de valor:
>>> array([[1], [2, 3]])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: setting an array element with a sequence.
Los arreglos tienen un atributo llamado shape, que es una tupla con los tamaos de cada
dimensin. En el ejemplo, a es un arreglo de dos dimensiones que tiene tres filas y cuatro
columnas:
>>> a.shape
(3, 4)
Los arreglos tambin tienen otro atributo llamado size que indica cuntos elementos tiene el
arreglo:
>>> a.size
12
Por supuesto, el valor de a.size siempre es el producto de los elementos de a.shape.
Hay que tener cuidado con la funcin len, ya que no retorna el tamao del arreglo, sino su
cantidad de filas:
>>> len(a)
3

Las funciones zeros y ones tambin sirven para crear arreglos bidimensionales. En vez de
pasarles como argumento un entero, hay que entregarles una tupla con las cantidades de filas y
columnas que tendr la matriz:
>>> zeros((3, 2))
array([[ 0., 0.],
[ 0., 0.],
[ 0., 0.]])
>>> ones((2, 5))
array([[ 1., 1., 1., 1., 1.],
[ 1., 1., 1., 1., 1.]])
Lo mismo se cumple para muchas otras funciones que crean arreglos; por ejemplo la
funcinrandom:
>>> from numpy.random import random
>>> random((5, 2))
array([[ 0.80177393, 0.46951148],
[ 0.37728842, 0.72704627],
[ 0.56237317, 0.3491332 ],
[ 0.35710483, 0.44033758],
[ 0.04107107, 0.47408363]])
Operaciones con arreglos bidimensionales
Al igual que los arreglos de una dimensin, las operaciones sobre las matrices se aplican trmino
a trmino:
>>> a = array([[5, 1, 4],
...
[0, 3, 2]])
>>> b = array([[2, 3, -1],
...
[1, 0, 1]])
>>> a + 2
array([[7, 3, 6],
[2, 5, 4]])
>>> a ** b
array([[25, 1, 0],

10

[ 0, 1, 2]])
Cuando dos matrices aparecen en una operacin, ambas deben tener exactamente la misma
forma:
>>> a = array([[5, 1, 4],
...
[0, 3, 2]])
>>> b = array([[ 2, 3],
...
[-1, 1],
...
[ 0, 1]])
>>> a + b
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: shape mismatch: objects cannot be broadcast to a single shape
Obtener elementos de un arreglo bidimensional
Para obtener un elemento de un arreglo, debe indicarse los ndices de su fila i y su
columna jmediante la sintaxis a[i, j]:
>>> a = array([[ 3.21,
[ 9.54, 0.30,
[ 5.62, 0.54,
[ 8.19, 2.12,
[ 8.72, 1.47,
>>> a[1, 2]
2.14

5.33,
2.14,
0.71,
6.28,
0.77,

4.67, 6.41],
6.57],
2.56],
8.76],
8.78]])

>>> a[4, 3]
8.78
>>> a[-1, -1]
8.78
>>> a[0, -1]
6.41
Tambin se puede obtener secciones rectangulares del arreglo usando el operador de rebanado
con los ndices:

11

>>> a[2:3, 1:4]

array([[ 0.54, 0.71, 2.56]])
>>> a[1:4, 0:4]
array([[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56],
[ 8.19, 2.12, 6.28, 8.76]])
>>> a[1:3, 2]
array([ 2.14, 0.71])
>>> a[0:4:2, 3:0:-1]
array([[ 6.41, 4.67, 5.33],
[ 2.56, 0.71, 0.54]])
>>> a[::4, ::3]
array([[ 3.21, 6.41],
[ 8.72, 8.78]])
Para obtener una fila completa, hay que indicar el ndice de la fila, y poner : en el de las columnas
(significa desde el principio hasta el final). Lo mismo para las columnas:
>>> a[2, :]
array([ 5.62, 0.54, 0.71, 2.56])
>>> a[:, 3]
array([ 6.41, 6.57, 2.56, 8.76, 8.78])
Note que el nmero de dimensiones es igual a la cantidad de rebanados que hay en los ndices:
>>> a[2, 3]
2.56

# valor escalar (arreglo de cero dimensiones)

>>> a[2:3, 3]
array([ 2.56])

# arreglo de una dimensin de 1 elemento

>>> a[2:3, 3:4] # arreglo de dos dimensiones de 1 x 1

array([[ 2.56]])

12

Otras operaciones

La trasposicion consiste en cambiar las filas por las columnas y viceversa. Para trasponer un
arreglo, se usa el mtodo transpose:
>>> a
array([[ 3.21, 5.33, 4.67, 6.41],
[ 9.54, 0.3 , 2.14, 6.57],
[ 5.62, 0.54, 0.71, 2.56]])
>>> a.transpose()
array([[ 3.21, 9.54, 5.62],
[ 5.33, 0.3 , 0.54],
[ 4.67, 2.14, 0.71],
[ 6.41, 6.57, 2.56]])
El mtodo reshape entrega un arreglo que tiene los mismos elementos pero otra forma. El
parmetro de reshape es una tupla indicando la nueva forma del arreglo:
>>> a = arange(12)
>>> a
array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])
>>> a.reshape((4, 3))
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
>>> a.reshape((2, 6))
array([[ 0, 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10, 11]])
La funcin diag aplicada a un arreglo bidimensional entrega la diagonal principal de la matriz (es
decir, todos los elementos de la forma a[i, i]):
>>> a
array([[ 3.21, 5.33, 4.67, 6.41],
13

[ 9.54, 0.3 , 2.14, 6.57],

[ 5.62, 0.54, 0.71, 2.56]])
>>> diag(a)
array([ 3.21, 0.3 , 0.71])
Adems, diag recibe un segundo parmetro opcional para indicar otra diagonal que se desee
obtener. Las diagonales sobre la principal son positivas, y las que estn bajo son negativas:
>>> diag(a, 2)
array([ 4.67, 6.57])
>>> diag(a, -1)
array([ 9.54, 0.54])
La misma funcin diag tambin cumple el rol inverso: al recibir un arreglo de una dimensin,
retorna un arreglo bidimensional que tiene los elementos del parmetro en la diagonal:
>>> diag(arange(5))
array([[0, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 2, 0, 0],
[0, 0, 0, 3, 0],
[0, 0, 0, 0, 4]])
Reducciones por fila y por columna

Algunas operaciones pueden aplicarse tanto al arreglo completo como a todas las filas o a todas
las columnas.
Por ejemplo, a.sum() entrega la suma de todos los elementos del arreglo. Adems, se le puede
pasar un parmetro para hacer que la operacin se haga por filas o por columnas:
>>> a = array([[ 4.3, 2.9, 9.1, 0.1, 2. ],
...
[ 8. , 4.5, 6.4, 6. , 4.3],
...
[ 7.8, 3.1, 3.4, 7.8, 8.4],
...
[ 1.2, 1.5, 9. , 6.3, 6.8],
...
[ 7.6, 9.2, 3.3, 0.9, 8.6],
...
[ 5.3, 6.7, 4.6, 5.3, 1.2],
...
[ 4.6, 9.1, 1.5, 3. , 0.6]])
14

>>> a.sum()
174.4
>>> a.sum(0)
array([ 38.8, 37. , 37.3, 29.4, 31.9])
>>> a.sum(1)
array([ 18.4, 29.2, 30.5, 24.8, 29.6, 23.1, 18.8])
El parmetro indica a lo largo de qu dimensin se har la suma. El 0 significa sumar a lo largo
de las filas. Pero hay que tener cuidado, por que lo que se obtiene son las sumas de las
columnas! Del mismo modo, 1 significa a lo largo de las columnas, y lo que se obtiene es el
arreglo con las sumas de cada fila.
Las operaciones a.min() y a.max() funcionan del mismo modo:
>>> a.min()
0.1
>>> a.min(0)
array([ 1.2, 1.5, 1.5, 0.1, 0.6])
>>> a.min(1)
array([ 0.1, 4.3, 3.1, 1.2, 0.9, 1.2, 0.6])
a.argmin() y a.argmax() tambin:
>>> a.argmin(0)
array([3, 3, 6, 0, 6])
>>> a.argmin(1)
array([3, 4, 1, 0, 3, 4, 4])

CONCLUSIONES

Con el mtodo bidimensional mejoramos nuestros resultados y mediante su funcin lo

colocamos en posicin ventajosa con respecto a otros mtodos.

Para la ejecucin de este mtodo de bsqueda usamos un algoritmo hbrido que combina
tcnicas inspiradas en bsqueda en vecindario variable, recocido simulado y tcnicas
constructivas que mejoran el mtodo de bsqueda

15

 Con esto realizamos un anlisis estadstico para demostrar la eficiencia de la metodologa

propuesta y tener conocimiento sobre el porcentaje de mejora al momento de realizar un
programa en particular

Se destaca una gran importancia de aplicar este mtodo para una codificacin eficiente
con tcnicas esenciales que se adapten adecuadamente a la naturaleza del problema en
estudio.

RECOMENDACIONES

Dentro de los trabajos futuros podran resolverse casos de prueba en donde las
condiciones del problema permitan nos dificulten muchos problemas el cual la aplicacin
de este mtodo sera muy eficaz para resolverlo de una manera rpida y precisa

Este mtodo es posible para la mayora de problemas que tengamos al momento de

realizar una bsqueda , ya sea muy extensa o

Adicionalmente, es un proceso un poco complicado en la estructura del programa al

momento de realizarlo pero muy eficaz en su proceso.

Bibliografa
http://es.slideshare.net/ShinobiGatomaster/savedfiles?s_title=17-arreglos-bidimensionalesjava&user_login=cpavella

16

http://wwwtemarioestructuradedatos2.blogspot.com/p/arreglos-bidimensionales.html
http://progra.usm.cl/apunte/materia/arreglos-2d.html
https://lenguajecmasmas.wordpress.com/2007/10/01/arreglos-bidimensionales-matrices/

Referencias:
Starting Out with Java: From Control Structures through Objects, 5/E
Tony Gaddis, Haywood Community College
ISBN-10: 0132855836 ISBN-13: 9780132855839
2013 Addison-Wesley Paper, 1152 pp
Published 02/16/2012 Instock
- See more at: http://www.pearsonhighered.com/educator/product/Starting-Out-with-Java-FromControl-Structures-through-Objects-5E/9780132855839.page#sthash.xJU5fHVc.dpuf

Microsoft Visual C# 2013 Step by Step

John Sharp
ISBN-10: 073568183X ISBN-13: 9780735681835
2014 Paper, 824 pp
Published 11/15/2013 Temporarily unavailable
- See more at: http://www.pearsonhighered.com/educator/product/Microsoft-Visual-C-2013-Stepby-Step/9780735681835.page#sthash.S9uEAxAL.dpuf

17