Stack (push & pop)

Computer: Software & Programmierung C/C++
#1

Hallo,
mein Programm soll unter C beliebig viele Punkte einlesen und in einer verketteten Liste speichern. Die Punkte sollen dann in Umgekehrter Reihenfolge der Eingabe auf dem Bildschirm ausgegeben werden. Der Benutzer kann nach jeder Eingabe entscheiden, ob er noch einen Punkt eingeben möchte (Eingabe ’p’), oder ob die gespeicherten Punkte ausgegeben werden sollen (Eingabe ’q’). Während der Ausgabe soll der Stack Punkt für Punkt geleert werden, so dass er zuletzt leer ist. Die Liste soll ausschließlich durch die Stack-Funktionen push() und pop() verwaltet werden. Die Punkte sollen in einer Schleife eingelesen und auf dem Stack abgelegt werden.
Folgende Funktionen sollen realisiert werden:
Void push(POINT pushPoint);
POINT pop();
tnt isEmpty //gibt wahr zurück wenn Stack leer
void printStackElement (Point aPoint); //gibt einen Punkt aus
Probleme bereitet mir push und pop. Weder in meinen Büchern noch im Internet habe ich was Brauchbares gefunden. Das Gerüst von main() hätte ich soweit:

#include
#include

struct punkt
{
int *x;
int *y;
int *z;
};

int main(void)
{
char buchstabe[1];
struct punkt read1;
read1.x = NULL;
read1.y = NULL;
read1.z = NULL;

buchstabe[0] = ‚s‘;

while(buchstabe[0] != ‚\0‘)
{
printf("‚p‘ fuer Punkt eingeben, ‚q‘ fuer Ausgabe: „);
scanf(“ %c", buchstabe);

if(buchstabe[0] == ‚p‘ || buchstabe[0] == ‚q‘)
{
if(buchstabe[0] == ‚p‘)
{
read1.x = (int *) malloc(sizeof (int));
read1.y = (int *) malloc(sizeof (int));
read1.z = (int *) malloc(sizeof (int));

printf(„Bitte X-Wert eingeben: „);
scanf(“%i“, &read1.x);

printf(„Bitte Y-Wert eingeben: „);
scanf(“%i“, &read1.y);

printf(„Bitte Z-Wert eingeben: „);
scanf(“%i“, &read1.z);
}
if(buchstabe[0] == ‚q‘)
{
break;
}
}

else
{
printf(„Sie haben weder ‚p‘ noch ‚q‘ eingegeben!\n“);
}
}
return 0;
}

Ich bin dankbar für jede Hilfe!
MfG
Christoph

#2

Hallo Christoph,

mein Programm soll unter C beliebig viele Punkte einlesen und
in einer verketteten Liste speichern. Die Punkte sollen dann
in Umgekehrter Reihenfolge der Eingabe auf dem Bildschirm
ausgegeben werden. Der Benutzer kann nach jeder Eingabe
entscheiden, ob er noch einen Punkt eingeben möchte (Eingabe
’p’), oder ob die gespeicherten Punkte ausgegeben
werden sollen (Eingabe ’q’). Während der Ausgabe
soll der Stack Punkt für Punkt geleert werden, so dass er
zuletzt leer ist. Die Liste soll ausschließlich durch die
Stack-Funktionen push() und pop() verwaltet werden. Die Punkte
sollen in einer Schleife eingelesen und auf dem Stack abgelegt
werden.
Folgende Funktionen sollen realisiert werden:
Void push(POINT pushPoint);
POINT pop();
tnt isEmpty //gibt wahr zurück wenn Stack leer
void printStackElement (Point aPoint); //gibt einen Punkt aus
Probleme bereitet mir push und pop. Weder in meinen Büchern
noch im Internet habe ich was Brauchbares gefunden. Das Gerüst
von main() hätte ich soweit:

Mit Deinem „Gerüst“ wirst Du nicht sehr weit kommen.
Aller Anfang ist schwer.

Da das wie eine Art Hausaufgabe aussieht, biete ich Dir
das „Gerüst“ von main und die Datenstrukturen an.

Den Spass, die fehlende Funktionalität nachzurüsten,
möchte ich Dir nicht nehmen :wink:

Die „Vorgaben“ für die Aufgabe erscheinen mir
teils unausgegoren, ich habe sie an entsprechender
Stelle modifiziert …

Grüße

CMБ

#include 
#include 

typedef struct { 
 int x, y, z; 
} POINT;

typedef struct \_Li { 
 POINT p; 
 struct \_Li \*next; 
} LISTE;

 int Eingabe( POINT \*punkt );
 void printStackElement( POINT punkt );
 int isEmpty( LISTE \*liste );
 
 int pop( POINT\* punkt, LISTE \*liste );
 void push( POINT punkt, LISTE \*liste );


 int main(void)
{
 LISTE liste;
 POINT p;

 while( Eingabe(&p) ) 
 push( p, &liste );
 

 while( pop(&p, &liste) ) 
 printStackElement( p );
 
 return 0;
}
#3

Danke für die Mühe! Ich hab’s jetzt so:

#include
#include

/* Typdefinitionen */
typedef struct punkt tPunkt, *tPtrPunkt;
typedef struct stackElement tStackElement, *tPtrStackElement;

struct punkt
{
int x, y, z;
};

struct stackElement
{
//struct Pointer
tPtrPunkt pPunkt;
tPtrStackElement pVorgaenger;
};

/* globale Variablen */
tPtrStackElement pStack = NULL; /* Der Stack an sich und der ist erst
mal leer */

/* lokale Funktionen */
void push( tPtrPunkt pNeuerPunkt )
{
tPtrStackElement pNeuesElement;

pNeuesElement = (tPtrStackElement) malloc( sizeof( tStackElement ) );

pNeuesElement->pVorgaenger = pStack; /* bisherigen Stack in das neue
Element einhaengen */
pNeuesElement->pPunkt = pNeuerPunkt; /* Daten reinkopieren */
pStack = pNeuesElement;
}

tPtrPunkt pop( void )
{
tPtrPunkt pPunktRetwert;
tPtrStackElement pStackTop;

pStackTop = pStack;

pPunktRetwert = pStackTop->pPunkt;

pStack = pStackTop->pVorgaenger; /* Den Stack um ein Element
verkürzen */

free( pStackTop ); /* Speicher aufraeumen */

return( pPunktRetwert );
}

/* Hauptprogramm */
int main( void )
{
char buchstabe;
tPtrPunkt pRead, pPunktVomStack;

do /* do-while-Schleife, weil wenigstens eine Eingabe p oder q erwartet
werden kann! */
{
printf( „‚p‘ fuer Punkt eingeben, ‚q‘ fuer Ausgabe: " );
scanf( " %c“, &buchstabe );

if ( ‚p‘ == buchstabe )
{ /* Neuen Speicher für neuen Punkt anfordern */
pRead = (tPtrPunkt) malloc( sizeof( tPunkt ) );
/* Punktwerte einlesen */
printf( "Bitte X-Wert eingeben: " );
scanf( „%d“, &( pRead->x ) );
printf( "Bitte Y-Wert eingeben: " );
scanf( „%d“, &( pRead->y ) );
printf( "Bitte Z-Wert eingeben: " );
scanf( „%d“, &( pRead->z ) );
/* und ab damit auf den Stack */
push( pRead );
}
else if ( ‚q‘ != buchstabe )
{ /* Boeser Benutzer!! :wink: */
printf( „Sie haben weder ‚p‘ noch ‚q‘ eingegeben!\n“ );
}
}
while ( buchstabe != ‚q‘ );

/* und jetzt wieder ausgeben */
while ( NULL != pStack )
{
pPunktVomStack = pop();

printf( „X = %d / Y = %d / Z = %d\n“, pPunktVomStack->x,
pPunktVomStack->y, pPunktVomStack->z );

free( pPunktVomStack );
}

return 0;
}