数据结构___马踏棋盘详尽实现+报告+通俗易懂注释

//◎2019.10.2 Created By LiMin Guo. All Rights Reserved.
//本算法马踏棋盘的演示程序，实现选择下一搜索位置的局部贪心策略，有效减少回溯的次数
//并支持寻找给定起点出发的多条以至全部行走路线,以及寻找行走路线的回溯过程
#include<malloc.h>
#include<limits.h>
#include<stdio.h>
#include<math.h>
#include<process.h>
#include<conio.h>
#include<dos.h>
#include<memory.h>
#define CLS system("cls")
#define OVERFLOW -1
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 1
#define STACK_INIT_SIZE 10 //存储空间初始分配量
#define STACKINCREMENT 2 //存储空间分配增量
#define N 8    //8*8棋盘
typedef int Status;
typedef struct SElemType
{
    int x,y,z;//x,y坐标，z为八个方向中当前方向下标
}chess;
int map[N][N][8]; //前两维为坐标，后一维为当前方向下标已按
int weight[N][N]; //各点出度
bool walked[N][N];  //标记数组，走过为1


//栈的定义部分
typedef struct SqStack
{
	SElemType *base; //栈底指针
	SElemType *top; //栈顶指针
	int stacksize; //当前栈内元素数量
}SqStack;
inline Status InitStack(SqStack *S) //栈的初始化
{
	(*S).base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
	if (!(*S).base)
		exit(OVERFLOW);
	(*S).top = (*S).base;
	(*S).stacksize = STACK_INIT_SIZE;
	return OK;
}
inline Status StackEmpty(SqStack S)//判断是否为空栈
{
	if (S.top == S.base)
		return TRUE;
	else
		return FALSE;
}
inline Status GetTop(SqStack S, SElemType *e)//获得栈顶元素
{
	if (S.top>S.base)
	{
		*e = *(S.top - 1);
		return OK;
	}
	else
		return ERROR;
}
inline Status SetTop(SqStack S, SElemType *e)//修改栈顶元素
{
	if (S.top>S.base)
	{
		*(S.top - 1) = *e;
		return OK;
	}
	else
		return ERROR;
}
inline Status Push(SqStack *S, SElemType e)//推入新元素入栈
{
	if ((*S).top - (*S).base >= (*S).stacksize)//栈满时追加新的分配空间
	{
		(*S).base = (SElemType *)realloc((*S).base, ((*S).stacksize + STACKINCREMENT)*sizeof(SElemType));
		if (!(*S).base)
			exit(OVERFLOW);
		(*S).top = (*S).base + (*S).stacksize;
		(*S).stacksize += STACKINCREMENT;
	}
	*((*S).top)++ = e;
	return OK;
}
inline Status Pop(SqStack *S, SElemType *e)//弹出一个栈顶元素
{
	if ((*S).top == (*S).base)
		return ERROR;
	*e = *--(*S).top;
	return OK;
}
static SElemType dir[8] =//八个方向
{
	{ -2, 1, 0 }, { -1, 2, 0 }, { 1, 2, 0 }, { 2, 1, 0 }, { 2, -1, 0 }, { 1, -2, 0 }, { -1, -2, 0 }, { -2, -1, 0 }
};
inline bool check(int i, int j)//检查(i,j)是否在棋盘内
{
	return  (i<0 || i >= 8 || j<0 || j >= 8)?0:1;
}
//先预处理出树上各点的出度
inline void setweight()
{
    memset(weight,0,sizeof(weight));
    for(int i=0;i<N;i++)
    {
        for(int j=0;j<N;j++)
        {
            for(int k=0;k<N;k++)
            {
                if(check(i+dir[k].x,j+dir[k].y))weight[i][j]++;
            }
        }
    }
}
inline void output(SqStack &a)
{
	SqStack b;//a是压入的栈,b是输出的栈
	int c[8][8] = { 0 } ;//初始先置零
	int j, k = N*N, l = 1, x, y;
	InitStack(&b);
	SElemType e;
	while (!StackEmpty(a))
	{
		Pop(&a, &e);
		c[e.x][e.y] = k;
		k--;//编号减一
		Push(&b, e);//存入b
	}
	GetTop(b, &e);
	x = e.x; y = e.y;
	printf("起始坐标:(%d,%d)n", x, y);
	while (!StackEmpty(b))
	{
		Pop(&b, &e);
		printf("(%d,%d)", e.x, e.y);
		Push(&a, e);
	}
	printf("n棋盘表示:       0  1  2  3  4  5  6  7n");
	printf("              ┌──┬──┬──┬──┬──┬──┬──┬──┬n");
	printf("             0");

	int s = 0;
	for (s = 0; s < 7; s++)
	{
		for (j = 0; j <= 7; j++)
		{
			if (c[s][j] < 10) printf("│ %d", c[s][j]); else
				printf("│%d", c[s][j]);
		}printf("│n");
		printf("              ");
		printf("├──┼──┼──┼──┼──┼──┼──┼──┼n");
		printf("             %d", s+1);
	}

	for (j = 0; j <= 7; j++)
	{
		if (c[s][j]<10) printf("│ %d", c[s][j]);
		else
			printf("│%d", c[s][j]);
	}printf("│n");
	printf("              ");
	printf("└──┴──┴──┴──┴──┴──┴──┴──┴n");

}

void setmap()//贪心算法的核心，八个方向的优先搜索顺序按照各自的出度排序，出度小的先搜索
{
	for (int i = 0; i<N; i++)
	{
		for (int j = 0; j<N; j++)
		{
			for (int k = 0; k<8; k++)
				map[i][j][k] = k;//先按默认顺序
			for (int k = 0; k<8; k++)
			{
				for (int m = k + 1; m<8; m++)
				{
					int d1 = map[i][j][k],x1 = i + dir[d1].x,y1 = j + dir[d1].y,d2 = map[i][j][m],x2 = i + dir[d2].x,y2 = j + dir[d2].y,l1 = check(x1, y1),l2 = check(x2, y2);
					if ((l1 == 0 && l2) || (l1&&l2 && (weight[x1][y1]>weight[x2][y2])))//check函数值为零的优先放后面，
					{
						map[i][j][k] = d2;
						map[i][j][m] = d1;   //冒泡排序，按照weight权值排序，如果check值为零放在最后
					}
				}
			}
		}
	}
}

inline  void init(int &x,int &y)
{
	for (int i = 0; i<N; i++)
		for (int j = 0; j<N; j++)
			walked[i][j] = 0;
	setweight();
	setmap();
	while (1)
	{
		printf("输入马的行、列坐标 Y (from 0 to 7):");
		scanf("%d%d", &x,&y);
		if (x<0 || x>7 || y<0 || y>7)
		{
			printf("输入错误!nn");
		}
		else
			break;
	}
};
inline void Path(int xx, int yy);
int main()
{
	int x, y;
	init(x,y);
	Path(x, y);

}
inline void Path(int xx, int yy)//核心代码
{
	SqStack path;
	SElemType pop_temp;
	SElemType pos, dest_p;  //当前点和目标点
	int step = 0, x, y, s, k = 1, l = 1, d = 0;
	char ch;
	pos.x = xx; pos.y = yy; pos.z = 0;
	walked[xx][yy] = 1;
	InitStack(&path);
	Push(&path, pos); //起始点入栈

	while (1)
	{
		if (step == (N*N - 1))//返回条件
		{
			output(path);
			printf("退出Quit扣q键     /    返回(重新设置起始点)扣b键   /  寻找下一条路径扣n键n");
			printf("第%d条路径", k);
			ch = getch();
			if (ch == 'b') { system("cls");main() ;}
			else if (ch == 'q') exit(1);
			else       //寻找并打印下一条路径
			{
				k++;//路径数+1

				Pop(&path, &pop_temp);
				GetTop(path, &pos);

				pos.z = pos.z + 1;//搜下一方向
				SetTop(path, &pos);  //换方向
				step--;
				continue;
			}
		}

		if (StackEmpty(path)) break;
		GetTop(path, &pos);
		x = pos.x;   y = pos.y;//该点坐标
		d = pos.z;	//该点出度

		if (d >= 8)	//退栈条件
		{
		    GetTop(path, &pos);
		    printf("(%d %d)退栈，回溯到",pos.x,pos.y);

			walked[x][y] = 0;     //清除走过标记
			step--;    //步数减一
			Pop(&path, &pop_temp);   //清除该点
			GetTop(path, &pos); //取之前的一个出边所连的点
			printf("(%d %d)!n",pos.x,pos.y);
			pos.z = pos.z + 1;
			SetTop(path, &pos);  //换方向搜索

		}
		if (d<8)//正常未搜完
		{
			s = map[x][y][d];//当前搜的方向

			dest_p.x = x + dir[s].x;
			dest_p.y = y + dir[s].y;
			if (check(dest_p.x, dest_p.y) && walked[dest_p.x][dest_p.y] == 0)
			//没被搜过并且在棋盘内，入栈
			{
				walked[x][y] = 1; //打上标记
				step++;
				dest_p.z = 0;//选择第一个方向
				Push(&path, dest_p);//入栈

			}
			else//搜过或不在棋盘内
			{
				pos.z = d + 1;//换方向，入栈
				SetTop(path, &pos);
			}
		}
	}
}