queue.h:
/*
* Code for basic C skills diagnostic.
* Developed for courses 15-213/18-213/15-513 by R. E. Bryant, 2017
*/
/*
* This program implements a queue supporting both FIFO and LIFO
* operations.
*
* It uses a singly-linked list to represent the set of queue elements
*/
#include <stdbool.h>
/************** Data structure declarations ****************/
/* Linked list element (You shouldn't need to change this) */
typedef struct ELE {
int value;
struct ELE *next;
} list_ele_t;
/* Queue structure */
typedef struct {
list_ele_t *head; /* Linked list of elements */
list_ele_t *tail;
unsigned size;
} queue_t;
/************** Operations on queue ************************/
/*
Create empty queue.
Return NULL if could not allocate space.
*/
queue_t *q_new();
/*
Free all storage used by queue.
No effect if q is NULL
*/
void q_free(queue_t *q);
/*
Attempt to insert element at head of queue.
Return true if successful.
Return false if q is NULL or could not allocate space.
*/
bool q_insert_head(queue_t *q, int v);
/*
Attempt to insert element at tail of queue.
Return true if successful.
Return false if q is NULL or could not allocate space.
*/
bool q_insert_tail(queue_t *q, int v);
/*
Attempt to remove element from head of queue.
Return true if successful.
Return false if queue is NULL or empty.
If vp non-NULL and element removed, store removed value at *vp.
Any unused storage should be freed
*/
bool q_remove_head(queue_t *q, int *vp);
/*
Return number of elements in queue.
Return 0 if q is NULL or empty
*/
int q_size(queue_t *q);
/*
Reverse elements in queue
No effect if q is NULL or empty
*/
void q_reverse(queue_t *q);
queue.c:
/*
* Code for basic C skills diagnostic.
* Developed for courses 15-213/18-213/15-513 by R. E. Bryant, 2017
*/
/*
* This program implements a queue supporting both FIFO and LIFO
* operations.
*
* It uses a singly-linked list to represent the set of queue elements
*/
#include <stdlib.h>
#include <stdio.h>
#include "harness.h"
#include "queue.h"
/*
Create empty queue.
Return NULL if could not allocate space.
*/
queue_t *q_new()
{
queue_t *q = NULL;
if((q = malloc(sizeof(queue_t))))
{
q->head = NULL;
q->tail = NULL;
q->size = 0;
return q;
}
else
{
return NULL;
}
}
/* Free all storage used by queue */
void q_free(queue_t *q)
{
/* How about freeing the list elements? */
/* Free queue structure */
if (q)
{
list_ele_t *i = q->head;
while(i)
{
list_ele_t *tmp = i;
i = i->next;
free(tmp);
}
free(q);
}
}
/*
Attempt to insert element at head of queue.
Return true if successful.
Return false if q is NULL or could not allocate space.
*/
bool q_insert_head(queue_t *q, int v)
{
list_ele_t *newh;
/* What should you do if the q is NULL? */
if (q)
{
if ((newh = malloc(sizeof(list_ele_t))))
{
newh->value = v;
newh->next = q->head;
q->head = newh;
if (!q->size)
{
q->tail = newh;
}
++q->size;
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
/*
Attempt to insert element at tail of queue.
Return true if successful.
Return false if q is NULL or could not allocate space.
*/
bool q_insert_tail(queue_t *q, int v)
{
/* You need to write the complete code for this function */
/* Remember: It should operate in O(1) time */
list_ele_t *newh;
if (q)
{
if ((newh = malloc(sizeof(list_ele_t))))
{
newh->value = v;
newh->next = NULL;
if (q->tail)
{
q->tail->next = newh;
q->tail = newh;
++q->size;
}
else
{
q->head = q->tail = newh;
++q->size;
}
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
/*
Attempt to remove element from head of queue.
Return true if successful.
Return false if queue is NULL or empty.
If vp non-NULL and element removed, store removed value at *vp.
Any unused storage should be freed
*/
bool q_remove_head(queue_t *q, int *vp)
{
/* You need to fix up this code. */
if (!q || !q->size)
{
return false;
}
else
{
if (vp)
{
*vp = q->head->value;
}
list_ele_t *tmp = q->head;
q->head = q->head->next;
free(tmp);
--q->size;
return true;
}
}
int q_size(queue_t *q)
{
/* You need to write the code for this function */
/* Remember: It should operate in O(1) time */
if (!q || !q->size)
{
return 0;
}
else
{
return q->size;
}
}
/*
Reverse elements in queue
*/
void q_reverse(queue_t *q)
{
if (q && q->size)
{
int cache[q->size];
list_ele_t *tmp = q->head;
for (int i = q->size - 1; (i >= 0) && (tmp != NULL); --i)
{
cache[i] = tmp -> value;
tmp = tmp->next;
}
tmp = q->head;
for (int i = 0; (i < q->size) && (tmp != NULL); ++i)
{
tmp->value = cache[i];
tmp = tmp->next;
}
}
}测试：
frank@under:~/Desktop/cs:app/lab/cprogramminglab/cprogramminglab-handout$ ./qtest
cmd>help
cmd>help
Commands:
# ... | Display comment
free | Delete queue
help | Show documentation
ih v [n] | Insert v at head of queue n times (default: n == 1)
it v [n] | Insert v at tail of queue n times (default: n == 1)
log file | Copy output to file
new | Create new queue
option [name val] | Display or set options
quit | Exit program
reverse | Reverse queue
rh [v] | Remove from head of queue. Optionally compare to expected value v
rhq [v] | Remove from head of queue without reporting value
show | Show queue contents
size [n] | Compute queue size n times (default: n == 1)
source file | Read commands from source file
time cmd arg ... | Time command execution
Options:
echo 1 Do/don't echo commands
error 5 Number of errors until exit
fail 30 Number of times allow queue operations to return false
malloc 0 Malloc failure probability percent
verbose 4 Verbosity level
cmd>new
cmd>new
q = []
cmd>show
cmd>show
q = []
cmd>ih 1
cmd>ih 1
q = [1]
cmd>ih 2
cmd>ih 2
q = [2 1]
cmd>ih 3
cmd>ih 3
q = [3 2 1]
cmd>size
cmd>size
Queue size = 3
q = [3 2 1]
cmd>it 0
cmd>it 0
q = [3 2 1 0]
cmd>it -1
cmd>it -1
q = [3 2 1 0 -1]
cmd>size
cmd>size
Queue size = 5
q = [3 2 1 0 -1]
cmd>reverse
cmd>reverse
q = [-1 0 1 2 3]
cmd>size
cmd>size
Queue size = 5
q = [-1 0 1 2 3]
cmd>rh -1
cmd>rh -1
Removed -1 from queue
q = [0 1 2 3]
cmd>size
评分：
frank@under:~/Desktop/cs:app/lab/cprogramminglab/cprogramminglab-handout$ ./driver.py
--- Trace Points
+++ TESTING trace trace-01-ops:
# Test of insert_head and remove_head
--- trace-01-ops 7/7
+++ TESTING trace trace-02-ops:
# Test of insert_head, insert_tail, and remove_head
--- trace-02-ops 7/7
+++ TESTING trace trace-03-ops:
# Test of insert_head, insert_tail, reverse, and remove_head
--- trace-03-ops 7/7
+++ TESTING trace trace-04-ops:
# Test of insert_head, insert_tail, and size
--- trace-04-ops 7/7
+++ TESTING trace trace-05-ops:
# Test of insert_head, insert_tail, remove_head reverse, and size
--- trace-05-ops 7/7
+++ TESTING trace trace-06-robust:
# Test operations on NULL queue
--- trace-06-robust 7/7
+++ TESTING trace trace-07-robust:
# Test operations on empty queue
--- trace-07-robust 7/7
+++ TESTING trace trace-08-robust:
# Test remove_head with NULL argument
--- trace-08-robust 7/7
+++ TESTING trace trace-09-malloc:
# Test of malloc failure on new
--- trace-09-malloc 7/7
+++ TESTING trace trace-10-malloc:
# Test of malloc failure on insert_head
--- trace-10-malloc 7/7
+++ TESTING trace trace-11-malloc:
# Test of malloc failure on insert_tail
--- trace-11-malloc 7/7
+++ TESTING trace trace-12-perf:
# Test performance of insert_tail
--- trace-12-perf 7/7
+++ TESTING trace trace-13-perf:
# Test performance of size
--- trace-13-perf 8/8
+++ TESTING trace trace-14-perf:
# Test performance of insert_tail, size, and reverse
--- trace-14-perf 8/8
--- TOTAL 100/100
