Programmierung eines Stacks

[Zarathustra]

Hallo Community,


ich hab eine Aufgabenstellung bekommen, doch ich hab absolut keine Ahnung wie ich anfangen bzw. wie ich das angehen soll und bitte daher um eure Hilfe und um viel Geduld mit einem Anfänger
Und zwar muss ich einen Stack programmieren. Die allgemeine Funktionsweise eines Stacks ist mir bekannt.
Die Aufgabe beinhaltet, dass der Stack 6, ich nenne es jetzt mal Elemente da mir kein besseres Wort einfällt, speicher muss und wenn ein weiteres kommt, muss eines raus fallen.
Ich hoffe, ich konnte die Aufgabenstellung gut genug formulieren und bitte nun um eure Hilfe.

Vielen Danke schon mal im Voraus.



LG

 

[JavaMeister]

Wie sollen wir helfen? Sollen wir für dich googeln?

 

[javampir]

hi,
hast du einen anzatz? Du musst doch eine Idee haben?
was für elemente willst du denn speichern?
Tipp: eine feste anzahl an elementen schreit nach einem array.
javampir

 

[Zarathustra]

Sorry, falls die Frage zu einfach ist bzw. sie sich einfach per Google Suche lösen lässt, aber ich habe schon gesucht und nichts passendes gefunden.... ;(
Oder ich war einfach zu blöd, dass ich die Lösung schon vor mir hatte und ich es nicht gerafft hab...

 

[JavaMeister]

Oder ich war einfach zu blöd, dass ich die Lösung schon vor mir hatte und ich es nicht gerafft hab...

Unmöglich das zu sagen, da wir nicht wissen, was du probiert hast.

 

[Zarathustra]

Hmm. Ich verstehe eigentlich die ganze Aufgabenstellung nicht. Wir sollen einen Stack programmieren, der eine fixe größe hat. Ein Stack zeichnet sich ja dadurch aus, dass er dynamisch ist...
Und wenn ich ein Array nehme, kann ich das LIFO Prinzip nicht anwenden. Lieg ich da richtig?

 

[JavaMeister]

Doch klar geht das mit einem array. Das hat ja nur 6 elemente, wenn das 7 kommt, muss eins raus.

 

[Moro]

Hmm. Ich verstehe eigentlich die ganze Aufgabenstellung nicht. Wir sollen einen Stack programmieren, der eine fixe größe hat. Ein Stack zeichnet sich ja dadurch aus, dass er dynamisch ist...
Und wenn ich ein Array nehme, kann ich das LIFO Prinzip nicht anwenden. Lieg ich da richtig?

Also erstmal: Ein Stack ist ein ziemlich allgemeines Konzept einer Datenstruktur. Es ist nicht festgelegt, ob der dynamisch ist oder nicht. Das ist eine Frage der Implementation.

Natürlich kannst du das LIFO-Prinzip mit einem Array anwenden. Musst dir halt in deiner Klasse überlegen, wie du die Kontrolle behaelst. Und dann entsprechend Methoden implementieren wie push(), die alle Werte "schiebt" und vorne dann einen Wert hinzufuegt. Wenn alle Plätze belegt sind, darf vorne nichts mehr hinzugefügt werden.

Was du auch machen kannst, ist eine Datenstruktur "from the scratch" programmieren. Eine Art verkette Liste, wo du eine Klasse Stack hast, die sich merkt wie viele Elemente im Stack liegen und wie viele Elemente maximal im Stack liegen dürfen. Dazu dann eine Klasse Knoten, die genau ein Element des Stacks repräsentiert. Dein instanziertes Stack Objekt verweist dann intern auf den ersten Knoten, und jeder Knoten verweist auf den sich unten liegenden Knoten (oder auf NULL, wenn es das letzte Objekt im Stack ist). Beim entfernen des ersten Knotens per LIFO, musst du dann einfach achten das dein Stack dann statt den ersten Knoten den zweiten mit einer Variable referenziert. Und jeder Knoten refernziert den unter sich liegenden usw.

Keine Ahnung, wie viel Java Erfahrung du hast und woher deine Aufgabe eigentlich kommt. Ggf. könnte das programmieren einer kleinen Datenstruktur schon advanced sein, wenn man die entsprechenden Konzepte nicht kennt. Wobei das eigentlich recht einfach ist. Das Konzept einer verketteten Liste gibt es hier: Javabeginners - Einfach verkettete Liste Das musst du dann nur entsprechend als "Stack" anlegen bzw. konzipieren (was im Prinzip fast genau so funktioniert, nur das deine Funktionen halt darauf achten müssen, dass der Stapel voll sein kann usw.).

 

[arilou]

@Moro: Bei einem Stack mit vorab bekannter maximaler Größe ist eine verkettete Liste "mit Kanonen auf Spatzen schießen". Da ist ein Array viel simpler.
Und man braucht darin auch nix "schiften", sondern kanns einfach von vorn nach hinten (oder umgekehrt) füllen und sich 'nen Index merken, bis wohin es gefüllt ist.

Erst beim "Rausfliegen eines 7. Elements" muss man sich überlegen, wie genau man das machen möchte - ggf. nochmal die Aufgabenstellung genau durchlesen.

 

[Moro]

@Moro: Bei einem Stack mit vorab bekannter maximaler Größe ist eine verkettete Liste "mit Kanonen auf Spatzen schießen". Da ist ein Array viel simpler.

Es kommt halt auf die Aufgabenstelllung an. Ich wollte es als Alternative nennen, da ich ja nicht weiß, ob es in seiner Aufgabe vorgesehen ist zur Realisierung einer Datenstruktur eine andere zu verwenden. Muss er selbst entscheiden.

Und man braucht darin auch nix "schiften", sondern kanns einfach von vorn nach hinten (oder umgekehrt) füllen und sich 'nen Index merken, bis wohin es gefüllt ist.
Erst beim "Rausfliegen eines 7. Elements" muss man sich überlegen, wie genau man das machen möchte - ggf. nochmal die Aufgabenstellung genau durchlesen.

Es kommt sehr darauf an, welche Art Stack er implementiert. Bei LIFO und FIFO geht das noch so ohne Shiften, bei einem Deque, bei dem Elemente sowohl vorn als auch hinten hinzufüget und entnommen werden können, dann nicht mehr - vorausgesetzt der Stack ist nicht dynamisch.

Letztendlich muss der TE selbst entscheiden, wie er vorgeht. Die Tipps hat er ja jetzt alle bekommen. Die genaue Implementation kann er sich selbst überlegen.

 

[Zarathustra]

Soooooo, ich muss einen Stack mittels Array erstellen.
Diese Funktionen soll das Programm enthalten:

 

[njans]

"Ungültige Angabe: Anhang"

 

[Zarathustra]

Soooooo, ich muss einen Stack mittels Array erstellen.
Diese Funktionen soll das Programm enthalten:

Jetzt sollte es funktionieren, sorry!

 

[njans]

Ja dann schreibe dir eine Klasse, die diese Methoden hat und implementiere das Verhalten eines Stacks.

 

[JavaMeister]

Ungültige Angabe: Konnte "Eigeninitiative" nicht finden.

Zarathustra, falls es Dir nicht aufgefallen ist, wird hier niemand eine fertige Lösung posten. Wenn du nicht anfägst mehr als "Ich habe keine Ahnung" oder "Hier das ist die Aufgabe" zu posten, dann wird das hier noch ein sehr langer Thread und dein Studium verlängert sich um mehrere Jahrhunderte.

 

[Zet]

[OT] Kommen um diese Zeit vermehrt Fragen zu Uni Aufgaben, oder irre ich mich?
Ist das schon immer so ?[/OT]

 

[VfL_Freak]

Moin,

[OT] Kommen um diese Zeit vermehrt Fragen zu Uni Aufgaben, oder irre ich mich?
Ist das schon immer so ?[/OT]

na ja, es ist halt Semesteranfang ....... :gaen:

Gruß
Klaus

 

[minzee]

Ich finde es seltsam, dass einerseit im Konstruktor eine Kapazität übergeben werden soll, in push und pop das aber scheinbar ignoriert wird. Ich würde das kontrollieren und ev. eine Exception werfen.

/**
 * Stack für int-Werte.
 * Maximal size Einträge erlaubt.
 */
class IntStack
{
   private int[] values; // Stack als Array
   private int size;     // Kapazität des Stacks
   private int cnt;      // Anzahl der auf dem Stack befindlichen Elemente
   
   /**
    * @param int size > 0
    */
   public IntStack(int size)
   {
      this.size = size;
      
      // Ein neuer Stack ist leer:
      this.cnt = 0;
      this.values = new int[size]; 
   }
   /**
    * @return int > 0
    */
   public int getSize()
   {
      return this.size;
   }
   /**
    * @return int >= 0
    */
   public int getEleCnt()
   {
      return this.cnt;
   }
   /**
    * @return boolean
    */
   public boolean isFull()
   {
      return this.cnt == this.size;
   }
   /**
    * @return boolean
    */
   public boolean isEmpty()
   {
      return this.cnt == 0;
   }
   /** 
    * @param int val
    * @throws Exception wenn voll
    */
   public void push(int val) throws Exception
   {
      if(isFull())
      {
         throw new Exception("push");
      }
      values[cnt++] = val; 
   }
   /**
    * @return int
    * @throws Exception wenn leer
    */
   public int pop() throws Exception
   {
      if(isEmpty())
      {
         throw new Exception("pop");
      }
      return values[--cnt]; 
   }
   /**
    * @return String
    */
   public String toString()
   {
      if(cnt == 0)
      {
         return "[]";
      }
      
      String s = "[";
      int i = 0;
      while(i < cnt - 1)
      {
         s += values[i++] + ", ";
      }
      return s + values[i] + "]";
   }
}
class Main
{
   public static void main(String[] args) 
   {   
      IntStack is = new IntStack(3);
      try
      {
         is.push(10);
         is.push(20);
         System.out.println(is.getEleCnt());
         System.out.println(is.pop());
         is.push(30);
         System.out.println(is);
      }
      catch(Exception e)
      {
         System.out.println("stack");
      }
   }
}

 

[Zarathustra]

Danke für die vielen Antworten:

Schlussendlich habe ich es wie folgt versucht:
MainClass:
[Java]
package stack;

public class Main {

public static void main(String[] args) {

Stack myStack = new Stack(6);
System.out.println(myStack.isEmpty());
myStack.push("1");
System.out.println(myStack.pop());
myStack.push("2");
System.out.println(myStack.peek());
myStack.push("3");
System.out.println(myStack.peek());
myStack.push("4");
System.out.println(myStack.peek());
myStack.push("5");
System.out.println(myStack.peek());
myStack.push("6");
System.out.println(myStack.peek());

}
}
[/Java]


StackClass
[Java]
package stack;

public class Stack {

int maxSize;
int top;
String array[];

public Stack(int Size) {

maxSize = Size;
array = new String[maxSize];
top = 0;

}

public boolean isEmpty(){

if(top == 0) {
return true;
}
else {
return false;
}

}

public void push(String str){

if(top < maxSize) {
array[top] = str;
top++;
}
else
System.out.println("Stack Overflow!!");

}
public String pop(){

if(!this.isEmpty()) {
String temp = this.peek();
array[top-1] = null;
top--;
return temp;
}
else {
return null;
}

}

public String peek() {

if(top > 0){
return array[top -1];
}
else {
return null;
}
}
}
[/Java]

 

[minzee]

Bei einem Stack ist das nicht vorgesehen, dass man mittendrin ein Element rausnehmen oder ersetzen könnte. Dann wäre es kein Stack mehr.

Guten Morgen minzee ,

ich hab' da mal ne' kleine Frage zu deinem Stack.

Ich habe den Stack mit folgendermaßen initialisiert:

Integer[] stack;

	// IntStack(int size) - Konstrkutor, size = maximale Anzahl an Elementen die
	// auf dem Stack gespeichert werden können
	Stack(int size)
	{
		stack = new Integer[size];
	}

damit ich prüfen kann ob ein Feld NULL ist, beispielsweiße wenn ich ein mittleres Element entferne, und das oberste an diese Stelle setzen möchte o.ä.

Du arbeitest ja mit einem Counter, wie würdest du dann soetwas umsetzen?

Oder ist das in diesem Fall garnicht vorgesehen ?
Du scheinst schon deutlich erfahrener zu sein, hättest du lust über meinen "stack"-Code mal drüberzuschauen ?


Grüße
Zet

Dein Posteingang ist voll, darum habe ich es hier reingeschrieben.