八皇后问题最简单算法

1.引子中国有一句古话，叫做“不撞南墙不回头"，生动的说明了一个人的固执，有点贬义，但是在软件编程中，这种思路确是一种解决问题最简单的算法，它通过一种类似于蛮干的思路，一步一步地往前走，每走一步都更靠近目标结果一些，直到遇到障碍物，我们才考虑往回走。

然后再继续尝试向前。

通过这样的波浪式前进方法，最终达到目的地。

当然整个过程需要很多往返，这样的前进方式，效率比较低下。

2.适用范围适用于那些不存在简明的数学模型以阐明问题的本质，或者存在数学模型，但是难于实现的问题。

3.应用场景在8*8国际象棋棋盘上，要求在每一行放置一个皇后，且能做到在竖方向，斜方向都没有冲突。

国际象棋的棋盘如下图所示：4.分析基本思路如上面分析一致，我们采用逐步试探的方式，先从一个方向往前走，能进则进，不能进则退，尝试另外的路径。

首先我们来分析一下国际象棋的规则，这些规则能够限制我们的前进，也就是我们前进途中的障碍物。

一个皇后q(x,y)能被满足以下条件的皇后q(row,col)吃掉1）x=row(在纵向不能有两个皇后)2) y=col（横向）3）col + row = y+x;（斜向正方向）4) col - row = y-x;（斜向反方向）遇到上述问题之一的时候，说明我们已经遇到了障碍，不能继续向前了。

我们需要退回来，尝试其他路径。

我们将棋盘看作是一个8*8的数组，这样可以使用一种蛮干的思路去解决这个问题，这样我们就是在8*8=64个格子中取出8个的组合，C(64,80) = 4426165368,显然这个数非常大，在蛮干的基础上我们可以增加回溯，从第0列开始，我们逐列进行，从第0行到第7行找到一个不受任何已经现有皇后攻击的位置，而第五列，我们会发现找不到皇后的安全位置了，前面四列的摆放如下:第五列的时候，摆放任何行都会上图所示已经存在的皇后的攻击，这时候我们认为我们撞了南墙了，是回头的时候了，我们后退一列，将原来摆放在第四列的皇后（3，4）拿走，从（3，4）这个位置开始，我们再第四列中寻找下一个安全位置为（7，4），再继续到第五列，发现第五列仍然没有安全位置，回溯到第四列，此时第四列也是一个死胡同了，我们再回溯到第三列，这样前进几步，回退一步，最终直到在第8列上找到一个安全位置（成功）或者第一列已经是死胡同，但是第8列仍然没有找到安全位置为止总结一下，用回溯的方法解决8皇后问题的步骤为：1）从第一列开始，为皇后找到安全位置，然后跳到下一列2）如果在第n列出现死胡同，如果该列为第一列，棋局失败，否则后退到上一列，在进行回溯3）如果在第8列上找到了安全位置，则棋局成功。

八皇后问题：在国际象棋里面皇后可以横走，竖走，斜走。

我们现在有一个8*8的棋盘，怎样摆放8个皇后，而使彼此不冲突，也就是怎样使在同一行，同一列，斜对角线上只存在一个皇后。

解决办法：回溯法回溯法：回溯法有“通用的解题法”之称。

应用回溯法解问题时，首先应该明确问题的解空间。

一个复杂问题的解决往往由多部分构成，即，一个大的解决方案可以看作是由若干个小的决策组成。

很多时候它们构成一个决策序列。

解决一个问题的所有可能的决策序列构成该问题的解空间。

解空间中满足约束条件的决策序列称为可行解。

一般说来，解任何问题都有一个目标，在约束条件下使目标值达到最大（或最小）的可行解称为该问题的最优解。

在解空间中，前k 项决策已经取定的所有决策序列之集称为k 定子解空间。

0 定子解空间即是该问题的解空间。

C语言代码：#include<stdio.h>int count=0;/*计数*/int fit(int (*Q)[8],int i,int j)/*判断是否适合摆放皇后*/{int t,e;for(t=i,e=0;e<8;e++)if(Q[t][e]==1&&e!=j) return 0;/*pan duan hang*/for(e=j,t=0;t<8;t++)if(Q[t][e]==1&&t!=i) return 0 ;/*pan duan lie*/for(e=j,t=i;e>0&&t>0;e--,t--)/*pan duan left up */if(Q[t][e]==1) return 0;for(e=j,t=i;e<8&&t<8;e++,t++)if(Q[t][e]==1) return 0; /*pan duan right down*/for(e=j,t=i;e<8&&t>0;e++,t--)if(Q[t][e]==1) return 0;/*pan duan right up*/for(e=j,t=i;e>0&&t<8;e--,t++)if(Q[t][e]==1) return 0;/*pan duan left down*/return 1;/*if all the conditions are the wrong ,then we will get 1 ,so the queenfunction will be told to make the Q[i][j]=1.we will put a queen on Q[i][j].*/}void queen(int (*Q)[8],int j)/*求8皇后问题的解*/{ int i,k;if(j==8)/*递归判断，当j=8，说明Q【】【7】中摆放了皇后，所以得到一个解*/{for(i=0;i<8;i++){for(k=0;k<8;k++)printf(" %d",Q[i][k]);/*统计摆放的种类，以及输出结果；*/printf("\n");}printf("\n");count++;return;}for(i=0;i<8;i++){if(fit(Q,i,j)>0)/*在生成解空间树的同时进行深度搜索，从而实现减枝*/{Q[i][j]=1;queen(Q,j+1);Q[i][j]=0;/*进行回溯,因为每次会形成不同的基点，然后沿着各基点进行深度搜索，所以每次搜索完要回到例外基点，所以前面搜索的基点必然要归为零*/}}}main(){int Q[8][8],i,j;for(i=0;i<8;i++)for(j=0;j<8;j++)Q[i][j]=0;queen(Q,0);printf("%d",count);}运行的部分结果：。

⼋皇后问题（经典算法-回溯法）问题描述：⼋皇后问题（eight queens problem）是⼗九世纪著名的数学家⾼斯于1850年提出的。

问题是：在8×8的棋盘上摆放⼋个皇后，使其不能互相攻击。

即任意两个皇后都不能处于同⼀⾏、同⼀列或同⼀斜线上。

可以把⼋皇后问题扩展到n皇后问题，即在n×n的棋盘上摆放n个皇后，使任意两个皇后都不能互相攻击。

思路：使⽤回溯法依次假设皇后的位置，当第⼀个皇后确定后，寻找下⼀⾏的皇后位置，当满⾜左上、右上和正上⽅向⽆皇后，即矩阵中对应位置都为0，则可以确定皇后位置，依次判断下⼀⾏的皇后位置。

当到达第8⾏时，说明⼋个皇后安置完毕。

代码如下：#include<iostream>using namespace std;#define N 8int a[N][N];int count=0;//判断是否可放bool search(int r,int c){int i,j;//左上+正上for(i=r,j=c; i>=0 && j>=0; i--,j--){if(a[i][j] || a[i][c]){return false;}}//右上for(i=r,j=c; i>=0 && j<N; i--,j++){if(a[i][j]){return false;}}return true;}//输出void print(){for(int i=0;i<N;i++){for(int j=0;j<N;j++){cout<<a[i][j]<<" ";}cout<<endl;}}//回溯法查找适合的放法void queen(int r){if(r == 8){count++;cout<<"第"<<count<<"种放法\n";print();cout<<endl;return;}int i;for(i=0; i<N; i++){if(search(r,i)){a[r][i] = 1;queen(r+1);a[r][i] = 0;}}}//⼊⼝int main(){queen(0);cout<<"⼀共有"<<count<<"放法\n"; return 0;}。

八皇后问题编辑八皇后问题，是一个古老而著名的问题，是回溯算法的典型例题。

该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出：在8X8格的国际象棋上摆放八个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。

高斯认为有76种方案。

1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。

计算机发明后，有多种方法可以解决此问题。

八皇后问题最早是由国际西洋棋棋手马克斯·贝瑟尔于1848年提出。

之后陆续有数学家对其进行研究，其中包括高斯和康托，并且将其推广为更一般的n皇后摆放问题。

八皇后问题的第一个解是在1850年由弗朗兹·诺克给出的。

诺克也是首先将问题推广到更一般的n皇后摆放问题的人之一。

1874年，S.冈德尔提出了一个通过行列式来求解的方法，这个方法后来又被J.W.L.格莱舍加以改进。

艾兹格·迪杰斯特拉在1972年用这个问题为例来说明他所谓结构性编程的能力。

八皇后问题在1990年代初期的著名电子游戏第七访客和NDS平台的著名电子游戏雷顿教授与不可思议的小镇中都有出现。

2名词解释算法介绍八皇后问题是一个以国际象棋为背景的问题：如何能够在 8×8 的国际象棋棋盘上放置八个皇后，使得任何一个皇后都无法直接吃掉其他的皇后？为了达到此目的，任两个皇后都不能处于同一条横行、纵行或斜线上。

八皇后问题可以推广为更一般的n 皇后摆放问题：这时棋盘的大小变为n ×n ，而皇后个数也变成n 。

当且仅当 n = 1 或 n ≥ 4时问题有解。

C 语言1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 intn=8;intx[9];intnum = 0;//解的个数//判断第k 个皇后能否放在第x[k]列boolPlace(intk){inti = 1;while ( i < k){if ( x[i]==x[k] || (abs (x[i]-x[k]) ==abs (i-k)) )returnfalse ;i++;}returntrue ;}void nQueens(intn){x[0] = x[1] =0;intk=1;while (k > 0){x[k]+=1;//转到下一行while (x[k]<=n && Place(k)==false ){//如果无解，最后一个皇后就会安排到格子外面去 x[k]+=1;}if (x[k]<=n){//第k 个皇后仍被放置在格子内，有解if (k==n){num++;cout << num <<":\t";for (inti=1; i<=n; i++){28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 cout << x[i] <<"\t";}cout << endl;}else {k++;x[k]=0;//转到下一行}}else //第k 个皇后已经被放置到格子外了，没解，回溯k--;//回溯}}int_tmain(intargc, _TCHAR* argv[]){nQueens(n);getchar ();return 0;}Java 算法1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 publicclass Queen {// 同栏是否有皇后，1表示有privateint [] column;// 右上至左下是否有皇后privateint [] rup;// 左上至右下是否有皇后privateint [] lup;// 解答privateint [] queen;// 解答编号privateint num;public Queen() {column =newint [8+1];rup =newint [2*8+1];lup =newint [2*8+1];for (int i =1; i <=8; i++)column[i] =1;2223242526272829303132333435363738394041424344454647484950515253545556575859606162636465 for(int i =1; i <=2*8; i++)rup[i] = lup[i] =1;queen =newint[8+1];}publicvoid backtrack(int i) {if(i >8) {showAnswer();}else{for(int j =1; j <=8; j++) {if(column[j] ==1&&rup[i+j] ==1&&lup[i-j+8] ==1) {queen[i] = j;// 设定为占用column[j] = rup[i+j] = lup[i-j+8] =0; backtrack(i+1);column[j] = rup[i+j] = lup[i-j+8] =1; }}}}protectedvoid showAnswer() {num++;System.out.println("\n解答 "+ num);for(int y =1; y <=8; y++) {for(int x =1; x <=8; x++) {if(queen[y] == x) {System.out.print(" Q");}else{System.out.print(" .");}}System.out.println();}}publicstaticvoid main(String[] args) {Queen queen =new Queen();queen.backtrack(1);66 67 }}Erlang 算法-module(queen).-export([printf/0,attack_range/2]).-define(MaxQueen, 4).%寻找字符串所有可能的排列%perms([]) ->%[[]];%perms(L) ->% [[H | T] || H <- L, T <-perms(L -- [H])].perms([]) ->[[]];perms(L)->[[H | T] || H <- L, T <- perms(L -- [H]),attack_range(H,T) == []].printf() ->L =lists:seq(1, ?MaxQueen),io:format("~p~n",[?MaxQueen]),perms(L).%检测出第一行的数字攻击到之后各行哪些数字%left 向下行的左侧检测%right 向下行的右侧检测attack_range(Queen,List) ->attack_range(Queen,left, List) ++ attack_range(Queen,right, List).attack_range(_, _, [])->[];attack_range(Queen, left, [H | _]) whenQueen - 1 =:= H ->[H];attack_range(Queen,right, [H | _]) when Queen + 1 =:= H->[H];attack_range(Queen, left, [_ | T])->attack_range(Queen - 1, left,T);attack_range(Queen, right, [_ | T])->attack_range(Queen + 1, right, T).C 语言算法C 代码头文件1 2 3 4 5 6 7 8 9 10 11 //eigqueprob.h#include#define N 8 /* N 表示皇后的个数 *//* 用来定义答案的结构体*/typedefstruct {intline;/* 答案的行号 */introw;/* 答案的列号 */}ANSWER_TYPE;/* 用来定义某个位置是否被占用 */12 13 14 15 16 17 18 19 20 typedefenum {notoccued = 0,/* 没被占用 */occued = 1/* 被占用 */}IFOCCUED; /* 该列是否已经有其他皇后占用 */IFOCCUED rowoccu[N];/* 左上-右下对角位置已经有其他皇后占用 */IFOCCUED LeftTop_RightDown[2*N-1];/* 右上-左下对角位置已经有其他皇后占用*/IFOCCUED RightTop_LefttDown[2*N-1];/* 最后的答案记录 */ANSWER_TYPE answer[N];主程序1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 #include "eigqueprob.h"/* 寻找下一行占用的位置 */void nextline(intLineIndex){static asnnum = 0;/* 统计答案的个数 */intRowIndex = 0;/* 列索引 */intPrintIndex = 0;/* 按列开始遍历 */for (RowIndex=0;RowIndex{/* 如果列和两个对角线上都没有被占用的话，则占用该位置 */if ((notoccued == rowoccu[RowIndex])\&&(notoccued == LeftTop_RightDown[LineIndex-RowIndex+N-1])\&&(notoccued == RightTop_LefttDown[LineIndex+RowIndex])){/* 标记已占用 */rowoccu[RowIndex] = occued;LeftTop_RightDown[LineIndex-RowIndex+N-1] = occued;RightTop_LefttDown[LineIndex+RowIndex] = occued;/* 标记被占用的行、列号 */answer[LineIndex].line = LineIndex;answer[LineIndex].row = RowIndex;/* 如果不是最后一行，继续找下一行可以占用的位置 */if ((N-1) > LineIndex ){nextline(LineIndex+1);}/* 如果已经到了最后一行，输出结果 */else{asnnum++;printf ("\nThe %dth answer is :",asnnum);for (PrintIndex=0;PrintIndex{343536373839404142434445464748495051525354 printf("(%d,%d) ",answer[PrintIndex].line+1,answer[PrintIndex].row+1}/* 每10个答案一组，与其他组隔两行 */if((asnnum % 10) == 0)printf("\n\n");}/* 清空占用标志，寻找下一组解 */rowoccu[RowIndex] = notoccued;LeftTop_RightDown[LineIndex-RowIndex+N-1] = notoccued;RightTop_LefttDown[LineIndex+RowIndex] = notoccued;}}}main(){inti = 0;/* 调用求解函数*/nextline(i);/* 保持屏幕结果*/getchar();}C语言实现图形实现对于八皇后问题的实现，如果结合动态的图形演示，则可以使算法的描述更形象、更生动，使教学能产生良好的效果。

算法⼊门经典-第七章例题7-2⼋皇后问题原本利⽤回溯思想解决的经典⼋皇后问题，其实也是可以⽤递归解决的~⼋皇后的递归解决思路：从第⼀⾏开始，依次判断0~8列的哪⼀列可以放置Queen，这样就确定了该⾏的Queen的位置，然后⾏数递增，继⽽递归实现下⼀⾏的判断，依次类推直到⾏数增加到8（⾏数从0开始的），此时为递归-----归的条件，即表⽰⼀种⼋皇后的解决⽅法完成，打印结果；之后进⾏下⼀种解决⽅法的寻找，⼤致思路个⼈理解是这样noDanger(row,j,(*chess)[8])函数是判断第row⾏第j列是否可以放置Queen#include<stdio.h>int count=0;//参数row：起始⾏//参数n:表⽰列数//参数(*chess)[8]表⽰指向棋盘每⼀⾏的指针int NotDanger(int row,int j,int (*chess)[8])//⽐较不同⾏同列上是否有其他皇后{int i,k,flag1=0,flag2=0,flag3=0,flag4=0,flag5=0;//判断列⽅向for(i=0;i<8;i++){if(*(*(chess+i)+j)!=0) //在这之前列上有其他皇后{flag1=1;break;}}for(i=row,k=j;i>=0&&k>=0;i--,k--){if(*(*(chess+i)+k)!=0) //左上⽅{flag2=1;break;}}for(i=row,k=j;i<8&&k<8;i++,k++){if(*(*(chess+i)+k)!=0) //右下⽅{flag3=1;break;}}for(i=row,k=j;i>=0&&k<8;i--,k++){if(*(*(chess+i)+k)!=0) //右上⽅{flag4=1;break;}}for(i=row,k=j;i<8&&k>=0;i++,k--){if(*(*(chess+i)+k)!=0) //左下⽅{flag5=1;break;}}if(flag1||flag2||flag3||flag4||flag5){return0;//如果有⼀个位置被占有危险}else return1;} /*int noDanger(int row,int j,int (*chess)[8]){int flag1=0,flag2=0,flag3=0,flag4=0,flag5=0;int i,k;//判断列for(i=0;i<8;i++){if(*(*(chess+i)+j)!=0){flag1=1;break;}}//判断左上⽅for(i=row,k=j;i>=0&&k>=0;i--,k--){if(*(*(chess+i)+k)!=0){flag2=1;break;}}//判断右下⽅for(i=row,k=j;i<8&&k<8;i++,k++){if(*(*(chess+i)+k)!=0){flag3=1;break;}}//判断左下⽅for(i=row,k=j;i<8&&k>=0;k--,i++){if(*(*(chess+i)+k)!=0){flag4=1;break;}}//判断右上⽅for(i=row,k=j;i>=0&&k<8;k++,i--){if(*(*(chess+i)+k)!=0){flag5=1;break;}}if(flag1||flag2||flag3||flag4||flag5){return 0;}else{return 1;}} */EightQueen(int row,int n,int (*chess)[8]){int chess2[8][8];int i,j;for(i=0;i<8;i++){for(j=0;j<8;j++){chess2[i][j]=chess[i][j];}}if(8==row){printf("第%d 种\n",count+1);for(i=0;i<8;i++){for(j=0;j<8;j++)printf("%3d ",*(*(chess2+i)+j));printf("\n");}count++;}else{//判断这个位置是否危险 j<列for(j=0;j<n;j++){if(NotDanger(row,j,chess2))//尝试每⼀列是否危险 {for(i=0;i<8;i++){//整⾏所有列的位置赋值为0*(*(chess2+row)+i)= 0;}*(*(chess2+row)+j)=1;//皇后的位置赋值为1EightQueen(row+1,n,chess2);//继续往下⼀⾏递归 }}}}int main(){int chess[8][8],i,j;for(i=0;i<8;i++){for(j=0;j<8;j++)chess[i][j]=0;}EightQueen(0,8,chess);printf("总共有%d种解决⽅法",count);return0;}。

⼋皇后以及N皇后问题分析⼋皇后是⼀个经典问题，在8*8的棋盘上放置8个皇后，每⼀⾏不能互相攻击。

因此拓展出 N皇后问题。

下⾯慢慢了解解决这些问题的⽅法：回溯法：回溯算法也叫试探法，它是⼀种系统地搜索问题的解的⽅法。

回溯算法的基本思想是：从⼀条路往前⾛，能进则进，不能进则退回来，换⼀条路再试。

在现实中，有很多问题往往需要我们把其所有可能穷举出来，然后从中找出满⾜某种要求的可能或最优的情况，从⽽得到整个问题的解。

回溯算法就是解决这种问题的“通⽤算法”，有“万能算法”之称。

N皇后问题在N增⼤时就是这样⼀个解空间很⼤的问题，所以⽐较适合⽤这种⽅法求解。

这也是N皇后问题的传统解法，很经典。

算法描述：1. 算法开始，清空棋盘。

当前⾏设为第⼀⾏，当前列设为第⼀列。

2. 在当前⾏，当前列的判断放置皇后是否安全，若不安全，则跳到第四步。

3. 在当前位置上满⾜条件的情况： 在当前位置放⼀个皇后，若当前⾏是最后⼀⾏，记录⼀个解； 若当前⾏不是最后⼀⾏，当前⾏设为下⼀⾏，当前列设为当前⾏的第⼀个待测位置； 若当前⾏是最后⼀⾏，当前列不是最后⼀列，当前列设为下⼀列； 若当前⾏是最后⼀⾏，当前列是最后⼀列，回溯，即清空当前⾏以及以下各⾏的棋盘，然后当前⾏设为上⼀⾏，当前列设为当前⾏的下⼀个待测位置； 以上返回第⼆步。

4.在当前位置上不满⾜条件： 若当前列不是最后⼀列，当前列设为下⼀列，返回到第⼆步； 若当前列是最后⼀列，回溯，即，若当前⾏已经是第⼀⾏了，算法退出，否则，清空当前⾏以及以下各⾏的棋盘，然后，当前⾏设为上⼀⾏，当前列设为当前⾏的下⼀个待测位置，返回第⼆步。

如何判断是否安全：把棋盘存储为⼀个N维数组a[N]，数组中第i个元素的值代表第i⾏的皇后位置，这样便可以把问题的空间规模压缩为⼀维O(N)，在判断是否冲突时也很简单， ⾸先每⾏只有⼀个皇后，且在数组中只占据⼀个元素的位置，⾏冲突就不存在了， 其次是列冲突，判断⼀下是否有a[i]与当前要放置皇后的列j相等即可。

软件英才网软件行业驰名招聘网站一步一步写算法（之八皇后）八皇后是一道很具典型性的题目。

它的基本要求是这样的：在一个8*8的矩阵上面放置8个物体，一个矩阵点只允许放置一个物体，任意两个点不能在一行上，也不能在一列上，不能在一条左斜线上，当然也不能在一条右斜线上。

初看到这道题目，大家的第一印象是遍历，但是经过实践之后发现遍历其实不好写，而且复杂度很低。

不仅需要遍历8*8*8*8*8*8*8*8*8 = 2^24次数据，还要判断各种条件，实际的计算复杂度还要比较这个高。

其实我们仔细看一看，这中间很多的计算其实很多是不需要的，因为如果我们在某一行没有可以插入的数据的话，那么这后面的行其实就不用考虑了。

也就是说，我们只有在保证前面插入的物体都合法有效的情况下，才能进行下一次的物体插入。

无谓的遍历只会是无用功。

那么，我们应该怎么做呢？其实步骤不太难：（1）在第n行寻找可以插入的位置，中间涉及到位置合法性的判断（2）如果没有可以插入的位置，返回（3）如果有可以插入的位置，插入数据。

此时再判断是否已经是最后一行，如果是，打印输出返回；反之继续对下一行数据进行试探处理。

有了上面的步骤，我们就可以书写代码了。

老规矩，朋友们可以自己先尝试一下。

a）定义全局堆栈和打印函数1static int gEightQueen[8] = {0};2static int gCount = 0;34void print()5{6int outer;7int inner;89for(outer = 0; outer <8; outer ++){10for(inner = 0; inner < gEightQueen[outer]; inner ++)11 printf("* ");1213 printf("# ");1415for(inner = gEightQueen[outer] + 1; inner < 8; inner ++)16 printf("* ");1718 printf("\n");软件英才网软件行业驰名招聘网站19 }2021 printf("=====================================\n");22}b）添加位置合法性的函数判断23int check_pos_valid(int loop, int value)24{25int index;26int data;2728for(index = 0; index < loop; index ++){29 data = gEightQueen[index];3031if(value == data)32return 0;3334if((index + data) == (loop + value))35return 0;3637if((index - data) == (loop - value))38return 0;39 }4041return 1;42}c）八皇后遍历43void eight_queen(int index)44{45int loop;4647for(loop = 0; loop < 8; loop++){48if(check_pos_valid(index, loop)){49 gEightQueen[index] = loop;5051if(7 == index){52 gCount ++, print();53 gEightQueen[index] = 0;54return;软件英才网软件行业驰名招聘网站55 }5657 eight_queen(index + 1);58 gEightQueen[index] = 0;59 }60 }61}总结：（1）迭代递归是编程的难点，需要自己好好实践，看别人写一百遍，不如自己写一遍（2）递归的时候务必注意函数return的出口（3）递归函数中语句的顺序不要随意更换（4）递归函数中注意数据的保存和恢复（5）递归函数也要验证，可以用程序验证法，也可以用其他函数的结果来验证。