1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:

// Queue.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const int puffergroesse = 20;

void queueerror(char *c)
{
	printf_s("Queuefehler: ");
	printf_s("%s", c);
	printf_s("\n");
	system("PAUSE");
	exit(1);
};

typedef struct queue /* Queue, implementiert als Ringpuffer mit 20 Elementen */
{
	int puffer[puffergroesse]; /* Ringpuffer */
	unsigned int anfang; /* Index des ersten Elements der Queue im Ringpuffer   */
	unsigned int ende;   /* Index des letzten Elements der Queue im Ringpuffer  */
	unsigned int anzahl; /* Anzahl der aktuell im Puffer gespeicherten Elemente */
	/* Anzahl muss gemerkt werden, da sonst voller Puffer  */
	/* nicht von einem leeren Puffer unterschieden werden  */
	/* kann                                                */
};

queue* emptyqueue() /* Erzeugen einer leeren Queue auf dem Heap*/
{
	queue *q = (queue *)malloc(sizeof(queue));
	/* Index für Anfang und Ende und Anzahl auf 0 setzen */
	if (q == NULL)
	{
		queueerror("Speichermangel, Anlegen einer neuen Queue auf Heap nicht möglich");
		return NULL;
	}
	else {
		q->anfang = 0;
		q->ende = 0;
		q->anzahl = 0;
		return q;
	};
};

int isempty(queue *q) /* Prüfen ob Queue leer     */
{
	if (q == NULL)
	{
		queueerror("isempty aufgerufen mit Nullpoiner");
		return 0;
	}
	else {q->anzahl==0;
		return 0;
	}
};

queue* rest(queue *q) /* Funktion, die vorderstes Element aus Queue entfernt */
{
	if (q == NULL)
	{
		queueerror("Rest mit Nullpointer aufgerufen");
		return NULL;
	}
	else if (isempty(q))
	{
		queueerror("Rest mit leerer Queue aufgerufen");
		return q;
	}
	else { q->anfang = (q->anfang+1)%puffergroesse;
	q->anfang--;
		return q;
	};
};

queue* append(queue *q, int i) /* fügt i hinten an der Queue an */
{
	if (q == NULL)
	{
		queueerror("Append mit Nullpointer aufgerufen");
		return NULL;
	}

	else if (q->anzahl == puffergroesse)
	{queueerror("Append mit vollem Puffer aufgerufen");
	return q; }
	else {
		q->puffer[q->ende] = i;
		q->ende = (q->ende + 1) % puffergroesse;
		q->anzahl++;
		return q;
	};
};

int top(queue *q) /* liefert erstes Element der Queue */
{
	if (q == NULL)
	{
		queueerror("Top mit Nullpointer aufgerufen");
		return 0;
	}
	else if (isempty(q))
	{
		queueerror("Top mit leerer Queue aufgerufen");
		return 0;
	}
	else {
		return q->puffer[q->anfang];
	};
};

void print(queue *q)
{
	if (q == NULL)
		queueerror("Queueausgabe mit Nullpointer aufgerufen");
	else if (isempty(q))
		printf_s("Queue ist leer\n");
	else { /* Hier Code einfügen und printf( ... ) entfernen*/
		printf_s("die Funktion wurde noch nicht implementiert\n");
	};
};

void loeschequeue(queue *q)
{
	if (q != NULL) free(q);
};


void queuetest()
{
	char c = 'x';
	int i;
	queue* q = NULL;
	while ((c != 'e') && (c != 'E'))
	{
		printf_s("Bitte Queueoperation eingeben: l = leere Queue, r = Rest, a = Append, t = Top,\n");
		printf_s("                               i = Isemepty, p = Ausgabe, e = Ende\n");
		fflush(stdin);
		c = getchar();
		switch (c)
		{
		case 'e':
		case 'E': break;
		case 'a':
		case 'A': printf_s("Append gewaehlt\n");
			printf_s("Bitte Zahl eingeben\n");
			scanf_s("%d", &i);
			q = append(q, i);
			break;
		case 'r':
		case 'R': printf_s("Rest gewaehlt\n");
			q = rest(q);
			break;
		case 'l':
		case 'L': printf_s("Erzeugen einer leeren Queue gewaehlt\n");
			loeschequeue(q);
			q = emptyqueue();
			break;
		case 't':
		case 'T': printf_s("Top gewaehlt\n");
			i = top(q);
			printf_s("%s%d\n", "Erstes Element der Queue: ", i);
			break;
		case 'i':
		case 'I': printf_s("Isempty gewaehlt\n");
			i = isempty(q);
			if (i != 0) printf_s("Queue ist leer\n");
			else printf_s("Queue ist nicht leer\n");
			break;
		case 'p':
		case 'P': printf_s("Ausgabe gewaehlt\n");
			print(q);
			break;
		default: break;
		};
	};
};

int main(void)
{
	queuetest();
	system("PAUSE");
	return 0;
}