unsigned int ABPEvenCount (PtABPNode proot)
{
PtABPNode node = proot;
PtQueue queue;
unsigned int count = 0;
if (proot == NULL) {
Error = ABP_EMPTY;
return -1;
}
if ((queue = QueueCreate(sizeof(PtABPNode))) == NULL) {
Error = NO_MEM;
return -1;
}
QueueEnqueue(queue, &node);
while (!QueueIsEmpty(queue)) {
QueueDequeue(queue, &node);
if (!(node->Elem & 1))
count++;
if (node->PtLeft != NULL)
QueueEnqueue(queue, &(node->PtLeft));
if (node->PtRight != NULL)
QueueEnqueue(queue, &(node->PtRight));
}
QueueDestroy(&queue);
Error = OK;
return count;
}
void queue_app_test(void)
{
unsigned int iloop = 0;
int data = 0;
SqQueue sq;
QueueCreate(&sq);
for(iloop=0; iloop < 16; iloop++)
{
#ifdef USE_LINE_QUEUE
QueueEnterL(&sq, iloop*8);
#else //USE_CIRCLE_QUEUE
QueueEnterC(&sq, iloop*8);
#endif
printf("queue get valid data len is %d \n", QueueGetTag(&sq)); //队列长度
}
#ifdef USE_LINE_QUEUE
while(QueueDeleteL(&sq, &data) != -1)
#else //USE_CIRCLE_QUEUE
while(QueueDeleteC(&sq, &data) != -1)
#endif
{
printf("queue get data value is %d \n", data);
printf("queue get remain data len is %d \n", QueueGetTag(&sq));
}
QueueDestroy(&sq);
return;
}
static void test_basics(void)
{
Queue *q = QueueNew(free);
assert_int_equal(0, QueueCount(q));
assert_true(QueueIsEmpty(q));
QueueEnqueue(q, xstrdup("hello"));
assert_int_equal(1, QueueCount(q));
assert_false(QueueIsEmpty(q));
assert_string_equal("hello", QueueHead(q));
QueueEnqueue(q, xstrdup("world"));
assert_int_equal(2, QueueCount(q));
assert_string_equal("hello", QueueHead(q));
char *head = QueueDequeue(q);
assert_string_equal("hello", head);
free(head);
assert_string_equal("world", QueueHead(q));
head = QueueDequeue(q);
assert_string_equal("world", head);
free(head);
QueueDestroy(q);
}
ADTErr SafeQueueDestroy(SafeQueue* _queue)
{
ADTErr error;
if(NULL == _queue)
{
return ERR_NOT_INITIALIZED;
}
/* destroying semaphores */
error = SemDestroy(&_queue->m_prodSem);
if (error != ERR_OK)
{
return error;
}
error = SemDestroy(&_queue->m_consSem);
if (error != ERR_OK)
{
return error;
}
if (SUCCESS != pthread_mutex_destroy(&_queue->m_mutex))
{
return ERR_MUTEX_DESTROY_FAILED;
}
/* destroying queue */
QueueDestroy(_queue->m_queue);
free(_queue);
return ERR_OK;
}
int main(int argc, char *argv[])
{
void *p = NULL;
long msg = 0;
void *pMsg = NULL;
p = QueueCreate(10);
if (NULL == p)
{
printf("Create queue failed.\n");
return -1;
}
msg = 90;
while (msg--)
{
if (QueuePush(p, (void *)msg) < 0)
{
printf("----------Queue is full now-----------\n");
break;
}
printf("Push ok. [msg: %ld, size: %d]\n", msg, QueueGetSize(p));
}
msg = 15;
while (msg--)
{
if (QueuePopPush(p, (void *)msg, &pMsg) < 0)
{
printf("----------QueuePopPush failed-----------\n");
break;
}
printf("PopPush ok. [msgPop: %ld, msgPush: %ld, size: %d]\n",
(long)pMsg, msg, QueueGetSize(p));
}
msg = 60;
while (msg--)
{
if (QueuePop(p, &pMsg) < 0)
{
printf("----------Queue is empty now-----------\n");
break;
}
printf("Pop ok. [msg: %ld, size: %d]\n", (long)pMsg, QueueGetSize(p));
}
QueueDestroy(p);
system("pause");
return 0;
}
static void test_destroy(void)
{
Queue *q = QueueNew(free);
QueueEnqueue(q, xstrdup("1"));
QueueEnqueue(q, xstrdup("2"));
QueueEnqueue(q, xstrdup("3"));
assert_int_equal(3, QueueCount(q));
QueueDestroy(q);
}
int QueueCreate(Queue_t * queue, int data_len)
{
if (queue->head != NULL)
QueueDestroy(queue);
pthread_mutex_init(&queue->token, NULL);
queue->data_len = data_len;
queue->head = NULL;
queue->tail = NULL;
queue->data_len = 0;
queue->queue_length = 0;
return 0;
}
/*****************************************************************************
* Destroy: destroy adjust video thread output method
*****************************************************************************
* Terminate an output method created by adjustCreateOutputMethod
*****************************************************************************/
static void Destroy( vlc_object_t *p_this )
{
filter_t *p_filter = (filter_t *)p_this;
filter_sys_t *p_sys = p_filter->p_sys;
BufferDestroy( &p_sys->input );
BufferDestroy( &p_sys->output );
QueueDestroy( &p_sys->atomic );
QueueDestroy( &p_sys->pending );
QueueDestroy( &p_sys->processed );
do_ListDestroy( &p_sys->overlays );
UnregisterCommand( p_filter );
var_DelCallback( p_filter, "overlay-input", AdjustCallback, p_sys );
var_DelCallback( p_filter, "overlay-output", AdjustCallback, p_sys );
vlc_mutex_destroy( &p_sys->lock );
free( p_sys->psz_inputfile );
free( p_sys->psz_outputfile );
free( p_sys );
}
void enet_slirp_stop(void) {
int ret;
if(slirp_inited) {
Log_Printf(LOG_WARN, "Stopping SLIRP");
slirp_inited=0;
//slirp_exit(0);
QueueDestroy(slirpq);
SDL_DestroyMutex(slirp_mutex);
SDL_WaitThread(tick_func_handle, &ret);
}
}
CTAsyncWorkQueue::~CTAsyncWorkQueue()
{
int size = 0;
m_stopped = 1;
if ((NULL != m_pEndQ) && (NULL != m_pRunQ))
{
while (1)
{
size = QueueGetSize(m_pEndQ) + QueueGetSize(m_pRunQ);
if (0 == size)
{
break;
}
printf("QueueGetSize(m_pEndQ): %d, QueueGetSize(m_pRunQ): %d\n",
QueueGetSize(m_pEndQ), QueueGetSize(m_pRunQ));
usleep(100 * 1000);
}
}
if (NULL == m_pThreadsGroup)
{
ThreadsGroupDestroy(m_pThreadsGroup, 1, 0);
m_pThreadsGroup = NULL;
}
if (NULL == m_pRunQ)
{
QueueDestroy(m_pRunQ);
m_pRunQ = NULL;
}
if (NULL == m_pEndQ)
{
QueueDestroy(m_pEndQ);
m_pEndQ = NULL;
}
}
///////////////////////////////////////////////////////////////////////////////
// ReqMgrDestroy
//
// Description:
// Destroys a request manager.
//
// Inputs:
// pReqMgr - Pointer to a request manager.
//
// Outputs:
// None.
//
// Returns:
// None.
//
///////////////////////////////////////////////////////////////////////////////
void
ReqMgrDestroy(
IN REQ_MGR* const pReqMgr )
{
REQUEST_OBJECT *pReq;
ASSERT( pReqMgr );
// Return all requests to the grow pool.
if( pReqMgr->m_Initialized )
{
while( NULL != (pReq = (REQUEST_OBJECT*)QueueRemove( &pReqMgr->m_RequestQueue )) )
GrowPoolPut( &pReqMgr->m_RequestPool, pReq );
}
QueueDestroy( &pReqMgr->m_RequestQueue );
GrowPoolDestroy( &pReqMgr->m_RequestPool );
pReqMgr->m_Initialized = FALSE;
}
void findSSShortestPath(graphT g, int v, int **distance) {
// int* findSSShortestPath(graphT g, int v) {
queueT queue = QueueInit(n);
// GraphPrint(g);
// int* distance = malloc(sizeof(int) * n);
int* parent = malloc(sizeof(int) * n);
for (int i = 0; i < n; ++i) {
// distance[i] = INT_MAX;
(*distance)[i] = INT_MAX;
parent[i] = UNDEFINED;
}
// distance[v] = 0;
(*distance)[v] = 0;
// printArray(distance, n);
QueueEnqueue(queue, v);
// printf("Enqueued %d\n", v);
while (!QueueIsEmpty(queue)){
int t = QueueDequeue(queue);
// printf("Dequeued %d\n", t);
// printf("Neighbor of %d: \n", t);
for (int i = 0; i < GraphOutDegreeForVertex(g, t); ++i) {
int w = g->alist[t]->list[i];
// printf(" %d\n", w);
if ((*distance)[w] == INT_MAX){
// if (distance[w] == INT_MAX){
parent[w] = t;
// distance[w] = distance[t] + 1;
(*distance)[w] = (*distance)[t] + 1;
QueueEnqueue(queue, w);
// printf("Enqueued %d\n", w);
}
}
}
// printArray(distance, n);
QueueDestroy(queue);
free(parent);
}
void ABPByLevel (PtABPNode proot) /* travessia por niveis - traversal by levels */
{
PtABPNode Node = proot; PtQueue Queue;
if (proot == NULL) { Error = ABP_EMPTY; return; } /* arvore vazia - empty tree */
if ((Queue = QueueCreate (sizeof (PtABPNode))) == NULL) { Error = NO_MEM ; return; }
QueueEnqueue (Queue, &Node); /* armazenar a raiz - storing the root */
while (!QueueIsEmpty (Queue))
{
QueueDequeue (Queue, &Node); /* retirar o no - retrieve the node */
printf ("%d ", Node->Elem); /* imprimir o elemento - printing the element */
/* armazenar a raiz da subarvore esquerda - storing the left subtree root */
if (Node->PtLeft != NULL) QueueEnqueue (Queue, &Node->PtLeft);
/* armazenar a raiz da subarvore direita - storing the right subtree root */
if (Node->PtRight != NULL) QueueEnqueue (Queue, &Node->PtRight);
}
QueueDestroy (&Queue); /* destruir a fila - releasing the queue */
Error = OK;
}
int
main( int ac, char *av[] )
{
pthread_t th[5];
int i;
M_t *pM;
int Ret;
void *pRet;
QueueInit( &Queue );
/* 1. timeout */
printf("### 1. 0s timed_wait timeout ###\n");
pthread_create( &th[0], NULL, ThreadWait, (void*)0 );
pRet = NULL;
pthread_join( th[0], &pRet );
ASSERT( (int)(intptr_t)(pRet) == ETIMEDOUT );
/* 2. timeout */
printf("### 2. 10s timed_wait timeout ###\n");
pthread_create( &th[0], NULL, ThreadWait, (void*)(10*1000) );
pRet = NULL;
pthread_join( th[0], &pRet );
ASSERT( (int)(intptr_t)(pRet) == ETIMEDOUT );
/* 3. timeout */
printf("### 3. 10s timed_wait receive and timeout###\n");
pthread_create( &th[0], NULL, ThreadWait, (void*)(10*1000) );
pM = M_Create( 3 );
Ret = QueuePostEntry( &Queue, pM, m_Lnk );
if( Ret < 0 ) goto err;
pRet = NULL;
pthread_join( th[0], &pRet );
ASSERT( (int)(intptr_t)(pRet) == ETIMEDOUT );
/* 4. one for-ever-wait thread */
printf("### 4. one for_ever_wait thread ###\n");
pthread_create( &th[0], NULL, ThreadWait, (void*)FOREVER );
pM = M_Create( 4 );
Ret = QueuePostEntry( &Queue, pM, m_Lnk );
if( Ret < 0 ) goto err;
sleep( 1 );
/* 5. multi for-ever-wait threads */
printf("### 5. multi for_ever_wait threads ###\n");
pthread_create( &th[1], NULL, ThreadWait, (void*)FOREVER );
pthread_create( &th[2], NULL, ThreadWait, (void*)FOREVER );
pthread_create( &th[3], NULL, ThreadWait, (void*)FOREVER );
pthread_create( &th[4], NULL, ThreadWait, (void*)FOREVER );
pM = M_Create( 5 );
Ret = QueuePostEntry( &Queue, pM, m_Lnk );
if( Ret < 0 ) goto err;
sleep( 1 );
/* 6. suspend/resume */
printf("### 6. suspend / count / resume###\n");
QueueSuspend( &Queue );
QueueMax(&Queue, 1 );
pM = M_Create( 6 );
Ret = QueuePostEntry( &Queue, pM, m_Lnk );
printf("Posted to suspended Queue Ret=%d Cnt=%d Omitted=%d\n",
Ret, QueueCnt(&Queue), QueueOmitted(&Queue));
pM = M_Create( 61 );
Ret = QueuePostEntry( &Queue, pM, m_Lnk );
printf("Posted to suspended Queue Ret=%d Cnt=%d Omitted=%d\n",
Ret, QueueCnt(&Queue), QueueOmitted(&Queue));
pM = M_Create( 62 );
Ret = QueuePostEntry( &Queue, pM, m_Lnk );
printf("Posted to suspended Queue Ret=%d Cnt=%d Omitted=%d\n",
Ret, QueueCnt(&Queue), QueueOmitted(&Queue));
sleep( 1 );
printf("q_cnt=%d\n", QueueCnt( &Queue ) );
printf("Resume Queue\n");
QueueResume( &Queue );
sleep( 1 );
/* 7. Abort */
printf("### 7. Abort ###\n");
QueueAbort( &Queue, 9 );
sleep( 10 );
for( i = 0; i < 5; i++ ) {
pRet = NULL;
pthread_join( th[i], &pRet );
ASSERT( (int)(intptr_t)(pRet) == SIGKILL );
}
QueueDestroy( &Queue );
printf("=== OK ===\n");
return( 0 );
err:
printf("=== NG ===\n");
return( -1 );
}
/***************************************************************
* Bank System Quit
****************************************************************/
int Bank_Sys_Term(void)
{
QueueDestroy(&sq);
QueueDestroy(&sq1);
return 0;
}
void serverKill( BalancedBTreeItem_t *node, IRCServer_t *server, bool unalloc )
{
LinkedListItem_t *listItem, *next;
IRCChannel_t *channel;
BalancedBTreeItem_t *item;
if( server->enabled || server->enabledChanged ) {
server->threadAbort = TRUE;
thread_deregister( server->txThreadId );
thread_deregister( server->threadId );
server->threadAbort = FALSE;
}
if( unalloc ) {
BalancedBTreeRemove( node->btree, node, LOCKED, FALSE );
} else {
server->enabled = FALSE;
}
if( server->txQueue ) {
/* This *might* leak the contents of any queue entries? */
QueueClear( server->txQueue, TRUE );
QueueLock( server->txQueue );
QueueDestroy( server->txQueue );
server->txQueue = NULL;
}
if( server->channels ) {
LinkedListLock( server->channels );
BalancedBTreeLock( server->channelName );
BalancedBTreeLock( server->channelNum );
for( listItem = server->channels->head; listItem; listItem = next ) {
next = listItem->next;
channel = (IRCChannel_t *)listItem;
regexpBotCmdRemove( server, channel );
LinkedListRemove( server->channels, listItem, LOCKED );
item = BalancedBTreeFind( server->channelName,
&channel->channel, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelName, item, LOCKED,
FALSE );
}
item = BalancedBTreeFind( server->channelNum,
&channel->channelId, LOCKED );
if( item ) {
BalancedBTreeRemove( server->channelNum, item, LOCKED,
FALSE );
}
ThreadAllNotifyChannel( channel );
cursesMenuItemRemove( 2, MENU_CHANNELS, channel->menuText );
free( channel->menuText );
free( channel->channel );
free( channel->fullspec );
free( channel->url );
free( channel );
}
LinkedListDestroy( server->channels );
BalancedBTreeDestroy( server->channelName );
BalancedBTreeDestroy( server->channelNum );
server->channels = NULL;
server->channelName = NULL;
server->channelNum = NULL;
}
if( unalloc ) {
free( server->server );
free( server->password );
free( server->nick );
free( server->username );
free( server->realname );
free( server->nickserv );
free( server->nickservmsg );
free( server->ircInfo.Server );
}
LinkedListLock( server->floodList );
for( listItem = server->floodList->head; listItem; listItem = next ) {
next = listItem->next;
LinkedListRemove( server->floodList, listItem, LOCKED );
free( listItem );
}
LinkedListDestroy( server->floodList );
server->floodList = NULL;
ThreadAllNotifyServer( server );
if( unalloc ) {
cursesMenuItemRemove( 2, MENU_SERVERS, server->menuText );
free( server->menuText );
free( server->threadName );
free( server->txThreadName );
free( server );
free( node );
}
}
int main(void)
{
QUEUE Queue = {0};
CASHIER *Cashier = NULL;
CASHIER EmptyCashier = {0};
CUSTOMER Customer = {0};
CUSTOMER EmptyCustomer = {0};
int CustomerNumber = 0;
int TotalItems = 0;
int TotalItemsSold = 0;
int SatisfiedCustomers = 0;
long TotalWaitTime = 0;
double Balance;
int NumCashiers;
unsigned long TempCashiers;
long CurrentSecond;
char Buff[10];
char *endp;
double p;
int i;
int NumCustomers = 0;
srand((unsigned)time(NULL));
/* get data from user */
printf("Welcome to ShopSim!\n\n");
printf("Your goal is to maximise profit.\n");
printf("Income is number of items processed * %f.\n",
PROFIT_PER_ITEM);
printf("Customers wander in at random, on average %f"
" per second.\n",
CHANCE_OF_CUSTOMER);
printf("Expenditure is %f per cashier.\n",
CASHIER_WAGE);
printf("You choose the number of cashiers.\n\n");
printf("Dissatisfied customers cost you goodwill.\n");
do
{
printf("How many cashiers today?\n");
if(NULL == fgets(Buff, sizeof Buff, stdin))
{
printf("Program aborted.\n");
exit(EXIT_FAILURE);
}
TempCashiers = strtoul(Buff, &endp, 10);
/* On some platforms, unsigned long is longer than int,
* so we use a temp to catch strtoul's value.
*/
if(endp == Buff ||
0 == TempCashiers ||
TempCashiers > (unsigned long)INT_MAX)
{
printf("Ahem. %s? Try again!\n\n", Buff);
}
else
{
NumCashiers = (int)TempCashiers;
Cashier = malloc(NumCashiers * sizeof *Cashier);
if(NULL == Cashier)
{
printf("Hmm. Not enough RAM for "
"that many cashiers. Try again.\n");
}
}
} while(NULL == Cashier);
for(i = 0; i < NumCashiers; i++)
{
Cashier[i] = EmptyCashier;
}
/* Run simulation from 9am till 5pm (28800 seconds) */
assert(OPENING_TIME < CLOSING_TIME);
for(CurrentSecond = OPENING_TIME;
CurrentSecond < CLOSING_TIME;
CurrentSecond++)
{
p = RandomP();
if(p < CHANCE_OF_CUSTOMER)
{
Customer = EmptyCustomer;
Customer.Index = CustomerNumber++;
Customer.JoinedQueue = CurrentSecond;
TotalItems += DoShopping(&Customer);
/* Customer is now set up. Let's add
* him to the queue.
*/
if(QUEUE_SUCCESS !=
QueueAdd(&Queue, 0, &Customer, sizeof Customer))
{
printf("Insufficient memory.\n");
exit(EXIT_FAILURE);
}
}
for(i = 0; i < NumCashiers; i++)
{
/* Deal with current customers */
if(Cashier[i].TimeRemaining > 0)
{
--Cashier[i].TimeRemaining;
if(0 == Cashier[i].TimeRemaining)
{
printf("%s: Cashier %d has served customer %d\n",
GetTime(CurrentSecond),
i,
Cashier[i].CustomerIndex);
}
}
else
{
/* Deal with new customer, if any */
if(QueueCount(&Queue) > 0)
{
QueueRemove(&Customer, &Queue);
Cashier[i].TimeRemaining =
(int)(Customer.NumItems * SECONDS_PER_ITEM);
printf("Cashier %d busy for %d seconds\n",
i, Cashier[i].TimeRemaining);
Cashier[i].CustomerIndex = Customer.Index;
TotalWaitTime += CurrentSecond;
TotalWaitTime -= Customer.JoinedQueue;
++SatisfiedCustomers;
++Cashier[i].NumCustomersSeen;
Cashier[i].NumItemsProcessed +=
Customer.NumItems;
TotalItemsSold += Customer.NumItems;
printf("%s: Cashier %d is serving customer %d\n",
GetTime(CurrentSecond),
i,
Cashier[i].CustomerIndex);
printf("Customer %d waiting time: %s\n",
Customer.Index,
GetTime(CurrentSecond -
Customer.JoinedQueue));
}
}
}
}
printf("%s: Simulation ended.\n", GetTime(CurrentSecond));
printf("Items sold :%9d ", TotalItemsSold);
printf("Items picked up:%9d ", TotalItems);
printf("Difference :%9d\n", TotalItems - TotalItemsSold);
printf("Satisfied customers:%9d ", SatisfiedCustomers);
printf("Dissatisfied customers:%9d\n",
CustomerNumber - SatisfiedCustomers);
if(TotalWaitTime > 0)
{
printf("Average wait time "
"(satisfied customers only): %s\n",
GetTime((long)(TotalWaitTime /
(double)SatisfiedCustomers)));
}
printf("\n\nCashier Report\n\n");
for(i = 0; i < NumCashiers; i++)
{
printf("Cashier %2d saw %d customers ",
i, Cashier[i].NumCustomersSeen);
printf("and dealt with %d items.\n",
Cashier[i].NumItemsProcessed);
}
Balance = TotalItemsSold * PROFIT_PER_ITEM;
printf("Total profit : %12.2f\n",
Balance);
printf("Less cashier wages: %12.2f\n",
NumCashiers * CASHIER_WAGE);
Balance -= NumCashiers * CASHIER_WAGE;
printf("Balance : %12.2f\n", Balance);
printf("Goodwill Penalty : %12.2f\n",
(CustomerNumber - SatisfiedCustomers) *
GOODWILL_PENALTY);
Balance -= (CustomerNumber - SatisfiedCustomers) *
GOODWILL_PENALTY;
printf("End Balance : %12.2f\n", Balance);
printf("You %s.\n",
Balance > 0 ?
"win" : "lose");
QueueDestroy(&Queue);
free(Cashier);
return 0;
}
int BFS(Graph *graph, BFSVertex *start, List *hops)
{
Queue queue;
AdjList *adjlist = NULL;
AdjList *adjlist_Clear = NULL;
BFSVertex *vertex_Clear = NULL;
BFSVertex *vertex_Adj = NULL;
ListElmt *element = NULL;
ListElmt *member = NULL;
for (element = ListHead(&GraphAdjLists(graph)); element != NULL; element = ListNext(element))
{
vertex_Clear = ((AdjList*)ListData(element))->vertex;
if (graph->match(vertex_Clear, start))
{
vertex_Clear->color = gray;
vertex_Clear->nHops = 0;
}
else
{
vertex_Clear->color = white;
vertex_Clear->nHops = -1;
}
}
QueueInit(&queue, NULL);
if (GraphAdjList(graph, start, &adjlist_Clear) != 0)
{
QueueDestroy(&queue);
return -1;
}
if (QueueEnqueue(&queue, adjlist_Clear) != 0)
{
QueueDestroy(&queue);
return -1;
}
while (QueueSize(&queue) > 0)
{
adjlist = QueuePeek(&queue);
for (member = ListHead(&adjlist->Adjacent); member != NULL; member = ListNext(member))
{
vertex_Adj = ListData(member);
if (GraphAdjList(graph, vertex_Adj, &adjlist_Clear))
{
QueueDestroy(&queue);
return -1;
}
vertex_Clear = adjlist_Clear->vertex;
if (vertex_Clear->color == white)
{
vertex_Clear->color = gray;
vertex_Clear->nHops = ((BFSVertex*)adjlist->vertex)->nHops + 1;
if (QueueEnqueue(&queue, adjlist_Clear) != 0)
{
QueueDestroy(&queue);
return -1;
}
}
}
if (QueueDequeue(&queue, (void**)&adjlist) == 0)
{
((BFSVertex*)adjlist->vertex)->color = black;
}
else
{
QueueDestroy(&queue);
return -1;
}
}
QueueDestroy(&queue);
ListInit(hops, NULL);
for (element = ListHead(&GraphAdjLists(graph)); element != NULL; element = ListNext(element))
{
vertex_Clear = ((AdjList*)ListData(element))->vertex;
if (vertex_Clear->nHops != -1)
{
if (ListInsert_Next(hops, ListTail(hops), vertex_Clear) != 0)
{
ListDestory(hops);
return -1;
}
}
}
return 0;
}
