C++ createQueue函数代码示例

// Driver program to test above functions
int main()
{
    struct node* root1=NULL,*root2=NULL;
    struct Queue* queue1=createQueue(SIZE),*queue2 = createQueue(SIZE);
    int i;

    for(i = 1; i <= 12; ++i)
        insert(&root1,i, queue1);
    for(i = 1; i <= 12; ++i)
        insert(&root2,i, queue2);


     mirror(root2);
    printf("The tree_1 elements are: ");
      levelOrder(root1);
        printf("\nThe tree_2 elements are: ");
      levelOrder(root2);
    printf("\n");

    if(checkmirror(root1,root2))
      printf("\nThe trees are mirror image");
    else
       printf("\nThe trees are not  mirror image");
    return 0;
}

void testCombine() {
  printf("\ntesting combine...\n");
  int success = 0;

  printf("Case 1: queues are the same size\n");
  Queue a = createQueue(4);
  enqueue(0,a); enqueue(1,a);
  enqueue(2,a); enqueue(3,a);
  printf("Queue a = ");
  printQueue(a);
  Queue b = createQueue(4);
  enqueue(0,b); enqueue(1,b);
  enqueue(2,b); enqueue(3,b);
  printf("Queue b = ");
  printQueue(b);
  Queue merged = combine(a,b);
  printf("Combination = ");
  printQueue(merged);
  success = merged->length = 8;

  printf("\nCase 2: b is larger\n");
  printf("Queue a = ");
  printQueue(a);
  freeQueue(b);
  b = createQueue(20);
  enqueue(0,b); enqueue(1,b);
  enqueue(2,b); enqueue(3,b);
  enqueue(4,b); enqueue(5,b);
  printf("Queue b = ");
  printQueue(b);
  freeQueue(merged);
  merged= combine(a,b);
  printf("Combination = ");
  printQueue(merged);
  success = success && merged->length == 8;

  printf("\nCase 3: a is larger\n");
  freeQueue(merged);
  merged= combine(b,a);
  printf("Combination = ");
  printQueue(merged);
  success = success && merged->length == 8;

  printf("\nCase 4: queue is empty\n");
  freeQueue(a);
  a = createQueue(2);
  freeQueue(merged);
  merged = combine(a,b);
  printf("Queue a = ");
  printQueue(a);
  printf("Queue b = ");
  printQueue(b);
  printf("Combination = ");
  printQueue(merged);
  success = success && merged->length == 0;

  if(success) printf("  ☺ success.\n");
  else printf("  ☹ failure.\n");
}

/************************* main *******************************/
int main() {
    new_packet = (unsigned char *)malloc(MTU);
    if(new_packet == NULL) {
        printf("Malloc failed\n");
        exit(EXIT_FAILURE);
    }

    struct nfq_handle *h = get_handle();
    fd_set rfds;

    // start the downstream code, later move to a thread
    initializeRabin(powers);
    int max_fd = 0;
    int down_fd = createQueue(h, DOWN_MOBILE_QUEUE, &cbDown);
    if(down_fd > max_fd)
        max_fd = down_fd;
    int up_fd = createQueue(h, UP_MOBILE_QUEUE, &cbUp);
    if(up_fd > max_fd)
        max_fd = up_fd;

    printlog(logfile, system_loglevel, LOG_DEBUG, 
            "Queue packet descriptors, down_fd: %d, up_fd: %d\n",
            down_fd, up_fd);

    int n = 0, rv = 0;
    char buf[4096] __attribute__ ((aligned));
    nfnl_rcvbufsiz(nfq_nfnlh(h), 4096 * 4096);
    while(true) {
        FD_ZERO(&rfds);
        FD_SET(down_fd, &rfds);
        FD_SET(up_fd, &rfds);
        n = select(max_fd + 1, &rfds, NULL, NULL, NULL);
        if(n == -1) {
            printlog(logfile, system_loglevel, LOG_CRITICAL, 
                    "Select returned error: %s\n", strerror(errno));
        } 
        if(FD_ISSET(down_fd, &rfds)) {
            rv = recv(down_fd, buf, sizeof(buf), 0);
            if(rv < 0) {
                printlog(logfile, system_loglevel, LOG_CRITICAL, 
                        "recv call failed: %s\n", strerror(errno));
            } else {
                nfq_handle_packet(h, buf, rv);
            }
        } 
        if(FD_ISSET(up_fd, &rfds)) {
            rv = recv(up_fd, buf, sizeof(buf), 0);
            if(rv < 0) {
                printlog(logfile, system_loglevel, LOG_CRITICAL, 
                        "recv call failed: %s\n", strerror(errno));
            } else {
                nfq_handle_packet(h, buf, rv);
            }
        }
    }

    // start the upstream code, later move to a thread
    return 0;
}

int main() {
	struct queue *q3 = NULL, *q5 = NULL, *q7 = NULL;
	q3 = createQueue();
	if (!q3) {
		printf("Failed to allocate memory for Queue\n");
		return 1;
	}

	q5 = createQueue();
	if (!q5) {
		printf("Failed to allocate memory for Queue\n");
		return 1;
	}
	q7 = createQueue();
	if (!q7) {
		printf("Failed to allocate memory for Queue\n");
		return 1;
	}

	int num = 1, count = 1, k = 50;

	/* initialize Queue */
	enqueue(q3,num*3);
	enqueue(q5,num*5);
	enqueue(q7,num*7);

	while (count<k) {
		num = getMinofQueues(q3,q5,q7);

		if (num < 0) {
			num = 1<<32
			break;
		}

		if (num == peekqueue(q3)) {
			num = dequeue(q3);
			enqueue(q3,num*3);
			enqueue(q5,num*5);
			enqueue(q7,num*7);
		}
		else if (num == peekqueue(q5)) {
			num = dequeue(q5);
			enqueue(q5,num*5);
			enqueue(q7,num*7);
		}
		if (num == peekqueue(q7)) {
			num = dequeue(q7);
			enqueue(q7,num*7);
		}

		count++;
		printQueue(q3);
		printQueue(q5);
		printQueue(q7);
		//printf("%d,",num);
	}

int main (int argc, char *argv[])
{
    int i;
    Item it;
    Queue q1,q2;

    printf("Test 1: Create queues\n");
    q1 = createQueue();
    q2 = createQueue();
    assert(q1 != NULL);
    assert(q2 != NULL);
    assert(queueLength(q1) == 0);
    assert(queueLength(q2) == 0);
    printf("Passed\n");

    printf("Test 2: Add to queues\n");
    for (i = 1; i <= MAX; i++) {
        enterQueue(q2,i);
        enterQueue(q1,i);
        assert(queueLength(q2) == i);
        assert(queueLength(q1) == i);
    }
    printf("Final q1: ");
    showQueue(q1);
    printf("Final q2: ");
    showQueue(q2);
    printf("Passed\n");

    printf("Test 3: Remove from queues\n");
    for (i = 1; i <= MAX; i++) {
        it = leaveQueue(q1);
        assert(queueLength(q1) == MAX-i);
        assert(i == it);
        it = leaveQueue(q2);
        assert(queueLength(q2) == MAX-i);
        assert(i == it);
    }
    printf("Passed\n");

    printf("Test 4: Destroy queues\n");
    dropQueue(q1);
    dropQueue(q2);
    printf("Passed\n");

    printf("Test 5: Remove from emoty queue\n");
    printf("This test should fail an assertion\n");
    q1 = createQueue();
    it = leaveQueue(q1);
    printf("Passed\n");

    return 0;
}

/*最短增广路径,计算路径*/
void getShortestIncrePath(Index S, Table T, Graph G)
{
    Queue Q = createQueue();
    enqueue(S, Q);

    /*初始化入度路径计算表时，发出节点被置0，
    我们在这里的目的是计算路径最小流*/
    T[S].dist = Infinity;

    Index V,W;


    while(!isEmpty(Q))
    {
        V = dequeue(Q);
        T[V].known = true;

        Edge edge = G->TheCells[V].next;
        while(edge !=NULL)
        {
            W = edge->vertexIndex;
            if(T[W].known == false)
            {
                T[W].dist = MIN(T[V].dist, edge->weight);
                T[W].path = V;
                enqueue(W,Q);
            }
            edge = edge->next;
        }
    }
    disposeQueue(Q);
}

int main(int argc, char *argv[]) {
	char* names = argv[1];
	char* name, **name_p;
	Queue* queue;
	struct Linked_list *iterator;

	queue = createQueue(sizeof(char*));
	name = strtok(names, ",");
	while (name != NULL) {
		printf("enqueueing %s - %i\n", name, QueueSize(queue));
		Enqueue(queue, name);
		name = strtok(NULL, ",");
	}
	for(iterator = queue->front->next; iterator != NULL; iterator = iterator->next) {
		printf("element %s\n", (char*)(iterator->value));
	}
//	printf("front %s\n", (char*)((Linked_list*)(front(queue)))->value);
	while(!QueueIsEmpty(queue)) {
		printf("dequeued ");
		fflush(stdout);
		DequeueElement(queue, (void**)&name);
//		name = *name_p;
		printf("%s - %i\n", name, QueueSize(queue));
	}
}

static void _traverseBFT (BSTNODE* root, void (*process) (PACKAGE* package) )
{
	BSTNODE* currentNode;
	BSTNODE* tempNode;
	QUEUE* queue;

	queue = createQueue();
	if(!queue)
	{
		printf("\nMemory Overflow!\n");
		exit(201);
	}
	currentNode = root;

	while(currentNode != NULL)
	{
		process ( currentNode->ptrPackage );
		if(currentNode->left != NULL)
			enqueue(queue, currentNode->left);
		if(currentNode->right != NULL)
			enqueue(queue, currentNode->right);
		if(!emptyQueue(queue))
		{
			dequeue(queue, (void**)&tempNode);
			currentNode = tempNode;
		}
		else currentNode = NULL;
	}
	queue = destroyQueue(queue);
	return;

}// _traverseBFT

void doBFS(maze_t* myMaze, adList_t* adList){
    queue_t* queue= createQueue(myMaze->roomNumber);;
    int start=getStartRoom(myMaze);
    //printf("%d\n",start);
    object_t* object;
    edge_t* edge;
    room_t* room;
    int largest=0;
    adList->object[start].room->depth=0;
    enqueue(queue,&(adList->object[start]));
    while (!empty(queue)) {
        //printf("here\n");
        object=dequeue(queue);
        //printf("dequeue room: %d ,depth:%d,%d",object->room->room,object->depth,adList->object[object->room->room].depth);
        edge=object->firstEdge;
        if (edge!=NULL)
            //printf("firstEdge: %d ",edge->number.number);
        for (;edge!=NULL;edge=edge->nextEdge) {
            if (edge->endRoom->room->depth==-1){
                room=edge->endRoom->room;
                enqueue(queue,&adList->object[edge->endRoom->room->room]);
                room->parent=object->room->room;
                //adList->object[edge->endRoom->room->room].room->parent=object->room->room;
                room->edge=edge->number.number;
                //adList->object[edge->endRoom->room->room].room->edge=edge->number.number;
                room->depth=object->room->depth+1;
                //adList->object[edge->endRoom->room->room].depth=adList->object[object->room->room].depth+1;
                //printf("enqueue room: %d ,depth:%d,object room:%d",edge->endRoom->room->room,adList->object[16].depth,object->room->room);
                largest=room->depth;
            }
        }
    }
    myMaze->maxDepth=largest;
    free(queue);
}

int checkStackPairwiseOrder(struct sNode *top) {
    struct Queue *q = createQueue();
    struct sNode *s = top;
    
    int pairwiseOrdered = 1;

    while (!isEmpty(s))
        enQueue(q, pop(&s));

    while (!queueIsEmpty(q))
        push(&s, deQueue(q)->key);

    while (!isEmpty(s)) {
        int n = pop(&s);
        enQueue(q, n);
        if (!isEmpty(s)) {
            int m  = pop(&s);
            enQueue(q, m);
            if(abs(n - m) != 1) {
                pairwiseOrdered = 0;
            }    
        }
    }    

    while (!queueIsEmpty(q))
        push(&s, deQueue(q)->key);
    return pairwiseOrdered;
}        

int main(int argc, char **argv)
{
    int readInts;
    struct node *root = NULL;
    struct Queue *queue = createQueue(SIZE);
    FILE *fp;

    fp = fopen(argv[1],"r");
    if (fp == NULL)
        printf("NO SUCH FILE EXISTS. PLEASE TRY AGAIN.");
    while (fscanf(fp, "%d", &readInts) != EOF)
    {
        //printf("Inserting %d into tree...\n", readInts);
        treeInsert(&root, readInts, queue);
    }
    fclose(fp);

    //for (int i = 0; i <= 12; ++i)
    //  treeInsert(&root, i, queue);
    //maxHeapify(root);
    levelOrder(root);
    printf("SIZE is %d\n", SIZE);

    return 0;
}

void test_to_enter_char_element_in_Queue_10(){
	Queue* actual = createQueue(2,sizeof(char));
	char value = '2';
	char* data = (char*)actual->elements;
	ASSERT(1==enQueue(actual,&value));
	free(actual);
}

void test_to_enter_double_element_in_Queue_8(){
	Queue* actual = createQueue(2,sizeof(double));
	double value = 2.00000;
	double* data = (double*)actual->elements;
	ASSERT(1==enQueue(actual,&value));
	free(actual);
}

void test_to_enter_float_element_in_Queue_7(){
	Queue* actual = createQueue(2,sizeof(float));
	float value = 2.0;
	float* data = (float*)actual->elements;
	ASSERT(1==enQueue(actual,&value));
	free(actual);
}

void test_to_enter_int_element_in_queue_6(){
	Queue* actual = createQueue(2,sizeof(int));
	int value = 2;
	int* data = (int*)actual->elements;
	ASSERT(1==enQueue(actual,&value));
	free(actual);
}