static void test_basics(void)
{
Queue *q = QueueNew(free);
assert_int_equal(0, QueueCount(q));
assert_true(QueueIsEmpty(q));
QueueEnqueue(q, xstrdup("hello"));
assert_int_equal(1, QueueCount(q));
assert_false(QueueIsEmpty(q));
assert_string_equal("hello", QueueHead(q));
QueueEnqueue(q, xstrdup("world"));
assert_int_equal(2, QueueCount(q));
assert_string_equal("hello", QueueHead(q));
char *head = QueueDequeue(q);
assert_string_equal("hello", head);
free(head);
assert_string_equal("world", QueueHead(q));
head = QueueDequeue(q);
assert_string_equal("world", head);
free(head);
QueueDestroy(q);
}
int main (int argc, char* argv[]) {
int val1 = 1;
int val2 = 2;
int val3 = 3;
int val4 = 4;
Queue q = QueueNew();
QueuePut(q, &val1, INT_VALUE);
QueuePut(q, &val2, INT_VALUE);
QueuePut(q, &val3, INT_VALUE);
QueuePut(q, &val4, INT_VALUE);
QueueItem qptr = q->head;
while (qptr != NULL) {
int* val = (int*) qptr->element;
printf("value: %d\n", *val);
qptr = qptr->next;
}
QueueIterator qiter = QueueIteratorNew(q, 1);
while (qiter->currentItem != NULL) {
int* val = (int*) qiter->currentItem->element;
printf("iterator value: %d\n", *val);
QueueIteratorAdvance(qiter);
}
}
static void test_destroy(void)
{
Queue *q = QueueNew(free);
QueueEnqueue(q, xstrdup("1"));
QueueEnqueue(q, xstrdup("2"));
QueueEnqueue(q, xstrdup("3"));
assert_int_equal(3, QueueCount(q));
QueueDestroy(q);
}
int main()
{
/* Enter your code here. Read input from STDIN. Print output to STDOUT */
queue q;
QueueNew(&q);
Enqueue(&q, 5);
Enqueue(&q, 6);
Enqueue(&q, 7);
PrintTop(&q);
PrintTop(&q);
return 0;
}
void rsort(int arr[], int len)
{
queue *qs[10];
for (int i = 0; i < 10; i++) qs[i] = QueueNew();
for (int i = 0; i < 3 ; i++) { // 3 digit mods
for (int j = 0; j < len; j++) { // array index
int tmp = arr[j];
for (int k = 0; k < i; k++) tmp /= 10; // get current digit
int index = (tmp % 10); // bucket
QueueAdd(qs[index], arr[j]);
}
rcopy(qs, 10, arr, len); // dump back to array
}
for (int i = 0; i < 10; i++) QueueFree(qs[i]);
}
int main()
{
Queue q;
QueueNew(&q, sizeof(int));
int a = 2;
int b = 3;
int c = 4;
QueueEnter(&q, &a);
QueueEnter(&q, &b);
QueueEnter(&q, &c);
int d, e, f;
QueueDelete(&q, &d);
printf("%d\n", d);
QueueDelete(&q, &e);
printf("%d\n", e);
QueueDelete(&q, &f);
printf("%d\n", f);
QueueFree(&q);
}
int main(void)
{
char c = '\0';
double result = 0.0;
int state = 0;
char* inputBuffer = NULL;
size_t inputCount = 0;
struct Queue inputCharQueue = { 0 };
if ( QueueNew(&inputCharQueue, sizeof(char)) != 0) {
return EXIT_FAILURE;
}
while (state != STATE_QUIT)
{
printf("Please enter an RPN expression: ");
while ((c = getchar()) != '\n' && c != EOF) {
(void) QueueEnqueue(&inputCharQueue, &c);
}
inputCount = QueueGetCount(&inputCharQueue);
char* newBuffer = (char*)realloc(inputBuffer, (inputCount + 1) * sizeof(char));
if (!newBuffer) {
state = STATE_OUT_OF_MEMORY;
break;
}
inputBuffer = newBuffer;
for (size_t i = 0u; i < inputCount; ++i) {
(void) QueueDequeue(&inputCharQueue, &inputBuffer[i]);
}
inputBuffer[inputCount] = '\0';
state = RPNEvaluate(inputBuffer, &result);
if (state == STATE_SUCCESS) {
printf("Value of expression: %g\n", result);
}
else if (state == STATE_OVERFLOW) {
fprintf(stderr, "Error: too many operands in the expression.\n");
}
else if (state == STATE_UNDERFLOW) {
fprintf(stderr, "Error: not enough operands in the expression.\n");
}
else if (state == STATE_INVALID_FORMAT) {
fprintf(stderr, "Error: expression is in invalid format.\n");
}
else if (state == STATE_OUT_OF_MEMORY) {
fprintf(stderr, "Error: computer out of memory.\n");
}
else if (state == STATE_NOT_SUPPORTED) {
fprintf(stderr, "Error: operator not supported.\n");
}
else if (state == STATE_INVALID_OPERAND) {
fprintf(stderr, "Error: invalid operand.\n");
}
else if (state == STATE_QUIT) {
printf("Thank you for using our application!\n");
}
else {
fprintf(stderr, "Internal error has occured. Please contact your software vendor.\n");
}
}
free(inputBuffer);
QueueDispose(&inputCharQueue);
getchar();
return EXIT_SUCCESS;
}
