21191
```

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct {
        //??
    } STACK;
    typedef struct {
        //??
    } QUEUE;
    void push(STACK*, int);
    int pop(STACK*);
    void printSTACK(STACK*);
    void put(QUEUE*, int);
    int get(QUEUE*);
    void printQUEUE(QUEUE*);
    
    int main(int argc, char* argv[])
    {
        int i,n;
        //??
        //??
        srand(time(NULL));
        for(i=0;i<3;i++)
        {
            n=rand()%100;
            printf("push %d\n", n);
            push(&s, n);
            printSTACK(&s);
        }
        for(i=0;i<3;i++)
        {
            printf("pop %d\n", pop(&s));
            printSTACK(&s);
        }
        for(i=0;i<3;i++)
        {
            n=rand()%100;
            printf("put %d\n", n);
            put(&q, n);
            printQUEUE(&q);
        }
        for(i=0;i<3;i++)
        {
            printf("get %d\n", get(&q));
            printQUEUE(&q);
        }
        return 0;
    }
    void push(STACK* s, int m)
    {
        //??
    }
    int pop(STACK* s)
    {
        //??
    }
    void printSTACK(STACK* s)
    {
        //??
    }
    void put(QUEUE* q, int n)
    {
        //??
    }
    int get(QUEUE* q)
    {
        //??
    }
    void printQUEUE(QUEUE* q)
    {
        //??
    }
    
```

* * *
```

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef struct _node{
        int n;
        struct _node *next;
    } node;
    typedef struct {
            int n;
            int a[];
    } STACK;
    typedef struct {
            int n;
            int in;
            int out;
            int a[];
    } QUEUE;
    node *createnode(int);
    void printnode(node*);
    node *addHead(node*,int);
    node *addHeadnode(node*,node*);
    void push(STACK*, int);
    int pop(STACK*);
    void printSTACK(STACK*);
    void put(QUEUE*, int);
    int get(QUEUE*);
    void printQUEUE(QUEUE*);
    
    int main(int argc, char* argv[])
    {
        int i,n;
        STACK s;
        s.n=0;
        QUEUE q;
        q.in=0;
        q.out=0;
        q.n=0;
        node *p;
        p=NULL;
        srand(time(NULL));
        for(i=0;i<3;i++)
        {
            n=rand()%100;
            printf("add %d\n", n);
            if(n<50)
            {
                p=addHead(p, n);
            }
            else
            {
                p=addTail(p, n);
            }
            printnode(p);
        }
        for(i=0;i<3;i++)
        {
            n=rand()%100;
            printf("push %d\n", n);
            push(&s, n);
            printSTACK(&s);
        }
        for(i=0;i<3;i++)
        {
            printf("pop %d\n", pop(&s));
            printSTACK(&s);
        }
        for(i=0;i<3;i++)
        {
            n=rand()%100;
            printf("put %d\n", n);
            put(&q, n);
            printQUEUE(&q);
        }
        for(i=0;i<3;i++)
        {
            printf("get %d\n", get(&q));
            printQUEUE(&q);
        }
        return 0;
    }
    void printnode(node *p)
    {
        while(p!=NULL)
        {
            printf("\t%d\n", p->n);
            p=p->next;
        }
    }
    node *createnode(int n)
    {
        node *p=malloc(sizeof(node));
        p->n=n;
        p->next=NULL;
        return p;
    }
    node *addHead(node *p, int n)
    {
        return addHeadnode(p,createnode(n));
    }
    node *addHeadnode(node *p, node *n)
    {
        n->next=p;
        return n;
    }
    void push(STACK* s, int m)
    {
        if(s->n>=N)return;
        s->a[s->n++]=m;
    }
    int pop(STACK* s)
    {
        if(s->n<=0)return -1;
        return s->a[--s->n];
    }
    void printSTACK(STACK* s)
    {
        int i;
        printf("\tn=%d\n", s->n);
        for(i=0;i<s->n;i++)
            printf("\ta[%d]=%d\n", i, s->a[i]);
    }
    void put(QUEUE* q, int n)
    {
        if(q->n>=N)return;
        q->n++;
        q->a[q->in++]=n;
        if(q->in >= N)q->in=0;
    }
    int get(QUEUE* q)
    {
        if(q->n<=0)return -1;
        q->n--;
        if(q->out>=N)q->out=0;
        return q->a[q->out++];
    }
    void printQUEUE(QUEUE* q)
    {
        int i;
        printf("\tin=%d\n", q->in);
        printf("\tout=%d\n", q->out);
        for(i=q->out;;i++)
        {
            if(i>=N)i-=N;
            if(i==q->in)return;
            printf("\ta[%d]=%d\n", i, q->a[i]);
    }
    }
    
```

これの??が入っている部分を適切に回答する問題なのですが  
まったくわかりません。下が自分で考えて書いたものですが。。。  
教えてください
CC BY-SA 3.0
2016-01-22T09:02:37.567
21187
2016-01-23T06:33:35.563
2016-01-23T06:33:35.563
5044
14105
question
c
「可変長なスタック，キュー」というデータ構造のプログラムを作成せよ
リンクリストを用いた実装例

```

    #include <stdio.h>
    #include <stdlib.h>
    #include <time.h> //time 関数のために必要
    
    typedef struct {
        struct node {
            int value;
            struct node *next;
        } *list;
    } STACK;
    
    typedef struct {
        struct node *top, *tail;
    } QUEUE;
    
    void push(STACK*, int);
    int pop(STACK*);
    void printSTACK(STACK*);
    void put(QUEUE*, int);
    int get(QUEUE*);
    void printQUEUE(QUEUE*);
    
    int main(void){
        int i,n;
        STACK s = { NULL };
        QUEUE q = { NULL, NULL};
    
        srand(time(NULL));
        for(i=0;i<3;i++)
        {
            n=rand()%100;
            printf("push %d\n", n);
            push(&s, n);
            printSTACK(&s);
        }
        for(i=0;i<3;i++)
        {
            printf("pop %d\n", pop(&s));
            printSTACK(&s);
        }
        for(i=0;i<3;i++)
        {
            n=rand()%100;
            printf("put %d\n", n);
            put(&q, n);
            printQUEUE(&q);
        }
        for(i=0;i<3;i++)
        {
            printf("get %d\n", get(&q));
            printQUEUE(&q);
        }
        return 0;
    }
    
    void push(STACK* s, int m){
        struct node *new_node = malloc(sizeof(*new_node));
        new_node->value = m;
        new_node->next = s->list;
        s->list = new_node;
    }
    
    int pop(STACK* s){
        if(s->list == NULL){
            fprintf(stderr, "stack is empty. can't pop\n");
            exit(-1);
        }
        struct node *temp = s->list;
        s->list = temp->next;
        int ret_value = temp->value;
        free(temp);
        return ret_value;
    }
    
    void printSTACK(STACK* s){
        struct node *temp = s->list;
    
        while(temp){
            printf("%d ", temp->value);
            temp = temp->next;
        }
        puts("");
    }
    
    void put(QUEUE* q, int n){
        struct node *new_node = malloc(sizeof(*new_node));
        new_node->value = n;
        new_node->next = NULL;
        if(q->top == NULL){
            q->top = q->tail = new_node;
        } else {
            q->tail = q->tail->next = new_node;
        }
    }
    
    int get(QUEUE* q){
        if(q->top == NULL){
            fprintf(stderr, "queque is empty. can't get\n");
            exit(-1);
        }
        struct node *temp = q->top;
        q->top = temp->next;
        int ret_value = temp->value;
        free(temp);
        return ret_value;
    }
    
    void printQUEUE(QUEUE* q){
        struct node *temp = q->top;
    
        while(temp){
            printf("%d ", temp->value);
            temp = temp->next;
        }
        puts("");
    }
    
```
CC BY-SA 3.0
2016-01-22T10:58:52.457
21191
2016-01-22T10:58:52.457
5044
21187
answer