public Nodo(Nodo x)
 {
     this.info = x.info;
     this.Sig  = x.Sig;
 }
 public Nodo()
 {
     info     = 0;
     this.Sig = null;
 }
 public Nodo(int info)
 {
     this.info = info;
     this.Sig  = null;
 }
        static void Main(/*string[] args*/)
        {
            lista1.Ins(5);
            lista1.Ins(6);
            lista1.Ins(6);
            lista1.Ins(4);
            lista1.InsInicio(8);
            lista1.InsInicio(10);
            lista1.InsInicio(6);
            lista1.Ins(2);
            lista1.InsInicio(2);
            lista1.Ver();

            Nodo Encontrado = lista1.Buscar(2);

            WriteLine("\nBusqueda de nodo con info " + Encontrado.info + ": " + Encontrado);
            Nodo anterior = lista1.Anterior(8);

            WriteLine("Anterior de nodo con info " + anterior.Sig + ": " + anterior);
            WriteLine("Nodo con indice: " + lista1[3] + "\n");
            lista1[3] = 55;
            lista1.Ver();
            lista1.Del(2);
            lista1.Ver();

            WriteLine("\nLista de algoritmos para sortear la lista enlazada:");
            WriteLine("1.- Bubble Sort");
            WriteLine("2.- Insertion Sort (Version inline)");
            WriteLine("3.- Selection Sort (Version inline)");
            WriteLine("4.- Merge Sort");
            WriteLine("5.- Quick Sort");


            int cantidad = lista1.Cantidad();
            int desicion = int.Parse(Console.ReadLine());

            switch (desicion)
            {
            case 1:

                //Bubble Sort
                WriteLine("Bubble Sort");
                for (int i = 1; i < cantidad; i++)
                {
                    for (int j = 0; j < cantidad - i; j++)
                    {
                        if (lista1[j] > lista1[j + 1])
                        {
                            Swap(j, j + 1);
                        }
                    }
                }
                lista1.Ver();
                break;

            case 2:
                //Insertion Sort version Inline
                WriteLine("Insertion Sort");
                int posAgujero = 0;

                for (int i = 1; i < cantidad; i++)
                {
                    posAgujero = i;
                    while (posAgujero > 0 && lista1[posAgujero] < lista1[posAgujero - 1])
                    {
                        Swap(posAgujero, posAgujero - 1);
                        posAgujero = posAgujero - 1;
                    }
                }
                lista1.Ver();
                break;

            case 3:
                //Selection Sort version inline
                WriteLine("Selection Sort");
                int indiceMenor = 0;
                for (int i = 0; i < cantidad - 1; i++)
                {
                    indiceMenor = i;
                    for (int j = i + 1; j < cantidad; j++)
                    {
                        if (lista1[j] < lista1[indiceMenor])
                        {
                            indiceMenor = j;
                        }
                    }
                    Swap(i, indiceMenor);
                }
                lista1.Ver();
                break;

            case 4:
                //Merge Sort
                WriteLine("Merge Sort");
                Lista lista2 = MergeSort(lista1);
                lista2.Ver();
                break;

            case 5:
                //Quick Sort
                WriteLine("Quick Sort");
                QuickSort(0, lista1.Cantidad() - 1);
                lista1.Ver();
                break;

            default:
                MainHandler MainDelegate = new MainHandler(Main);
                MainDelegate.Invoke();
                break;
            }
        }