Stapel(stack)

[pedantic-freak]

sothis_ schrieb:

wenn man wirklich nur zugriff auf das erste element braucht ist dies sogar eher noch sinnvoller, als für jede anwendung gleich eine verkettete liste zu implementieren

so ist es. und dass man nur zugriff auf das oberste element hat, ist ja das, was einen stack ausmacht.

[Tachyon]

sothis_ schrieb:

Tachyon schrieb:

hochtapel-freak schrieb:

goto anywhere; schrieb:

Du musst eigentlich nur folgendes wissen:
- Wie funktioniert malloc()?
- Was ist ein Stack?
- Was ist eine einfach verkettete Liste?

und wenn man rausgefunden hat, was ein stack ist, dann kommt man auch drauf, dass man dafür keine verkettete liste braucht.

Wenn die Anforderung ist, beliebig viele Elemente hinzufügen zu können, macht das aber schon Sinn...

warum? ein einfacher stack mit realloc() tut's auch. wenn man wirklich nur zugriff auf das erste element braucht ist dies sogar eher noch sinnvoller, als für jede anwendung gleich eine verkettete liste zu implementieren

Bei großen Stracks ist realoc schädlich. Es reduziert die Performance und fragmentiert den Speicher. Da ist eine einfach-rückwärts verkettete Liste sinnvoller.
Mal davon abgesehen brauchts bei einem Stack Zugriff aufs letzte Element.

[sothis_]

Tachyon schrieb:

Bei großen Stracks ist realoc schädlich. Es reduziert die Performance und fragmentiert den Speicher. Da ist eine einfach-rückwärts verkettete Liste sinnvoller.
Mal davon abgesehen brauchts bei einem Stack Zugriff aufs letzte Element.

das problem hast du auch bei einer verketteten liste mit vielen knoten, malloc() und free() für jeden knoten aufzurufen hat den selben effekt. bei einer liste ist es das letzte element, ja. mit oberstes element meinte ich bildlich das erste element auf dem stack.

[goto anywhere*]

hasso wollte es mit einer einfach verketteten Liste realisieren, also habe ich's auch so gemacht.

[linklist-freak]

goto anywhere; schrieb:

hasso wollte es mit einer einfach verketteten Liste realisieren, also habe ich's auch so gemacht.

in hassos aufgabe ist keine verkettete gefordert. warum soll man sich's unnötig schwer machen?

[goto anywhere*]

Dann nimmt man wohl am besten gleich C++ und die STL, wenn man's auf Einfachheit absieht:

#include <iostream>
#include <cstdlib>
#include <string>
#include <stack>

typedef struct{
	unsigned int alter;
	unsigned int gehalt;
	std::string name;
}st_el;

int main(void){
	std::stack<st_el>	stack;
	st_el				el={0,0,"Name"};

	for(int cnt=0;cnt<100;++cnt)
		stack.push(el);

	for(int cnt=0;cnt<100;++cnt){
		el=stack.top(); stack.pop();
		std::cout<<el.alter<<", "<<el.gehalt<<", "<<el.name<<std::endl;
	}

	std::cin.get();
}

[Tachyon]

goto anywhere; schrieb:

Dann nimmt man wohl am besten gleich C++ und die STL, wenn man's auf Einfachheit absieht:

a) Soll er selbst einen Stack entwerfen, und nicht einen fertigen benutzen
b) Ist es durch aus ein Unterschied, ob man C oder C++ benutzt, vor allem, wenn in den Anforderungen C als Programmiersprache angegeben wird.

[RapIstMeinHobby]

goto anywhere; schrieb:

Dann nimmt man wohl am besten gleich C++ und die STL, wenn man's auf Einfachheit absieht:

#include <iostream>
#include <cstdlib>
#include <string>
#include <stack>

typedef struct{
	unsigned int alter;
	unsigned int gehalt;
	std::string name;
}st_el;

int main(void){
	std::stack<st_el>	stack;
	st_el				el={0,0,"Name"};

	for(int cnt=0;cnt<100;++cnt)
		stack.push(el);

	for(int cnt=0;cnt<100;++cnt){
		el=stack.top(); stack.pop();
		std::cout<<el.alter<<", "<<el.gehalt<<", "<<el.name<<std::endl;
	}

	std::cin.get();
}

kannst du mit diesem hässlichen kram bitte mal aus dem ansi c forum abhauen? danke.

[Laufentenwickler]

Entwerfe doch zuerst einen Stack mit einer Maximalhöhe, das Grundgerüst etwa so:

#define STACKMAX 100

typedef struct {
    int size;
    int data[STACKMAX];
} Stack;

void createStack(Stack* s) {...};
int pop(Stack* s);
void push(Stack* s, int val);

Hoffe das hilft. Machts doch nicht zu kompliziert. Er weiß noch nicht was Zeiger sind und ihr schlagt verkettete Listen vor. Scherzkekse. Lass die Finger davon und versuch dich an was einfachem.

[windozer]

das macht man aber mit einer liste, das wird ihm der prof in der vorlesung auch so gesagt haben. alles andere ist doch quatsch.

[goto anywhere*]

Laufentenwickler schrieb:

Entwerfe doch zuerst einen Stack mit einer Maximalhöhe, das Grundgerüst etwa so:

#define STACKMAX 100

typedef struct {
    int size;
    int data[STACKMAX];
} Stack;

void createStack(Stack* s) {...};
int pop(Stack* s);
void push(Stack* s, int val);

Hoffe das hilft. Machts doch nicht zu kompliziert. Er weiß noch nicht was Zeiger sind und ihr schlagt verkettete Listen vor. Scherzkekse. Lass die Finger davon und versuch dich an was einfachem.

Du meinst man sollte 'dynamisch' über den Haufen werfen?-Also so etwas in der Art?:

#define STACKLENGHT 10

const int POP=0;
const int PUSH=1;

typedef struct{
	unsigned int alter;
	unsigned int gehalt;
	char name[1024];
}st_el;

int stack(int push_or_pop,st_el *element){
	static st_el stack[STACKLENGHT]={0};
	static int st_ptr=0;

	if(push_or_pop==PUSH){
		if(st_ptr<STACKLENGHT){
			stack[st_ptr++]=*element;
			return 0;
		}
		else{
			return -1;
		}
	}
	else{
		if(st_ptr>0){
			*element=stack[--st_ptr];
			return 0;
		}
		else{
			return -1;
		}
	}
}

[B.B.]

windozer schrieb:

das macht man aber mit einer liste, das wird ihm der prof in der vorlesung auch so gesagt haben. alles andere ist doch quatsch.

Nö.
Vorzugsweise schätzt man die benötigte Größe ab und nimmt einen Speicherblock, der etwas größer ist.
Wird der Block trotdem mal zu klein, wählt man einen nächst größeren.
Oder noch besser, man legt einen zweiten Stack an.

[Laufentenwickler]

@goto anywhere: Nein, so meinte ich das bestimmt nicht. Eher so:

#define STACKMAX 100

typedef struct {
    int size;
    int data[STACKMAX];
} Stack;

void init(Stack* s) {
    s->size = 0;
};
int pop(Stack* s) {
    return s->data[--s->size];
};
void push(Stack* s, int val) {
    s->data[s->size++] = val;
}

...
Stack test;
init(test);
push(test, 1);
push(test, 2);
printf("%d", pop(test));
push(test, 3);
printf("%d", pop(test));
printf("%d", pop(test));

Das kann man dann noch mit Fehlererkennung (overflow, underflow) und dann durch ralloc erweitern, dann eventuell sich noch Gedanken über eine sinvolle Strategie für Stackgroße und Vergrößerung, und man hat schon was sehr brauchbares zusammen.

[aufgabenversteher-freak]

Entwerfen Sie ein Programm (Datenentwurf und Modulentwurf als Struktogramm) zum Hinzufügen von beliebig vielen Elementen in einen Stapel (stack) nach Wunsch.

[Fuzzy+]

aufgabenversteher-freak schrieb:

Entwerfen Sie ein Programm (Datenentwurf und Modulentwurf als Struktogramm) zum Hinzufügen von beliebig vielen Elementen in einen Stapel (stack) nach Wunsch.

Das ist nicht realierbar. Es gibt nicht beliebig viel Speicherplatz.

[iterations-flamer]

Es gibt nicht beliebig viel Speicherplatz.

Und deshalb ist pi auch 3+1/7.

[Tachyon]

iterations-flamer schrieb:

Es gibt nicht beliebig viel Speicherplatz.

Und deshalb ist pi auch 3+1/7.

Ja? Und ich dachte immer, pi = acos(-1.0)...

[ohmanrolf]

ihr seid mal wieder lollig

[Fuzzy+]

iterations-flamer schrieb:

Es gibt nicht beliebig viel Speicherplatz.

Und deshalb ist pi auch 3+1/7.

Was hat denn das jetzt damit zu tun.

[hasso]

hey leute..

Wie ich sehe habt ihr verschieden viele varianten das problem zu lösen ... langsam blick ich nicht mehr durch welche die sinnvollste ist.

Hab mich heut den ganzen tag mit zeiger auseinandergesetzt und morgen werd ich mich mit realloc und malloc und strukturen.... beschäftigen...

Welche ist nun die sinnvollste bzw unkomplitzierteste die auch die Aufgabenstellung erfüllt.?

gruß