NTSTATUS
VIOSerialShutDownAllQueues(
    IN WDFOBJECT WdfDevice,
    IN BOOLEAN   bFinal)
{
    NTSTATUS		status = STATUS_SUCCESS;
    PPORTS_DEVICE	pContext = GetPortsDevice(WdfDevice);
    UINT                nr_ports, i;

    TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "--> %s\n", __FUNCTION__);

    VirtIODeviceRemoveStatus(pContext->pIODevice , VIRTIO_CONFIG_S_DRIVER_OK);

    if(pContext->isHostMultiport)
    {
        DeleteQueue(&pContext->c_ivq, bFinal);
        DeleteQueue(&pContext->c_ovq, bFinal);
    }

    nr_ports = pContext->consoleConfig.max_nr_ports;
    for(i = 0; i < nr_ports; i++ )
    {
        if(pContext->in_vqs && pContext->in_vqs[i])
        {
            DeleteQueue(&(pContext->in_vqs[i]), bFinal);
        }

        if(pContext->out_vqs && pContext->out_vqs[i])
        {
            DeleteQueue(&(pContext->out_vqs[i]), bFinal);
        }
    }
    TraceEvents(TRACE_LEVEL_INFORMATION, DBG_INIT, "<-- %s\n", __FUNCTION__);
    return status;
}
Example #2
0
int main()
{
	FILE *ptr;
	ptr=fopen("file.txt","r");
	CheckFileForError(ptr);
	
  CreateQueue();

  char str[80];
  int i, pnum, atime,btime;
 	while(fgets(str,80,ptr)!=NULL)
 	{
    int *point;

    point = FindNuminString(str,0);
    pnum = *point;
    point = FindNuminString(str,*(point+1));
    atime = *point;
    point = FindNuminString(str,*(point+1));
    btime = *point;
   
   EnQueue(pnum,atime,btime);
  }
  
  CalculatePSJF();


	fclose(ptr);
	DeleteQueue();
	return 0;
}
Example #3
0
static  bool    JustMoveLabel( common_info *max, ins_entry *ins )
/***************************************************************/
{
    oc_class            cl;
    ins_entry           *lbl;
    ins_entry           *add;
    ins_entry           *next;

  optbegin
    if( PrevClass( max->start_del ) != OC_LABEL )
        optreturn( FALSE );
    lbl = PrevIns( max->start_del );
    if( _Attr( lbl ) & ATTR_SHORT )
        optreturn( FALSE );
    cl = PrevClass( lbl );
    if( !_TransferClass( cl ) )
        optreturn( FALSE );
    DeleteQueue( lbl );
    InsertQueue( lbl, PrevIns( max->start_com ) );
    add = PrevIns( max->start_del );
    for( ;; ) {
        next = NextIns( add );
        DelInstr( next );
        if( next == ins ) {
            break;
        }
    }
    Untangle( lbl );
    optreturn( TRUE );
}
Example #4
0
int main()
{
	FILE *ptr;
	ptr=fopen("file.txt","r");
	CheckFileForError(ptr);
	
  CreateQueue();

  char str[80];
  int i, pnum, atime,btime;
 	while(fgets(str,80,ptr)!=NULL)
 	{
    int *point;

    point = FindNuminString(str,0);
    pnum = *point;
    point = FindNuminString(str,*(point+1));
    atime = *point;
    point = FindNuminString(str,*(point+1));
    btime = *point;
   
   EnQueue(pnum,atime,btime);
  }
  int time_quantum;
  printf("\n Enter the time quantum: ");
  scanf("%d",&time_quantum);
  CalculateRR(time_quantum);


	fclose(ptr);
	DeleteQueue();
	return 0;
}
Example #5
0
static  void    TransformJumps( ins_entry *ins, ins_entry *first )
/****************************************************************/
{
    ins_entry           *add;
    ins_entry           *next;
    ins_entry           *lbl;
    oc_class            cl;

  optbegin
    if( _Class( ins ) == OC_RET )
        optreturnvoid;
    lbl = _Label( ins )->ins;
    if( lbl == NULL )
        optreturnvoid;
    add = lbl;
    for( ;; ) {
        if( add == NULL )
            optreturnvoid;
        cl = _Class( add );
        if( _TransferClass( cl ) )
            break;
        if( cl == OC_LABEL ) {
            if( _Attr( add ) & ATTR_SHORT )
                optreturnvoid;
            _ClrStatus( _Label( add ), SHORTREACH );
        }
        add = NextIns( add );
    }
    if( add == first || add == ins )
        optreturnvoid;
    if( FindShort( first, lbl ) )
        optreturnvoid;
    for( ;; ) {
        next = PrevIns( add );
        DeleteQueue( add );
        InsertQueue( add, first );
        if( add == lbl )
            break;
        add = next;
    }
    DeleteQueue( first );
    InsertQueue( first, next );
    Untangle( NextIns( first ) );
  optend
}
Example #6
0
void DeinitPathFinder(PathFinder* pathFinder)
{
    DeleteQueue(pathFinder->openList);
    for (int i = 0; i < pathFinder->map->width; ++i)
        free(pathFinder->nodeMap[i]);
    free(pathFinder->nodeMap);

    DeletePath(pathFinder);
}
Example #7
0
void printtopsortorder(graph g)
 {
  Queue q;
  ptrtoedge tempedge;
  int *degree;
  int count,count2,tempint;
  q = NewQueue();
  printf("\n");
  /*set up the degree array*/
  degree = malloc(sizeof(int)*g->numvertices);
  if(degree == NULL)
   FatalError("\nout of memory");
  for(count=0;count<g->numvertices;count++)
   degree[count] = 0;
  for(count = 0;count<g->numvertices;count++)
   {
    tempedge = g->array[count];
    while(tempedge != NULL)
     {
      degree[tempedge->vertex]++;
      tempedge = tempedge->next;
     }
   }
  /*sort and print out the sorted vertices*/
  count2 = g->numvertices;
  while(count2 != 0)
  {
  /*get vertices to print out this time around*/
  for(count=0;count<g->numvertices;count++)
   {
    if(degree[count] == 0)
     {
      Enqueue(count,q);
     }
   }
  /*in case of a cycle exit wiht error*/
  if(IsEmptyQueue(q))
   FatalError("There is a cycle involving the remaining vertices.");
  /*adjust degree for the removed vertices and print out the vertex*/
  while(!IsEmptyQueue(q))
   {
    count2--;
    tempint = Dequeue(q);
    printf("%d ",tempint);
    degree[tempint] = -1;
    tempedge = g->array[tempint];
    while(tempedge != NULL)
     {
      degree[tempedge->vertex] -= 1;
      tempedge = tempedge->next;
     }

   }

  }
  DeleteQueue(q);
 }
Example #8
0
int main(void)
{
	Stack s1;
	Stack s2;
	s1 = CreateStack(10);
	s2 = CreateStack(10);
	Item it = 1;
	AddQueue(it, s1,s2);
	it = 2;
	AddQueue(it,s1,s2);
	it = 3;
	AddQueue(it,s1,s2);
	DeleteQueue(&it,s1,s2);
	printf("%d\n",it);
	DeleteQueue(&it,s1,s2);
	printf("%d\n",it);
	DeleteQueue(&it,s1,s2);
	printf("%d\n",it);
}
Example #9
0
/*server engine start function */
int main(int argc,char *argv[])
{
    char * Ip_Addr = NULL;
    char * sPort;
    char * tmpptr;
    char * ServerId = NULL;
    int Port;
    ServerId = argv[1];
    int new_fd,i,j,thread_no;
    debug_print(("Server Engine Open!\n"));
    /*初始化任务队列*/
    p = (tQueue *)malloc(sizeof(struct Queue));
    InitQueue(p);
    /*创建MAX_THREADNUM个线程,并初始化该线程对应的信号量*/
    for(i = 0;i < MAX_THREADNUM ; i++)
    {
        thread_no = i;
        sem_init(&pSems[i],0,0); //初始化线程信号量
        if(pthread_create(&thread_id[i] ,NULL,(void*)AllocateTask,(void*)thread_no) != 0)
        {
            fprintf(stderr,"pthread_create Error,%s:%d\n",__FILE__,__LINE__);
            exit(-1);
        }
    }         
    ServerPrepare(ServerId);    
    printf("server engine open!\n");
    pthread_mutex_init(&mutex, NULL);
    while(1)
    {
        new_fd = ServerOpen();
        ptask = (tQueueNode *)malloc(sizeof(struct QueueNode));
        ptask->sockfd = new_fd;
        tmpptr = RecvData(new_fd);
        memcpy(ptask->pBuf,tmpptr,strlen(tmpptr)+1);
        ptask->bufsize = strlen(ptask->pBuf);
        debug_print(("ptask you want insert:sockfd is %d,pBuf is %s,bufsize is %d\n",ptask->sockfd,\
                                                                               ptask->pBuf,\
                                                                               ptask->bufsize));
        InQueue(p,ptask);   //如果收到数据则入队等候处理
        j = (rand()%3);     //随机唤醒其中的一个线程将资源分配给该线程
        debug_print(("V op +%d thread\n",j));
        sem_post(&pSems[j]);   //用信号量v操作将资源数目+1
    }
    ServerCloseinfo(ServerId);
    CloseServer();
    for(i = 0;i < MAX_THREADNUM;i++)
    {
        sem_destroy(&pSems[i]);
        DeleteQueue(p);
    } 
    return 0;
}
Example #10
0
void InsertInBinaryTree(struct BinaryTreeNode *root, int insertData) {
    struct BinaryTreeNode *temp;
    struct BinaryTreeNode *insertNode;
    struct DynArrayQueue *Q = CreateQueue();
    insertNode = (struct BinaryTreeNode *)malloc(sizeof(struct BinaryTreeNode));
    if(!insertData) {
        printf("Memory Error!\n");
        return;
    }
    insertNode->data = insertData;
    insertNode->left = NULL;
    insertNode->right = NULL;
    if (!root) {
        printf("!root!\n");
        root = insertNode;
        return;
    }
    EnQueue(Q, root);
    while (!IsEmptyQueue(Q)) {
        temp = DeQueue(Q);
        if (temp->left) {
            EnQueue(Q, temp->left);
        } else {
            temp->left = insertNode;
            printf("%d insert into left of %d\n", insertNode->data, temp->data);
            DeleteQueue(Q);
            return;
        }
        if (temp->right) {
            EnQueue(Q, temp->right);
        } else {
            temp->right = insertNode;
            printf("%d insert into right of %d\n", insertNode->data, temp->data);
            DeleteQueue(Q);
            return;
        }
    }
    DeleteQueue(Q);
}
Example #11
0
// right - left >= 0  ---> 1, otherwise 0
// down - top >= 0  ---> 1, otherwise 0
void CompactColor(unsigned char *CompactValue, double *HistogramValue)
{
	qdata		*pop, Queue[NUM_BINS];
	int			qfront = 0, qrear = 0;
	int			width = 8;		// 8x8 = 64
	int			i, j, jj, count;
	double		left, right;

	AddQueue(Queue, &qrear, 0, 0, 8, 8, 0);

	count = 0;
	while( (pop=DeleteQueue(Queue, &qfront, qrear)) )
	{
		left = right = 0;			// left also denote top, right also denote down
		if( pop->flag == 0 )		// right - left
		{
			for(j=pop->posY, jj=pop->posY*width; j<pop->posY+pop->sizeY; j++, jj+=width)
				for(i=pop->posX; i<pop->posX+pop->sizeX/2; i++)
					left += HistogramValue[jj+i];
			for(j=pop->posY, jj=pop->posY*width; j<pop->posY+pop->sizeY; j++, jj+=width)
				for(i=pop->posX+pop->sizeX/2; i<pop->posX+pop->sizeX; i++)
					right += HistogramValue[jj+i];
		}
		else						// down - top
		{
			for(j=pop->posY, jj=pop->posY*width; j<pop->posY+pop->sizeY/2; j++, jj+=width)
				for(i=pop->posX; i<pop->posX+pop->sizeX; i++)
					left += HistogramValue[jj+i];
			for(j=pop->posY+pop->sizeY/2, jj=(pop->posY+pop->sizeY/2)*width; j<pop->posY+pop->sizeY; j++, jj+=width)
				for(i=pop->posX; i<pop->posX+pop->sizeX; i++)
					right += HistogramValue[jj+i];
		}

		CompactValue[count] = (right>left) ? 1 : 0;
		count ++;

		// push into queue
		if( pop->flag == 0 && pop->sizeX > 1 )
		{
			AddQueue(Queue, &qrear, pop->posX, pop->posY, pop->sizeX/2, pop->sizeY, 1);
			AddQueue(Queue, &qrear, pop->posX+pop->sizeX/2, pop->posY, pop->sizeX/2, pop->sizeY, 1);
		}
		else if( pop->flag == 1 && pop->sizeY > 2 )
		{
			AddQueue(Queue, &qrear, pop->posX, pop->posY, pop->sizeX, pop->sizeY/2, 0);
			AddQueue(Queue, &qrear, pop->posX, pop->posY+pop->sizeY/2, pop->sizeX, pop->sizeY/2, 0);
		}
	}
}
Example #12
0
int LayerOrder(BiTree bt)
{
	LinkQueue Q;
	BiTree p;
	InitQueue(&Q);
	if(bt==NULL)return(FALSE);
	EnterQueue(&Q,bt);
	while(IsEmpty(Q)==0)
	{
		DeleteQueue(&Q,&p);
		printf("%c ",p->data);
		if(p->LChild)EnterQueue(&Q,p->LChild);
		if(p->RChild)EnterQueue(&Q,p->RChild);
	}
	printf("\n");
	return(TRUE);
}
Example #13
0
void main(){
	SeqQueue Q;
	char str[]="ABCDEFGH";
	int i,length=8;
	char x;
	InitQueue(&Q);
	for(i=0;i<length;i++){
		EnterQueue(&Q,str[i]);
	}
	DeleteQueue(&Q,&x);
	printf("出队列的元素为:%c\n",x);	//显示输出出队列的元素
	printf("顺序队列中的元素为:");
	if(!QueueEmpty(Q)){
		for(i=Q.front;i<Q.rear;i++)
			printf("%c",Q.queue[i]);
	}
	printf("\n");
	system("pause");
}
Example #14
0
void BFS(LGraph Graph ,Vertex V , void (*Visit)(Vertex) )
{
    Queue  queue;
    Vertex v;
    PtrToAdjVNode w;
    queue = CreateQueue(20);
    AddQueue(queue,V);
    VisitedBFS[V] = 1;/*标记已经访问*/
	Visit(V);
	while(queue->front != queue->rear){/*队列不为空*/
        v = DeleteQueue(queue);
        for(w = Graph->G[v].FirstEdge ; w != NULL ; w = w->next )
            if(VisitedBFS[w->AdjV] == 0){
				AddQueue(queue,w->AdjV);
				VisitedBFS[w->AdjV] = 1;
				Visit(w->AdjV);
			}
        
    }     
} 
int SizeOfBinaryTreeNonRecrusive(struct BinaryTreeNode *root) {
    int size = 0;
    struct BinaryTreeNode *temp;
    struct DynArrayQueue *Q = CreateQueue();
    if(!root) {
        return size;
    }
    EnQueue(Q, root);
    while(!IsEmptyQueue(Q)) {
        temp = DeQueue(Q);
        size++;
        if (temp->left) {
            EnQueue(Q, temp->left);
        }
        if (temp->right) {
            EnQueue(Q, temp->right);
        }
    }
    DeleteQueue(Q);
    return size;
}
Example #16
0
void main()
{
	Queue *queue = NULL;
	Element item;
	queue = CreateQueue();

	item.key = 1;
	printf("Add ist element into the queue.\n");
	AddQueue(queue, item);
	PrintQueue(queue);

	printf("Add 2st element into the queue.\n");
	item.key = 2;
	AddQueue(queue, item);
	PrintQueue(queue);

	printf("Add 2st element into the queue.\n");
	item.key = 3;
	AddQueue(queue, item);
	PrintQueue(queue);

	printf("Add 2st element into the queue.\n");
	item.key = 4;
	AddQueue(queue, item);
	PrintQueue(queue);

	printf("Delete the top element from the queue.\n");
	item = DeleteQueue(queue);
	printf("Delete %d\n", item.key);
	PrintQueue(queue);

	printf("Destroy the queue.\n");
	DestoryQueue(queue);

	PrintQueue(queue);
}
Example #17
0
int main()
{
  printf("############ WELCOME TO QUEUE OPERATIONS ############# \n \n");
  int i=0;
  int size=0,data=0;
  queue *Q=(queue *)malloc(sizeof(queue));
  while(1)
  {
  printf("\n 1)Create a Queue(Press 1)\n 2)Insert an element(Press 2)\n 3)Delete an element(Press 3)\n 4)Show the Queue(Press 4)\n 5)Delete a Queue(Press 5)\n 6)Show Queue Size(Press 6)\n 7)Exit(Press 7 to exit) \n");
  scanf("%d",&i);
  switch(i)
  {
    case 1:

        printf("\nEnter the size of the stack= ");
        scanf("%d",&size);
       *CreateQueue(Q,size);
       printf("Enter the values of the element (Press -1  to stop)= \n");
       while(1)
       {

          scanf("%d",&data);
          if(data==-1)
              break;
          else
              Enqueue(Q,data);
       };
       break;

    case 2:
          printf("\nEnter the value of the element= ");
          scanf("%d",&data);
          if(data==-1)
              break;
          else
              Enqueue(Q,data);
        break;

    case 3:
          printf("The element deleted is =%d\n",Dequeue(Q));
          break;
    case 4:
       if (flag==1)
       {
        if(!isEmptyQueue(Q))
        {
          printf("\nThe elements of the Queue are: ");
          for(i=Q->head;i<=Q->tail;i++)
            printf("%d ",Q->array[i]);
          printf("\n");
        }
        else
            printf("Queue is empty !!!! \n");
       }
      else
        printf("There is no Queue !!! \n");
          break;
    case 5:
          DeleteQueue(Q);
          printf("Queue is deleted !!! \n");
          break;
    case 6:
          printf("The Queue size is = %d\n",Queuesize(Q));
          break;
    case 7:
          exit(0);
    default:
          printf("Invalid option \n");
          break;
   }
  }

 return 0;
}
Example #18
0
extern  bool    StraightenCode( ins_entry *jump )
/***********************************************/
{
    ins_entry   *next;
    ins_entry   *insert;
    ins_entry   *hoist;
    ins_entry   *end_hoist;
    oc_class    cl;
    obj_length  align;

    optbegin
    hoist = _Label( jump )->ins;
    if( hoist == NULL )
        optreturn( false );
    if( hoist == LastIns )
        optreturn( false );
    cl = PrevClass( hoist );
    if( !_TransferClass( cl ) )
        optreturn( false );

    end_hoist = NULL;
    for( next = hoist; ; next = NextIns( next ) ) {
        if( next == jump ) { // pushing code down to jump
            if( end_hoist == NULL )
                optreturn( false );
            if( FindShort( hoist, end_hoist ) )
                optreturn( false );
            break;
        }
        if( next == NULL ) { // hauling code up to jump
            if( FindShort( jump, hoist ) )
                optreturn( false );
            break;
        }
        cl = _Class( next );
        if( end_hoist == NULL && _TransferClass( cl ) ) {
            end_hoist = next;
        }
    }

    align = _ObjLen( hoist );
    insert = jump;
    for( ;; ) {
        if( hoist == NULL ) {
            ChgLblRef( jump, AddNewLabel( LastIns, align ) );
            next = LastIns;
            break;
        }
        next = NextIns( hoist );
        DeleteQueue( hoist );
        InsertQueue( hoist, insert );
        if( hoist == jump )
            optreturn( false );
        insert = hoist;
        cl = _Class( hoist );
        if( _TransferClass( cl ) ) {
            IsolatedCode( insert );
            break;
        }
        hoist = next;
    }
    InsDelete = true;
    Untangle( next );
    if( _Class( jump ) != OC_DEAD ) {
        Untangle( _Label( jump )->ins );
    }
    optreturn( true );
}
Example #19
0
bool ReadWriteDynQueue(const string &szIndex, const string &szDll, const string &szFunc, const char *pszQuery, 
                       const int &nSize, char *pBuffer, int &nRetSize, string szIDCUser = "******",
                       string szAddr = "localhost")
{
    static const string szLabel = "DYNPARAM";
    static const string szDLLName = "DLL";
    static const string szFUNC = "FUNC";
    static const string szParam = "PARAMS";
    static const char szSeparator = '#';

    bool bRet = false;
    string szRefreshQueue(getRefreshQueueName(szIndex)), szQueueName(makeQueueName());
    string szParamQueue(szQueueName + "_R"), szRetQueue(szQueueName + "_W");
    CreateQueue(szRetQueue, 1, szIDCUser, szAddr);
    CreateQueue(szParamQueue, 1, szIDCUser, szAddr);
    CreateQueue(szRefreshQueue, 1, szIDCUser, szAddr);

    int nDllSize = static_cast<int>(szDll.size()) + 2, nFuncSize = static_cast<int>(szFunc.size()) + 2;

    char *pDll = new char[nDllSize];
    if(pDll)
    {
        memset(pDll, 0, nDllSize);
        strcpy(pDll, szDll.c_str());
        if(PushMessage(szParamQueue, szDLLName, pDll, nDllSize, szIDCUser, szAddr))
        {
            char *pFunc = new char[nFuncSize];
            if(pFunc)
            {
                memset(pFunc, 0, nFuncSize);
                strcpy(pFunc, szFunc.c_str());
                if(PushMessage(szParamQueue, szFUNC, pFunc, nFuncSize, szIDCUser, szAddr))
                {
                    if(PushMessage(szParamQueue, szParam, pszQuery, nSize, szIDCUser, szAddr))
                    {
                        int nQueueSize = static_cast<int>(szQueueName.size()) + 2;
                        char *pszQueue = new char[nQueueSize];
                        if(pszQueue)
                        {
                            memset(pszQueue, 0, nQueueSize);
                            strcpy(pszQueue, szQueueName.c_str());
                            if(PushMessage(szRefreshQueue, szLabel, pszQueue, nQueueSize, szIDCUser, 
                                szAddr))
                            {
                                int nTimes = 0;
                                while(!bRet)
                                {
                                    if(nTimes >= 40)
                                        break;
                                    bRet = ReadFromRetQueue(szRetQueue, pBuffer, nRetSize, szIDCUser, szAddr);
                                    nTimes ++;
                                }
                            }
                            delete []pszQueue;
                        }
                    }
                }
                delete []pFunc;
            }
        }
        delete []pDll;
    }
    DeleteQueue(szRetQueue, szIDCUser, szAddr);

    return bRet;
}
Example #20
0
int main()
{
	int i,r;
	printf("Testing Queue\n");
	Queue* queue = CreateQueue();

	printf("Inserting values\n");
	for(i = 0; i < 5 ; i++)
	{	
		printf("%d\n",i);
		int result = QueueEnqueue(queue, i);
		if(result == 0)
		{
			printf("%d\n",i);
		}
		else
		{
			printf("Error in enqueuing queue\n");
		}
	}

	printf("Removing values\n");
	for(i = 0; i < 5 ; i++)
	{
		int result =QueueDequeue(queue, &r);
		if(result == 0)
		{
			printf("%d\n",r);
		}
		else
		{
			printf("Error in dequeuing queue\n");
		}
	}

	DeleteQueue(queue);

	printf("\nTesting Stack\n");

	Stack* stack = CreateStack();
	for(i = 0; i < 5 ; i++)
	{
		int result = StackPush(stack, i);
		if(result == 0)
		{
			printf("%d\n",i);
		}
		else
		{
			printf("Error in pushing to stack");
		}
	}

	for(i = 0; i < 5 ; i++)
	{
		int result = StackPop(stack, &r);
		if(result == 0)
		{
			printf("%d\n",r);
		}
		else
		{
			printf("Error in popping values");
		}
	}
	
	DeleteStack(stack); 
	return 0;
}
Example #21
0
int main()
{
	struct timeval t1, t2;
	double elapsedTime;
	srand(time(NULL));
	int i;
	int r;
	int result; 

	printf("Testing Queue\n");
	// start timer
	gettimeofday(&t1, NULL);
	Queue* queue = CreateQueue();

	for(i = 0; i < NO_OF_ELEMENTS ; i++)
	{
		// Generate a random value and put that to stack
		r = rand();	
		result = QueueEnqueue(queue, r);
		if(result != 0)
		{
			printf("Error in enqueuing queue\n");
		}
	}

	for(i = 0; i < NO_OF_ELEMENTS ; i++)
	{
		result =QueueDequeue(queue, &r);
		if(result != 0)
		{
			printf("Error in dequeuing queue\n");
		}
	}

	DeleteQueue(queue);

	// Time calculation
	gettimeofday(&t2, NULL);
	elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0;
	elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0;
	printf("Elapsed time %f\nQueue testing completed...\n", elapsedTime);
	
	printf("\nTesting Stack\n");
	// start timer
	gettimeofday(&t1, NULL);

	Stack* stack = CreateStack();
	for(i = 0; i < NO_OF_ELEMENTS ; i++)
	{
		// Generate a random value and put that to stack
		r = rand();	
		result = StackPush(stack, r);
		if(result != 0)
		{
			printf("Error in pushing to stack");
		}
	}

	for(i = 0; i < NO_OF_ELEMENTS ; i++)
	{
		result = StackPop(stack, &r);
		if(result != 0)
		{
			printf("Error in poping stack");
		}
	}
	
	DeleteStack(stack); 

	// Time calculation
	gettimeofday(&t2, NULL);
	elapsedTime = (t2.tv_sec - t1.tv_sec) * 1000.0;
	elapsedTime += (t2.tv_usec - t1.tv_usec) / 1000.0;

	printf("Elapsed time %f\nStack testing completed...\n", elapsedTime);

	return 0;
}
Example #22
0
void FindPath(PathFinder* pf)
{
    //printf("(%d, %d) -> (%d, %d)\t", pf->startx, pf->starty, pf->endx, pf->endy);
    for (int i = 0; i < pf->map->width; i++)
    {
        for (int e = 0; e < pf->map->height; e++)
        {
            pf->nodeMap[i][e].f = 0;
            pf->nodeMap[i][e].g = 0;
            pf->nodeMap[i][e].h = 0;
            pf->nodeMap[i][e].open = NoList;
            pf->nodeMap[i][e].parent = NULL;
        }
    }
    DeleteQueue(pf->openList);
    pf->openList = CreateQueue(nodeMinCompare, pf->map->width * pf->map->height);

    int x = pf->startx;
    int y = pf->starty;

    // Step 1: Add starting node to the open list.
    AddOpen(pf, x, y, NULL);

    // Step 2: Repeat
    // If there's nothing in the open list anymore or we arrive at the destination, stop
    while (GetQueueSize(pf->openList) > 0)
    {
        //printf("%d ", GetQueueSize(pf->openList));
        // a) Look for the lowest F cost square on the open list.
        Node* current = (Node*)QueueRemove(pf->openList);

        x = current->x;
        y = current->y;

        // b) Switch it to the closed list.
        current->open = OnClosedList;

        // c) For each of the 8 squares adjacent to this current square, attempt to add it
        //    to the open list.
        // AddOpen checks for adjacent-validity and whether the node is a wall or not.
        AddOpen(pf, x - 0, y - 1, current);
        AddOpen(pf, x - 0, y + 1, current);
        AddOpen(pf, x - 1, y - 0, current);
        AddOpen(pf, x + 1, y - 0, current);

        // Diagonal Check
        if (pf->allowDiagonal)
        {
            AddOpen(pf, x - 1, y - 1, current);
            AddOpen(pf, x + 1, y - 1, current);
            AddOpen(pf, x - 1, y + 1, current);
            AddOpen(pf, x + 1, y + 1, current);
        }

        // Are we done?
        if (x == pf->endx && y == pf->endy &&
            pf->nodeMap[pf->endx][pf->endy].open == OnClosedList)
        {
            // Step 3: Save Path
            DeletePath(pf);
            SavePath(pf, current);

            /*
            PathNode* p = pf->path;
            if (p == NULL)
                printf(" No Path?");
            while (p)
            {
                printf("(%p) %d, %d", p, p->x, p->y);
                p = p->parent;
            }
            */
            break;
        }
    }
    printf("Pathfinding done\n");
}
Example #23
0
int main(void)
{
	int select;		/*保存选择变量*/
	size_t pos;		/*位序*/
	Elem e;			/*保存从函数返回的结点的值*/
	Elem v;			/*保存传递给函数的结点的值*/
	
	size_t i= 0;
	LINKQUEUE Q;
	InitQueue(&Q);
	srand((int)time(NULL));
	while (i < 10)
	{
		InsertQueue(&Q, rand()%20);
		++i;
	}

	while (1)	/*while_@1*/
	{
		if (!Q.front)
		{
			printf("队列不存在!\n");
			break;
		}

		system("cls");
		Menu();

		printf("请输入您的选择(1~10):");
		scanf("%d", &select);
		getchar();

		switch (select)	/*switch_@1*/
		{
		case 1:			/*入队*/
			v = InputValue("入队元素为:");
			if (FAILE == InsertQueue(&Q, v))
			{
				printf("入队失败!\n");
			}
			else
			{
				printf("入队成功!\n");
			}
			
			getchar();
			break;
		case 2:			/*输出队列*/
			printf("队列为:");
			TraveQueue(&Q);
			
			getchar();
			break;
		case 3:			/*出队*/
			if (OK == DeleteQueue(&Q, &e))
			{
				printf("出队成功,删除的元素是%d!\n", e);
			}
			else
			{
				printf("删除失败!\n");
			}

			getchar();
			break;

		case 4:			/*输出队列的长度*/
			printf("表长为: %d \n", QueueLength(&Q));
			
			getchar();
			break;

		case 5:			/*清空队列*/
			ClearQueue(&Q);
			printf("该表已经清空!\n");
			
			getchar();
			break;

		case 6:			/*返回队头元素*/
			if (OK == GetHead(&Q, &e))
			{
				printf("该结点为:%d\n", e);
			}
			else
			{
				printf("不存在!\n");
			}

			getchar();	
			break;

		case 7:			/*判断队列是否为空*/
			if (QueueEmpty(&Q) == TRUE)
			{
				printf("队列为空!\n");
			}
			else
			{
				printf("队列非空!\n");
			}

			getchar();	
			break;
		
		case 8:			/*销毁队列*/
			DestroyQueue(&Q);
			printf("队列已删除!\n");

			getchar();	
			break;
		
		default:
			printf("请重新选择!\n");
			
			getchar();
			break;
		}/*switch_@1*/

	}	/*while_@1*/
	
	return EXIT_SUCCESS;
}