Punteros y esrtructura de datos C#

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

namespace Lista
{
    unsafe class PunterosEstructuras
    {

        static void Main(string[] args)
        {


            //********************************
            //** Utilización de estructuras **
            //********************************

            //Crea el objeto vacio
            Persona p1 = new Persona();


            //Crea el objeto con valores
            Persona p2 = new Persona("Angel", "Lopez", 30, 1.70);


            //Crea el objeto
            Persona p3;

            //Asigna valores
            p3.Nombre = "Susan";
            p3.Apellido = "Ochoa";
            p3.Edad = 27;
            p3.Estatura = 1.67;

            Console.Write("Nombre: {0} \n Apellido: {1} \n Edad: {2} Estatura: {3} \n", p3.Nombre, p3.Apellido, p3.Edad, p3.Estatura);
           


            //********************************
            //**         Punteros           **
            //********************************

 
                int ejemploEdad = 30;
                int* ejemploPuntero;
                Console.WriteLine("Edad [ejemploEdad]= {0} \n", ejemploEdad);


                //Declara variable Edad y le asigna 30
                int Edad = 30;

                //Declara puntero pEdad
                //pEdad apunta a una variable entera
                int* pEdad;
               
                //Obtiene la dirección de memoria
                //de la variable Edad y la asigna al puntero (&)
                pEdad = &Edad;

                //Imprime contenido de la variable Edad: 30
                Console.WriteLine("Edad= {0}\n", Edad);
                               
                //Realiza el direccionamiento indirecto del puntero,
                //imprime desde el puntero pEdad el contenido de Edad: 30 (*)
                Console.WriteLine("Edad [pEdad]= {0}\n", *pEdad);

                //Realiza el direccionamiento indirecto del puntero,
                //suma 3 desde el puntero pEdad y lo asigna al contenido de Edad: 33 (*)
                *pEdad += 3;
                Console.WriteLine("Edad= {0}\n", Edad);
             
                //Asignación de puntero a puntero
                ejemploPuntero = pEdad;
               
                //Realiza el direccionamiento indirecto del puntero,
                //suma 3 desde el puntero ejemploPuntero y lo
                //asigna al contenido de Edad: 35 (*)

                *ejemploPuntero += 2;
                Console.WriteLine("Edad= {0}", Edad);


                //********************************
                //**  Punteros  y  estructuras  **
                //********************************


                    //Crea el objeto loc
                    Location loc;

                    //Asigna valores a sus variables internas
                    loc.X = 90;
                    loc.Y = 10;


                    //Declara puntero pStruct
                    //pStruct apunta a una estructura
                    Location* pStruct;

                    //Obtiene la dirección de memoria
                    //de la estructura loc y la asigna al puntero (&)
                    pStruct = &loc;

                    //Para tener acceso a un miembro de una
                    //estructura a través de un puntero.  
                    Console.WriteLine("X = {0}", pStruct->X);

                    //Para tener acceso a un miembro de una
                    //estructura a través de un puntero.
                    //Modifica su valor
                    pStruct->X = 200;

                    Console.WriteLine("X = {0}", pStruct->X);

      }


        //**********************************
        //***Declaración de una estructura**
        //**********************************

        public struct Location
        {
            public int X;
            public int Y;          
        }

        public struct Persona
        {
            public string Nombre;
            public string Apellido;
            public int Edad;
            public double Estatura;

            public Persona(string _nombre, string _apellido, int _edad, double _estatura)
            {
                Nombre = _nombre;
                Apellido = _apellido;
                Edad = _edad;
                Estatura = _estatura;
            }
           
        }

    }
}

Listas enlazadas C#

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

namespace ListasEnlazadas
{
    class Program
    {
        static void Main(string[] args)
        {
            ListaEnlazable lista = new ListaEnlazable();

            for (int i = 0; i < 10; i++)
            {
                 lista.Add(i+"angel");
            }

            for (int i = 0; i < lista.Count; i++)
            {
                Console.Write(lista[i] +"\n");
            }


            Console.Write("\n");

            lista.Insert(3, "lopez");

            for (int i = 0; i < lista.Count; i++)
            {
                Console.Write(lista[i] + "\n");
            }

            string a = lista[3].ToString();
       


        }



        public class Nodo
        {

 
            public object  valor;//valor del nodo
            public Nodo proximo;//Enlace con otro nodo

            //Al constructor le pasamos un valor y un nodo próximo
            public Nodo(object valor, Nodo proximo)
            {
                this.valor = valor;
                this.proximo = proximo;
            }

            //O le pasamos un valor y por defecto el nodo próximo es null
            public Nodo(object valor): this(valor,null) {}

           
        }


        public class ListaEnlazable:IList
        {
            Nodo primero, ultimo;
            int contador;


            public ListaEnlazable()
            {
                //Inicializamos primero y último vacios
                primero = ultimo = new Nodo(null);
                contador = 0;
            }

       

            #region IList Members


            public int Add(object x)
            {
                //Nodo auxiliar con valor x
                Nodo elem = new Nodo(x);

                if (contador == 0)
                {
                    //Si la lista está vacia
                    primero = elem;
                }
                else
                {
                    //Enlazo el nuevo nodo desde el último
                    ultimo.proximo = elem;
                }

                contador++;
                //actualizo último
                ultimo = elem;

                return 0;
            }

            public void Insert(int index, object x)
            {
                //El índice está fuera de del array
                if (index < 0 || index > contador)
                    throw new IndexOutOfRangeException();

                //Creamos un nodo para recorrer la lista
                Nodo temp = primero;

                //Recorremos los nodos hasta la posición index-1

                for (int i = 0; i < index - 1; i++)
                    temp = temp.proximo;

                //Creamos un nuevo nodo con el valor x y lo enlazamos
                //con el nodo de la posición index

                Nodo nuevo = new Nodo(x, temp.proximo);
                temp.proximo = nuevo;
                contador++;

            }

            public int IndexOf(object x)
            {
               //Recorremos los nodos como vimos en el método anterior
                Nodo temp = primero;

                for (int i = 0; i < contador; i++)
                {
                    //si encontramos x
                    if (temp.valor.Equals(x))
                        //se retorna la posición
                        return i;
                    temp = temp.proximo;
                }

                //Si no está, retornamos -1
                return -1;
            }

            public bool Contains(object x)
            {
                //Retornamos true si el método devuelve un índice positivo
                return (IndexOf(x) >= 0);
             
            }

            public void Remove(object x)
            {
                Nodo temp = primero;

                for (int i = 0; i < contador; i++)
                {

                    if (temp.valor.Equals(x))
                        temp = temp.proximo;
                }

            }

            public int Count
            {
                get { return contador; }
            }

            public object this[int index]
            {
                //aquí programamos como acceder al elemento
                get
                {
                    if (index >= 0 && index < contador)
                    {

                        Nodo cursor = primero;

                        for (int i = 0; i < index; i++)
                            cursor = cursor.proximo;

                        //se retorna el valor que está en index
                        return cursor.valor;
                   
                    }
                    else throw new IndexOutOfRangeException("Indice fuera de rango");
                }
                //Aquí programamos como darle un valor al elemento
                //que está en la posición index
                set
                {

                    if (index >= 0 && index < contador)
                    {

                        Nodo cursor = primero;
                        for (int i = 0; i < index; i++)
                            cursor = cursor.proximo;

                        //cambiamos el valor del elemento que está en el index
                        cursor.valor = value;

                    }
                    else throw new IndexOutOfRangeException("Indice fuera de rango");

                }

            }


           
            public void Clear()
            {
                throw new NotImplementedException();
            }
                 
            public bool IsFixedSize
            {
                get { throw new NotImplementedException(); }
            }

            public bool IsReadOnly
            {
                get { throw new NotImplementedException(); }
            }
         
            public void RemoveAt(int index)
            {
                throw new NotImplementedException();
            }
           

            #endregion

            #region ICollection Members
           
            public void CopyTo(Array array, int index)
            {
                throw new NotImplementedException();
            }

            public bool IsSynchronized
            {
                get { throw new NotImplementedException(); }
            }

            public object SyncRoot
            {
                get { throw new NotImplementedException(); }
            }
           
            #endregion

            #region IEnumerable Members
           
            public IEnumerator GetEnumerator()
            {
                throw new NotImplementedException();
            }
           
            #endregion
        }



    }
}

C#, calcular promedio anual

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

namespace TONELADAS
{
    class Program
    {
        static void Main(string[] args)
        {
           
           
            Console.Title = "JOSUE SANTANA !!!!!!!!!!!!!!^_^";
            Console.ForegroundColor = ConsoleColor.Magenta;
            Console.BackgroundColor = ConsoleColor.Cyan;
            Console.Clear();
            double[] toneladas=new double[12];
            double prom;
            int c=0;
            int w = 0;
            double suma=0;
            int i;
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine(@"PROBLEMA: EN UN ARREGLO UNIDIMENSIONAL
SE HAN ALMACENADO EL NUMERO TOTAL DE TONELADAS DE CEREALES CONSECHADOS
DURANTE CADA MES DEL AÑO ANTERIOR");
            Console.WriteLine();
            Console.WriteLine();
            for (i = 0; i < 12; i++)
            {
                Console.Write("Toneladas cosechadas por mes: ");
                toneladas[i]=double.Parse(Console.ReadLine());
                suma += toneladas[i];

            }

            prom = suma / 12;

            for (i = 0; i < 12; i++)
            {
                if (toneladas[i] >= prom)
                {
                    c++;
                }
            }

            for (i = 0; i < 12; i++)
            {
                if (toneladas[i] < prom)
                {
                    w++;
                }
            }

   

            Console.WriteLine("El promedio anual de toneladas cosechadas: "+prom);

            Console.WriteLine("Meses cosecha superior al promedio anual : "+prom+" total: "+c);

            Console.WriteLine("Meses cosecha inferior al promedio anual  : " + prom + " total: " + w);
         


            Console.ReadLine();
        }
    }
}

Recursividad Fibonacci

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

namespace tarea
{
    class Program
    {
        static int Fibonaci(int n)
        {
            if ((n == 1 || n == 2))
            {
                return 1;
            }

            else
            {
                return Fibonaci(n - 1) + Fibonaci(n - 2);
            }



        }



        static void Main(string[] args)
        {
            int n;
            Console.WriteLine("Introduce un numero fibonacci: ");
            n = Convert.ToInt32(Console.ReadLine());

            Console.WriteLine("Serie fibonacci:"+n+"es"+Fibonaci(n));
            Console.Read();
        }
     
    }
}

Calcular el factorial recursivo

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

namespace Tarea
{
    class Factorial
    {
        public static int factorial(int n)
        {
            return n == 0 ? 1 : factorial(n - 1) * n;
        }

        public static void Main(string[] args)

        {
            Console.Write("Numero: ");
            int n = int.Parse(Console.ReadLine());

            Console.WriteLine("Factorial: {0}", factorial(n));
        }
    }
}
       

Trabajar con arrelgos, numero mayor,menor

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

namespace MayorMenor
{
    class Program
    {
        static void Main(string[] args)
        {
            int mayor = 0;
            //int mayor = -99;
            int menor = 99;
            int i, n, numero;

            Console.Write("Ingrese la cantidad de numeros a comparar: ");
            n = Int32.Parse(Console.ReadLine());

            for (i = 0; i < n; i++)
            {
                //Console.Write((i + 1) + " numero: ");
                Console.WriteLine("Numero: ");

                numero = Int32.Parse(Console.ReadLine());

                if (mayor < numero)
                {
                    mayor = numero;
                }

                if (menor > numero)
                {
                    menor = numero;
                }
            }

            Console.WriteLine("El numero mayor es: " + mayor);
           Console.WriteLine("El numero menor es: " + menor);

            Console.ReadKey();
        }
    }
}

/////////////////////////////////////////////////////////

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

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int mayor=0;
            int n, numero;
            int i;

            Console.WriteLine("Introduce la cantidad: ");
            n = Convert.ToInt32(Console.ReadLine());

            for (i =0; i < n;i++)
            {
                Console.WriteLine("numero: ");
                numero = Convert.ToInt32(Console.ReadLine());

                if (numero >mayor)
                {
                    mayor=numero;
                 
                }
   
            }

            Console.WriteLine("El mayor es: " + mayor);


            Console.Read();


        }
    }
}