C# Demonstrate the fail-soft array

class FSDemo {
  static void Main() {
    FailSoftArray fs = new FailSoftArray(5, -1);
    int x;

    // Show quiet failures.
    Console.WriteLine("Fail quietly.");
    for(int i=0; i < (fs.Length * 2); i++)
      fs.Put(i, i*10);

    for(int i=0; i < (fs.Length * 2); i++) {
      x = fs.Get(i);
      if(x != -1) Console.Write(x + " ");
    }
    Console.WriteLine("");

    // Now, handle failures.
    Console.WriteLine("\nFail with error reports.");
    for(int i=0; i < (fs.Length * 2); i++)
      if(!fs.Put(i, i*10))
        Console.WriteLine("Index " + i + " out-of-bounds");

    for(int i=0; i < (fs.Length * 2); i++) {
      x = fs.Get(i);
      if(x != -1) Console.Write(x + " ");
      else
        Console.WriteLine("Index " + i + " out-of-bounds");
    }
  }
}

C# Public vs private access.

using System;

class MyClass {
  private int alpha; // private access explicitly specified
  int beta;          // private access by default
  public int gamma;  // public access

  /* Methods to access alpha and beta.  It is OK for a member
     of a class to access a private member of the same class. */

  public void SetAlpha(int a) {
    alpha = a;
  }

  public int GetAlpha() {
    return alpha;
  }

  public void SetBeta(int a) {
    beta = a;
  }

  public int GetBeta() {
    return beta;
  }
}
 
class AccessDemo {
  static void Main() {
    MyClass ob = new MyClass();
 
    // Access to alpha and beta is allowed only through methods.
    ob.SetAlpha(-99);
    ob.SetBeta(19);
    Console.WriteLine("ob.alpha is " + ob.GetAlpha());
    Console.WriteLine("ob.beta is " + ob.GetBeta());

    // You cannot access alpha or beta like this:
//  ob.alpha = 10; // Wrong! alpha is private!
//  ob.beta = 9;   // Wrong! beta is private!

    // It is OK to directly access gamma because it is public.
    ob.gamma = 99;
   }
}

Program C# Compute your weight on the moon.

using System;

class Moon {  
  static void Main() {  
    double earthweight; // weight on earth
    double moonweight;  // weight on moon  
 
    earthweight = 165.0;  
 
    moonweight = earthweight * 0.17;
 
    Console.WriteLine(earthweight + " earth-pounds is equivalent to " +
                      moonweight + " moon-pounds.");  
 
  }  
}

Numeros primos C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace numerosprimos
{
    class Program
    {
        static void Main(string[] args)
        {
            int numero = 2;
            for (numero = 2; numero < 100; numero++)
            {
                Console.WriteLine("Numeros primos del 1 al 100"+numero);
            }

            Console.ReadLine();

        }
    }
}

Tabla de la verdad C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TablaDeLaVerdad
{
    class Program
    {
        static void Main(string[] args)
        {

            //encuentra los numeros primos entre 2 y 100
            int i, j;
            bool esPrimo;

            for (i = 2; i < 100;i++ )
            {
                esPrimo = true;
                //prueba si un numero uniformemente es divisible

               for(j=2;j<=i/j;j++)
               
             
                if((i%j) == 0)
               
                esPrimo=false;
                if(esPrimo)

                    Console.WriteLine(i+" es primo");
               
                Console.ReadLine();
            }

        }
    }
}

Tablero Ajedrez C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TableroAjedres
{
    class Program
    {
        static void Main(string[] args)
        {
            int falfil, calfil; // posición inicial del alfil
            int fila, columna;  // posición actual del alfil

            Console.WriteLine("Posición del alfil:");
            Console.Write("  fila    ");
            falfil = Convert.ToInt32(Console.ReadLine());
            Console.Write("  columna ");
            calfil = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine(); // dejar una línea en blanco

            // Pintar el tablero de ajedrez
            for (fila = 1; fila <= 8; fila++)
            {
                for (columna = 1; columna <= 8; columna++)
                {
                    if ((fila + columna == falfil + calfil) ||
                       (fila - columna == falfil - calfil))
                        Console.Write("* ");
                    else if ((fila + columna) % 2 == 0)
                        Console.Write("B ");
                    else
                        Console.Write("N ");
                }
                Console.WriteLine(); // cambiar de fila

            }
            Console.ReadLine();
        }
    }
}

Teorema Newton C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TeoremaDeNewton
{
    class Program
    {
        static void Main(string[] args)
        {
            double n; //numero
            double aprox; //aproximacion de la raiz cuadrada
            double antaprox; //anterior aproximacion a la raiz cuadrada
            double epsilon; //coeficiente de error

            do
            {
                Console.Write("Número: ");
                n = Convert.ToDouble(Console.Read());
            }

            while (n < 0);
            do
            {
                Console.WriteLine("Raiz cuadrada aproximada: ");
                aprox = Convert.ToDouble(Console.Read());
            }

            while (aprox <= 0);
            do
            {
                Console.WriteLine("Coeficiente de error: ");
                epsilon = Convert.ToDouble(Console.Read());


            }

            while (epsilon <= 0);
            do
            {
                antaprox = aprox;
                aprox = (n/antaprox + antaprox) / 2;
            }

            while (Math.Abs(aprox - antaprox) >= epsilon);
            Console.WriteLine("La raiz cuadrada de {0:F2} es {1:F2}", n, aprox);

       

        }

    }
   
}

Factorial recursivo C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace RecursionFact
{
    class Recursivo
    {
         static int Factorial(int n)
        {
            if (n == 0)
            {
                return (1);
            }

               
            else
                return (n * Factorial(n - 1));
        }



        static void Main(string[] args)
        {
            int n;
            Console.WriteLine("Introduce un numero: ");
            n = Convert.ToInt32(Console.ReadLine());
            Console.WriteLine("El facotrial de: "+n+" es "+Factorial(n));
            Console.ReadLine();
            //Console.WriteLine("el factorial es: "+Factorial(5));
       
        }
    }
}

Factorial Java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package factorial;
import java.util.Scanner;

public class Factorial {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
       
        Scanner leer=new Scanner(System.in);
       
        double numero;
        int i=0;
   
        double factorial=1;
       
        System.out.print("Introduce un numero: ");
        numero=leer.nextInt();
       
        for(i=1;i<numero+1;i++)
       
        {
            factorial=factorial*i;
     
        }
        System.out.println("El factorial es:"+factorial);
    }
}

Menus paralelos C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace MENUPARALELOS
{
    class Program
    {
        static void Main(string[] args)
        {

            string[] NOMBRE = new string[5];
            int[] CALIFICACION1 = new int[5];
            int[] CALIFICACION2 = new int[5];

            int j = 0, w = 0;
            string  b = "", nom = "", x;
            int i = 0, cali1, cali2;
            string Opcion = "";

            Random objeto = new Random();
            float numero = objeto.Next(5, 10);


            while (Opcion != "X" )
            {
                Console.ForegroundColor = ConsoleColor.DarkGray;
                Console.BackgroundColor = ConsoleColor.Cyan;
       


                Console.WriteLine();
                Console.WriteLine("****___MENU DE ARREGLOS PARALELOS____****:");
                Console.WriteLine();
                Console.WriteLine("A) !!-INSERTAR");
                Console.WriteLine("B) !!-MODIFICAR");
                Console.WriteLine("C) !!-ELIMINAR");
                Console.WriteLine("X) !!-SALIR");
                Console.Write("SELECCIONA UNA OPCION:");
                Opcion = Console.ReadLine();

                switch (Opcion)
                {
                    case "A":

                        do
                        {

                            if (j < 5)
                            {

                                Console.Write("Introduzca Un Nombre:");
                                NOMBRE[j] = Console.ReadLine();

                               // Console.Write("ingrese calificacion 1:");
                                //cal1[j] = int.Parse(Console.ReadLine());
                                CALIFICACION1[j] = objeto.Next(5, 10);
                                Console.WriteLine("CALIFICACION 1: " + CALIFICACION1[j]);
                                CALIFICACION2[j] = objeto.Next(5, 10);
                                Console.WriteLine("CALIFICACION 1: "+CALIFICACION2[j]);
                                //Console.Write("ingrese calificacion 2:");
                                //cal2[j] = int.Parse(Console.ReadLine());
                                Console.WriteLine();

                                j++;

                            }
                            else
                                Console.WriteLine("!!!!!!----------Los Arreglos Están Llenos  ^__^------!!!!!");


                            Console.WriteLine("Desea Ingresar Otro Dato (SI/NO)");
                            b = Console.ReadLine();
                        } while (b == "SI");

                        break;




                    case "B":

                        Console.Write("Alumno Que Desea Modificar: ");
                        x = Console.ReadLine();

                        for (i = 0; i < 5; i++)
                            if (NOMBRE[i] == x)
                            {
                                Console.WriteLine();

                                Console.WriteLine("-------!!!!!...NUEVOS DATOS!!!!!!! -------- ");

                                Console.WriteLine("Ingrese Nombre:");
                                nom = Console.ReadLine();
                                NOMBRE[i] = nom;

                                //Console.WriteLine("ingrese calificacion 1:");
                                CALIFICACION1[i] = objeto.Next(5, 10);
                           
                                //cali1 = int.Parse(Console.ReadLine());
                                //cal1[i] = cali1;

                                //Console.WriteLine("ingrese calificacion 2: ");
                                //cali2 = int.Parse(Console.ReadLine());
                                //al2[i] = cali2;
                                    CALIFICACION2[i] = objeto.Next(5, 10);

                                Console.WriteLine();


                                for (i = 0; i < 5; i++)
                                {
                                    Console.WriteLine();

                                    Console.WriteLine(NOMBRE[i]);
                                    Console.WriteLine(CALIFICACION1[i]);
                                    Console.WriteLine(CALIFICACION2[i]);
                                }

                            }

                            else
                                Console.WriteLine("El Alumno No Existe");
                        break;



                    case "C":
                        Console.WriteLine();

                        Console.WriteLine("Elemento Que Desea Borrar");
                        x = Console.ReadLine();

                        for (i = 0; i < j; i++)
                            if (NOMBRE[i] == x)
                            {

                                for (i = 0; i < 5 - 1; i++)
                                {
                                    NOMBRE[i] = NOMBRE[i + 1];
                                    CALIFICACION1[i] = CALIFICACION1[i + 1];
                                    CALIFICACION2[i] = CALIFICACION2[i + 1];
                                }
                                j = j - 1;
                            }

                        for (i = 0; i < 5; i++)
                        {
                            Console.WriteLine(NOMBRE[i]);
                            Console.WriteLine(CALIFICACION1[i]);
                            Console.WriteLine(CALIFICACION2[i]);
                        }
                        break;
                }
            }

        }


        }
    }

Adivinar numero asignado C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Adivinador
{
    class Program
    {
        static void Main(string[] args)
        {
            int secreto = 21;
            int numero;
            string Opcion = "SI";

            //Console.WriteLine("\t\t!!!!!-PROGRAMA DE LA SUERTE-!!!!!\n\n\n");


            do
            {
                Console.WriteLine("\t\t!!!!!-PROGRAMA DE LA SUERTE-!!!!!\n\n\n");

                /*
                Console.WriteLine("Queres Jugar (SI/NO)?");
                Opcion = Convert.ToString(Console.ReadLine());
            */

            Console.Write(" Adivina  un numero del 1 al- 100: ");
            numero =Convert.ToInt32(Console.ReadLine());

            if (numero == secreto)
            {
                Console.WriteLine("Felicidades haz ganado");
            }

            else if  (numero !=secreto)
            {
                Console.WriteLine("No haz adivinado");
            }

            Console.WriteLine("Queres Jugar (SI/NO)?");
            Opcion = Convert.ToString(Console.ReadLine());
     

            } while (Opcion == "SI" | Opcion == "si");
        }
    }
}

Arreglos paralelos calcular promedio C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Arreglos_Pararelos
{
    class Program
    {
        static void Main(string[] args)
        {
            int i;
            float PROM = 0.0f;
            float AC = 0;

           //le puse la dimension de 5 para comprobar mas rapido el funcionamiento del programa.
       //el programa original es 30 calif y alumnos solo tendriamos que cambiar los numeros 5 por 30...

            Random objeto = new Random();
             float   numero = objeto.Next(5, 10);




            string[] nombre = new string[5];
            float[] calif = new float[5];

            for (i = 0; i < 5; i++)
            {
                for (i = 0; i < 5; i++)
                {
                    Console.WriteLine("Introduce el nombre: ");
                    nombre[i] = Convert.ToString(Console.ReadLine());

               
                   calif[i] = objeto.Next(5, 10);
                 

                    AC += calif[i];
                }
            }

            PROM = AC / 5;

            Console.WriteLine("El promedio dle grupo es: " + PROM);

            for (i = 0; i < 5; i++)
            {
                if (calif[i] < PROM)
                {
                    Console.WriteLine("El nombre de los alumnos con calificacion menor al promedio: "+nombre[i]);


                }



            }


            Console.ReadLine();
        }
    }
}
       
       

Serie Fibonacci Java

/*

 */
package fibonacci;
import java.util.Scanner;

public class Fibonacci {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
     
         Scanner leer=new Scanner(System.in);
        int c;
        int a=0;
        int b=1;
        int numero,i;
     
     
        System.out.print("Introduce un numero para fibonnaci: ");
        numero=leer.nextInt();
     
     
        for(i=0;i<numero;i++){
         
         
            c=a+b;
            a=b;
            b=c;
         
              System.out.print(" "+a);
        }
        // TODO code application logic here
    }
}

Numero primo Java

package primo;
import java.util.Scanner;

public class Primo {

 
    public static void main(String[] args) {
       
       
      int numero, i;
      boolean primo;
     
      Scanner entrada = new Scanner(System.in);
     
       do
       {
     
       
               System.out.println("Introduzca un número >2: ");
       
            numero = entrada.nextInt();
     
                   
       if(numero<=0)
           System.out.println("ERROR: no ha introducido un número entero positivo");
     
     
     
       }while(numero<=0);
     
     
       if(numero==1)
        primo = true;
     
       else{i = 2;
       while (numero%i!=0)
           i++;
     
       if (numero==i)  
           primo=true;
     
       else  
           primo=false;
       }
     
       System.out.print("\nEl número "+numero);
     
       if(!primo)System.out.print(" no");
     
       System.out.println(" es primo");
    }
}
     
     

       
       
   

Tabla de multiplicar Java

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package calculadora;
import java.util.Scanner;

/**
 *
 * @author gamma4
 */
public class Calculadora {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
       
        int i,dato, Tablas;
       
        Scanner LEER = new Scanner(System.in);
       
        System.out.print("Intoduce un numero:");
        dato = LEER.nextInt();
       
        for(i=1;i<11;i++)
        {          
          Tablas = (i) * dato;
          System.out.println(dato + "*" + i + "="+ Tablas);
       
        }
        // TODO code application logic here
    }
}

Arbol Binario Consola C#

//ClaseArbolBinarioBusqueda


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Arbol_Binario_Consola
{
    class ClaseArbolBinarioBusqueda
    {
        // Declaración privada  de la raíz del ABB
        private ClaseNodoArbolBinarioBusqueda raiz;

        // Constructor
        public ClaseArbolBinarioBusqueda()
        {
            Raiz = null;  // Inicializa el ABB vacío
        }

        // Propiedad pública para acceder a la raíz
        public ClaseNodoArbolBinarioBusqueda Raiz
        {
            get { return (raiz); }
            set { raiz = value; }
        }

        // Método público para detectar si el ABB está vacío
        public bool EstaVacio()
        {
            if (Raiz == null)
                return (true);
            else
                return (false);
        }

        // Método público que recibe como argumento el Nodo que se desea insertar
        public bool Insertar(ClaseNodoArbolBinarioBusqueda Nodo)
        {
            ClaseNodoArbolBinarioBusqueda NuevoNodo;

            if (EstaVacio())  // Si el ABB está vacío
            {
                // Creación del NuevoNodo
                NuevoNodo = new ClaseNodoArbolBinarioBusqueda();
                NuevoNodo = Nodo;
                Raiz = NuevoNodo;  // Establecer la Raíz
                return (true);  // Inserción exitosa
            }
            else
            {
                ClaseNodoArbolBinarioBusqueda NodoActual = Raiz;
                ClaseNodoArbolBinarioBusqueda Padre = null;

                // Inicia el recorrido del ABB hasta llegar a una hoja
                while (NodoActual != null)
                {
                    // Verifica si está duplicado
                    if (NodoActual.Dato == Nodo.Dato)
                        return (false);  // No se insertó ... duplicado

                    // Verifica el subárbol que debe recorrer
                    if (Nodo.Dato < NodoActual.Dato)
                    {
                        Padre = NodoActual;  // Recorre el subárbol izquierdo
                        NodoActual = NodoActual.HijoIzq;
                    }
                    else
                    {
                        Padre = NodoActual;  // Recorre el subárbol derecho
                        NodoActual = NodoActual.HijoDer;
                    }
                }

                // Creación del nuevo nodo
                NuevoNodo = new ClaseNodoArbolBinarioBusqueda();
                NuevoNodo = Nodo;

                if (Nodo.Dato < Padre.Dato)
                    Padre.HijoIzq = NuevoNodo;  // Se inserta por la Izquierda
                else
                    Padre.HijoDer = NuevoNodo;  // Se inserta por la Derecha

                return (true);  // Inserción exitosa
            }
        }

        // Método público que recibe como argumento el Nodo que se desea eliminar
        public bool Eliminar(ClaseNodoArbolBinarioBusqueda Nodo)
        {
            if (EstaVacio()) // Verifica si el ABB está vacío
                return (false); // No se eliminó... está vacío

            ClaseNodoArbolBinarioBusqueda NodoActual = Raiz, Padre = null;

            // Búsqueda del nodo que se desea eliminar
            while (NodoActual.Dato != Nodo.Dato)
            {
                if (Nodo.Dato < NodoActual.Dato)
                {
                    Padre = NodoActual;
                    NodoActual = NodoActual.HijoIzq;  // Recorre el subárbol izquierdo
                }
                else
                {
                    if (Nodo.Dato > NodoActual.Dato)
                    {
                        Padre = NodoActual;
                        NodoActual = NodoActual.HijoDer; // Recorre el subárbol derecho
                    }
                }
               
                if (NodoActual == null)
                    return (false);  // No se eliminó ... no existe el nodo
            }

            // Se encontró el nodo que se desea eliminar

            // Caso 1: Si el NodoActual no tiene hijo derecho entonces su hijo izquierdo se convierte en
            // el nodo apuntado por su Padre
            if (NodoActual.HijoDer == null)
            {
                if (Padre == null)
                    Raiz = NodoActual.HijoIzq;
                else
                {
                    if (Padre.Dato > NodoActual.Dato)
                        Padre.HijoIzq = NodoActual.HijoIzq;
                    else
                    {
                        if (Padre.Dato < NodoActual.Dato)
                            Padre.HijoDer = NodoActual.HijoIzq;
                    }
                }
            }
            else
            {
                // Caso 2: Si el hijo derecho del NodoActual no tiene hijo izquierdo entonces el hijo derecho
                // del NodoActual reemplaza al NodoActual

                if (NodoActual.HijoDer.HijoIzq == null)
                {
                    NodoActual.HijoDer.HijoIzq = NodoActual.HijoIzq;
                    if (Padre == null)
                        Raiz = NodoActual.HijoDer;
                    else
                    {
                        if (Padre.Dato > NodoActual.Dato)
                            Padre.HijoIzq = NodoActual.HijoDer;
                        else
                        {
                            if (Padre.Dato < NodoActual.Dato)
                                Padre.HijoDer = NodoActual.HijoDer;
                        }
                    }
                }
                else
                {
                    // Caso 3: Si el hijo derecho del NodoActual tiene hijo izquierdo se reemplaza el
                    // NodoActual con el hijo menor del subárbol derecho

                    // Inicia la búsqueda del nodo ubicado más a la izquierda de la rama derecha

                    ClaseNodoArbolBinarioBusqueda NodoMenor = NodoActual.HijoDer.HijoIzq, PadreDelNodoMenor = NodoActual.HijoDer;

                    while (NodoMenor.HijoIzq != null)
                    {
                        PadreDelNodoMenor = NodoMenor;
                        NodoMenor = NodoMenor.HijoIzq;
                    }

                    // El subárbol izquierdo de su padre se convierte en el subárbol derecho del NodoMenor
                    PadreDelNodoMenor.HijoIzq = NodoMenor.HijoDer;

                    // Asigna los hijos del NodoMenor a los hijos del NodoActual
                    NodoMenor.HijoIzq = NodoActual.HijoIzq;
                    NodoMenor.HijoDer = NodoActual.HijoDer;

                    if (Padre == null)
                        Raiz = NodoMenor;
                    else
                    {
                        if (Padre.Dato > NodoActual.Dato)
                            Padre.HijoIzq = NodoMenor;
                        else
                        {
                            if (Padre.Dato < NodoActual.Dato)
                                Padre.HijoDer = NodoMenor;
                        }
                    }
                }
            }
            return (true);
        }

        // Método público que recibe como argumento el Nodo que se desea buscar
        public bool Buscar(ClaseNodoArbolBinarioBusqueda Nodo)
        {
            if (EstaVacio())
                return (false);  // No se encontró... el ABB está vacío

            // Inicia la búsqueda del Nodo en la Raíz
            ClaseNodoArbolBinarioBusqueda NodoActual = Raiz;

            while (NodoActual != null)
            {
                if (NodoActual.Dato == Nodo.Dato)
                    return (true);  // Búsqueda exitosa
                else
                    if (Nodo.Dato > NodoActual.Dato)
                        NodoActual = NodoActual.HijoDer; // Recorre el subárbol derecho
                    else
                        NodoActual = NodoActual.HijoIzq;  // Recorre el subárbol izquierdo
            }
            return (false);  // No se encontró el nodo
        }

        // Método público recursivo para recorrer el ABB en modo PreOrden
        public void PreOrden(ClaseNodoArbolBinarioBusqueda NodoActual, ref string Resultado)
        {
            if (NodoActual != null)
            {
                Resultado = Resultado + "-> " + NodoActual.Dato.ToString();  // Visita el NodoActual
                PreOrden(NodoActual.HijoIzq, ref Resultado); // Llamada recursiva para recorrer PreOrden el subárbol izquierdo
                PreOrden(NodoActual.HijoDer, ref Resultado);// Llamada recursiva para recorrer PreOrden el subárbol derecho
            }
        }

        // Método público recursivo para recorrer el ABB en modo InOrden
        public void InOrden(ClaseNodoArbolBinarioBusqueda NodoActual, ref string Resultado)
        {
            if (NodoActual != null)
            {
                InOrden(NodoActual.HijoIzq, ref Resultado); // Llamada recursiva para recorrer InOrden el subárbol izquierdo
                Resultado = Resultado + "-> " + NodoActual.Dato.ToString();  // Visita el NodoActual
                InOrden(NodoActual.HijoDer, ref Resultado); // Llamada recursiva para recorrer InOrden el subárbol derecho
            }
        }

        // Método público recursivo para recorrer el ABB en modo PostOrden
        public void PostOrden(ClaseNodoArbolBinarioBusqueda NodoActual, ref string Resultado)
        {
            if (NodoActual != null)
            {
                PostOrden(NodoActual.HijoIzq, ref Resultado); // Llamada recursiva para recorrer PostOrden el subárbol izquierdo
                PostOrden(NodoActual.HijoDer, ref Resultado); // Llamada recursiva para recorrer PostOrden el subárbol derecho
                Resultado = Resultado + "-> " + NodoActual.Dato.ToString();  // Visita el NodoActual
            }
        }


        // Método público recursivo para vaciar el Árbol Binario de Búsqueda
        public void Vaciar()
        {
            if (!EstaVacio())  // Si no está vacío ...
            {
                // Se invoca el método recursivo para recorrer el ABB y eliminar cada uno de sus nodos
                // (iniciando en la Raiz)
                RecorrerYBorrar(Raiz);

                Raiz = null; // Se inicializa el ABB vacío
            }
        }

        // Método recursivo privado para recorrer el ABB y eliminar cada nodo
        private void RecorrerYBorrar(ClaseNodoArbolBinarioBusqueda NodoActual)
        {
            if (NodoActual != null)
            {
                RecorrerYBorrar(NodoActual.HijoIzq); // Llamada recursiva para recorrer PostOrden el subárbol izquierdo
                RecorrerYBorrar(NodoActual.HijoDer); // Llamada recursiva para recorrer PostOrden el subárbol derecho
                Eliminar(NodoActual);  // Elimina el NodoActual
            }
        }

    }
}


/////////////////////ClaseNodoArbolBinarioBusqueda



using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Arbol_Binario_Consola
{
    class ClaseNodoArbolBinarioBusqueda
    {
        private ClaseNodoArbolBinarioBusqueda hijoizq;
        private int dato;
        private ClaseNodoArbolBinarioBusqueda hijoder;

        // Constructor
        public ClaseNodoArbolBinarioBusqueda()
        {
            HijoDer = null;
            HijoIzq = null;
        }

        // Propiedad pública para acceder al dato
        public int Dato
        {
            get { return (dato); }
            set { dato = value; }
        }

        // Propiedad pública para acceder al hijo izquierdo
        public ClaseNodoArbolBinarioBusqueda HijoIzq
        {
            get { return (hijoizq); }
            set { hijoizq = value; }
        }

        // Propiedad pública para acceder al hijo derecho
        public ClaseNodoArbolBinarioBusqueda HijoDer
        {
            get { return (hijoder); }
            set { hijoder = value; }
        }

    }
}

/////////////////////////program

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Arbol_Binario_Consola

{

    class Program

    {

        static ClaseArbolBinarioBusqueda ArbolBinarioBusqueda = new ClaseArbolBinarioBusqueda();

        static void Main(string[] args)

        {

            int opcion = 0;

            ClaseNodoArbolBinarioBusqueda Nodo;

            Nodo = new ClaseNodoArbolBinarioBusqueda();  Nodo.Dato = 90; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 50; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 150; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 20; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 75; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 95; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 175; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 5; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 25; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 66; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 80; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 92; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 111; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 166; ArbolBinarioBusqueda.Insertar(Nodo);

            Nodo = new ClaseNodoArbolBinarioBusqueda(); Nodo.Dato = 200; ArbolBinarioBusqueda.Insertar(Nodo);

        

            do

            {

                Console.Clear();

                Console.WriteLine("ÁRBOLES BINARIOS DE BÚSQUEDA\n");

                Console.WriteLine("1.- Insertar nodo");

                Console.WriteLine("2.- Eliminar nodo");

                Console.WriteLine("3.- Buscar nodo");

                Console.WriteLine("4.- Recorrido Pre-Orden");

                Console.WriteLine("5.- Recorrido In-Orden");

                Console.WriteLine("6.- Recorrido Post-Orden");

                Console.WriteLine("7.- Vaciar");

                Console.WriteLine("0.- Salir");

                Console.Write("\n¿Opción? ");

                opcion = int.Parse(Console.ReadLine());

                switch (opcion)

                {

                    case 1: InsertarNodo(); break;

                    case 2: EliminarNodo(); break;

                    case 3: BuscarNodo(); break;

                    case 4: RecorrerPreOrden(); break;

                    case 5: RecorrerInOrden(); break;

                    case 6: RecorrerPostOrden(); break;

                    case 7: VaciarArbol(); break;

                }

            } while (opcion != 0);

        }

        // Método para capturar un dato e insertarlo en el árbol binario de búsqueda

        static void InsertarNodo()

        {

            // Declaración del objeto local

            ClaseNodoArbolBinarioBusqueda Nodo = new ClaseNodoArbolBinarioBusqueda();

            Console.Clear();

            Console.WriteLine("INSERTAR DATO EN EL ÁRBOL BINARIO DE BÚSQUEDA");

            Console.Write("\nNúmero ? ");

            Nodo.Dato = int.Parse(Console.ReadLine());  // Captura del dato del nodo que se desea insertar

            if (ArbolBinarioBusqueda.Insertar(Nodo)) //Se invoca el método para insertar el nodo en el árbol binario de búsqueda

                Console.WriteLine("\nDato insertado en el Árbol Binario de Búsqueda");

            else

                Console.WriteLine("\nNo se insertó el dato (duplicado)");

            Console.ReadKey();

        }

        // Método para capturar un dato, buscarlo y eliminarlo del árbol binario de búsqueda

        static void EliminarNodo()

        {

            // Declaración del objeto local

            ClaseNodoArbolBinarioBusqueda Nodo = new ClaseNodoArbolBinarioBusqueda();

            Console.Clear();

            Console.WriteLine("ELIMINAR DATO DEL ÁRBOL BINARIO");

            Console.Write("\nNúmero ? ");

            Nodo.Dato = int.Parse(Console.ReadLine());  // Captura del dato del nodo que se desea eliminar

            if (ArbolBinarioBusqueda.Eliminar(Nodo)) //Se invoca el método para insertar el nodo en el ABB

                Console.WriteLine("\nDato eliminado del Árbol Binario de Búsqueda");

            else

                Console.WriteLine("\nNo se eliminó el dato (no existe)");

            Console.ReadKey();

        }

        // Método para buscar un dato en el árbol binario de búsqueda

        static void BuscarNodo()

        {

            // Declaración del objeto local

            ClaseNodoArbolBinarioBusqueda Nodo = new ClaseNodoArbolBinarioBusqueda();

            Console.Clear();

            Console.WriteLine("BUSCAR DATO EN EL ÁRBOL BINARIO");

            Console.Write("\nNúmero ? ");

            Nodo.Dato = int.Parse(Console.ReadLine()); // Captura del dato del nodo que se desea buscar

            if (ArbolBinarioBusqueda.Buscar(Nodo)) // Se invoca el método para buscar el nodo en el ABB

                Console.WriteLine("\nEl Dato sí está almacenado en el Árbol Binario de Búsqueda");

            else

                Console.WriteLine("\nNo se encontró el dato (no existe)");

            Console.ReadKey();

        }

        static void RecorrerPreOrden()

        {

            string Resultado = " ";  // Cadena que almacena los nodos visitados

            Console.Clear();

            Console.WriteLine("RECORRIDO PRE-ORDEN DEL ÁRBOL BINARIO DE BÚSQUEDA\n");

            if (!ArbolBinarioBusqueda.EstaVacio())

            {

                // Se ejecuta el método para recorrer los nodos almacenados en el árbol binario de búsqueda

                ArbolBinarioBusqueda.PreOrden(ArbolBinarioBusqueda.Raiz, ref Resultado);

            }

            else

                Resultado = "Árbol Binario de Búsqueda vacío ...";

            Console.WriteLine(Resultado+"\n");  // Despliega el Resultado

            Console.ReadKey();

        }

        static void RecorrerInOrden()

        {

            string Resultado = ""; // Cadena que almacena los nodos visitados

            Console.Clear();

            Console.WriteLine("RECORRIDO IN-ORDEN DEL ÁRBOL BINARIO DE BÚSQUEDA\n");

            if (!ArbolBinarioBusqueda.EstaVacio())

            {

                // Se ejecuta el método para recorrer los nodos almacenados en el árbol binario de búsqueda

                ArbolBinarioBusqueda.InOrden(ArbolBinarioBusqueda.Raiz, ref Resultado);

            }

            else

                Resultado = "Árbol Binario de Búsqueda vacío ...";

            Console.WriteLine(Resultado); // Despliega la cadena con los nodos visitados

            Console.ReadKey();

        }

        static void RecorrerPostOrden()

        {

            string Resultado = "";  // Cadena que almacena los nodos visitados

            Console.Clear();

            Console.WriteLine("RECORRIDO POST-ORDEN DEL ÁRBOL BINARIO DE BÚSQUEDA\n");

            if (!ArbolBinarioBusqueda.EstaVacio())

            {

                // Se ejecuta el método para recorrer los nodos almacenados en el árbol binario de búsqueda

                ArbolBinarioBusqueda.PostOrden(ArbolBinarioBusqueda.Raiz, ref Resultado);

            }

            else

                Resultado = "Árbol Binario de Búsqueda vacío ...";

            Console.WriteLine(Resultado);  // Despliega la cadena con los nodos visitados

            Console.ReadKey();

        }

        static void VaciarArbol()

        {

            Console.Clear();

            Console.WriteLine("VACIAR EL ÁRBOL BINARIO DE BÚSQUEDA\n");

            // Se ejecuta el método para recorrer el ABB y eliminar cada uno de sus nodos e 

            // inicializarlo vacío

            ArbolBinarioBusqueda.Vaciar();

            Console.WriteLine("Se eliminaron todos los nodos del ABB (Árbol vaciado)");

            Console.ReadKey();

        }

    }

}

C# Pila Consola mediante la clase generica Stack

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Pila_Consola_Generica
{
    class Program
    {
        static Stack<int> Pila = new Stack<int>();

        static void Main(string[] args)
        {
            UInt16 opcion = 0;

            do
            {
                Console.Clear();
                Console.WriteLine("PILA USANDO COLECCIONES GENÉRICAS\n");
                Console.WriteLine("1.- Insertar dato (Push)");
                Console.WriteLine("2.- Eliminar dato (Pop)");
                Console.WriteLine("3.- Mostrar datos de la pila");
                Console.WriteLine("4.- Eliminar todos los datos de la pila (Vaciar)");
                Console.WriteLine("0.- Salir");
                Console.Write("\nOpción ? ");

                opcion = UInt16.Parse(Console.ReadLine());

                switch (opcion)
                {
                    case 1: InsertarEnPila(); break;
                    case 2: EliminarEnPila(); break;
                    case 3: MostrarDatos(); break;
                    case 4: VaciarPila(); break;
                }

            } while (opcion != 0);
        }

        public static void InsertarEnPila()
        {
            int Dato=0;

            Console.Clear();
            Console.WriteLine("INSERTAR DATO EN LA PILA GENÉRICA");
            Console.Write("\n\nNúmero entero ? ");
            Dato = int.Parse(Console.ReadLine()); // Captura el dato que se desea insertar

            // Invoca el método Push del objeto Pila de la clase genérica Stack
            Pila.Push(Dato); // Inserta el Dato en la Pila
        }

        public static void EliminarEnPila()
        {
            Console.Clear();
            Console.WriteLine("ELIMINAR EL ÚLTIMO DATO ALMACENADO EN LA PILA GENÉRICA");

            // Intenta ejecutar el método Pop
            try
            {
                // Invoca el método Pop del objeto Pila de la clase genérica Stack
                int Dato=Pila.Pop(); // Elimina el dato de la pila y lo recibe la variabla Dato
                Console.WriteLine("\n\nDato eliminado: " + Dato.ToString());
            }
            catch(InvalidOperationException e) // Si ocurre una excepción ...
            {
                // Despliega el mensaje de error
                Console.WriteLine("\n\nNo se realizó la eliminación... "+e.Message);
            }
            Console.ReadKey();
        }

        public static void MostrarDatos()
        {
            Console.Clear();
            Console.WriteLine("DATOS ALMACENADOS EN LA PILA GENÉRICA\n");

            // Intenta recorrer la Pila
            try
            {
                // Recorre cada Dato de la Pila
                foreach (int Dato in Pila)
                    Console.WriteLine(Dato);

                // Muestra la cantidad de elementos usando el método Count()
                Console.WriteLine("\nTop = " + Pila.Count());
            }
            catch (InvalidOperationException e)  // Si ocurre una excepción ...
            {
                // Despliega el mensaje correspondiente
                Console.WriteLine("\n\nPila vacía... " + e.Message);
            }
            Console.ReadKey();
        }

        public static void VaciarPila()
        {
            char sn;
            Console.Clear();
            Console.WriteLine("ELIMINAR TODOS LOS ELEMENTOS DE LA PILA (VACIAR)\n");

            // Solicita al usuario que confirme la operación
            do
            {
                Console.Write("¿Está seguro que desea vaciar la pila [S/N] ?");
                sn = char.Parse(Console.ReadLine());
                sn = Char.ToUpper(sn);  // Convierte a mayúsculas el caracter capturado
            } while (sn != 'S' && sn != 'N');

            if (sn == 'S')  // Si se confirma la operación ...
            {
                Pila.Clear();  // Invoca el método para limpiar la pila
                Console.WriteLine("\n\nSe eliminaron todos los elementos de la pila !!!");
                Console.ReadKey();
            }
        }

    }
}

Pila Consola C#

//////////////////////////clase pila

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Pilas
{
    public class ClasePila
    {
        private readonly int Max;  // Tamaño de la pila
        private int Top;  // Cantidad de datos almacenados
        private int[] Arreglo;  // Arreglo de la pila

        // Constructor que recibe el Tamaño de la pila
        public ClasePila(int Tamaño)
        {
            Top = 0;  // Inicializa la pila vacía
            Max = Tamaño; // Define el tamaño de la pila
            Arreglo = new int[Tamaño];  // Crea el arreglo
        }

        // Método para determinar si la pila está llena
        private bool EstaLlena()
        {
            if (Top == Max)
                return (true);
            else
                return (false);
        }

        // Método para determinar si la pila está vacía
        private bool EstaVacia()
        {
            if (Top == 0)
                return (true);
            else
                return (false);
        }

        // Método para insertar un dato en la pila
        public bool Push(int dato)
        {
            if (!EstaLlena())  // Si no está llena ...
            {
                Arreglo[Top] = dato;  // Inserta el dato
                Top++;  // Incrementa la cantidad de datos almacenados
                return (true); // Dato insertado con éxito
            }
            else
                return (false);  // No se insertó el dato
        }

        // Método para eliminar el último dato insertado en la pila
        public bool Pop()
        {
            if (!EstaVacia())  // Si no está vacía ...
            {
                Top--;  // Disminuye la cantidad de datos almacenados
                return (true);  // Dato eliminado con éxito
            }
            else
                return (false);  // No se eliminó el dato
        }

        // Método para mostrar en pantalla los datos de la pila
        public string Mostrar()
        {
            string Resultado = "\n";  // Inicializa el resultado

            if (!EstaVacia())  // Si no está vacía ...
            {
                // Ciclo para recorrer el arreglo de la pila
                for (int i = 0; i <= Top - 1; i++)
                    Resultado = Resultado + "\n[" + i.ToString()+"] -> "+Arreglo[i].ToString();

                Resultado = Resultado + "\n\nTop = " + Top.ToString(); // Mostrar el Top
                Resultado = Resultado + "\nMax = " + Max.ToString();  // Mostrar el Max
            }
            else
                Resultado="\n\nPila vacía !!!";
            return (Resultado);  // Devolver el Resultado
        }

        // Método para eliminar todos los datos de la pila
        public void Vaciar()
        {
            // Se inicializa a cero la cantidad de elementos almacenados en la pila
            Top = 0;
        }
    }
}

///////////////////////program

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Pilas

{

    class Program

    {

        static ClasePila Pila = new ClasePila(10);   // Declaración del objeto de la Pila

            public static void Main(string[] args)

            {

                Int16 opcion = 0;

                do

                {

                    Console.Clear();

                    Console.WriteLine("P I L A S");

                    Console.WriteLine("\n1.- Insertar dato (PUSH)");

                    Console.WriteLine("2.- Eliminar dato (POP)");

                    Console.WriteLine("3.- Mostrar datos de la Pila");

                    Console.WriteLine("4.- Eliminar todos los datos de la Pila (VACIAR)");

                    Console.WriteLine("0.- Salir");

                    Console.Write("\n\nOpcion ? ");

                    opcion = Int16.Parse(Console.ReadLine());

                    switch (opcion)

                    {

                        case 1: InsertarEnPila(); break;

                        case 2: EliminarEnPila(); break;

                        case 3: MostrarDatos(); break;

                        case 4: VaciarPila(); break;

                    }

                } while (opcion != 0);

            }

            public static void InsertarEnPila()

            {

                int Dato = 0;

                Console.Clear();

                Console.WriteLine("INSERTAR DATO EN LA PILA");

                Console.Write("\nNúmero entero ? ");

                Dato = int.Parse(Console.ReadLine()); // Se captura el número que se desea insertar

                // Se ejecuta el método Push del objeto Pila

                if(Pila.Push(Dato))

                    Console.WriteLine("\nDato insertado en la pila !!!"); 

                else

                    Console.WriteLine("\nPila llena ...");

                Console.ReadKey();

            }

            public static void EliminarEnPila()

            {

                Console.Clear();

                Console.WriteLine("ELIMINAR El ÚLTIMO DATO ALMACENADO EN LA PILA");

                

                // Se ejecuta el método Push del objeto Pila

                if (Pila.Pop())

                    Console.WriteLine("\nDato eliminado de la pila !!!");

                else

                    Console.WriteLine("\nPila vacía ...");

                Console.ReadKey();

            }

            public static void MostrarDatos()

            {

                Console.Clear();

                Console.WriteLine("DATOS ALMACENADOS EN LA PILA");

                // Se ejecuta el método para mostrar los datos de la pila

                Console.WriteLine(Pila.Mostrar());

                Console.ReadKey();

            }

            public static void VaciarPila()

            {

                char sn;

                Console.Clear();

                Console.WriteLine("ELIMINAR TODOS LOS ELEMENTOS DE LA PILA (VACIAR)\n");

                // Solicita al usuario que confirme la operación

                do

                {

                    Console.Write("¿Está seguro que desea vaciar la pila [S/N] ?");

                    sn = char.Parse(Console.ReadLine());

                    sn = Char.ToUpper(sn);  // Convierte a mayúsculas el caracter capturado

                } while (sn != 'S' && sn != 'N');

                if (sn == 'S')

                {

                    Pila.Vaciar();  // Invoca el método correspondiente

                    Console.WriteLine("\n\nSe eliminaron todos los elementos de la pila !!!");

                    Console.ReadKey();

                }

            }

    }

}