FORMULARIO COLA EN C#

 

PROGRAMA EN WINDOWS FORMS CON C#

 HACER DOS CLASES EN EL PROYECTO: NODO Y COLAS.

 

CLASE NODO.CS

using System;

using System.Collections.Generic;

using System.Text;

 

namespace cola

{

    public class Nodo

    {

        public string valor;

        public Nodo siguiente;

 

        public Nodo(string palabra)

        {

            valor = palabra;

            siguiente = null;

        }

    }

}

CLASE COLAS.CS

 

using System;

using System.Collections.Generic;

using System.Text;

 namespace cola

{

    public class Colas

    {

                public Nodo primero;

                public Nodo ultimo;

                public Colas()

                {

                                               primero = null;

                                               ultimo = null;

                }

                public void Encolar(string texto)

                {

                               Nodo nuevo = new Nodo(texto);

                               if (ultimo == null)

                               {

                                               primero = nuevo;

                                               ultimo = nuevo;

                               }

                               else

                               {

                                               ultimo.siguiente = nuevo;

                                               ultimo = nuevo;

                               }

                }

                public string Desencolar()

                {

                               if (primero == null) return null;

                               string texto = primero.valor;

                               primero = primero.siguiente;

                               if (primero == null) ultimo = null;

                               return texto;

                }

}

    }

CODIGO DEL FORMULARIO:

namespace cola

{

    public partial class Form1 : Form

    {

        private Colas micola;

        public Form1()

        {

            InitializeComponent();

            micola = new Colas();

        }

         private void Form1_Load(object sender, EventArgs e)

        {

         }

         private void btnEncolar_Click(object sender, EventArgs e)

        {

            if (txtEntrada.Text != "")

            {

                micola.Encolar(txtEntrada.Text);

                RefrescarLista();

            }

         }

         private void btnDesencolar_Click(object sender, EventArgs e)

        {

            string encontrado = micola.Desencolar();

            if (encontrado != null)

            {

                MessageBox.Show("salio: " + encontrado);

                RefrescarLista();

             }

        }

        private void RefrescarLista()

        {

            ltsCola.Items.Clear();

            Nodo actual = micola.primero;

            while (actual != null)

            {

                ltsCola.Items.Add(actual.valor);

                actual = actual.siguiente;

            }

        }

    }

 }

MODELANDO UNA BASE DE DATOS

 CLASE

INICIANDO MYSQL

CONCEPTO

CARACTERISTICAS

INTERFAZ

CODIGO PARA INICIAR BASE DE DATOS

CODIGO PARA BUSCAR EN BASE DE DATOS

TEORIA

base de datos

 clase

GRAFICOS Y TENDENCIA

 ejercicio

GRAFICO DE PASTEL

GRAFICO DE BARRAS APILADAS

GRAFICO DE COLUMNAS

GRAFICO DE BURBUJAS

GRAFICO DE PUNTOS

GRAFICO DE JERARQUIA

GRAFICO DE CASCADA

TENDENCIA

COLAS EN C#

COLAS

Una cola con nodos es una estructura de datos lineal que sigue el principio FIFO (First-In, First-Out), pero que en lugar de usar un arreglo (vector) con tamaño fijo, utiliza objetos conectados entre sí.

Aquí tienes el concepto desglosado en puntos clave:

1. El concepto de Nodo

Imagina que cada elemento es un "vagón" de un tren. Un nodo es un objeto que tiene dos compartimentos:

Dato: La información que guardas (en tu caso, un string).

Enlace (Siguiente): Una flecha o puntero que apunta a la ubicación del siguiente nodo en la memoria.

2. Memoria Dinámica

A diferencia de un arreglo donde debes decir "esta cola tendrá 10 espacios", en una cola con nodos la memoria se solicita conforme se necesita.

Si agregas un elemento, creas un nodo.

Si lo quitas, el nodo se destruye.

La cola puede crecer infinitamente mientras tengas memoria RAM disponible.

3. Los Punteros de Control

Para que una cola funcione, necesitamos saber siempre dos cosas:

Frente (Primero): ¿Quién es el que sigue para salir? (De aquí se desencola).

Final (Último): ¿Quién es el más reciente en llegar? (Aquí se encola).

CODIGO:

using System;

using System.Runtime.CompilerServices;

using System.Security.Cryptography.X509Certificates;

class Nodo

{

    public int dato;

    public Nodo Siguiente;

 

    public Nodo(int dato)

    {

     this.dato = dato;

   

     this.Siguiente=null;

 

    }

}

class Cola

{

 

    private Nodo inicio;

    private Nodo final;

    public Cola()

    {

        inicio = null;

        final = null;

    }

    public void Encolar(int valor)

    {

        Nodo nuevoNodo = new Nodo(valor);

        if (inicio == null)

        {

            inicio = nuevoNodo;

            final = nuevoNodo;

        }

        else

        {

            final.Siguiente = nuevoNodo;

            final = nuevoNodo;

 

        }

    }

    public int desencolar()

    {

        if (inicio == null)

        {

            Console.WriteLine("la cola esta vacia");

            return -1;

        }

        int aux = inicio.dato;

        inicio = inicio.Siguiente;

 

        if (inicio == null)

        {

            final = null;

        }

 

        return aux;

    }

    public void mostrar()

    {

        if (inicio == null)

        {

            Console.WriteLine("la cola esta vacia");

            return;

 

        }

 

        Nodo actual = inicio;

        Console.WriteLine("la cola :");

        while (actual != null)

        {

            Console.WriteLine(actual.dato + " ");

            actual = actual.Siguiente;

        }

        Console.WriteLine();

       

 

    }         

 

class Programa

{

    static void Main()

    {

        Cola cola = new Cola();

        cola.Encolar(5);

        cola.Encolar(14);

        cola.Encolar(3);

        cola.Encolar(33);

        cola.Encolar(9);

        cola.Encolar(14);

        cola.Encolar(17);

        cola.Encolar(4);

        cola.mostrar();

        //Console.WriteLine("frente"+cola.)

        Console.WriteLine("desencolar" + cola.desencolar());

        cola.mostrar();

    

    }

}

 

PRACTICA : DESREF E INDIRECTO

EJERCICIO

DESREF

INDIRECTO

SI

Y,O

DIAS

SI ANIDADO

GRAFICOS DE COLUMNA MOVIBLE

GRAFICO DE BURBUJAS

FUNCIONES DE BUSQUEDA

 BUSQUEDAS

DESREF

INDIRECTO

INDICE

COINCIDIR

ELEGIR

PRACTICA DE EXCEL INTERMEDIO

 EJERCICIO

C# : ARBOLES BINARIOS

ARBOLES BINARIOS

Los árboles binarios en C# son estructuras de datos jerárquicas donde cada nodo tiene, como máximo, dos hijos: izquierdo y derecho. Son fundamentales para organizar información de forma no secuencial y optimizar procesos de búsqueda y ordenamiento.

CODIGO:

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

 

namespace ConsoleApplication9

{

    using System;

 

    // Clase Nodo del árbol

    public class Nodo

    {

        public int valor;

        public Nodo izquierdo;

 

 

 

        public Nodo derecho;

 

        public Nodo(int valor)

        {

            this.valor = valor;

            izquierdo = null;

            derecho = null;

        }

    }

 

    // Clase principal del Árbol Binario de Búsqueda

    public class ArbolBinarioBusqueda

    {

        private Nodo raiz;

 

        public ArbolBinarioBusqueda()

        {

            raiz = null;

        }

 

        // Insertar un nuevo valor

        public void Insertar(int valor)

        {

            raiz = InsertarRec(raiz, valor);

        }

 

        private Nodo InsertarRec(Nodo raiz, int valor)

        {

            // Si el nodo está vacío, crear nuevo nodo

            if (raiz == null)

            {

                raiz = new Nodo(valor);

                return raiz;

            }

 

            // Ir a la izquierda si el valor es menor

            if (valor < raiz.valor)

                raiz.izquierdo = InsertarRec(raiz.izquierdo, valor);

            // Ir a la derecha si el valor es mayor

            else if (valor > raiz.valor)

                raiz.derecho = InsertarRec(raiz.derecho, valor);

 

            return raiz;

        }

 

        // Buscar un valor en el árbol

        public bool Buscar(int valor)

        {

            return BuscarRec(raiz, valor);

        }

 

        private bool BuscarRec(Nodo raiz, int valor)

        {

            // Árbol vacío o valor encontrado

            if (raiz == null || raiz.valor == valor)

                return raiz != null;

 

            // Buscar en subárbol izquierdo si valor es menor

            if (valor < raiz.valor)

                return BuscarRec(raiz.izquierdo, valor);

 

            // Buscar en subárbol derecho si valor es mayor

            return BuscarRec(raiz.derecho, valor);

        }

 

        // Eliminar un nodo

        public void Eliminar(int valor)

        {

            raiz = EliminarRec(raiz, valor);

        }

 

        private Nodo EliminarRec(Nodo raiz, int valor)

        {

            if (raiz == null) return raiz;

 

            if (valor < raiz.valor)

                raiz.izquierdo = EliminarRec(raiz.izquierdo, valor);

            else if (valor > raiz.valor)

                raiz.derecho = EliminarRec(raiz.derecho, valor);

            else

            {

                // Nodo con un solo hijo o sin hijos

                if (raiz.izquierdo == null)

                    return raiz.derecho;

                else if (raiz.derecho == null)

                    return raiz.izquierdo;

 

                // Nodo con dos hijos: obtener el inorder successor

                raiz.valor = MinimoValor(raiz.derecho);

 

                // Eliminar el inorder successor

                raiz.derecho = EliminarRec(raiz.derecho, raiz.valor);

            }

            return raiz;

        }

 

        private int MinimoValor(Nodo raiz)

        {

            int minimo = raiz.valor;

            while (raiz.izquierdo != null)

            {

                minimo = raiz.izquierdo.valor;

                raiz = raiz.izquierdo;

            }

            return minimo;

        }

 

        // Recorrido Inorden (izquierda-raíz-derecha)

        public void Inorden()

        {

            InordenRec(raiz);

            Console.WriteLine();

        }

 

        private void InordenRec(Nodo raiz)

        {

            if (raiz != null)

            {

                InordenRec(raiz.izquierdo);

                Console.Write(raiz.valor + " ");

                InordenRec(raiz.derecho);

            }

        }

 

        // Recorrido Preorden (raíz-izquierda-derecha)

        public void Preorden()

        {

            PreordenRec(raiz);

            Console.WriteLine();

        }

 

        private void PreordenRec(Nodo raiz)

        {

            if (raiz != null)  

            {

                Console.Write(raiz.valor + " ");

                PreordenRec(raiz.izquierdo);

                PreordenRec(raiz.derecho);

            }

        }

 

        // Recorrido Postorden (izquierda-derecha-raíz)

        public void Postorden()

        {

            PostordenRec(raiz);

            Console.WriteLine();

        }

 

        private void PostordenRec(Nodo raiz)

        {

            if (raiz != null)

            {

                PostordenRec(raiz.izquierdo);

                PostordenRec(raiz.derecho);

                Console.Write(raiz.valor + " ");

            }

        }

 

        // Altura del árbol

        public int Altura()

        {

            return AlturaRec(raiz);

        }

 

        private int AlturaRec(Nodo raiz)

        {

            if (raiz == null)

                return -1;

            return 1 + Math.Max(AlturaRec(raiz.izquierdo), AlturaRec(raiz.derecho));

        }

 

        // Verificar si el árbol está vacío

        public bool EstaVacio()

        {

            return raiz == null;

        }

    }

 

    // Programa principal para probar el árbol

    class Program

    {

        static void Main(string[] args)

        {

            ArbolBinarioBusqueda arbol = new ArbolBinarioBusqueda();

 

            // Insertar valores

            int[] valores = { 50, 30, 70, 20, 40, 60, 80 };

            Console.WriteLine("Insertando valores: ");

            foreach (int val in valores)

            {

                arbol.Insertar(val);

                Console.Write(val + " ");

            }

            Console.WriteLine("\n");

 

            // Recorridos

            Console.WriteLine("=== RECORRIDOS ===");

            Console.Write("Inorden:  "); arbol.Inorden();

            Console.Write("Preorden: "); arbol.Preorden();

            Console.Write("Postorden:"); arbol.Postorden();

 

            // Búsquedas

            Console.WriteLine("\n=== BÚSQUEDAS ===");

            Console.WriteLine("Buscar 40: " + (arbol.Buscar(40) ? "ENCONTRADO" : "NO ENCONTRADO"));

            Console.WriteLine("Buscar 90: " + (arbol.Buscar(90) ? "ENCONTRADO" : "NO ENCONTRADO"));

 

            // Altura

            Console.WriteLine("\nAltura del árbol: " + arbol.Altura());

 

            // Eliminar nodo

            Console.WriteLine("\nEliminando nodo 20...");

            arbol.Eliminar(20);

            Console.Write("Nuevo Inorden: "); arbol.Inorden();

            Console.ReadKey(); // Pausa para ver resultados;

        }

      

    }

 

}