none
como recorer un matriz RRS feed

  • Pregunta

  • hola me pudieran ayudar con este programa tengo que recorrer la matriz y decirme en que numero estoy

            class ListaGenericaDoble
            {
                class Nodo
                {
                    public int info;
                    public Nodo ant, sig;
                }
    
                private Nodo raiz;
    
                public ListaGenericaDoble()
                {
                    raiz = null;
                }
    
                void Insertar(int pos, int x)
                {
                    if (pos <= Cantidad() + 1)
                    {
                        Nodo nuevo = new Nodo();
                        nuevo.info = x;
                        if (pos == 1)
                        {
                            nuevo.sig = raiz;
                            if (raiz != null)
                                raiz.ant = nuevo;
                            raiz = nuevo;
                        }
                        else
                            if (pos == Cantidad() + 1)
                        {
                            Nodo reco = raiz;
                            while (reco.sig != null)
                            {
                                reco = reco.sig;
                            }
                            reco.sig = nuevo;
                            nuevo.ant = reco;
                            nuevo.sig = null;
                        }
                        else
                        {
                            Nodo reco = raiz;
                            for (int f = 1; f <= pos - 2; f++)
                                reco = reco.sig;
                            Nodo siguiente = reco.sig;
                            reco.sig = nuevo;
                            nuevo.ant = reco;
                            nuevo.sig = siguiente;
                            siguiente.ant = nuevo;
                        }
                    }
                }
    
                public int Extraer(int pos)
                {
                    if (pos <= Cantidad())
                    {
                        int informacion;
                        if (pos == 1)
                        {
                            informacion = raiz.info;
                            raiz = raiz.sig;
                            if (raiz != null)
                                raiz.ant = null;
                        }
                        else
                        {
                            Nodo reco;
                            reco = raiz;
                            for (int f = 1; f <= pos - 2; f++)
                                reco = reco.sig;
                            Nodo prox = reco.sig;
                            reco.sig = prox.sig;
                            Nodo siguiente = prox.sig;
                            if (siguiente != null)
                                siguiente.ant = reco;
                            informacion = prox.info;
                        }
                        return informacion;
                    }
                    else
                        return int.MaxValue;
                }
    
                public void Borrar(int pos)
                {
                    if (pos <= Cantidad())
                    {
                        if (pos == 1)
                        {
                            raiz = raiz.sig;
                            if (raiz != null)
                                raiz.ant = null;
                        }
                        else
                        {
                            Nodo reco;
                            reco = raiz;
                            for (int f = 1; f <= pos - 2; f++)
                                reco = reco.sig;
                            Nodo prox = reco.sig;
                            prox = prox.sig;
                            reco.sig = prox;
                            if (prox != null)
                                prox.ant = reco;
                        }
                    }
                }
    
                public void Intercambiar(int pos1, int pos2)
                {
                    if (pos1 <= Cantidad() && pos2 <= Cantidad())
                    {
                        Nodo reco1 = raiz;
                        for (int f = 1; f < pos1; f++)
                            reco1 = reco1.sig;
                        Nodo reco2 = raiz;
                        for (int f = 1; f < pos2; f++)
                            reco2 = reco2.sig;
                        int aux = reco1.info;
                        reco1.info = reco2.info;
                        reco2.info = aux;
                    }
                }
    
                public int Mayor()
                {
                    if (!Vacia())
                    {
                        int may = raiz.info;
                        Nodo reco = raiz.sig;
                        while (reco != null)
                        {
                            if (reco.info > may)
                                may = reco.info;
                            reco = reco.sig;
                        }
                        return may;
                    }
                    else
                        return int.MaxValue;
                }
    
                public int PosMayor()
                {
                    if (!Vacia())
                    {
                        int may = raiz.info;
                        int x = 1;
                        int pos = x;
                        Nodo reco = raiz.sig;
                        while (reco != null)
                        {
                            if (reco.info > may)
                            {
                                may = reco.info;
                                pos = x;
                            }
                            reco = reco.sig;
                            x++;
                        }
                        return pos;
                    }
                    else
                        return int.MaxValue;
                }
    
                public int Cantidad()
                {
                    int cant = 0;
                    Nodo reco = raiz;
                    while (reco != null)
                    {
                        reco = reco.sig;
                        cant++;
                    }
                    return cant;
                }
    
                public bool Ordenada()
                {
                    if (Cantidad() > 1)
                    {
                        Nodo reco1 = raiz;
                        Nodo reco2 = raiz.sig;
                        while (reco2 != null)
                        {
                            if (reco2.info < reco1.info)
                            {
                                return false;
                            }
                            reco2 = reco2.sig;
                            reco1 = reco1.sig;
                        }
                    }
                    return true;
                }
    
                public bool Existe(int x)
                {
                    Nodo reco = raiz;
                    while (reco != null)
                    {
                        if (reco.info == x)
                            return true;
                        reco = reco.sig;
                    }
                    return false;
                }
    
                public bool Vacia()
                {
                    if (raiz == null)
                        return true;
                    else
                        return false;
                }
    
                public void Imprimir()
                {
                    Nodo reco = raiz;
                    while (reco != null)
                    {
                        Console.Write(reco.info + "-");
                        reco = reco.sig;
                    }
                    Console.WriteLine();
                }
    
                static void Main(string[] args)
                {
                    ListaGenericaDoble lg = new ListaGenericaDoble();
                    lg.Insertar(1, 10);
                    lg.Insertar(2, 20);
                    lg.Insertar(3, 30);
                    lg.Insertar(2, 15);
                    lg.Insertar(1, 115);
                    lg.Insertar(2, 75);
                    lg.Insertar(4, 90);
                    lg.Imprimir();
                    Console.WriteLine("Luego de Borrar el primero");
                    lg.Borrar(1);
                    lg.Imprimir();
                    Console.WriteLine("Luego de Extraer el segundo");
                    lg.Extraer(2);
                    lg.Imprimir();
                    Console.WriteLine("Luego de Intercambiar el primero con el tercero");
                    lg.Intercambiar(1, 3);
                    lg.Imprimir();
                    if (lg.Existe(10))
                        Console.WriteLine("Se encuentra el 20 en la lista");
                    else
                        Console.WriteLine("No se encuentra el 20 en la lista");
                    Console.WriteLine("La posición del mayor es:" + lg.PosMayor());
                    if (lg.Ordenada())
                        Console.WriteLine("La lista está ordenada de menor a mayor");
                    else
                        Console.WriteLine("La lista no está ordenada de menor a mayor");
                    Console.ReadKey();
                }
            }
        }
    }
    


    FAHS

    sábado, 20 de octubre de 2018 17:49

Todas las respuestas

  • Hola FRANCK8299,

    Si notas en tu clase Nodo tienes 2 apuntadores

    public Nodo ant, sig;

    Que son precisamente los elementos que vas a usar para recorrer tu lista

    Que seria algo así (de tu método Intercambiar)

    Nodo reco1 = raiz;                    
    for (int f = 1; f < pos1; f++)                        
    reco1 = reco1.sig;

    Entonces declara el índice f, fuera del for() y de esa manera sabras en que elemento vas en relación a cómo va incrementando, ahora con tu 

    public int info;

    Es donde vas llenando el tamaño de tu lista doblemente enlazada

    Me da pena que preguntes cómo recorrer una lista si ya lo tienes en tus métodos.

    Deberías de poner atención a entender qué hace el código que tiene.

    Erick Rivera
     ____
    Por favor recuerde "Marcar como respuesta" las respuestas que hayan resuelto su problema, es una forma común de reconocer a aquellos que han ayudado, y hace que sea más fácil para los otros visitantes encontrar la solución más tarde.
    Microsoft ofrece este servicio de forma gratuita, con la finalidad de ayudar a los usuarios y la ampliación de la base de datos de conocimientos relacionados con los productos y tecnologías de Microsoft. 
    Este contenido es proporcionado "tal cual" y no implica ninguna responsabilidad de parte de Microsoft.

    • Propuesto como respuesta Metaconta martes, 11 de junio de 2019 19:54
    martes, 11 de junio de 2019 18:26
  • La instrucción foreach ofrece una manera sencilla y limpia de iterar los elementos de una matriz.

    Para matrices unidimensionales, la instrucción foreach procesa los elementos en orden creciente de índice, comenzando con el índice 0 y terminando con el índice Length - 1:

    C#
    int[] numbers = { 4, 5, 6, 1, 2, 3, -2, -1, 0 };
    foreach (int i in numbers)
    {
        System.Console.Write("{0} ", i);
    }
    // Output: 4 5 6 1 2 3 -2 -1 0
    

    En el caso de matrices multidimensionales, los elementos se recorren de tal manera que primero se incrementan los índices de la dimensión más a la derecha, luego la siguiente dimensión a la izquierda, y así sucesivamente a la izquierda:

    C#
    int[,] numbers2D = new int[3, 2] { { 9, 99 }, { 3, 33 }, { 5, 55 } };
    // Or use the short form:
    // int[,] numbers2D = { { 9, 99 }, { 3, 33 }, { 5, 55 } };
    
    foreach (int i in numbers2D)
    {
        System.Console.Write("{0} ", i);
    }
    // Output: 9 99 3 33 5 55
    
    En cambio, con las matrices multidimensionales, usar un bucle for anidado ofrece un mayor control sobre el orden en el que se procesan los elementos de la matriz.

    http://electronica-pic.blogspot.com

    martes, 11 de junio de 2019 19:55