Stack Simulation

[Shadowstyle]

Hey Leute

Ich habe hier etwas in Java geschrieben, was so ungefähr funktionieren soll wie ein Stack. Ich fange grade erst an, nicht so streng sein.
Vielleicht braucht es ja einer.
Einfacher Stack:

/**
 * Die Klasse Stack, dient dazu das Verhalten eines Stacks zu verdeutlichen.
 * @author (Shadowstyle) 
 * @version (1.0.0.2)
 */
public class Stack1
{
    private static final int defaultSize = 20; // Die Standart Größe, wenn man sich nicht entscheiden kann.
    private int freiPos = 0; //Die Freie Position, wo ein Wert draufgelegt wird.
    private int size; // Die Größe des Stacks. 
    private int[] data; //Der Stack.
    
     /**
     * Konstruktor für  den Standart Stack
     */
    public Stack1()
    {
           size = defaultSize;
           data = new int[size];
          
     }

    /**
     * Konstruktor für Stacks nach Wunsch.
     */
    public Stack1(int size)
    {
        this.size = (size < 0)?defaultSize:size;
        data = new int[this.size];
       
    }
    /**
     * Die Methode prüft, ob der Stapel leer ist. 
     */
    public boolean isEmpty()
    {
        return (freiPos == 0);
    }
    /**
     * Die Methode prüft, ob der Stapel voll ist.
     */
    public boolean isFull()
    {
        return (freiPos == size);
    }
    /**
     * Die Methode zeigt den letzten Wert, der auf dem Stack war.
     */
    public int top()
    {
        if (!isEmpty() )
            return (data[freiPos - 1] );
        else
            return (-1); // Vereinbarung, wenn der Stack leer ist.
        }
    /**
     * Mit der Methode, kann man ein Wert vom Stack nehmen.
     */    
    public void pop()
    {
        if (!isEmpty())
        {
         freiPos--;
         data[freiPos] = 0;
         }
        else 
           System.out.println("Der Stack ist leer, " + "der letzte Wert war " + top() + ".");
    }
    /**
     *Durch die Methode, wird ein Wert auf den Stack gelegt. 
     */
    public void push(int stapel_wert)
    {
        if (!isFull() )
        {
          data [freiPos] = stapel_wert;
          freiPos++;
        }
        else 
        System.out.println("Der Stack ist voll, " + "der letzte Wert war " + top() + ".");
    }
    /**
     * Diese Methode zeigt die akutelle Position im Stack.
     */
    public void zeige_Akutelle_Position()
    {
        System.out.println("Deine Akutelle Position im Stack ist " + (freiPos+1)) ;
    }
    
    /**
     * Hier wird aus einer bestimmten Position im Stack, der Wert ausgelesen.
     */
    public void call(int Position)
    {
        System.out.println("Der Wert der Position ist " + data[Position-1] + ".");
    }
    
    /**
     * Mit dieser Methode, werden an allen Positionen im Stack, die Werte ausgegeben
     */
    public void call_all()
      {
         for (int i = 0; i < freiPos; i++)
           {
             System.out.println("An Stelle " + (i+1) + " im Stack, ist der Wert " + data[i]+ ".");
           }
            
      }
}

Double-Stack:

/**
 * Die Klasse simmuliert einen Double Stack.
 * @author (Shadowstyle) 
 * @version (1.0.0.0)
 */
public class Double_Stack
{
    
    private static final int defaultSize = 20;
    private int[] data;
    private int size;
    private int freipos1 = 0;
    private int freipos2;
    
    
    public Double_Stack()
    {
        size = defaultSize;
        data = new int[defaultSize];
        freipos2 = size-1;
        
    }
    
    public Double_Stack(int size)
    {
        this.size = (size < 0)?defaultSize:size;
        data = new int[this.size];
        freipos2 = size-1;
    }
    
    public boolean isEmpty(int stacknumber)
    {
        
        if(stacknumber == 1)
        { 
            return(freipos1 == 0);
        }
        else if(stacknumber == 2)
        {
            return(freipos2 == size-1 );
        }
        return false;
     }
     
    public boolean isFull()
     {
        return (freipos1 > freipos2);
    }
    
    public int top(int stacknumber)
    {
        if(!isEmpty(stacknumber) && stacknumber == 1)
          {
             return (data[freipos1-1] );
            }
        else if(!isEmpty(stacknumber) && stacknumber == 2)
            {
              return (data[freipos2+1] );
            }
        return -1; //Vereinbarung, falls es nicht klappt.
    }
    
    public void push(int stacknumber, int stapel_wert)
    {
        if (!isFull() && stacknumber == 1 )
        {
            data [freipos1] = stapel_wert;
            freipos1++;
        }
        else if (!isFull() && stacknumber == 2 )
        {
            data [freipos2] = stapel_wert; 
            freipos2--;
        }
        else
         System.out.println("Falsche Stacknummer angegeben oder der Stack ist voll");
        }
        
     public void pop(int stacknumber)
    {
        if (!isEmpty(stacknumber) && stacknumber == 1)
        {
            freipos1--;
            
        }
        else if (!isEmpty(stacknumber) && stacknumber == 2)
        {
            freipos2++;
          
        }
        else 
            System.out.println("Falsche Stacknummer angegeben oder der Stack ist leer");
    }
   
    public int groesse(int stacknumber)
    {
       if (stacknumber == 1)
       {
           return freipos1;
        }
       else if (stacknumber == 2)
       {
           return size-1-freipos2;
        }
       return -1; // Vereinbarung, falls kein Ergebnis kommt.
    }

    public void zeigeInhalt(int stacknumber)
    {
        if (!isEmpty(stacknumber) && stacknumber == 1)
        {
            for (int i = 0; i < freipos1; i++)
            {
             System.out.println("An Stelle" + (i+1) + "ist der Wert " + data[i]+ ".");
            }
        }
            else if (!isEmpty(stacknumber) && stacknumber == 1)
        {
            for (int a = 0; a < freipos2; a--) 
            System.out.println("An Stelle" + (a+1) + "ist der Wert " + data[a]+ ".");
        }
        else 
            System.out.println("Der Stack ist Leer");
   }
}

[Metropoler]

Hallo Shadowstyle,

ich möchte dir nicht zu Nahe treten, aber dein Programm/Quellcode hat nichts mit einem Stack zu tun. Dein Stack scheint von außen einer zu sein, arbeitet im inneren aber mit einem Array. Ein Stack wird aber nicht mit einem Array gesteuert, sondern mit Referenzen.

Die Implementation eines Stacks nach ABI 2011 (NRW) Vorgaben sieht folgendermaßen aus:

public class Stack {

    class Element {
        
        private Element next;
        private Object item;
        
        /**
         * Der 1. Konstruktor
         **/
        public Element() {
            this(null, null);
        }
        
        /**
         * Der 2. Konstruktor
         **/
        public Element(Object item) {
            this(item, null);
        }
        
        /**
         * Der Standarkonstruktor
         **/
        public Element(Object item, Element next) {
            this.item = item;
            this.next = next;
        }
        
        /**
         * Gibt das Object aus
         * 
         * @return das Object
         **/
        public Object getItem() {
            return item;
        }
        
        /**
         * Setz das Object
         * 
         * @param item Das Object
         **/
        public void setItem(Object item) {
            this.item = item;
        }
        
        public Element getNext() {
            return next;
        }
        
        public void setNext(Element next) {
            this.next = next;
        }  
    }

    private Element sp;
    
    public Stack() {
        sp = null;
    }
    
    public boolean isEmpty() {
        return sp == null;
    }
    
    public void pop() {
        if (!isEmpty()) {
            sp = sp.getNext();
        } else {
            sp = null;
        }
        
    }
    
    public void push(Object item) {     
        Element tmp = new Element(item, sp);
        sp = tmp;
    }
    
    public Object top() {
        if (!isEmpty()) return sp.getItem();
        else {
            return "0";
        }
    } 
}

Abgesehen davon, ist der Stack schon eine Basisklasse in Java: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Stack.html

€dit: Und was ist denn ein Double-Stack?

[Shadowstyle]

Hey Metropoler danke für deine Antwort
Das sind aufgaben, aus meinem Unterricht, ich entwickel immer noch ein paar Sachen dazu.
Wir sollten halt erstmal sowas in der Art wie ein Stack machen.
Es gibt natürlich schon eine Basisklasse, doch es dient zum Lernen.
Wie genau funktioniert ein Array?
Was kann man damit alles machen?.
Dieses setzten wir z.B. in einem Stack um.
Ein Double Stack ist nur ein Beispiel, wie man sowas weiterführen kann, z.B. ein Multistack etc. Es geht in dem Beispiel darum, dass man
z.B. mehr Stacks als einen verwalten kann, oder Stapel. So ist man nicht immer nur auf einen beschränkt.
Dieses sind einfach nur Ideen für weitere Konzepte.
Ich werde mir die Vorgaben mal angucken.
Danke

[EBFE]

@Topicstarter:
lass dich davon nicht verwirren:

ich möchte dir nicht zu Nahe treten, aber dein Programm/Quellcode hat nichts mit einem Stack zu tun. Dein Stack scheint von außen einer zu sein, arbeitet im inneren aber mit einem Array. Ein Stack wird aber nicht mit einem Array gesteuert, sondern mit Referenzen.

Stack ist in erster Linie eine Datenstruktur mit bestimmten Eigenschaften.
Wie diese letzendlich implementiert wird, spielt keine Rolle.
Es sollen eben mindestens push/pop und peek Operationen zur Verfügung stehen (der "echte" Stack in Programmen ist z.B auch ein Array im Speicher)

[energy47]

so siehts aus.. ein Stack kann man mit hilfe von Array oder einer art LinkedList realisieren.. die Grundoperationen sind entscheidend.