#pragma once
#include <stdio.h>
#include <malloc.h>
#include <memory.h>
#define N 10
typedef enum BOOL
{
TRUE=1,
FALSE=0
}BOOL;
typedef struct queen_node
{
int level;
int position;
}queen_node;
typedef struct queen_stack
{
int pointer;
int size;
int volume;
queen_node** container;
}queen_stack;
/*create a queen node.*/
void queen_node_create(queen_node** const the_node);
/*initialize the queen node value.*/
void queen_node_init(queen_node* const the_node,const int level,const int position);
/*free the queen node.*/
void queen_node_free(queen_node* const the_node);
/*copy a queen node to another.*/
void queen_node_copy(queen_node* const the_destination,const queen_node* const the_source);
/*get next queen node*/
void queen_node_next(queen_node* const the_node,const int level,const int position);
/*create queen stack.*/
void queen_stack_create(queen_stack** const the_stack,const int stack_volume);
/*free queen stack.*/
void queen_stack_free(queen_stack* const the_stack);
/*push queen node to queen stack.*/
BOOL queen_stack_push(queen_stack* const the_stack,const queen_node* const the_node);
/*pop queen node from queen stack.*/
BOOL queen_stack_pop(queen_stack* const the_stack,queen_node* const the_node);
/*return the queen stack whether overflow.*/
BOOL queen_stack_overflow(const queen_stack* const the_stack);
/*return the queen stack whether empty.*/
BOOL queen_stack_empty(const queen_stack* const the_stack);
/*fill the number array with the stack data*/
void number_array_fill(int** const the_array,const queen_stack* const the_stack,const int array_dimension);
/*create number array.*/
void number_arrary_create(int*** const the_arrary,const int array_dimension);
/*assign number array.*/
void number_array_assign(int** const the_array,const int row,const int column,const int array_dimension);
/*print number array data to screen.*/
void number_array_print(const int** const the_array,const int array_dimension);
/*free number arrary data.*/
void number_array_free(int** const the_array,const int array_dimension);
/*clear the number array data*/
void number_array_clear(int** const the_array,const int array_dimension);
int main()
{
/*declare values.*/
int** the_array=NULL;
queen_node* current_node=NULL;
queen_stack* current_stack=NULL;
int next_position=-1;
int next_level=-1;
int position_index=0;
BOOL found=FALSE;
/*create values.*/
number_arrary_create(&the_array,N);
queen_node_create(¤t_node);
queen_stack_create(¤t_stack,N+1);
/*push root to stack*/
queen_stack_push(current_stack,current_node);
while(queen_stack_empty(current_stack) == FALSE)
{
number_array_clear(the_array,N);
number_array_fill(the_array,current_stack,N);
found=FALSE;
for(position_index=current_node->position+1;position_index<N;position_index++)
{
if(the_array[current_stack->pointer][position_index] == 0)
{
next_position=position_index;
found=TRUE;
break;
}
}
if(found==FALSE)
{
queen_stack_pop(current_stack,current_node);
}
else
{
next_level=current_stack->pointer;
queen_node_init(current_node,next_level,next_position);
queen_stack_push(current_stack,current_node);
queen_node_init(current_node,-1,-1);
if(queen_stack_overflow(current_stack)==TRUE)
{
number_array_clear(the_array,N);
number_array_fill(the_array,current_stack,N);
number_array_print(the_array,N);
queen_stack_pop(current_stack,current_node);
}
}
}
/*free number arrary.*/
number_array_free(the_array,N);
the_array=NULL;
/*free current node.*/
queen_node_free(current_node);
current_node=NULL;
/*free current stack.*/
queen_stack_free(current_stack);
current_stack=NULL;
return 0;
}
void queen_node_create(queen_node** const the_node)
{
(*the_node)=(queen_node*)malloc(sizeof(queen_node));
memset((*the_node),0,sizeof(queen_node));
(*the_node)->level=-1;
(*the_node)->position=-1;
}
void queen_node_init(queen_node* const the_node,const int level,const int position)
{
the_node->level=level;
the_node->position=position;
}
void queen_node_free(queen_node* const the_node)
{
free(the_node);
}
void queen_node_copy(queen_node* const the_destination,const queen_node* const the_source)
{
the_destination->level=the_source->level;
the_destination->position=the_source->position;
}
void queen_node_next(queen_node* const the_node,const int level,const int position)
{
the_node->level=level;
the_node->position=position;
}
void queen_stack_create(queen_stack** const the_stack,const int stack_volume)
{
(*the_stack)=(queen_stack*)malloc(sizeof(queen_stack));
memset((*the_stack),0,sizeof(queen_stack));
(*the_stack)->volume=stack_volume;
(*the_stack)->pointer=-1;
(*the_stack)->size=0;
(*the_stack)->container=(queen_node**)malloc(sizeof(queen_node*)*(*the_stack)->volume);
memset((*the_stack)->container,0,sizeof(queen_node*)*(*the_stack)->volume);
}
void queen_stack_free(queen_stack* const the_stack)
{
int volume_index=0;
for(volume_index=0;volume_index<=the_stack->pointer;volume_index++)
{
queen_node_free(the_stack->container[volume_index]);
the_stack->container[volume_index]=NULL;
}
free(the_stack->container);
the_stack->container=NULL;
free(the_stack);
}
BOOL queen_stack_push(queen_stack* const the_stack,const queen_node* const the_node)
{
if(the_stack->size < the_stack->volume)
{
the_stack->pointer++;
queen_node_create(&(the_stack->container[the_stack->pointer]));
queen_node_copy(the_stack->container[the_stack->pointer],the_node);
the_stack->size++;
return TRUE;
}
else
{
return FALSE;
}
}
BOOL queen_stack_pop(queen_stack* const the_stack,queen_node* const the_node)
{
if(the_stack->size>0)
{
queen_node_copy(the_node,the_stack->container[the_stack->pointer]);
the_stack->container[the_stack->pointer]=NULL;
the_stack->pointer--;
the_stack->size--;
return TRUE;
}
else
{
return FALSE;
}
}
BOOL queen_stack_overflow(const queen_stack* const the_stack)
{
return the_stack->size == the_stack->volume ? TRUE : FALSE;
}
BOOL queen_stack_empty(const queen_stack* const the_stack)
{
return the_stack->size == 0 ? TRUE : FALSE;
}
void number_arrary_create(int*** const the_arrary,const int array_dimension)
{
int arrary_index=0;
(*the_arrary)=(int**)malloc(sizeof(int*)*array_dimension);
memset((*the_arrary),0,sizeof(int*)*array_dimension);
for(arrary_index=0;arrary_index<array_dimension;arrary_index++)
{
(*the_arrary)[arrary_index]=(int*)malloc(sizeof(int)*array_dimension);
memset((*the_arrary)[arrary_index],0,sizeof(int)*array_dimension);
}
}
void number_array_assign(int** const the_array,const int row,const int column,const int array_dimension)
{
int row_index=0;
int column_index=0;
the_array[row][column]=1;
for(column_index=0;column_index<column;column_index++)
{
if(the_array[row][column_index] == 0)
{
the_array[row][column_index]=2;
}
}
for(column_index=column+1;column_index<array_dimension;column_index++)
{
if(the_array[row][column_index] == 0)
{
the_array[row][column_index]=2;
}
}
for(row_index=0;row_index<row;row_index++)
{
if(the_array[row_index][column] == 0)
{
the_array[row_index][column]=2;
}
}
for(row_index=row+1;row_index<array_dimension;row_index++)
{
if(the_array[row_index][column] == 0)
{
the_array[row_index][column]=2;
}
}
for(row_index=row-1,column_index=column-1;row_index>=0 && column_index>=0 ;row_index--,column_index--)
{
if(the_array[row_index][column_index] == 0)
{
the_array[row_index][column_index]=2;
}
}
for(row_index=row+1,column_index=column+1;row_index<array_dimension && column_index<array_dimension;row_index++,column_index++)
{
if(the_array[row_index][column_index] == 0)
{
the_array[row_index][column_index]=2;
}
}
for(row_index=row-1,column_index=column+1;row_index>=0 && column_index<array_dimension;row_index--,column_index++)
{
if(the_array[row_index][column_index] == 0)
{
the_array[row_index][column_index]=2;
}
}
for(row_index=row+1,column_index=column-1;row_index<array_dimension && column_index>=0;row_index++,column_index--)
{
if(the_array[row_index][column_index] == 0)
{
the_array[row_index][column_index]=2;
}
}
}
void number_array_print(const int** const the_array,const int array_dimension)
{
int row_index=0;
int column_index=0;
static int number=1;
printf("--------------- the %d queen data---------------\n\n",number++);
for(row_index=0;row_index<array_dimension;row_index++)
{
for(column_index=0;column_index<array_dimension;column_index++)
{
if(the_array[row_index][column_index]==2)
{
printf("%d ",0);
}
else
{
printf("%d ",the_array[row_index][column_index]);
}
}
printf("\n");
}
printf("\n");
}
void number_array_free(int** const the_array,const int array_dimension)
{
int row_index=0;
for(row_index=0;row_index<array_dimension;row_index++)
{
free(the_array[row_index]);
the_array[row_index]=NULL;
}
free(the_array);
}
void number_array_fill(int** const the_array,const queen_stack* const the_stack,const int array_dimension)
{
int stack_index=0;
for(stack_index=the_stack->pointer;stack_index>0;stack_index--)
{
number_array_assign(the_array,the_stack->container[stack_index]->level,the_stack->container[stack_index]->position,array_dimension);
}
}
void number_array_clear(int** const the_array,const int array_dimension)
{
int row_index=0;
int column_index=0;
for(row_index=0;row_index<array_dimension;row_index++)
{
for(column_index=0;column_index<array_dimension;column_index++)
{
the_array[row_index][column_index]=0;
}
}
}原文地址：http://blog.csdn.net/yonshi/article/details/32151491
