Estructura de Datos

Da clic sobre la imagen para ir al enlace de descarga de Visual Studio:

Da clic sobre la imagen para ir al enlace de descarga de IntelliJ:

Da clic en este enlace para que grafiques cada una de las funciones de complejidad del tiempo.

	Funcion Entero Fun1(Entero N)
	Inicio_Funcion
		Declarar M como Entero;
		M = 0;

		Para(Entero I=0; I < N; I++)
		Inicio_Para
			M+=1;
		Fin_Para

		Retornar M;
	Fin_Funcion
			

	Funcion Entero Fun2(Entero N)
	Inicio_Funcion
		Declarar I, J, M como Entero;
		M = 0;

		Para(Entero I=0; I < N; I++)
		Inicio_Para
			Para(Entero J=0; J < N; J++)
			Inicio_Para
				M+=1;
			Fin_Para
		Fin_Para
		
		Retornar M;
	Fin_Funcion
			

	Funcion Entero Fun4(Entero N)
	Inicio_Funcion
		Declarar I, M Como Entero;
		M=0;
		I=1;

		Mientras(I < N)
		Inicio_Mientras
			M+=1;
			I=I*2;
		Fin_Mientras
		Retornar M;
	Fin_Funcion
			

	Funcion Entero Fun6(Entero N)
	Inicio_Funcion
		Declarar I,J,K,M Como Entero;
		M=0;
		
		Para(I=0; I < N; I++)
		Inicio_Para
			Para(J=0; J < N; J++)
			Inicio_Para
				Para(K=0; K < N; K++)
				Inicio_Para
					M+=1;
				Fin_Para
			Fin_Para
		Fin_Para

		Retornar M;
	Fin_Funcion
			

	Funcion Entero Fun10(Entero N)
	Inicio_Funcion
		Declarar I,J,M Como Entero;
		M=0;

		Para(I=0; I < N; I++)
		Inicio_Para
			Para(J=I; J > 0; J--)
			Inicio_Para
				M+=1;
			Fin_Para
		Fin_Para

		Retornar M;
	Fin_Funcion
			

Clase Nodo

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

	namespace Estructura_U3_Practica1_ListaEnlazadaSimple
	{
		class Nodo
		{
			public Object Dato { get; set; }
			public Nodo Siguiente { get; set; }

			//Constructor
			public Nodo(object valorDato) : this(valorDato, null)
			{

			}

			public Nodo(object valorDato, Nodo siguiente)
			{
				Dato = valorDato;
				Siguiente = siguiente;
			}
		}
	}

			

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

	namespace Estructura_U3_Practica1_ListaEnlazadaSimple
	{
		class Lista
		{
			Nodo nodoPrincipio;
			Nodo nodoUltimo;

			public Lista()
			{
				nodoPrincipio = nodoUltimo = null;
			}

			public bool Vacio()
			{
				return nodoPrincipio == null;
			}

			public void AgregarNodoAlPrincipio(object valorNodo) {

				if (Vacio())
				{
					nodoPrincipio = nodoUltimo = new Nodo(valorNodo);
				}
				else
				{
					nodoPrincipio = new Nodo(valorNodo, nodoPrincipio);
				}

			}

			public void AgregarNodoAlUltimo(object valorNodo)
			{
				if (Vacio())
				{
					nodoUltimo = nodoPrincipio = new Nodo(valorNodo);
				}
				else
				{
					nodoUltimo = nodoUltimo.Siguiente = new Nodo(valorNodo);
				}
			}

			public void EliminarNodoAlUltimo()
			{
				if (Vacio())
				{
					throw new ExcepcionListaVacia();
				}

				object nodoAEliminar = nodoUltimo.Dato;

				if (nodoPrincipio == nodoUltimo)
				{
					nodoPrincipio = nodoUltimo = null;
				}
				else
				{
					Nodo nodoTemp = nodoPrincipio;

					while (nodoTemp.Siguiente != nodoUltimo)
					{
						nodoTemp = nodoTemp.Siguiente;
					}

					nodoUltimo = nodoTemp;
					nodoTemp.Siguiente = null;

				}
			}

			public void EliminarNodoAlPrincipio()
			{
				if (Vacio())
				{
					throw new ExcepcionListaVacia();
				}

				object nodoEliminar = nodoPrincipio.Dato;

				if (nodoPrincipio == nodoUltimo)
				{
					nodoPrincipio = nodoUltimo = null;
				}
				else
				{
					Nodo nodoTemp = nodoPrincipio.Siguiente;
					nodoPrincipio.Siguiente = null;
					nodoPrincipio = nodoTemp;
				}
			}

			public void MostrarLista()
			{
				if (Vacio())
				{
					Console.WriteLine("Esta Vacía");
					return;
				}

				Console.WriteLine("La lista tiene:");

				Nodo nodoTemp = nodoPrincipio;

				while (nodoTemp != null)
				{
					Console.Write("|{0}|°|-->",nodoTemp.Dato);
					nodoTemp = nodoTemp.Siguiente;
				}
			}

		}
	}

			

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

	namespace Estructura_U3_Practica1_ListaEnlazadaSimple
	{
		class ExcepcionListaVacia : ApplicationException
		{
			public ExcepcionListaVacia() : base("Esta lista esta vacia") { }
		}
	}

			

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

	namespace Estructura_U3_Practica1_ListaEnlazadaSimple
	{
		class ProbarLista
		{
			static Lista lista;

			static void Main(string[] args)
			{
				lista = new Lista();

				Menu();

				Console.WriteLine("Fin"); Console.ReadLine();

			}

			static void Menu()
			{
				string opcion = "";
				object nodo;

				do
				{
					Console.WriteLine("\n¿Qué desean hacer?");
					Console.WriteLine("1. Agregar Nodo al Principio");
					Console.WriteLine("2. Agregar Nodo al Último");
					Console.WriteLine("3. Eliminar Nodo al Principio");
					Console.WriteLine("4. Eliminar Nodo al Último");
					Console.WriteLine("5. Mostrar Lista");
					Console.WriteLine("EXIT. Salir");
					opcion = Console.ReadLine();

					switch (opcion)
					{
						case "1":
							Console.WriteLine("Ingresa un dato para el Nodo:");
							nodo = Console.ReadLine();
							lista.AgregarNodoAlPrincipio(nodo);
							break;
						case "2":
							Console.WriteLine("Ingresa un dato para el Nodo:");
							nodo = Console.ReadLine();
							lista.AgregarNodoAlUltimo(nodo);
							break;
						case "3":
							Console.WriteLine("Eliminando Nodo al Pincipio");
							lista.EliminarNodoAlPrincipio();
							break;
						case "4":
							Console.WriteLine("Eliminar Nodo al Último");
							lista.EliminarNodoAlUltimo();
							break;
						case "5":
							Console.WriteLine("Mostrar Lista");
							lista.MostrarLista();
							break;
						default:
							break;
					}

				} while (opcion != "exit" && opcion != "EXIT");
			}
		}
	}

			

Clase Nodo

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

	namespace Estructura_U3_Practica1_ListaEnlazadaSimple
	{
		class Nodo
		{
			public Object Dato { get; set; }
			public Nodo Siguiente { get; set; }

			//Constructor
			public Nodo(object valorDato) : this(valorDato, null)
			{

			}

			public Nodo(object valorDato, Nodo siguiente)
			{
				Dato = valorDato;
				Siguiente = siguiente;
			}
		}
	}

			

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

	namespace Estructura_U3_Practica1_ListaEnlazadaSimple
	{
		class Lista
		{
			Nodo nodoPrincipio;
			Nodo nodoUltimo;

			public Lista()
			{
				nodoPrincipio = nodoUltimo = null;
			}

			public bool Vacio()
			{
				return nodoPrincipio == null;
			}

			public void AgregarNodoAlPrincipio(object valorNodo) {

				if (Vacio())
                {
                    Nodo nodo = new Nodo(valorNodo);
                    nodoPrincipio = nodo;
                    nodoUltimo = nodoPrincipio;
                    nodoUltimo.Siguiente = nodoPrincipio;

                }
                else
                {
                    Nodo nodo = new Nodo(valorNodo, nodoPrincipio);
                    nodoUltimo.Siguiente = nodo;
                    nodoPrincipio = nodo;
                }

			}

			public void AgregarNodoAlUltimo(object valorNodo)
			{
				if (Vacio())
                {
                    nodoUltimo.Siguiente = nodoPrincipio = nodoUltimo = new Nodo(valorNodo);
                }
                else
                {
                    Nodo nodo = new Nodo(valorNodo, nodoPrincipio);
                    nodoUltimo.Siguiente = nodo;
                    nodoUltimo = nodo;
                }
			}

			public void EliminarNodoAlUltimo()
			{
				if (Vacio())
                {
                    throw new ExcepcionListaVacia();
                }

                if(nodoPrincipio == nodoUltimo)
                {
                    nodoPrincipio = nodoUltimo = null;
                }
                else
                {
                    Nodo nodoTemp = nodoPrincipio;
                    while(nodoTemp.Siguiente != nodoUltimo)
                    {
                        nodoTemp = nodoTemp.Siguiente;
                    }
                    nodoUltimo.Siguiente = null;
                    nodoUltimo = nodoTemp;
                    nodoUltimo.Siguiente = nodoPrincipio;
                }
			}

			public void EliminarNodoAlPrincipio()
			{
				if (Vacio())
                {
                    throw new ExcepcionListaVacia();
                }

                if(nodoPrincipio == nodoUltimo)
                {
                    nodoPrincipio = nodoUltimo = null;
                }
                else
                {
                    Nodo nodoTemp = nodoPrincipio.Siguiente;
                    nodoUltimo.Siguiente = null;
                    nodoPrincipio.Siguiente = null;
                    nodoUltimo.Siguiente = nodoTemp;
                    nodoPrincipio = nodoTemp;
                }
			}

			public void MostrarLista()
			{
				if (Vacio())
                {
                    Console.WriteLine("Esta vacía");
                    return;
                }

                Console.WriteLine("La lista tiene:");

                Nodo nodoTemp = nodoPrincipio;
                int c = 0;

            while (c != 2)
                {
                    Console.Write("|{0}|°|-->", nodoTemp.Dato);
                    nodoTemp = nodoTemp.Siguiente;

                    if(nodoTemp == nodoPrincipio.Siguiente)
                    {
                        c++;
                    }
                }
			}

		}
	}

			

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

	namespace Estructura_U3_Practica1_ListaEnlazadaSimple
	{
		class ExcepcionListaVacia : ApplicationException
		{
			public ExcepcionListaVacia() : base("Esta lista esta vacia") { }
		}
	}

			

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

	namespace Estructura_U3_Practica1_ListaEnlazadaSimple
	{
		class ProbarLista
		{
			static Lista lista;

			static void Main(string[] args)
			{
				lista = new Lista();

				Menu();

				Console.WriteLine("Fin"); Console.ReadLine();

			}

			static void Menu()
			{
				string opcion = "";
				object nodo;

				do
				{
                    Console.WriteLine("\nLISTA ENLAZADA SIMPLE CIRCULAR");
					Console.WriteLine("\n¿Qué desean hacer?");
					Console.WriteLine("1. Agregar Nodo al Principio");
					Console.WriteLine("2. Agregar Nodo al Último");
					Console.WriteLine("3. Eliminar Nodo al Principio");
					Console.WriteLine("4. Eliminar Nodo al Último");
					Console.WriteLine("5. Mostrar Lista");
					Console.WriteLine("EXIT. Salir");
					opcion = Console.ReadLine();

					switch (opcion)
					{
						case "1":
							Console.WriteLine("Ingresa un dato para el Nodo:");
							nodo = Console.ReadLine();
							lista.AgregarNodoAlPrincipio(nodo);
							break;
						case "2":
							Console.WriteLine("Ingresa un dato para el Nodo:");
							nodo = Console.ReadLine();
							lista.AgregarNodoAlUltimo(nodo);
							break;
						case "3":
							Console.WriteLine("Eliminando Nodo al Pincipio");
							lista.EliminarNodoAlPrincipio();
							break;
						case "4":
							Console.WriteLine("Eliminar Nodo al Último");
							lista.EliminarNodoAlUltimo();
							break;
						case "5":
							Console.WriteLine("Mostrar Lista");
							lista.MostrarLista();
							break;
						default:
							break;
					}

				} while (opcion != "exit" && opcion != "EXIT");
			}
		}
	}

			

Clase Nodo

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

	namespace Estructura_U3_Practica3_ListasDbleEnlazadas
	{
		class Nodo
		{
			public object Dato { get; set; }
    		public Nodo Siguiente { get; set; }
			public Nodo Anterior { get; set; }

			public Nodo(object valorDato) : this (valorDato, null)
			{

			}

			public Nodo(object valorDato, Nodo siguiente)
			{
				Dato = valorDato;
				Siguiente = siguiente;

			}
		}
	}

	

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

	namespace Estructura_U3_Practica3_ListasDbleEnlazadas
	{
		class Lista
		{
			Nodo nodoPrincipio, nodoUltimo;

			public Lista()
			{
				nodoPrincipio = nodoUltimo = null;
			}

			public bool Vacio()
			{
				return nodoPrincipio == null;
			}

			public void AgregarNodoAlPrincipio(object valorNodo)
			{
				if (Vacio())
				{
					nodoPrincipio = nodoUltimo = new Nodo(valorNodo);
				}
				else
				{
					nodoPrincipio = nodoPrincipio.Anterior = new Nodo(valorNodo, nodoPrincipio);
				}
			}

			public void AgregarNodoAlUltimo(object nodoValor)
			{
				if (Vacio())
				{
					nodoPrincipio = nodoUltimo = new Nodo(nodoValor);
				}
				else
				{
					Nodo nodoNuevo = new Nodo(nodoValor);
					nodoNuevo.Anterior = nodoUltimo;
					nodoUltimo = nodoUltimo.Siguiente = nodoNuevo;
				}
			}

			public void EliminarNodoAlPrincipio()
			{
				if (Vacio())
				{
					throw new ExcepcionListaVacia();
				}
				else
				{
					object nodoEliminar = nodoPrincipio.Dato;

					if (nodoPrincipio == nodoUltimo)
					{
						nodoPrincipio = nodoUltimo = null;
					}
					else
					{
						Nodo nodoTemp = nodoPrincipio.Siguiente;
						nodoTemp.Anterior = nodoPrincipio.Siguiente = null;
						nodoPrincipio = nodoTemp;
					}
				}
			}

			public void EliminarNodoAlUltimo()
			{
				if (Vacio())
				{
					throw new ExcepcionListaVacia();
				}

				object nodoAEliminar = nodoUltimo.Dato;

				if (nodoPrincipio == nodoUltimo)
				{
					nodoUltimo = nodoPrincipio = null;
				}
				else
				{
					Nodo nodoTemp = nodoUltimo.Anterior;
					nodoTemp.Siguiente = null;
					nodoUltimo.Anterior = null;
					nodoUltimo = nodoTemp;
				}

			}

			public void MostrarListaPU()
			{
				if (Vacio())
				{
					Console.WriteLine("Está Vacía");
					return;
				}

				Console.WriteLine("\nLa lista contiene:");

				Nodo nodoTemp = nodoPrincipio;

				while (nodoTemp != null)
				{
					Console.Write("|{0}|°|==", nodoTemp.Dato);
					nodoTemp = nodoTemp.Siguiente;
				}
			}

			public void MostrarListaUP()
			{
				if (Vacio())
				{
					Console.WriteLine("Está Vacía");
					return;
				}

				Console.WriteLine("\nLa lista contiene:");
				Nodo nodoTemp = nodoUltimo;

				while (nodoTemp != null)
				{
					Console.Write("|{0}|°|==", nodoTemp.Dato);
					nodoTemp = nodoTemp.Anterior;
				}
			}

		}
	}

	

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

	namespace Estructura_U3_Practica3_ListasDbleEnlazadas
	{
		class ExcepcionListaVacia : ApplicationException
		{
			public ExcepcionListaVacia() : base("Esta vacía") { }
		}
	}

	

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

	namespace Estructura_U3_Practica3_ListasDbleEnlazadas
	{
		class ProbarLista
		{
			static Lista lista;

			static void Main(string[] args)
			{
				lista = new Lista();
				Menu();

				Console.WriteLine("Fin"); Console.ReadLine();
			}

			static void Menu()
			{
				string opcion = "";
				object nodo;

				do
				{
					Console.WriteLine("\n¿Qué desean hacer?");
					Console.WriteLine("1. Agregar Nodo al Principio");
					Console.WriteLine("2. Agregar Nodo al Último");
					Console.WriteLine("3. Eliminar Nodo al Principio");
					Console.WriteLine("4. Eliminar Nodo al Último");
					Console.WriteLine("5. Mostrar Lista del Principio al Último");
					Console.WriteLine("6. Mostrar Lista del Último al Principio");
					Console.WriteLine("EXIT. Salir");
					opcion = Console.ReadLine();

					switch (opcion)
					{
						case "1":
							Console.WriteLine("Ingresa un dato para el Nodo:");
							nodo = Console.ReadLine();
							lista.AgregarNodoAlPrincipio(nodo);
							break;
						case "2":
							Console.WriteLine("Ingresa un dato para el Nodo:");
							nodo = Console.ReadLine();
							lista.AgregarNodoAlUltimo(nodo);
							break;
						case "3":
							Console.WriteLine("Eliminando Nodo al Pincipio");
							lista.EliminarNodoAlPrincipio();
							break;
						case "4":
							Console.WriteLine("Eliminar Nodo al Último");
							lista.EliminarNodoAlUltimo();
							break;
						case "5":
							Console.WriteLine("Mostrar Lista del Principio al Último");
							lista.MostrarListaPU();
							break;
						case "6":
							Console.WriteLine("Mostrar Lista del Último al Principio");
							lista.MostrarListaUP();
							break;
						}
					} while (opcion != "exit" && opcion != "EXIT");
				}
			}
		}

	

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

	namespace Estructura_U3_Practica3_ListasDbleEnlazadas
	{
		class Nodo
		{
			public object Dato { get; set; }
			public Nodo Siguiente { get; set; }
			public Nodo Anterior { get; set; }

			public Nodo(object valorDato) : this (valorDato, null)
			{

			}

			public Nodo(object valorDato, Nodo siguiente)
			{
				Dato = valorDato;
				Siguiente = siguiente;
			}
		}
	}
	

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

	namespace Estructura_U3_Practica3_ListasDbleEnlazadas
	{
		class Lista
		{
			Nodo nodoPrincipio, nodoUltimo;

			public Lista()
			{
				nodoPrincipio = nodoUltimo = null;
			}

			public bool Vacio()
			{
				return nodoPrincipio == null;
			}

			public void AgregarNodoAlPrincipio(object valorNodo)
			{
				if (Vacio())
				{
					nodoPrincipio = nodoUltimo = new Nodo(valorNodo);
				}
				else
				{
					nodoPrincipio = nodoPrincipio.Anterior = new Nodo(valorNodo, nodoPrincipio);
				}
				nodoPrincipio.Anterior = nodoUltimo;
				nodoUltimo.Siguiente = nodoPrincipio;
			}

			public void AgregarNodoAlUltimo(object nodoValor)
			{
				if (Vacio())
				{
					nodoPrincipio = nodoUltimo = new Nodo(nodoValor);
				}
				else
				{
					Nodo nodoNuevo = new Nodo(nodoValor);
					nodoNuevo.Anterior = nodoUltimo;
					nodoUltimo = nodoUltimo.Siguiente = nodoNuevo;
				}
				nodoPrincipio.Anterior = nodoUltimo;
				nodoUltimo.Siguiente = nodoPrincipio;

			}

			public void EliminarNodoAlPrincipio()
			{
				if (Vacio())
				{
					throw new ExcepcionListaVacia();
				}
				else
				{
					object nodoEliminar = nodoPrincipio.Dato;

					if (nodoPrincipio == nodoUltimo)
					{
						nodoPrincipio = nodoUltimo = null;
					}
					else
					{
						Nodo nodoTemp = nodoPrincipio.Siguiente;
						nodoTemp.Anterior = nodoPrincipio.Siguiente = null;
						nodoPrincipio = nodoTemp;

						nodoPrincipio.Anterior = nodoUltimo;
						nodoUltimo.Siguiente = nodoPrincipio;

					}
				}
			}

			public void EliminarNodoAlUltimo()
			{
				if (Vacio())
				{
					throw new ExcepcionListaVacia();
				}

				object nodoAEliminar = nodoUltimo.Dato;

				if (nodoPrincipio == nodoUltimo)
				{
					nodoUltimo = nodoPrincipio = null;
				}
				else
				{
					Nodo nodoTemp = nodoUltimo.Anterior;
					nodoTemp.Siguiente = null;
					nodoUltimo.Anterior = null;
					nodoUltimo = nodoTemp;

					nodoPrincipio.Anterior = nodoUltimo;
					nodoUltimo.Siguiente = nodoPrincipio;
				}
			}

			public void MostrarListaPU()
			{
				if (Vacio())
				{
					Console.WriteLine("Está Vacía");
					return;
				}

				Console.WriteLine("\nLa lista contiene:");

				Nodo nodoTemp = nodoPrincipio;

				while (nodoTemp != nodoUltimo)
				{
					Console.Write("|{0}|°|==", nodoTemp.Dato);
					nodoTemp = nodoTemp.Siguiente;
				}
				while (nodoTemp != nodoPrincipio)
				{
					Console.Write("|{0}|°|==", nodoTemp.Dato);
					nodoTemp = nodoTemp.Anterior;
				}
				Console.Write("|{0}|°|", nodoTemp.Dato);
			}

			public void MostrarListaUP()
			{
				if (Vacio())
				{
					Console.WriteLine("Está Vacía");
					return;
				}

				Console.WriteLine("\nLa lista contiene:");
				Nodo nodoTemp = nodoUltimo;

				while (nodoTemp != nodoPrincipio)
				{
					Console.Write("|{0}|°|==", nodoTemp.Dato);
					nodoTemp = nodoTemp.Anterior;
				}
				while (nodoTemp != nodoUltimo)
				{
					Console.Write("|{0}|°|==", nodoTemp.Dato);
					nodoTemp = nodoTemp.Siguiente;
				}
				Console.Write("|{0}|°|", nodoTemp.Dato);
			}
		}
	}

	

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

	namespace Estructura_U3_Practica3_ListasDbleEnlazadas
	{
		class ExcepcionListaVacia : ApplicationException
		{
			public ExcepcionListaVacia() : base("Esta vacía") { }
		}
	}

	

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

	namespace Estructura_U3_Practica3_ListasDbleEnlazadas
	{
		class ProbarLista
		{
			static Lista lista;

			static void Main(string[] args)
			{
				lista = new Lista();
				Menu();

				Console.WriteLine("Fin"); Console.ReadLine();
			}

			static void Menu()
			{
				string opcion = "";
				object nodo;

				do
				{
					Console.WriteLine("\n¿Qué desean hacer?");
					Console.WriteLine("1. Agregar Nodo al Principio");
					Console.WriteLine("2. Agregar Nodo al Último");
					Console.WriteLine("3. Eliminar Nodo al Principio");
					Console.WriteLine("4. Eliminar Nodo al Último");
					Console.WriteLine("5. Mostrar Lista del Principio al Último");
					Console.WriteLine("6. Mostrar Lista del Último al Principio");
					Console.WriteLine("EXIT. Salir");
					opcion = Console.ReadLine();

					switch (opcion)
					{
						case "1":
							Console.WriteLine("Ingresa un dato para el Nodo:");
							nodo = Console.ReadLine();
							lista.AgregarNodoAlPrincipio(nodo);
							break;
						case "2":
							Console.WriteLine("Ingresa un dato para el Nodo:");
							nodo = Console.ReadLine();
							lista.AgregarNodoAlUltimo(nodo);
							break;
						case "3":
							Console.WriteLine("Eliminando Nodo al Pincipio");
							lista.EliminarNodoAlPrincipio();
							break;
						case "4":
							Console.WriteLine("Eliminar Nodo al Último");
							lista.EliminarNodoAlUltimo();
							break;
						case "5":
							Console.WriteLine("Mostrar Lista del Principio al Último");
							lista.MostrarListaPU();
							break;
						case "6":
							Console.WriteLine("Mostrar Lista del Último al Principio");
							lista.MostrarListaUP();
							break;
						default:
							break;
					}
				} while (opcion != "exit" && opcion != "EXIT");
			}
		}
	}

	

Clase Nodo

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

    namespace _2020_Pilas4A
    {
        class Nodo
        {
            public object Dato { get; set; }
            public Nodo Siguiente { get; set; }
            public Nodo Anterior { get; set; }

            public Nodo(object valorDato) : this(valorDato, null)
            {

            }

            public Nodo(object valorDato, Nodo siguiente)
            {
                Dato = valorDato;
                Siguiente = siguiente;

            }
        }
    }
            

Clase Lista

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

    namespace _2020_Pilas4A
    {
        class Lista
        {
            Nodo nodoPrincipio, nodoUltimo;

            public Lista()
            {
                nodoPrincipio = nodoUltimo = null;
            }

            public bool Vacio()
            {
                return nodoPrincipio == null;
            }

            public void AgregarNodoAlPrincipio(object valorNodo)
            {
                if (Vacio())
                {
                    nodoPrincipio = nodoUltimo = new Nodo(valorNodo);
                }
                else
                {
                    nodoPrincipio = nodoPrincipio.Anterior = new Nodo(valorNodo, nodoPrincipio);
                }
            }

            public void AgregarNodoAlUltimo(object nodoValor)
            {
                if (Vacio())
                {
                    nodoPrincipio = nodoUltimo = new Nodo(nodoValor);
                }
                else
                {
                    Nodo nodoNuevo = new Nodo(nodoValor);
                    nodoNuevo.Anterior = nodoUltimo;
                    nodoUltimo = nodoUltimo.Siguiente = nodoNuevo;
                }
            }

            public void EliminarNodoAlPrincipio()
            {
                if (Vacio())
                {
                    throw new ExcepcionListaVacia();
                }
                else
                {
                    object nodoEliminar = nodoPrincipio.Dato;

                    if (nodoPrincipio == nodoUltimo)
                    {
                        nodoPrincipio = nodoUltimo = null;
                    }
                    else
                    {
                        Nodo nodoTemp = nodoPrincipio.Siguiente;
                        nodoTemp.Anterior = nodoPrincipio.Siguiente = null;
                        nodoPrincipio = nodoTemp;
                    }
                }
            }

            public void EliminarNodoAlUltimo()
            {
                if (Vacio())
                {
                    throw new ExcepcionListaVacia();
                }

                object nodoAEliminar = nodoUltimo.Dato;

                if (nodoPrincipio == nodoUltimo)
                {
                    nodoUltimo = nodoPrincipio = null;
                }
                else
                {
                    Nodo nodoTemp = nodoUltimo.Anterior;
                    nodoTemp.Siguiente = null;
                    nodoUltimo.Anterior = null;
                    nodoUltimo = nodoTemp;
                }

            }

            public void MostrarListaPU()
            {
                if (Vacio())
                {
                    Console.WriteLine("Está Vacía");
                    return;
                }

                Console.WriteLine("\nLa pila contiene:");

                Nodo nodoTemp = nodoPrincipio;

                while (nodoTemp != null)
                {
                    Console.WriteLine("|{0}|", nodoTemp.Dato);
                    nodoTemp = nodoTemp.Siguiente;
                }
            }

            public void MostrarListaUP()
            {
                if (Vacio())
                {
                    Console.WriteLine("Está Vacía");
                    return;
                }

                Console.WriteLine("\nLa pila contiene:");
                Nodo nodoTemp = nodoUltimo;

                while (nodoTemp != null)
                {
                    Console.WriteLine("|{0}|", nodoTemp.Dato);
                    nodoTemp = nodoTemp.Anterior;
                }
            }
        }
    }

            

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

    namespace _2020_Pilas4A
    {
        class Pila : Lista
        {
            public Pila() { }

            public void Push(object valorNodo)
            {
                AgregarNodoAlUltimo(valorNodo);
            }

            public void Pop()
            {
                EliminarNodoAlUltimo();
            }

            public void MostrarPilaHastaElTope()
            {
                MostrarListaPU();
            }

            public void MostrarPilaHastaElFondo()
            {
                MostrarListaUP();
            }
        }
    }

            

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

    namespace _2020_Pilas4A
    {
        class ExcepcionListaVacia : ApplicationException
        {
            public ExcepcionListaVacia() : base("Esta vacía") { }
        }
    }

            

    using System;

    namespace _2020_Pilas4A
    {
        class Program
        {
            static Pila pila;

            static void Main(string[] args)
            {
                pila = new Pila();
                Menu();

                Console.WriteLine("Fin"); Console.ReadLine();
            }

            static void Menu()
            {
                string opcion = "";
                object nodo;

                do
                {
                    Console.WriteLine("\n¿Qué desean hacer?");
                    Console.WriteLine("1. Push");
                    Console.WriteLine("2. Pop");
                    Console.WriteLine("3. Mostrar Pila hasta el Tope");
                    Console.WriteLine("4. Mostrar Pila hasta el Fondo");
                    Console.WriteLine("EXIT. Salir");
                    opcion = Console.ReadLine();

                    switch (opcion)
                    {
                        case "1":
                            Console.WriteLine("Ingresa un dato para el Nodo:");
                            nodo = Console.ReadLine();
                            pila.Push(nodo);
                            break;
                        case "2":
                            pila.Pop();
                            break;
                        case "3":
                            Console.WriteLine("Mostrar Pila hasta el Tope");
                            pila.MostrarPilaHastaElTope();
                            break;
                        case "4":
                            Console.WriteLine("Mostrar Pila hasta el Fondo");
                            pila.MostrarPilaHastaElFondo();
                            break;
                    }
                } while (opcion != "exit" && opcion != "EXIT");
            }
        }
    }
            

Clase Nodo

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

    namespace _2020_Colas4A
    {
        class Nodo
        {
            //Propiedades
            public object Dato { get; set; }
            public Nodo Siguiente { get; set; }
            public Nodo Anterior { get; set; }

            //Constructores
            public Nodo(object valorDato):this(valorDato, null) { }

            public Nodo(object valorDato, Nodo siguiente)
            {
                Dato = valorDato;
                Siguiente = siguiente;
            }

        }
    }
            

Clase Lista

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

    namespace _2020_Colas4A
    {
        class Lista
        {
            //Apuntadores
            Nodo nodoPrincipio, nodoUltimo;

            //Constructor
            public Lista()
            {
                nodoPrincipio = nodoUltimo = null;
            }

            //Método vacío
            public bool Vacio()
            {
                return nodoPrincipio == null;
            }

            public void AgregarNodoAlUltimo(object nodoValor)
            {
                if (Vacio())
                {
                    nodoPrincipio = nodoUltimo = new Nodo(nodoValor);
                }
                else
                {
                    Nodo nodoNuevo = new Nodo(nodoValor);
                    nodoNuevo.Anterior = nodoUltimo;
                    nodoUltimo = nodoUltimo.Siguiente = nodoNuevo;
                }
            }

            public void EliminarNodoAlPrincipio()
            {
                if (Vacio())
                {
                    throw new ExcepcionListaVacia();
                }
                else
                {
                    if(nodoPrincipio == nodoUltimo)
                    {
                        nodoPrincipio = nodoUltimo = null;
                    }
                    else
                    {
                        Nodo nodoTemp = nodoPrincipio.Siguiente;
                        nodoTemp.Anterior = nodoPrincipio.Siguiente = null;
                        nodoPrincipio = nodoTemp;
                    }
                }
            }

            public void MostrarListaPU()
            {
                if (Vacio())
                {
                    Console.WriteLine("Está Vacía");
                    return;
                }

                Console.WriteLine("\nLa lista contiene:");

                Nodo nodoTemp = nodoPrincipio;

                while (nodoTemp != null)
                {
                    Console.Write("| {0} | - ", nodoTemp.Dato);
                    nodoTemp = nodoTemp.Siguiente;
                }
            }

            public void MostrarListaUP()
            {
                if (Vacio())
                {
                    Console.WriteLine("Está Vacía");
                    return;
                }

                Console.WriteLine("\nLa lista contiene:");
                Nodo nodoTemp = nodoUltimo;

                while (nodoTemp != null)
                {
                    Console.Write("| {0} | - ", nodoTemp.Dato);
                    nodoTemp = nodoTemp.Anterior;
                }
            }
        }
    }

            

Clase Cola

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

    namespace _2020_Colas4A
    {
        class Cola
        {
            //Asociando
            private Lista cola;

            public Cola()
            {
                cola = new Lista();
            }

            public void Enqueue(object valorNodo)
            {
                cola.AgregarNodoAlUltimo(valorNodo);
            }

            public void Dequeue()
            {
                cola.EliminarNodoAlPrincipio();
            }

            public void MostrarColaPU()
            {
                cola.MostrarListaPU();
            }

            public void MostrarColaUP()
            {
                cola.MostrarListaUP();
            }
        }
    }
            

Clase ExcepcionListaVacia

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

    namespace _2020_Colas4A
    {
        class ExcepcionListaVacia : ApplicationException
        {
            public ExcepcionListaVacia() : base("Esta vacía") { }
        }
    }

            

Clase Program

    using System;

    namespace _2020_Colas4A
    {
        class Program
        {
            static Cola cola;

            static void Main(string[] args)
            {
                cola = new Cola();
                Menu();

                Console.WriteLine("Fin"); Console.ReadLine();
            }

            static void Menu()
            {
                string opcion = "";
                object nodo;

                do
                {
                    Console.WriteLine("\n¿Qué desean hacer?");
                    Console.WriteLine("1. Enqueue");
                    Console.WriteLine("2. Dequeue");
                    Console.WriteLine("3. Mostrar Cola del PU");
                    Console.WriteLine("4. Mostrar Cola de UP");
                    Console.WriteLine("EXIT. Salir");
                    opcion = Console.ReadLine();

                    switch (opcion)
                    {
                        case "1":
                            Console.WriteLine("Ingresa un dato para el Nodo:");
                            nodo = Console.ReadLine();
                            cola.Enqueue(nodo);
                            break;
                        case "2":
                            cola.Dequeue();
                            break;
                        case "3":
                            cola.MostrarColaPU();
                            break;
                        case "4":
                            cola.MostrarColaUP();
                            break;
                    }
                } while (opcion != "exit" && opcion != "EXIT");
            }
        }
    }

            

Las listas enlazadas, las pilas y las colas son estructuras de datos lineales (es decir, secuenciales). Un árbol es una estructura de datos bidimensional no lineal, con propiedades especiales. Los nodos de un árbol contienen dos o más enlaces.

Árboles binarios: árboles cuyos nodos contienen dos enlaces (de los cuales uno, ambos o ninguno pueden ser null). El nodo raíz es el primer nodo en un árbol. Cada enlace en el nodo raíz hace referencia a un hijo. El hijo izquierdo es el primer nodo en el subárbol izquierdo, y el hijo derecho es el primer nodo en el subárbol derecho. Los hijos de un nodo específico se llaman hermanos. Un nodo sin hijos se llama nodo hoja. Por lo general, los científicos computacionales dibujan los árboles partiendo desde el nodo raíz, hacia abajo; exactamente lo opuesto a la manera en que crecen la mayoría de los árboles reales.

Árbol binario de búsqueda: (sin valores duplicados en los nodos) tiene la característica de que los valores en cualquier subárbol izquierdo son menores que el valor en el nodo padre del subárbol, y los valores en cualquier subárbol derecho son mayores que el valor en el nodo padre del subárbol. Hay que tener en cuenta que la figura del árbol binario de búsqueda que corresponde a un conjunto de datos puede depender del orden en el que se insertan los valores en el árbol.

• Preorden: raíz, izquierdo, derecho
• Inorden: izquierdo, raíz, derecho
• Postorden: izquierdo, derecho, raíz

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

	namespace Estructura_De_Datos_U6_Practica1
	{
		class NodoArbol
		{
			private NodoArbol nodoIzquierdo;
			private int datos;
			private NodoArbol nodoDerecho;

			public NodoArbol(int datosNodo)
			{
				datos = datosNodo;
				nodoIzquierdo = nodoDerecho = null;
			}

			public NodoArbol NodoIzquierdo
			{
				get
				{
					return nodoIzquierdo;
				}
				set
				{
					nodoIzquierdo = value;
				}
			}

			public NodoArbol NodoDerecho
			{
				get
				{
					return nodoDerecho;
				}
				set
				{
					nodoDerecho = value;
				}
			}

			public int Datos
			{
				get
				{
					return datos;
				}
				set
				{
					datos = value;
				}
			}

			public void Insertar(int valorInsercion)
			{
				if (valorInsercion < datos)
				{
					if (nodoIzquierdo == null)
					{
						nodoIzquierdo = new NodoArbol(valorInsercion);
					}
					else
					{
						nodoIzquierdo.Insertar(valorInsercion);
					}
				}
				else if (valorInsercion > datos)
				{
					if (nodoDerecho == null)
					{
						nodoDerecho = new NodoArbol(valorInsercion);
					}
					else
					{
						nodoDerecho.Insertar(valorInsercion);
					}
				}
			}
		}
	}
	

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

	namespace Estructura_De_Datos_U6_Practica1
	{
		class Arbol
		{
			private NodoArbol raiz;

			//Constructor
			public Arbol()
			{
				raiz = null;
			}

			public void InsertarNodo(int valorInsercion)
			{
				if (raiz == null)
				{
					raiz = new NodoArbol(valorInsercion);
				}
				else
				{
					raiz.Insertar(valorInsercion);
				}
			}

			//Recorrido raíz, izquiero, derecho
			public void RecorridoPreorden()
			{
				AyudantePreorden(raiz);
			}

			private void AyudantePreorden(NodoArbol nodo)
			{
				if (nodo == null)
				{
					return;
				}

				Console.WriteLine(nodo.Datos);

				AyudantePreorden(nodo.NodoIzquierdo);

				AyudantePreorden(nodo.NodoDerecho);
			}

			//Recorrido izquierdo, raíz, derecho
			public void RecorridoInorden()
			{
				AyudanteInorden(raiz);
			}
			private void AyudanteInorden(NodoArbol nodo)
			{
				if (nodo == null)
				{
					return;
				}
				AyudanteInorden(nodo.NodoIzquierdo);
				Console.WriteLine(nodo.Datos);
				AyudanteInorden(nodo.NodoDerecho);
			}

			//Izquierdo, derecho raíz
			public void RecorridoPostorden()
			{
				AyudantePostorden(raiz);
			}

			private void AyudantePostorden(NodoArbol nodo)
			{
				if (nodo == null)
				{
					return;
				}

				AyudantePostorden(nodo.NodoIzquierdo);

				AyudantePostorden(nodo.NodoDerecho);

				Console.WriteLine(nodo.Datos);

			}

		}
	}	
	

En el tema 9 se presenta el programa de árboles binarios, sin embargo, falta por completarse ya que falta la clase Program y el menú en donde se deben mostrar los métodos de: insertar nodos al árbol, realizar el recorrido preorden, inorden y postorden, para que el usuario pueda selecionar uno de ellos.

Elabora un reporte PDF en donde expliques los métodos de ordenamiento (de inserción directa, de inserción binaria, shell short, quick sort, burbuja, shaker sort y merge sort) y de búsqueda (secuencial y binario). El reporte digital PDF deberá incluir numeración de página, letra arial tamaño 14 y títulos y preguntas en negritas con letra más grande (16), texto justificado y con ilustraciones y seguir el siguiente formato:

1. Portada: Nombre de la escuela, logotipo de la escuela, carrera, asignatura, profesor, nombre del alumno, matrícula, grupo, lugar y fecha.
2. Introducción (mínimo una cuartilla)
3. Desarrollo: de cada uno de los métodos de ordenamiento y búsqueda se indica:
   • Nombre
   • Descripción
   • Pseudocódigo
   • Ejemplo con C#
4. Conclusiones personales (mínimo una cuartilla)
5. Referencias (mínimo 5 referencias)

Elabora un programa en donde integres las estructuras de datos (listas doblemente enlazadas circulares, pilas, colas y árboles binarios) en un solo proyecto de consola C#. Después, elabora un reporte PDF en donde expliques cada una de estas estructuras y además menciona cuál es el análisis de complejidad de cada estructura. El reporte digital PDF deberá incluir numeración de página, letra arial tamaño 14 y títulos y preguntas en negritas con letra más grande (16), texto justificado y con ilustraciones y seguir el siguiente formato:

1. Portada: Nombre de la escuela, logotipo de la escuela, carrera, asignatura, profesor, nombre del alumno, matrícula, grupo, lugar y fecha.
2. Introducción (mínimo una cuartilla)
3. Desarrollo: de cada uno de las estructuras incluir:
   • Nombre
   • Descripción
   • Número de clases
   • Principales propiedades implementadas
   • Principales métodos implementados
   • Ejemplo con ilustraciones
   • Ejemplo con código C#
   • Análisis de complejidad
4. Conclusiones personales (mínimo dos cuartilla donde expliques con tus propias palabras lo aprendido durante el cuatrimestre)
5. Referencias (mínimo 5 referencias)