Guardar informacion en una pila

[TickTack]

Hola,

la idea era guardar informacion en una lista tipo pila con un comando /report y luego ver todas las informaciones de la lista en un listBox con /reports.

En el formulario hice un listBox y un textBox.

El problema es que no se me muestra ninguna informacion.


Aqui el codigo fuente:

Código [Seleccionar] Expandir


private Nodo raiz;

        public Form1()
        {
            InitializeComponent();
        }

        private void textBox2_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyCode == Keys.Enter)
            {
                if(textBox2.Text.Contains("/report"))
                {
                    Insertar(textBox2.Text.Substring(8));
                    textBox2.Clear();
                }

                if(textBox2.Text == "/reports")
                {
                    Imprimir();
                    textBox2.Clear();
                }
                e.SuppressKeyPress = true;
            }
        }

        public void Insertar(string x)
        {
            Nodo nuevo;
            nuevo = new Nodo();
            nuevo.info = x;
            if (raiz == null)
            {
                nuevo.sig = null;
                raiz = nuevo;
            }
            else
            {
                nuevo.sig = raiz;
                raiz = nuevo;
            }
        }

        class Nodo
        {
            public string info;
            public Nodo sig;
        }

        public void Imprimir()
        {
            Nodo reco = raiz;
            listBox1.Items.Add("Listado de todos los elementos de la pila.");
            while (reco != null)
            {
                listBox1.Items.Add(reco.info + "-");
                reco = reco.sig;
            }
            listBox1.Items.Add(Environment.NewLine);
        }


Gracias y saludos

PD.: Si no quieren mostrarme el codigo no importa. Pueden hacerme preguntas como: "Te fijaste lo que hiciste ahi o ahi" o "Te acuerdas que esto es asi y asi?"

[Serapis]

Te pongo el pseudocódigo de lo que podría ser la estructura de una pila. Tu luego lo transformas a código NET, y después creas la interfaz para usarla...

Es mejor separar siempre que sea posible, el objeto que se crea de la operatoria que haga el cliente con ese objeto.

Entonces crea un nuevo proyecto, llámale  como quieras, luego añade una clase y llámala Pîla

Código [Seleccionar] Expandir

clase pública Pila

   privado array entero ePila()  // los valores se alamcenarán aquí
   privado entero sCapacidad  // cantidad total de ítems que caben en la pila
   privado entero sItems   // cantidad de ítems que tiene la pila en un momento dado.

   Entero = publico Propiedad solo lectura Capacidad
       devolver sCapacidad  
   fin Propiedad

   Entero = publico Propiedad solo lectura Items
       Devolver sItems
   Fin Propiedad

   Buleano = publico Funcion EstaVacia
       Devolver (sItems=0)     // Si sItems es 0, la pila está vacía.
   Fin funcion

   Buleano = publico Funcion EstaLlena
       Devolver (sItems = sCapacidad)  // Si el valor de lo que contiene es igual a la capacidad, la pila está llena.
   Fin Funcion

   // Constructor de la clase, exige una cantidad para limitar la Pila.
   publico Funcion Nuevo(entero Cantidad)
      Si (cantidad > 0) luego
          Redimensionar array sPila(0 a Cantidad-1)
          sCapacidad = Cantidad
          sItems = 0
      Si no
          Generar ERROR "La cantidad de elementos en la Pila no puede ser 0 (ni un valor negativo)"
       Fin si
   Fin Funcion

   Buleano = Publico Funcion Meter(entero Valor)
       Si (EstaLlena = FALSE) entonces // invocamos un método de la propia clase
           ePila(sItems) = Valor
           sItems += 1  
           Devolver TRUE  
       Si no
           Generar ERROR " La pila está llena. Imposible añadir más elementos."
           Devolver FALSE
       Fin si
   Fin Funcion

   entero = publico Funcion Sacar // no lleva parámetros, la pila siempre saca elementos de la cima.
       Si (EstaVacia = FALSE) luego            
           sItems -=1    // simplemente se baja el puntero, no es preciso eliminar nada (salvo que se guardaren referencias de objetos).
            Devolver ePila(sItems)
       Si no
           Generar ERROR "La pila está vacía. no contiene elementos para extraer.
           Devolver 0
       Fin Si
   Fin funcion

   privada Funcion Destruir // el desctructor de la clase.
       Vaciar  
   Fin funcion

   privada Funcion Vaciar  //si esta función se hace pública necesitaría otra pareja llamada NuevaCapacidad(Cantidad) que haga lo mismo que hace el constructor... si no quedaría vacía y sin posibilidad de ser populada...
       sCapacidad=0
       sItems = 0
       Borrar array ePila
   Fin Funcion

   
Fin Clase

Éste pseudocódigo es un sencillo código pero completo para una pila. Incluso contiene dos métodos para consultar el estado de la pila (estaLlena y EstaVacia), que no son imprescindibles, pero internamente las vamos a usar, así que por que no hacerlos públicos...

Cómo usarla ?:
La pila es limitada, al valor que se le indica cuando se contruye una instancia de la clase. Es decir, tú puedes hacer uso de la pila por ejemplo desde una ventana o desde otra clase, lo mejor para probarlo es crear unos botones en un formulario y unas cajas de texto, los botones podrían ser 'crear()', Meter(), Sacar:  (los paréntesis en Crear y Meter, indican que requieren un parámetro que podría tomarlo de una caja de texto asociado a dicho botón.

Crear una instancia de la pil:

Código [Seleccionar] Expandir

Pila p = Nueva Pila(25) //y creas una instancia de la Pila en p, que puede contener hasta 25 elementos.

Esta pila tiene varias limitaciones, no solo la cantidad de elemntos que puede contener (las pilas en general se diseñan para contener pequeñas cantidades, no cientos de millones, rara vez se necesitará un pila muy grande, un ejemplo de esas excepciones son precisamente los programas compiladores.
Bueno, otra limitación de esta pila es que la hemos limitado al tipo de datos entero. como es un proyecto de prueba, es suficiente, pero podrías hacerla de cualquier tipo incluso para admitir cualquier tipo...

Una Pila, es una estructura para guardar elementos y luego obtenerlos en orden inverso a como se metieron, es decir, la forma lógica de verlo, es imaginandose poner un libro en el suelo y lueo otro encima y luego otro y luego otro... esto es: "apilar libros"... directamente solo puedes coger el último, el que está arriba en  la cima, para coger otro más abajo, debes primero retirar los que tienes encima. Las pilas, por esto mismo se usan en casos donde se requiere precisamente mantener ese orden (inverso al que se ha metido).

Apilar datos:

Código [Seleccionar] Expandir

p.Meter(12)
p.Meter(567)
entero n= -1234
p.Meter(n)
p.Meter(-44)

Probar los métodos y propiedades:

Código [Seleccionar] Expandir

Mensaje p.Capacidad
Mensaje p.Items
Mensaje p.EstaLlena
Mensaje p.EstaVacia

Retirar datos:

Código [Seleccionar] Expandir

entero n = p.Sacar
mensaje n  // el último valor metido fue -44, luego este es el primer valor sacado.
n = p.Sacar // se obtiene -1234, que fue el penúltimo metido.

Mensaje p.Items

etc....

Si tienes alguna duda, pregunta...

p.d.: no te conformes con ejecutar el proyecto a "saco" (F5, run), si no paso a paso (F11, debug... no recuerdo si en C# es también esa tecla F11 )

[Eleкtro]

PD.: Si no quieren mostrarme el codigo no importa. Pueden hacerme preguntas como: "Te fijaste lo que hiciste ahi o ahi" o "Te acuerdas que esto es asi y asi?"

Ese comentario creo que está de más, sinceramente. Me habría gustado profundizar en el concepto "comandos" y por qué carece de sentido su utilización en una GUI ...al menos a simple vista sin que expliques más sobre tus intenciones.



El compañero @NEBIRE está claro que pretende que trabajes mucho en implementar las cosas por ti mismo para que vayas aprendiendo conceptos y de todo un poco en general, jeje, pero tampoco sería un delito hacerte saber que la librería de clases de .NET Framework ya expone una representación abstracta de una Pila, mediante la colección LIFO genérica System.Collections.Generic.Stack<T> (o la no genérica: System.Collections.Stack), y una representación de una Cola, la colección FIFO genérica System.Collections.Generic.Queue<T> (o la no genérica: System.Collections.Queue):

Código (csharp) [Seleccionar] Expandir

Stack<string> pila = new Stack<string>(capacidad);
Queue<string> cola = new Queue<string>(capacidad);

Eso es en esencia todo lo que necesitarías para empezar a administrar el uso de una Pila (y de una Cola); ahora, y gracias al concepto de herencias, puedes tomar la clase Stack<T> y extenderla (para añadirle nuevos miembros/métodos/características) según las necesidades que tuvieses:

Código (csharp) [Seleccionar] Expandir

[ComVisible(false)]
[DebuggerDisplay("Count = {Count}")]
[DebuggerStepThrough()]
public class ExtendedStack<T> : Stack<T> {

   [DebuggerNonUserCode()]
   public ExtendedStack() : base() {}
   public ExtendedStack(int capacity) : base(capacity) {}
   public ExtendedStack(IEnumerable<T> collection) : base(collection) {}

   [EditorBrowsable(EditorBrowsableState.Always)]
   public void PushRange(IEnumerable<T> items) {
       foreach (T item in items) {
           this.Push(item);
       }
   }

   [EditorBrowsable(EditorBrowsableState.Always)]
   public T[] Pop(int amount) {
       if (this.Count < amount) {
           throw new ArgumentOutOfRangeException(paramName: "amount");
       }
       List<T> list = new List<T>();
       for (int x = 0; x <= (amount - 1); x++) {
           list.Add(this.Pop());
       }
       return list.ToArray();
   }

   [EditorBrowsable(EditorBrowsableState.Always)]
   public T[] Peek(int amount) {
       if (this.Count < amount) {
           throw new ArgumentOutOfRangeException(paramName: "amount");
       }
       Stack<T> tmpStack = new Stack<T>(Enumerable.Reverse(this));
       List<T> list = new List<T>();
       for (int x = 0; x <= (amount - 1); x++) {
           list.Add(tmpStack.Pop());
       }
       tmpStack.Clear();
       return list.ToArray();
   }

   [EditorBrowsable(EditorBrowsableState.Always)]
   public void Reverse() {
       Stack<T> tmpStack = new Stack<T>(Enumerable.Reverse(this));
       this.Clear();
       this.PushRange(tmpStack);
       tmpStack.Clear();
   }

}

...El código de arriba es tan solo un ejemplo demostrativo y escrito al vuelo (no del todo optimizado), lo cierto es que nada de eso te debería resultar necesario hacerlo, pero no está de más enseñarte un poco el abanico de posibilidades que tienes a tu alcance...

Sencillamente limítate a usar la clase Stack<T> tal cual para representar una pila de objetos, o el ejercicio en pseudo-code que te ha indicado @NEBIRE para poner en práctica los conocimientos que lleves aprendidos...

Saludos.

[TickTack]

Hola NEBIRE, hole Elektro,

muchas gracias por sus aportes. Aunque no se nada de VB, en internet se puede encontrar un traductor: http://converter.telerik.com/

Sus codigos sirven. Es bueno saber como usar una pila en C#.

Les queria comentar que antes de leer sus mensajes encontre una forma de guardar informacion en una lista (aparte de usar pilas). Y me familiarize mucho con ella. Es mas. Ustedes saben que soy el peor programador de este foro. Pero con esto yo nunca jamas tuve problemas. Ni en el aprendizaje ni en la practica. A saber: List <string>

Esta clase me ha ayudado muchisimo en mis programas. Que les parece?


PD.: Muchas gracias por su ayuda de nuevo.

[Serapis]

Claro...
1 - La lista es el objeto por excelencia para guardar cosas un poco inconexas entre sí, pero masnteniendo cierto orden y cuya cantidad se desconoce a priori y/o pueda necesitarse muchos añadidos y eliminados contínuos.
2 - La pila se elige, sólo cuando los datos a almacenar deban ser mantenidos en orden inverso a como se han metido... (LIFO: Last In, First Out; Ultimo en Entrar, Primero en Salir, como la pila de libros).
3 - Igualmente (a una pila) una cola, se elige cuando los datos a lamacenar deban ser mantenidos en el orden de llegada... (FIFO: First In, first Out; Primero en entrar, Primero en Salir, justo como la cola del cine).

Las pilas y las colas, pueden construirse con arrays y también con nodos, igual que una lista enlazada.
4 - El array frente a la Lista, tiene la ventaja de la velocidad de acceso a los ítems, que además es elegible en acceso aleatorio (a cualquiera con total independencia), la lista enlazada al igual que con llas pilas y colas, se accede a sus elementos de forma secuencial...
5 - También tienes los árboles como estructura compleja, estos serñán tu preferencia cuando los datos tengan o deban mantener entre sí cierta dependencia. Hay una gran variedad de árboles que cubren muchas posibilidades. Pero en un primer encuentro, basta mirar los árboles de forma genérica.

6 - Los grafos, son como árboles 'irregulares', y tiene su uso porque al igual que en la vida es corriente que no haya nada de forma regular, los grafos permiten cierta flexiblidad mayor que los árboles a cambio de una mayor complejidad (en la estructura finalmente formada, que puede ser más abstracta).

Finalmente cuando la elección de preferencia sea la lista, pero deba hacerse un uso intensivo de búsquedas, y sea preciso un acceso aleatorio, la estructura de preferencia será la tabla hash. Es una estructura más compleja, pero tiene la flexibilidad de la lista enlazada, con la casi velocidad del array, en búsqueda incluso gana.

Documéntate sobre estos diferentes objetos y aprende a determinar cuando usar uno u otro...

[TickTack]

Documéntate sobre estos diferentes objetos y aprende a determinar cuando usar uno u otro...

Vale.

Oye NEBIRE. Tu sabes de casualidad de un curso o tutorial que va despues de lo basico?


Gracias y saludos

[Serapis]

A ver, libros hay infinidad, que cubren todas las temáticas.

- LIBROS: Yo soy partidario de que cualquier persona que se dedique a este mundo, debería comprar como mínimo un par de libros al año, sea para actualizarse, sea para ampliar conocimientos... aún después de una dilatada experiencia, uno nunca sabrá todo, pero sus conocimientos serán muy, muy amplios.

Un libro que se titule 'curso de...' no parece que vaya a ser un buen libro. Siempre es mejor un libro que por ejemplo se titulare "...x tema, a Fondo".

Por supuesto no puede juzgarse un libro solo por el título, y menos si encima el título viene de algún modo impuesto por la editorial...

----------------------------
- MSDN: De todos modos insisto en que el MSDN, es la biblia de Visual-Studio (y una base profunda para otros lenguajes ajenos a NET, después de todo la teoría es la misma para todos, solo cambia como la adapta cada equipo y pequeñas diferencias en nombres o en modo de implementar los detalles).
Además, lo hay en varios idiomas, y si no hay traducción a x idioma, se hacen traducciones automáticas, como las palabras suelen ser siempre las mismas, las traducciones (automáticas) suelen ser bastante logradas.
No solo se describe (en MSDN) todo el Framework de NET (y las tecnologías asociadas), también posee libros... por ejemplo en los manuales de ayuda que venían en vb6 en formato chm, venía infinidad de libros, bien que el título del documento eran los peregrinos: VBREF98.CHM cuyo título real es: "Referencia de los controles de Visual Basic".
En MSDN hay extensa documentación y es muy útill para aquellos que no quieren o no pueden gastarse en lo que vale un par de libros (ver: artículos técnicos).
https://msdn.microsoft.com/es-es/library/ms310241
No viene mal, ir anticipando cosas futuribles (que luego algunas ya están, otras vendrán y otras jamás verán la luz):
https://msdn.microsoft.com/es-es/library/dd367845.aspx  (http://msdn.com/oslo)

----------------------------
- Auto documentación en VS: Si tienes instalado Visual Studio (cualquier versión) se adjunta la especificación de los lenguajes que hayas decidido instalar. No recuerdo si esto es así, solo si decidiste tener la ayuda local...
Yo por ejemplo para VB, tengo el paper con la especificación del lenguaje VB, que se incluye con el propio Visual-Studio, que documenta y describe cada término del lenguaje, en el formato BNF ampliado (eBNF. En realidad cuando estudias la descripción de un lenguaje es el más exacto conocimiento del lenguaje, porque la implementación parte de esa descricpción. No es una descripción a la ligera, es la descripción utilizada para programarlo. El fichero es un docx, llamado: Visual Basic Language Specification 10.0.docx un tocho de 624 páginas. La gramática se describe en el capítulo 13 en la página 551. Y la ruta donde se localiza es más o menos:
C:\Program Files\Microsoft Visual Studio 10.0\VB\Specifications\3082
(nota que que la versión 10.0 serefiere a Visual Studio 2010).

Ya he hablado en alguna ocasión del BNF, al que la gente parece darle poca o nula importancia, cuando es el 100% de un lenguaje y todo en la forma más estrictamente resumida y fidedigna.

Incluso encuentro la especificación, de CSharp, en la ruta equivalente:
C:\Program Files\Microsoft Visual Studio 10.0\VC#\Specifications\3082
(la subcarpeta 3082 (ó 1034), refiere siempre al español, la 1033 al inglés)
CSharp Language Specification.doc (versión 4.0) en español, un tocho de 884páginas, repartidos en 14 capítulos. Lagramática viene en el capítulo 14, página 791

También tengo el de la versión de VS 2008, (versión 3.0) de CSharp (CSharp Language Specification.doc) aunque este viene en inglés, y se localiza en la ruta:
C:\Program Files\Microsoft Visual Studio 9.0\VC#\Specifications\1033
que es un documento word (.doc) de 519 páginas, repartidos en 18 capítulos y 3 apéndices.
La gramática se describe en el apéndice B, que es lo primero que yo leería... no te preocupes si no te enteras, cuando regreses a ello de nuevo tras leerte lo previo, podrás verlo más claro...

(ojo este documento (y los otros comentados) es el que se acompaña con la versión  VS- 2008 y 2010), si tienes una versión más reciente, pues es muy probable que la especificación también sea una versión más reciente).
Si no lo localizas en tu equipo (busca en la carpeta de Visual Studio, con ruta similar a las que he mostrado), me dices y lo comprimo y miro de subirlo a una página de descargas... recuerda que el de 2008 lo tengo en inglés y el de 2010 en español (C#).

----------------------------
- ECMA: Finalmente aclarar que hay muchos lenguajes que se suscriben a estándares de lo que se espera que sea un lenguaje y tal... por ejemplo los ECMA.
http://www.ecma-international.org/publications/standards/Standard.htm

Por lo que al leerse un paper del estándar, básicamente tienes acceso a la forma en que muchos lenguajes serán programados. tampoco hace falta estar a la última, vale perfectamente un paper que date de hace 5-8 años, en general algo nuevo, suele añadir características, más que eliminar o cambiar las previas.

Por ejemplo, La especificación de C#, consta en un el ECMA-334 (4ºedición que data del 2006) , puedes bajarlo en formato pdf, de aquí:
http://www.ecma-international.org/publications/standards/Ecma-334.htm
Yo lo renombré (en mi equipo) como: Ecma-334 - C# Language Specification - 4ºed. Junio 2006.pdf

----------------------------
- RFC También para cuestiones muy específicas (algoritmos, protocolos, etc...) tienes la RFC (Request For Comment), para cuando trates de implementar por tí mismo un estándar que sea totalmente compatible con lo existente. http://www.ietf.org/rfc/ (tarda en cargar, paciencia)

Por ejemplo el algoritmo Deflate de compresión es el rfc: "rfc1951 - DEFLATE Compressed Data Format Specification version 1.3"
O por ejemplo, el chat (por el que preguntabas en otro mensaje), está descrito en el rfc1459.
La gramática BNF (que puede consdierarse la gramática de las gramáticas), se describe en: rfc4234


...................................
...................................
...................................

p.d.: Olvidé mencionar que wikipedia, es también una buena fuente, especialmente porque suele usarse un lenguaje accesible para todo el mundo (salvo en los artículos más matemáticos, que algunos se pasan y parece que la wikipedia es exclusivamente para profesionales). También porque en muchos de ellos, el nivel no es profundo, pero si llega a mucho más que lo básico.
Wikipedia es especialmente interesante para cuestiones puntuales... listas, pilas, colas, etc... viene ahí perfectamwente aclarados.
Si no enuentras el artículo pertinente en español búscalo en inglés...

También olvidé decirte que en cuanto a libros, tras lo básico que llevan títulos del tipo: "fundamentos de programación" lo siguiente en nivel, suelen tener títulos del tipo: "Algoritmos y estructuras de datos".
A veces suele acompañarse las explicaciones de algo de código, en tal caso si tienes ya preferencia por algún lenguaje, añade "... en x", siendo x el nombre del lenguaje que prefieras. Aunque mi consejo es que aprendas todo esto de modo independiente de cualquier lenguaje.

[TickTack]

Muchas gracias NEBIRE. Aunque los links que me pasaste, algunos de ellos, tienen contenido muy dificil de entender para mi, podre tomarme demasiado tiempo para comoprender todo esto........

[Serapis]

Si, claro... pero esto es como Hacienda, uno debe saber donde está, para cuando te haga falta.

En general en wikipedia, puedes encontrar un poco de todo a un nivel intermedio... si necesitas profundizar más, pués ya tienes enlaces donde ir, tu guárdalos y ya los usarás cuando llegue la ocasión.