Programando en C# 11

Anuncios

En Programando en C# 11 vamos a aprender algunos códigos simples de ordenamiento y búsqueda de datos. Si bien en Programando en C#10 di un ejemplo de una búsqueda secuencial, no es el único tipo de búsqueda que hay.

Los temas a tratar hoy son entre otros Arreglos, Ordenamiento y búsqueda

-Algoritmos de ordenamiento.
-Algoritmos de búsqueda: -Elementos desordenados.
-Elementos ordenados.


Consideremos inicialmente:

<?
        int val
;// valor a buscar.
        
int[] = new int[5];

        public 
void GenerarNumeros()
        {
            
Random num = new Random();
            for (
int i 0v.Lengthi++)
                
v[i] = num.Next(10);
        }
>


Generamos números aleatoreamente en un vector de cinco lugares.


<?
      
public void OrdenarNumeros() //De menor a mayor.
        
{
            
int aux;
            for (
int i 0v.Length 1i++)
                for (
int j 1v.Lengthj++)
                    if (
v[i] < v[j]) //Si le cambiamos el signo sería de mayor a menor.
                    
{
                        
aux v[i];
                        
v[i] = v[j];
                        
v[j] = aux// Vemos que el auxiliar toma el valor de la posición "i", luego esa posición toma el valor de la posición "j", y luego la posición "j" adquiere el valor que se guardó en aux.
                    
}
        }
>


Vemos que para ordenar los números, primero debemos crear un auxiliar, este lo usaremos para poder pasar los valores a un área segura mientras trastocamos el vector.
Creamos dos comandos for, cada comando se le llama método burbuja, cuando son dos, uno dentro del otro, se le llama burbuja mejorada.

Lo que hace es revisa si uno es mas grande que el anterior y lo manda al final del vector.

El siguiente tema es "Búsqueda secuencial":

<?
        
public void BusquedaSecuencial(int val)
        {
            
int pos = -1;
            
int i 0;
            while ((
pos == -1) && (v.Length))
            {
                if (
v[i] == val)
                    
pos i;
                
i++;
            }
            if (
pos != -1)
            {
                
//Elemento encontrado
                //en la posición pos. 
            
}
            else
            {
                
//no encontrado.
                //
            
}
        }
>


En la posición "pos = -1" lo que hacemos es asignarle un valor imposible para que pueda ser adquirido por cualquier resultado matemático que apliquemos en números positivos.
Como vimos en post anteriores, habíamos dado la diferencia entre el comando while y el comando for, pues aquí vemos dicha diferencia: El comando for sirve para iteraciones que sabemos cuantas veces se van a repetir, mientras que el comando while se usa para iteraciones que no sabemos cuantas veces se van a repetir.

En la condición del while, mientras pos sea igual a -1 e "i" sea menor a la extensión total del vector, lo primero que hará es comparar si el valor en i es igual al valor dado por el usuario, si es igual, pos toma el valor de i y pasa la consecuencia de si lo encuentra. Si no es un valor igual, a i se le suma 1 y vuelve a compararse.
Cuando se sale de la iteración se compara el valor de pos, si es distinto a -1, el elemento es encontrado en la posición pos y se hace todo lo que se deba hacer con dicho valor.
Si no lo encuentra, se hace otra consecuencia.

Siguiente caso: Búsqueda binaria.

<?
        
public void BusquedaBinaria(int val)
        {
            
int pos = -1;
            
int ini 0;
            
int fin v.Length 1;
            
int medio = (ini fin) / 2;

            while ((
ini <= fin) && (pos == -1))
            {
                if (
v[medio] == val)
                    
pos medio;
                else if (
v[medio] < val)
                    
ini medio 1;
                else
                    
fin medio 1;
                
medio = (ini fin) / 2;
            }
            if (
pos != -1)
            {
                
// Elemento encontrado a la posición pos.
            
}
            else
            {
                
// Elemento no encontrado.
            
}
        }
>


En este caso lo que tenemos es "posición = -1", se toma por referencia las posiciones iniciales y finales del vector y la posición del medio del vector.
Entonces lo que hace es esto, En el while se tiene por condición: mientras inicio sea menor o igual al fin y posición sea -1 va a comparar el valor de la posición del medio con el valor que busca el usuario. Si la encontró, pos deja de ser -1 y pasa a ser "medio". En el caso de que el valor buscado sea mayor al valor del medio, se pone que el inicio es el valor del medio mas 1, si el al revés, se establece que la posición del fin es el medio -1. Entonces lo que hace es comparar de nuevo, busca la posición del medio de lo que quedó y las posiciones, en el caso de no encontrarse se van a terminar cruzando. En el caso de encontrase va a ser si o si el valor medio de las posiciones.


Para que quede mas claro:


Val
I----I----I----I----I

Inicio:
Val<=
I----I----I----I----I
ini medio fin

Val
I----I----I
ini med fin

Fíjense que en este caso en dos pasos encontró el valor. El caso es que si hacemos una búsqueda con una burbuja mejorada, sirve, pero es ineficiente al momento de ser encarada con los recursos de una maquina. Lo mismo pasa con una búsqueda secuencial, pero si comparamos las dos anteriores con la búsqueda binaria, encontraremos que ocupa mucho menos recursos.


Tarea:
1- Unan todo a un programa y logren que ande.

6 comentarios - Programando en C# 11

@leomax77
interesante, por casualidad no tenés algún post que explique lo de eventos y delegados que es lo que más me complica saludos
@trukof
tambien estoy interesado en eventos y delegados, y otros temas de C#
@venturitaron
yo voy hacer un tuto si quiren de eventos
Lelale dijo:
leomax77 dijo:interesante, por casualidad no tenés algún post que explique lo de eventos y delegados que es lo que más me complica saludos

Todo contestado por mp


Lelale dijo:
leomax77 dijo:interesante, por casualidad no tenés algún post que explique lo de eventos y delegados que es lo que más me complica saludos

Todo contestado por mp

yo voy hacer un tuto si quiren de eventos
@rodri9090
No entendi a esta parte:
"Para que quede mas claro:


Val
I----I----I----I----I

Inicio:
Val<=
I----I----I----I----I
ini medio fin

Val
I----I----I
ini med fin

Fíjense que en este caso en dos pasos encontró el valor. El caso es que si hacemos una búsqueda con una burbuja mejorada, sirve, pero es ineficiente al momento de ser encarada con los recursos de una maquina. Lo mismo pasa con una búsqueda secuencial, pero si comparamos las dos anteriores con la búsqueda binaria, encontraremos que ocupa mucho menos recursos."
o tas mintiendo?
lo se refiero..que no has asignado a esta parte poniendo en siguientes casos: Búsqueda binaria, Búsqueda secuencial, números aleatoreamente en un vector de cinco lugares.

Val
I----I----I----I----I

Inicio:
Val<=
I----I----I----I----I
ini medio fin

Val
I----I----I
ini med fin

"Lo mismo pasa con una búsqueda secuencial, pero si comparamos las dos anteriores con la búsqueda binaria, encontraremos que ocupa mucho menos recursos." Y esta parte no entiendi parece estas mintiendo que esto "encontraremos que ocupa mucho menos recursos" es muy ambiguo.

Debería explicar así: "Lo mismo pasa con una búsqueda secuencial, que consume menos recursos y otra que esta la búsqueda binaria, encontraremos que ocupa muchos recursos." bueno no se? toy dando un ejemplo no más para no estar mintiendo o tas mintiendo?
@Lelale
Te lo explico mas claro:
Secuencial, pasás uno por uno revisando el valor del dato para luego ordenarlo.
Uno por uno al punto que revisaste todos los elementos de tu vector y los repasaste mas de una vez para poder ordenarlos.
La burbuja mejorada hace eso también, pero ahorra a penas recursos.
@Lelale
La binaria ordena diciendo "este es el valor del elemento que quiero ordenar, es mayor a la mitad?" si-no, si es no, lo coloca a la derecha "es mayor a la cuarta parte?", no, lo coloca mas a la derecha "es mayor a la octava parte?" y así hasta que lo pone en un lugar donde es mayor al punto de comparación.