示例#1
0
Item deque_pop_back()
{
    assert(!deque_empty());
    tail = (tail - 1 + MAX) % MAX;
    count--;
    return content[tail];
}
示例#2
0
static void
deque_test_enqueue_dequeue(deque_t q,
                           void (*in)(deque_t, element_t),
                           element_t (*out)(deque_t),
                           int rand_n, double rand_d)
{
    int i;
    double* d;

    SHOW_FUNC_INFO(in, out);
    srand(time(0));
    for (i = 0; i < 10; ++i) {
        d = (double*)malloc(sizeof(*d));
        *d = rand() % rand_n * rand_d;
        in(q, d);
        fprintf(stdout, "[%02d] deque enqueue element : %lf\n", i, *d);
    }
    fprintf(stdout, "deque size is : %d ===>\n", deque_size(q));
    d = deque_peek_front(q);
    fprintf(stdout, "\tfront element of deque : %lf\n", *d);
    d = deque_peek_rear(q);
    fprintf(stdout, "\trear element of deque: %lf\n", *d);
    while (!deque_empty(q)) {
        d = out(q);
        fprintf(stdout, "deque dequeue element : %lf\n", *d);
        free(d);
    }
}
示例#3
0
Item deque_pop_front()
{
    assert(!deque_empty());
    head = (head + 1) % MAX;
    count--;
    return content[head];
}
示例#4
0
int deque_peek_front( const deque dq, TYPE *item){
  if( deque_empty( dq) ){
    return DEQUE_EMPTY;
  }
  *item = dq->cbuffer[dq->front];
  return DEQUE_SUCCESS;
}
示例#5
0
/**
 * Tests if a queue is empty.
 */
bool_t queue_empty(const queue_t* cpque_queue)
{
    assert(cpque_queue != NULL);

#ifdef CSTL_QUEUE_LIST_SEQUENCE
    return list_empty(&cpque_queue->_t_sequence);
#else
    return deque_empty(&cpque_queue->_t_sequence);
#endif
}
示例#6
0
void deque_push_back(Item n)
{
    assert(!deque_full());

    if (deque_empty()) {
        set_init_state();
    }

    content[tail] = n;
    tail          = (tail + 1) % MAX;
    count++;
}
示例#7
0
/**
 * Tests if a stack is empty.
 */
bool_t stack_empty(const cstl_stack_t* cpsk_stack)
{
    assert(cpsk_stack != NULL);

#if defined (CSTL_STACK_VECTOR_SEQUENCE)
    return vector_empty(&cpsk_stack->_t_sequence);
#elif defined (CSTL_STACK_LIST_SEQUENCE)
    return list_empty(&cpsk_stack->_t_sequence);
#else
    return deque_empty(&cpsk_stack->_t_sequence);
#endif
}
示例#8
0
int deque_get_item( const deque dq, int pos, TYPE *item){
  int newpos;
  if( deque_empty( dq) ){
    return DEQUE_EMPTY;
  }
  if( pos >= deque_size( dq) ){
    return DEQUE_OUT_OF_BOUNDS;
  }
  newpos =  (dq->front+pos) % dq->cbuffersize;
  *item = dq->cbuffer[newpos];
  return DEQUE_SUCCESS;
}
示例#9
0
void deque_push_front(Item n)
{
    assert(!deque_full());

    if (deque_empty()) {
        head = 0;
        tail = 1;
    }

    content[head] = n;
    head          = (head - 1 + MAX) % MAX;
    count++;
}
示例#10
0
int deque_peek_back( const deque dq, TYPE *item){
  int backpos;
  if( deque_empty( dq) ){
    return DEQUE_EMPTY;
  }
  if( dq->back == 0 ){
    backpos = dq->cbuffersize -1;
  }else{
    backpos = dq->back -1;
  }
  *item = dq->cbuffer[backpos];
  return DEQUE_SUCCESS;
}
示例#11
0
int main()
{
    const char *output[] = {"EsaY", "YasE", "aYsE", "asYE"};
    const char *input = "EasY";
    const char *pinput; /* point to input */
    const char *poutput; /* point to output */
    size_t i;

    for (i = 0; i < SIZE(output); i++) {
        pinput = input;
        poutput = output[i];
        printf("for pattern %s:\n", poutput);

        for (; *poutput != '\0';) {
            if (!deque_empty() && deque_front() == *poutput) {
                printf("+\t%c\n", deque_pop_front());
                poutput++;
            } else if (!deque_empty() && deque_back() == *poutput) {
                printf("*\t%c\n", deque_pop_back());
                poutput++;
            } else { /* the deque is empty or not the first or last */
                if (islower(*pinput)) {
                    deque_push_back(*pinput++);
                } else if (isupper(*pinput)) {
                    deque_push_front(*pinput++);
                } else if (*pinput == '\0') {
                    printf("unable to generate such pattern\n");
                    break;
                }
            }
        }

        putchar('\n');
    }

    return 0;
}
示例#12
0
int deque_pop_back( deque dq, TYPE *item){
  if( deque_empty( dq) ){
    return DEQUE_EMPTY;
  }
  if(dq->back == 0 ){ 
    dq->back = dq->cbuffersize-1;
  }else{
    dq->back--;
  }
  *item = dq->cbuffer[dq->back];
  if( (double) deque_size(dq) / (double) dq->cbuffersize < 0.25  &&
      deque_size( dq) > MINSIZE ){
    if( deque_shrink( dq) == DEQUE_MEM_ERROR ){
      return DEQUE_MEM_ERROR;
    }
  }
  return DEQUE_SUCCESS;
}
示例#13
0
int deque_pop_front( deque dq, TYPE *item){
  if( deque_empty( dq) ){
    return DEQUE_EMPTY;
  }
  *item = dq->cbuffer[dq->front];
  if(dq->front == dq->cbuffersize -1){
    dq->front = 0;
  }else{
    dq->front++;
  }
  if( (double) deque_size(dq) / (double) dq->cbuffersize < 0.25 &&
      deque_size( dq) > MINSIZE ){
    if( deque_shrink( dq) == DEQUE_MEM_ERROR ){
      return DEQUE_MEM_ERROR;
    }
  }
  return DEQUE_SUCCESS;
}
示例#14
0
Item deque_back()
{
    assert(!deque_empty());
    size_t index = (tail - 1 + MAX) % MAX;
    return content[index];
}
示例#15
0
Item deque_front()
{
    assert(!deque_empty());
    size_t index = (head + 1) % MAX;
    return content[index];
}
示例#16
0
void simple_test( void){
  deque dq;
  double a;
  int i, status;

  fprintf( stdout, "Testing deque_allocate: " );
  dq = deque_alloc();
  if( dq != NULL ){
    fprintf( stdout, "success!\n");
  }else{
    fprintf( stdout, "failed!\n");
  }
  fprintf( stdout, "Testing deque_empty: ");
  if( deque_empty( dq) ){
    fprintf( stdout, "success!\n");
  }else{
    fprintf( stdout, "failed!\n");
  }

  a = 2.5;
  fprintf( stdout, "Testing deque_push_back, value=%1.2g: ", a);
  if( deque_push_back( dq, a ) == DEQUE_SUCCESS ){
    fprintf( stdout, "success!\n");
  }else{
    fprintf( stdout, "failed!\n");
  }
  a = 3.14159;
  fprintf( stdout, "Testing deque_peek_back: ");
  if( deque_peek_back( dq, &a) == DEQUE_SUCCESS ){
    fprintf( stdout, "success!, value=%1.2g\n", a);
  }else{
    fprintf( stdout, "failed, value=%1.2g\n", a);
  }
  fprintf( stdout, "Testing deque_size: ");
  fprintf( stdout, "size=%d\n", deque_size( dq));
  fprintf( stdout, "Testing deque_pop_back: ");
  a = 3.14159;
  if( deque_pop_back( dq, &a) == DEQUE_SUCCESS ){
    fprintf( stdout, "success!, value=%1.2g\n", a);
  }else{
    fprintf( stdout, "failed!, value=%1.2g\n", a);
  }
  a = 3.14159;
  fprintf( stdout, "Testing deque_pop_back on empty deque: ");
  if( deque_pop_back( dq, &a) != DEQUE_EMPTY ){
    fprintf( stdout, "failed!, value=%1.2g\n", a);
  }else{
    fprintf( stdout, "success!,\n");
    fprintf( stdout, "  caught empty deque, value=%1.2g\n", a);
  }

  a = 2.5;
  fprintf( stdout, "Testing deque_push_front, value=%1.2g: ", a);
  if( deque_push_front( dq, a ) == DEQUE_SUCCESS ){
    fprintf( stdout, "success!\n");
  }else{
    fprintf( stdout, "failed!\n");
  }
  a = 3.14159;
  fprintf( stdout, "Testing deque_peek_front: ");
  if( deque_peek_front( dq, &a) == DEQUE_SUCCESS ){
    fprintf( stdout, "success!, value=%1.2g\n", a);
  }else{
    fprintf( stdout, "failed, value=%1.2g\n", a);
  }
  fprintf( stdout, "Testing deque_size: ");
  fprintf( stdout, "size=%d\n", deque_size( dq));
  fprintf( stdout, "Testing deque_pop_front: ");
  a = 3.14159;
  if( deque_pop_front( dq, &a) == DEQUE_SUCCESS ){
    fprintf( stdout, "success!, value=%1.2g\n", a);
  }else{
    fprintf( stdout, "failed!, value=%1.2g\n", a);
  }
  a = 3.14159;
  fprintf( stdout, "Testing deque_pop_front on empty deque: ");
  if( deque_pop_front( dq, &a) != DEQUE_EMPTY ){
    fprintf( stdout, "failed!, value=%1.2g\n", a);
  }else{
    fprintf( stdout, "success!,\n");
    fprintf( stdout, "  caught empty deque, value=%1.2g\n", a);
  }

  fprintf( stdout, "Testing deque_get_item: ");
  for( i=0; i<5; i++ ){
    a = (double) i + 0.545;
    if( deque_push_back( dq, a) != DEQUE_SUCCESS ){
      fprintf( stderr, "deque push back failed!\n" );
      deque_free( dq);
      return;
    }
    a = (-1. - (double) i) + 0.545;
    if( deque_push_front( dq, a) != DEQUE_SUCCESS ){
      fprintf( stderr, "deque push front failed!\n" );
      deque_free( dq);
      return;
    }
  }
  for( i=0; i<10; i++){
    status = deque_get_item( dq, i, &a);
    if( status != DEQUE_SUCCESS || a != (-5. + (double) i) + 0.545 ){
      fprintf( stderr, "deque get_item failed!\n" );
      deque_free( dq);
      return;
    }
  }
  a = 3.14159;
  status = deque_get_item( dq, 11, &a);
  if( status != DEQUE_OUT_OF_BOUNDS || a != 3.14159 ){
    fprintf( stderr, "deque get_item out of bounds failed!\n");
    deque_free( dq);
  }
  fprintf( stdout, "success!\n");

  deque_free( dq);
}