• 首先，以字典序最小的排列起始，并且为该排列的每个元素赋予一个移动方向，初始所有元素的移动方向都向左。
• 在排列中查找这样的元素，该元素按照其对应的移动方向移动，可以移动到一个合法位置，且移动方向的元素小于该元素，在所有满足条件的元素中，找到其中的最大者。
• 将该元素与其移动方向所对应的元素交换位置。
• 对于排列中，所有元素值大于该元素的元素，反转其移动方向。

这里有几个概念需要说明一下，所谓合法位置，是指该元素按照其移动方向移动，不会移动到排列数组之外，例如对于<4，<1，<2，<3，此时对于元素4，如果继续向左移动，就会超过数组范围，所以4的下一个移动位置是非法位置。而且，所有元素，都只能向比自己小的元素的方向移动，如上面例子中的元素2，3，而元素1是不能够移动到元素4的位置的。每次移动，都要对可以移动的所有元素中的最大者进行操作，上例中元素1，4不能移动，2，3都存在合法的移动方案，此时需要移动3，而不能移动2。合法移动之后，需要将所有大于移动元素的元素的移动方向反转，上例中的元素3移动后的结果是4>，1<，<3，<2，可以看到，元素4的移动方向改变了。再如此例子<2，<1，3>，4>，对于其中的元素2，4，其对应的下一个移动位置都是非法位置，而对于元素1，3，其下一个移动位置的元素，都比他们要大，对于该排列就找不到一个可以的移动方案，这说明该算法已经达到终态，全排列生成结束。下面是该算法的代码

inline int SJTNext(unsigned int* index, size_t array_size, int* move)
{
	unsigned int i, j, t;

	//找到最大合法移动的元素索引
	for(i = array_size - 1, j = array_size; i != UINT_MAX; --i)
	{
		if(i + move[i] < array_size && index[i] > index[i + move[i]])
		{
			if(j == array_size)
			{
				j = i;
				continue;
			}

			if(index[i] > index[j])
			{
				j = i;
			}
		}
	}

	//未发现合法的移动策略
	if(j == array_size)
	{
		return 1;
	}

	t = index[j];//要交换位置的元素
	i = j + move[j];//发生交换的位置
	swap(index, i, j);
	swap(move, i, j);

	//将所有比t大的元素的移动方向反转
	for(i = 0; i < array_size; ++i)
	{
		if(index[i] > t)
		{
			move[i] = -move[i];
		}
	}

	return 0;
}

/*
 * 基于最小变换的Steinhaus–Johnson–Trotter算法
 */
void FullArray(char* array, size_t array_size)
{
	unsigned int index[array_size];
	int move[array_size];

	for(unsigned int i = 0; i < array_size; ++i)
	{
		index[i] = i;
		move[i] = -1;
	}

	ArrayPrint(array, array_size, index);

	while(!SJTNext(index, array_size, move))
	{
		ArrayPrint(array, array_size, index);
	}
}

代码使用了一个伴随数组move标记对应位置元素的移动方向，在元素移动时，move数组中的对应元素也要相应移动。该算法从初始排列<1,<2,<3,<4开始，可以生成4元素的所有排列，直至最终排列<2，<1，3>，4>为止，其状态转移如下图所示：

未完待续....

Steinhaus-Johnson-Trotter 生成全排列算法