// 保持稳定性要求折半查找返回最后相等的关键字的位置或其右边
// high+1: 插入的位置

分析:
由于折半插入排序和直接插入排序相比, 仅减少了关键字比较的次数, 而记录移动次数不变. 其时间复杂度仍为O(n^2).  而且它查找和移动不是在同一个迭代中完成的. 所以只有当n较大时其性能才略优于直接插入排序.

对于n皇后问题来说，每一行每一列每条对角线上最多有一个皇后，那么对于这样的每个元素（行、列或对角线）我们可以用一个bool值来表示是否已经有皇后在该元素上，这样判断是否冲突就变得十分简单，只需要读取一个bool值。另外需要记录棋盘的格局，考虑到一行只有一个皇后，可以建议一个一维数组保存每一行的皇后占用的列号。

这样基本就OK了，只是对于行而言，我们采用了回溯法（剪枝函数）保证了每行只有一个皇后，这样行的bool数组就可以省略了。

整个程序的实现如下：
//queens.h
static const int MAX_SIZE = 20;

class queens
{
public:
 queens(const int & size);
 void add(const int & col);
 void remove(const int & col);
 bool guarded(const int & col);
 bool finished();
 void print();
 int size;
private:
 int count;
 int array[MAX_SIZE];
 bool downward[MAX_SIZE*2-1];
 bool upward[MAX_SIZE*2-1];
 bool cols[MAX_SIZE];
};

//queens.cpp
#include "queens.h"
#include <iostream>
using namespace std;

queens::queens(const int & size)
{
 this->size = size;
 count = 0;
 for(int i=0; i<MAX_SIZE; i++)
  cols[i] = false;
 for(i=0; i<MAX_SIZE*2-1; i++)
  upward[i] = downward[i] = false;
 for(i=0; i<MAX_SIZE; i++)
  array[i] = -1;
}

void queens::add(const int & col)
{
 array[count] = col;
 cols[col] = downward[size-1-(count-col)] = upward[count+col] = true;
 ++count;
}

void queens::remove(const int & col)
{
 array[--count] = -1;
 cols[col] = downward[size-1-(count-col)] = upward[count+col] = false;
}

bool queens::guarded(const int & col)
{
 if( cols[col] || downward[size-1-(count-col)] || upward[count+col] )
  return true;
 return false;
}

bool queens::finished()
{
 return count==size ? true : false;
}

void queens::print()
{
 static int num = 0;
 ++num;
 cout<<"solution "<<num<<endl;
 for(int i=0; i<size; i++)
 {
  for(int j=0; j<size; j++)
   if( j == array[i] )
    cout<<"1  ";
   else
    cout<<"0  ";
  cout<<endl;
 }
 cout<<endl<<endl<<endl; 
}

//test.cpp
#include <iostream>
#include "queens.h"

using namespace std;

void chess_board( queens config )
{
 if( config.finished() )
  config.print();
 else
  for(int i=0; i<config.size; i++)
   if( !config.guarded(i) )
   {
    config.add(i);
    chess_board(config);
    config.remove(i);
   } 
}

int main()
{
 queens configuration(8);
 chess_board(configuration);
}

分析后可见，皇后之间互不攻击当且仅当满足下列条件：
1) 每一行只能有一个皇后
2) 每一列只能有一个皇后
3) 任意条对角线上面只能有一个皇后

若按照从左到右从上到下的顺序手动摆放皇后，会发现算法遵循的是回溯法的思想。于是我们遵循top-down design的顺序来设计整个算法和程序。

采用OOP的思想，先假设存在一个·表示棋盘格局的类queens，则定义回溯函数solve_from(queens configuration)，configuration表示当前棋盘格局，算法不断扩展棋盘的当前格局（找到下一个非冲突位置），当找到一个解决方案时打印该方案。该递归函数采用回溯法求出所有解。main函数调用solve_from时传递的实参是一个空棋盘。

对于模拟棋盘的queens类，我们可以定义三个数据成员：
1) size：棋盘的边长，即大小
2) count：已放置的互不冲突的皇后数
3) array[][]：布尔矩阵，true表示当前格有皇后

这里需要稍加思考以便稍后可以简化程序：因为每行只能放一个皇后，从上到下，从左到右放，那么count个皇后占用的行为0——count－1。所以 count还表示下一个皇后应该添加在哪一行。这样，add和remove操作的入口参数就只需要提供列号就行了，降低了耦合度 ：）

为了模拟棋盘操作，应该至少提供以下方法：
1) 初始化一个size大小的空棋盘queens(int size)
2) 插入一个非冲突的皇后add( int col )
3) 删除最新插入的皇后remove( int col )
4) 判断要插入的皇后是否与已存在的棋盘格局相冲突bool guarded( int col )
5) 判断是否棋盘已满bool finished( )
6) 若棋盘已满则打印棋盘格局print()

于是solve_from定义如下：
void solve_from( queens &configuration )
{
      if( configuration.finished() )
            configuration.print();
      else
            for( int i=0; i<size; i++ )
                  if( !configuration.guarded( i ) )
                  {
                        configuration.add( i );
                        solve_from(configuration);
                        configuration.remove( i );
                  }
}

queens的方法实现如下：
static const int MAX_SIZE = 20
queens::queens( const int & size )
{
      for( int i=0; i<MAX_SIZE; i++ )
           for( int j=0; j<MAX_SIZE; j++ )
                  array[ i ][ j ] = false;
      this->size = size;
      count = 0;      
}

void queens::add( const int & col )
{
      array[ count++ ][ col ] = true;
}

void queens::remove( const int & col )
{
      array[ --count ][ col ] = false;
}

关于guarded还有一点说明：
由于回溯法中的剪枝函数configuration.remove保证了每行只有一个皇后，我们是需要判断列冲突与对角线冲突的情况。而且由递归的顺序是从上到下从左到右，所以我们也不需要判断下方的列和对角线，也就是说只要判断三个方向：
current——top
current——upper-left
current——upper-right
工作量就减少了一半以上。

bool queens::guarded( const int & col )
{
      bool gu = false;
      // current——top
      for( int i=0; !gu&&i<count; i++ )
           gu = array[ i ][ col ];
      // current——up-left
      for( i=1; !gu&&(count-i>=0)&&(col-i>=0); i++ )
           gu = array[ count-i ][ col-i ];
      // current——up-right
      for( i=1; !gu&&(count-i>=0)&&(col+i<=size; i++ )
           gu = array[ count-i ][ col+i ];
      return gu;
}

bool queens::finished()
{
      return count<size ? false : true;
}

bool queens::print()
{
      static int num = 0;
      ++num;
      cout<<"solution "<<num<<endl;
      for( int i=0; i<size; i++ )
      {
            for( int j=0; j<size; j++ )
                cout<<array[ i ][ j ]<<"   ";
           cout<<endl;
      }
      cout<<endl<<endl<<endl;              
}

用最简单的求阶层函数来举例：
n! = n*(n-1)*(n-2)***2*1

常见的递归实现如下：
int fun(int n)
{
      if( n<=1 ) return 1;
      return n*fun(n-1);
}
不用多说，这个实现下每次递归调用都会在当前层的工作记录中分配一个4字节（IBM兼容机）的空间来存放n的值。若栈的深度为DEPTH，那么一共需要DEPTH×4个字节存放参数。

那么能不能避免这些存储空间呢，我们来看看引用的情况：
int fun(int &n)
{
      if( n<=1 ) return 1;
      return n*fun(n-1);
}
这段代码编译不能通过，原因是n-1只是一个右值。这里简单介绍一下c＋＋中的无名对象（变量）。c＋＋中的无名对象与const常量有些相似，他们都只能做右值而不能做左值，区别是const常量是有地址的可以取地址，而无名对象一般是不可以的。这里n－1有点无名对象的味道，因为fun要求一个变量引用。由于n－1是右值，所以把参数类型改成int fun(const int & n)就可以了。

int fun(const int &n)
{
      if( n<=1 ) return 1;
      return n*fun(n-1);
}
现在运行通过了，但是栈空间需求仍然没有减少，因为引用的是无名对象，无名对象只是寄存器中的一个值，是没有RAM地址的。所以每递归调用一次，就会在工作记录中分配空间来存放n－1，实际效果相当于const int n = n-1;

那么换个思路。以上程序之所以如此是因为传给递归函数的不是n本身，现设计如下：
int fun(const int & n)
{
      cout<<(long)&n<<endl;
      if( n<=1 ) return 1;
      --n;
      return (n+1)*fun(n);
}
这个程序运行正确而且所有的n确实是最外面的那个n的引用（打印的地址均一致）。有些人会怀疑这个程序不能正确的求出n!。想想也对，当递归不断深入到最里层的时候n＝1，递归回退的时候n仍然还是1，那结果不就成了1×2×2×2××××2了么？？您可以试试看，结果可能出乎您的预料：计算出的确实是 n! 原因如下：
每调用一层时先计算n+1，n＋1的结果保存在register中，进入下一层递归前编译器会把适当的register的值压栈以便日后恢复，这里某个寄存器就存放着运算的中间结果n+1。日后返回该层时虽然此时n确实是1，但是n＋1的结果已经计算过，所以只是从栈顶取出n+1而非重新计算。作为思考，您可以试试看将(n+1)*fun(n)改成fun(n)*(n+1)，它将得出错误的结果。

看来，递归调用函数使用引用参数和普通使用引用参数的非递归调用函数是有区别的：并不是使用了引用参数后就一定能够节省栈的空间，这取决于具体的递归函数（复杂。。。^_^）

当然，在递归函数中使用引用参数还有一种目的，当然是为了改变实参的数值罗。对于非内部类型的对象而言，使用引用往往可以既节省空间又同时可以修改实参的值，这里就不再举例了。