APENDICE B.
Codificación de Estructuras de Datos

B.1 Arreglos unidimensionales estáticos

using System;
namespace Ejercicio1_Burbuja
{
     public class Vector
     {
               string[] elementos= new string[10];

               public Vector()
               {
                     Console.WriteLine("INGRESE 10 NOMBRES");
                     for(int i=0; i<elementos.Length; i++)
                     elementos[i]:= Console.ReadLine();
               } 


               [STAThread]
               static void Main(string[] args)
               {
                      Vector V1= new Vector();
                      Console.ReadLine();
               }
       }
}

B.2 Arreglos unidimensionales dinámicos

using System;
namespace Vectores
{
     public class Vector
     {
            int[] elementos;

            public void AdicionarNota(int nota)
            {
                     if (elementos==null)
                         elementos = new int[1];
                     else
                     {
                              int [] temp= new int[elementos.Length+1];
                              elementos.CopyTo(temp,0);
                              elementos=temp;
                      }
                      elementos[elementos.Length-1]=nota;
             }

             public Vector CrearVector()
             {
                     int nota=0;
                     Vector Vec= new Vector();
                     Console.WriteLine("Cuantos elementos:");
                     int n= int.Parse(Console.ReadLine());
                     Console.WriteLine("Valores:");
                     for(int x=0; x<n; x++)
                    {
                              nota=int.Parse(Console.ReadLine());
                              Vec.AdicionarNota(nota);
                     }
                     return Vec;
            }
}
     class Class1
     {
             static void Main(string[] args)
             {
                      Vector V1= new Vector();
                      Vector V2= new Vector();
                      V1=V1.CrearVector();
                      V2=V2.CrearVector();
                      Console.ReadLine();
              }
       }
}

B.3 Métodos de ordenamiento y búsqueda

using System;
namespace Ejercicio1_Burbuja
{
     public class Vector
     {
              string[] elementos= new string[10];

              public Vector()
              {
                     Console.WriteLine("INGRESE 10 NOMBRES");
                     for(int i=0; i<elementos.Length; i++)
                     elementos[i]= Console.ReadLine();
               }

public void Burbuja()
{
    string aux;
              for(int i=0; i<elementos.Length; i++)
                for(int j=0; j<(elementos.Length-i); j++)
                    if (elementos[j]› elementos[j+1])
     {
          aux= elementos[j];
               elementos[j] =elementos[j+1];
               elementos[j+1] = aux;
         
     }
                
}

public void Busqueda()
{
     // Aquí se escribe el recorrido
}
                 
            [STAThread]
            static void Main(string[] args)
            {
                  Vector V1= new Vector();
                  V1.Burbuja();
                  V1.Ver();
                  Console.ReadLine();

            }
      }
}

B.4 Estructuras de Datos Lineales Dinámicos (Listas Simples)

Using System;
namespace EJEMPLO_LISTAS_SIMPLES
{
      public  class Nodo
      {
            public int dato;
            public Nodo sig;
      }

      public class  Lista
      {
          public Nodo ini;
            public Nodo fin;

            void Insertar()
            {
                  Nodo aux = new Nodo();
                  aux.dato = int.Parse(Console.ReadLine());            
                  if (ini == null)
                  {
                        aux.sig= null;
                        ini = aux;       
                  }
                  else
                  {
                        fin.sig= aux;
                        aux.sig = null;
                  }                      
                  fin= aux;
            }

            public void Eliminar()
            {
           
                  // Agregar código para eliminar nodos    
            }
            public static void  Main()
            {
                  Lista L1 = new Lista();
                  char op;
                  do
                  {
                        Console.WriteLine("1. Insertar");
                        Console.WriteLine("2. Visualizar");
                        Console.WriteLine("3. Eliminar");
                        Console.WriteLine("4. Salir");
                        op= char.Parse(Console.ReadLine());
                        switch (op )
                        {
                              case '1':
                                     L1.Insertar();
                                    break;
                              case '2':
L1.Visualizar();
                                    break;
                              case '3':
L1.Eliminar();
                                    break;
                        }
                  } while (op!='4');
            }     // FIN DE MAIN
      } // FIN DE LA CLASE LISTA
} // FIN DE NAMESPACE

B.5 Recursividad

using System;
namespace Ej_Recursivo
{
      class Fact
      {
            int n, Result;
            public Fact(int num)
            {
                  n=num;
                  Result=Factorial(n);
            }
            public int Factorial(int n)
            {
                     if (n==1 || n==0)
                       return (1);
                     else
                       return (n * Factorial (n-1));
            }
static void Main(string[] args)
{
        Console.WriteLine("Dé un número: ");
        int numero=int.Parse(Console.ReadLine());
        Fact Num = new Fact(numero);
        Console.WriteLine(numero + "!=" + Num.Result);
 } // Fin del Main
} // Fin de la clase Fact
} // Fin del namespace