/*
• *Создать очередь на основе двусвязного списка.
• **Создать стек на основе двусвязного списка.
*/
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#define T int
#define QMAX 100
typedef struct Node {
T payload;
struct Node *prev;
struct Node *next;
} Node;
Node *newNode() {
Node
*n
= (Node
*)malloc(sizeof(Node
)); if (n == NULL) {
return n;
}
n->prev = NULL;
n->next = NULL;
return n;
}
typedef struct Queue {
Node *recent;
Node *oldest;
int size;
} Queue;
Queue newQueue() {
Queue
*q
= (Queue
*)malloc(sizeof(Queue
)); if (q == NULL) {
return *q;
}
q->recent = NULL;
q->oldest = NULL;
q->size = 0;
return *q;
}
void qPush(T val, Queue *q){
if (q->size >= QMAX){
puts("Queue is full! Do some cleanup first!"); return;
}
Node *tmp = newNode();
tmp->payload = val;
if (q->oldest == NULL)
q->oldest = tmp;
else if (q->recent == NULL) {
tmp->prev = q->oldest;
q->oldest->next = tmp;
q->recent = tmp;
} else {
tmp->prev = q->recent;
q->recent->next = tmp;
q->recent = tmp;
}
q->size++;
}
T qPop(Queue *q){
if (q->oldest == NULL) {
return 0;
}
Node *tmp = q->oldest;
T val = tmp->payload;
if (&q->oldest == &q->recent || q->recent == NULL) {
} else {
q->oldest = q->oldest->next;
}
q->size--;
return val;
};
int bilen(long n) { //calculates length of a binary representation of a dec number
return (int)(log(n
)/0.693147 + 1); //0.693147 == log(2); }
void goida(Node *n) {
if(!n){
return;
}
printf("Paylod is %2d! GOIDA!\n", n
->payload
); if (n->next != NULL) goida(n->next);
}
void l7(){
printf("binary representation of 512 have length of %d\n", bilen
(512)); printf("binary representation of 511 have length of %d\n", bilen
(511)); Queue q = newQueue();
int i =0;
for(i = 0; i < 105; i++) qPush(i, &q);
Queue q2 = newQueue();
goida(q2.oldest);
goida(q.oldest);
for (i
= 0; i
< 101; i
++ ) printf("Goida! %d!\n", qPop
(&q
));
goida(q.oldest);
printf("size of q: %d\n", q.
size); printf("size of q: %d\n", q.
size);
}
int main(int argc, const char * argv[]) {
l7();
return 0;
}
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