八数码问题的深度优先搜索，怎么运行没结果啊？希望高手给看看，谢谢哈！

#include <stdio.h>
#include<stdlib.h>
#define COL 3
#define ROW 3
#define TOTAL 9
struct STATE
{
int matrix[TOTAL];
struct STATE *parent;
};
typedef struct STATE State;
struct QUEUE
{
struct STATE *current;
struct QUEUE *next;
int flag;
};
typedef struct QUEUE Queue;
int DFSSolve(int *,int *);
int EnqueueChild(State *);
int MoveAndEnqueue(State *, int, int );
State *StateConstruct(int *, State *);
Queue *QueueConstruct(State *);
int IsEqual(int *, int *);
int ShowSolutionPath(State *);
int Destruct();
int openDequeue();
int closedDequeue();
Queue *openHead = NULL;
Queue *openTail = NULL;
Queue *closedHead = NULL;
Queue *closedTail = NULL;

int main()
{
int initial[TOTAL],goal[TOTAL];
int i;
printf("Initial:\n");
for(i=0;i<TOTAL;i++)
scanf("%d",&initial[i]);

printf("\nGoal:\n");
for(i=0;i<TOTAL;i++)
scanf("%d",&goal[i]);

DFSSolve(initial,goal);
return 0;
}


int DFSSolve( int *entryArray, int *goal)
{
State *entryState = StateConstruct(entryArray,NULL);
openHead = QueueConstruct(entryState);
openTail = openHead;

while( ! IsEqual(openHead->current->matrix,goal) )
{
if((openHead->flag)!=1)
{
openHead->flag=1;
EnqueueChild(openHead->current);

}
openHead= openHead->next;

}
ShowSolutionPath(openHead->current);
Destruct();
return 1;
} /*end BFSSolve()*/
int EnqueueChild(State *parent)
{
int i;
for(i=0;i<TOTAL;i++)
{
if(parent->matrix[i]==0)
{
if( (i+1)/COL == i/COL )
MoveAndEnqueue(parent,i,i+1);
if( (i-1+COL)/COL == (i+COL)/COL ) /*excluding 0-1*/
MoveAndEnqueue(parent,i,i-1);
if( i+COL < TOTAL )
MoveAndEnqueue(parent,i,i+COL);
if( i-COL >= 0 )
MoveAndEnqueue(parent,i,i-COL);
break;
}
}

return 0;
}
int MoveAndEnqueue(State *parent,int x, int y)
{
State *state = StateConstruct(parent->matrix,parent);
Queue *queue=(Queue*)malloc(sizeof(Queue));
queue= QueueConstruct(state);
queue->next=NULL;
state->matrix[x] = parent->matrix[y];
state->matrix[y] = parent->matrix[x];
queue->next=openHead;
openHead = queue ;
return 0;
} /*end MoveAndEnqueue()*/
State *StateConstruct(int *matrix,State *parent)
{
int i;
State *state = (State*)malloc(sizeof(State));
if( state==NULL )
{
Destruct();
exit(0);
}
for(i=0;i<TOTAL;i++)
state->matrix[i] =matrix[i];
state->parent =parent;
return state;
} /*end StateConstruct()*/
Queue *QueueConstruct(State *state)
{
Queue *queue = (Queue*)malloc(sizeof(Queue));
if( queue==NULL )
{
Destruct();
exit(0);
}
queue->current = state;
queue->next = NULL;
queue->flag=0;
return queue;
} /*end QueueConstruct()*/
int IsEqual(int *matrix, int *goal)
{
int i;
for(i=0;i<TOTAL;i++)
if(matrix[i] != goal[i])
return 0;
return 1;
} /*end IsEqual()*/

int ShowSolutionPath(State *state)
{
State *curState = state;
Queue *curQueue = NULL;
Queue *lastQueue = NULL;
Queue *temp;
int i;
while(curState != NULL)
{
curQueue = (Queue*)malloc(sizeof(Queue));
if( curQueue==NULL )
{
while(curQueue != NULL)
{
temp = curQueue;
curQueue = curQueue->next;
free(temp);
}
Destruct();
exit(0);
}
///////////前插法，将链表逆序
curQueue->current = curState;
curQueue->next = lastQueue;
lastQueue = curQueue;
curState = curState->parent;
}
while(curQueue != NULL)
{
for(i=0;i<TOTAL;i++)
{
if( i%COL == 0) printf("\n");
printf("%d ",curQueue->current->matrix[i]);
}
temp = curQueue;
curQueue = curQueue->next;
free(temp);
printf("\n");
}
return 0;
}
int Destruct()
{
Queue *temp;

while(openHead != NULL)
{
free(openHead->current);
temp = openHead;
openHead = openHead->next;
free(temp);
}
return 0;
}
int openDequeue()
{
Queue *headTemp;
headTemp = openHead;
openHead = openHead->next;
free(headTemp->current);
free(headTemp);
return 0;
}
int closedDequeue()
{
Queue *headTemp;
headTemp = openHead;
openHead = openHead->next;
free(headTemp->current);
free(headTemp);
return 0;
}